perf: lazy load daemon handlers

Author: thymikee

.github/workflows/size.yml

@@ -0,0 +1,56 @@
+name: Size
+
+on:
+  pull_request:
+
+permissions:
+  contents: read
+  pull-requests: write
+
+concurrency:
+  group: size-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  bundle-size:
+    name: Bundle Size
+    if: github.event.pull_request.head.repo.full_name == github.repository
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Setup toolchain
+        uses: ./.github/actions/setup-node-pnpm
+
+      - name: Preserve report script
+        run: cp scripts/size-report.mjs /tmp/agent-device-size-report.mjs
+
+      - name: Measure base size
+        run: |
+          git checkout --detach "${{ github.event.pull_request.base.sha }}"
+          pnpm install --frozen-lockfile
+          pnpm build
+          node /tmp/agent-device-size-report.mjs --json /tmp/agent-device-size-base.json
+
+      - name: Measure PR size
+        run: |
+          git checkout --detach "${{ github.event.pull_request.head.sha }}"
+          pnpm install --frozen-lockfile
+          pnpm build
+          node scripts/size-report.mjs \
+            --compare /tmp/agent-device-size-base.json \
+            --json .tmp/size-report.json \
+            --markdown .tmp/size-report.md
+
+      - name: Add job summary
+        run: cat .tmp/size-report.md >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Comment on PR
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          GITHUB_PR_NUMBER: ${{ github.event.pull_request.number }}
+        run: node scripts/size-report.mjs --post-comment .tmp/size-report.md

package.json

@@ -96,6 +96,8 @@
     "build:macos-helper": "swift build -c release --package-path macos-helper",
     "build:all": "pnpm build:node && pnpm build:xcuitest",
     "ad": "node bin/agent-device.mjs",
+    "size": "node scripts/size-report.mjs",
+    "size:markdown": "node scripts/size-report.mjs --json .tmp/size-report.json --markdown .tmp/size-report.md",
     "lint": "oxlint . --deny-warnings",
     "format": "oxfmt --write src test skills package.json tsconfig.json tsconfig.lib.json rslib.config.ts vitest.config.ts .github/actions/setup-node-pnpm/action.yml .oxlintrc.json .oxfmtrc.json '!test/skillgym/.skillgym-results/**'",
     "fallow": "fallow --summary",

scripts/size-report.mjs

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { gzipSync } from 'node:zlib';
+
+const COMMENT_MARKER = '<!-- agent-device-size-report -->';
+
+const args = parseArgs(process.argv.slice(2));
+const cwd = path.resolve(args.cwd ?? process.cwd());
+
+if (args.postComment) {
+  await postGitHubComment(args.postComment, args.pr);
+  process.exit(0);
+}
+
+const report = collectReport(cwd);
+const baseReport = args.compare ? JSON.parse(fs.readFileSync(args.compare, 'utf8')) : null;
+
+if (args.json) {
+  writeFile(args.json, `${JSON.stringify(report, null, 2)}\n`);
+}
+
+const markdown = formatMarkdown(report, baseReport);
+
+if (args.markdown) {
+  writeFile(args.markdown, markdown);
+} else {
+  process.stdout.write(markdown);
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--cwd') parsed.cwd = readValue(argv, ++index, arg);
+    else if (arg === '--json') parsed.json = readValue(argv, ++index, arg);
+    else if (arg === '--markdown') parsed.markdown = readValue(argv, ++index, arg);
+    else if (arg === '--compare') parsed.compare = readValue(argv, ++index, arg);
+    else if (arg === '--post-comment') parsed.postComment = readValue(argv, ++index, arg);
+    else if (arg === '--pr') parsed.pr = readValue(argv, ++index, arg);
+    else if (arg === '--help' || arg === '-h') {
+      process.stdout.write(`Usage: node scripts/size-report.mjs [options]
+
+Options:
+  --cwd <path>             Project root to measure. Defaults to cwd.
+  --json <path>            Write the raw size report JSON.
+  --markdown <path>        Write the markdown report.
+  --compare <path>         Compare against a previously written JSON report.
+  --post-comment <path>    Post or update the markdown report on the current PR.
+  --pr <number>            Pull request number for --post-comment.
+`);
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return parsed;
+}
+
+function readValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value || value.startsWith('--')) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+
+function collectReport(root) {
+  const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  const jsFiles = walk(path.join(root, 'dist', 'src')).filter((file) => file.endsWith('.js'));
+  if (jsFiles.length === 0) {
+    throw new Error('No dist/src JavaScript files found. Run `pnpm build` before measuring size.');
+  }
+
+  const chunks = jsFiles
+    .map((file) => {
+      const buffer = fs.readFileSync(file);
+      return {
+        path: path.relative(root, file),
+        rawBytes: buffer.byteLength,
+        gzipBytes: gzipSync(buffer, { level: 9 }).byteLength,
+      };
+    })
+    .sort((left, right) => right.rawBytes - left.rawBytes);
+
+  const js = chunks.reduce(
+    (total, chunk) => ({
+      files: total.files + 1,
+      rawBytes: total.rawBytes + chunk.rawBytes,
+      gzipBytes: total.gzipBytes + chunk.gzipBytes,
+    }),
+    { files: 0, rawBytes: 0, gzipBytes: 0 },
+  );
+
+  return {
+    packageName: packageJson.name,
+    version: packageJson.version,
+    generatedAt: new Date().toISOString(),
+    js,
+    npmPack: collectNpmPack(root),
+    chunks: chunks.slice(0, 20),
+  };
+}
+
+function walk(root) {
+  if (!fs.existsSync(root)) return [];
+  const entries = fs.readdirSync(root, { withFileTypes: true });
+  return entries.flatMap((entry) => {
+    const entryPath = path.join(root, entry.name);
+    return entry.isDirectory() ? walk(entryPath) : [entryPath];
+  });
+}
+
+function collectNpmPack(root) {
+  const cachePath = path.join(root, '.tmp', 'npm-cache');
+  fs.mkdirSync(cachePath, { recursive: true });
+  const result = spawnSync(
+    'npm',
+    ['pack', '--dry-run', '--ignore-scripts', '--json', '--cache', cachePath],
+    { cwd: root, encoding: 'utf8' },
+  );
+  if (result.status !== 0) {
+    throw new Error(`npm pack --dry-run failed:\n${result.stderr || result.stdout}`);
+  }
+  const parsed = JSON.parse(result.stdout);
+  const pack = Array.isArray(parsed) ? parsed[0] : parsed;
+  return {
+    filename: pack.filename,
+    tarballBytes: pack.size,
+    unpackedBytes: pack.unpackedSize,
+    files: pack.entryCount ?? pack.files?.length ?? 0,
+  };
+}
+
+function formatMarkdown(report, baseReport) {
+  const rows = [
+    metricRow('JS raw', baseReport?.js.rawBytes, report.js.rawBytes),
+    metricRow('JS gzip', baseReport?.js.gzipBytes, report.js.gzipBytes),
+    metricRow('npm tarball', baseReport?.npmPack.tarballBytes, report.npmPack.tarballBytes),
+    metricRow('npm unpacked', baseReport?.npmPack.unpackedBytes, report.npmPack.unpackedBytes),
+  ];
+
+  const changedChunks = baseReport
+    ? formatChangedChunks(report.chunks, baseReport.chunks ?? [])
+    : formatTopChunks(report.chunks);
+
+  return `${COMMENT_MARKER}
+## Size Report
+
+| Metric | Base | Current | Diff |
+|---|---:|---:|---:|
+${rows.join('\n')}
+
+${changedChunks}
+`;
+}
+
+function metricRow(label, base, current) {
+  return `| ${label} | ${formatMaybeBytes(base)} | ${formatBytes(current)} | ${formatDiff(base, current)} |`;
+}
+
+function formatTopChunks(chunks) {
+  const rows = chunks.slice(0, 5).map((chunk) => {
+    return `| \`${chunk.path}\` | ${formatBytes(chunk.rawBytes)} | ${formatBytes(chunk.gzipBytes)} |`;
+  });
+  return `Top chunks:
+
+| Chunk | Raw | Gzip |
+|---|---:|---:|
+${rows.join('\n')}
+`;
+}
+
+function formatChangedChunks(currentChunks, baseChunks) {
+  const baseByPath = new Map(baseChunks.map((chunk) => [chunk.path, chunk]));
+  const rows = currentChunks
+    .map((chunk) => {
+      const base = baseByPath.get(chunk.path);
+      return {
+        path: chunk.path,
+        rawDiff: base ? chunk.rawBytes - base.rawBytes : chunk.rawBytes,
+        gzipDiff: base ? chunk.gzipBytes - base.gzipBytes : chunk.gzipBytes,
+      };
+    })
+    .filter((chunk) => chunk.rawDiff !== 0 || chunk.gzipDiff !== 0)
+    .sort((left, right) => Math.abs(right.gzipDiff) - Math.abs(left.gzipDiff))
+    .slice(0, 5)
+    .map((chunk) => {
+      return `| \`${chunk.path}\` | ${formatSignedBytes(chunk.rawDiff)} | ${formatSignedBytes(chunk.gzipDiff)} |`;
+    });
+
+  if (rows.length === 0) {
+    return 'Top changed chunks: no changes in the largest emitted chunks.\n';
+  }
+
+  return `Top changed chunks:
+
+| Chunk | Raw diff | Gzip diff |
+|---|---:|---:|
+${rows.join('\n')}
+`;
+}
+
+function formatMaybeBytes(value) {
+  return typeof value === 'number' ? formatBytes(value) : '-';
+}
+
+function formatDiff(base, current) {
+  return typeof base === 'number' ? formatSignedBytes(current - base) : '-';
+}
+
+function formatBytes(value) {
+  const absoluteValue = Math.abs(value);
+  if (absoluteValue < 1000) return `${value} B`;
+  if (absoluteValue < 1000 * 1000) return `${(value / 1000).toFixed(1)} kB`;
+  return `${(value / (1000 * 1000)).toFixed(1)} MB`;
+}
+
+function formatSignedBytes(value) {
+  if (value === 0) return '0 B';
+  const sign = value > 0 ? '+' : '-';
+  return `${sign}${formatBytes(Math.abs(value))}`;
+}
+
+function writeFile(filePath, contents) {
+  fs.mkdirSync(path.dirname(path.resolve(filePath)), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+}
+
+async function postGitHubComment(markdownPath, explicitPrNumber) {
+  const token = process.env.GITHUB_TOKEN;
+  const repository = process.env.GITHUB_REPOSITORY;
+  const prNumber = explicitPrNumber ?? process.env.GITHUB_PR_NUMBER;
+  if (!token || !repository || !prNumber) {
+    throw new Error('GITHUB_TOKEN, GITHUB_REPOSITORY, and PR number are required to post a comment.');
+  }
+
+  const body = fs.readFileSync(markdownPath, 'utf8');
+  const headers = {
+    accept: 'application/vnd.github+json',
+    authorization: `Bearer ${token}`,
+    'content-type': 'application/json',
+    'x-github-api-version': '2022-11-28',
+  };
+  const [owner, repo] = repository.split('/');
+  const commentsUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${prNumber}/comments`;
+  const commentsResponse = await fetch(`${commentsUrl}?per_page=100`, { headers });
+  if (!commentsResponse.ok) {
+    throw new Error(`Failed to list PR comments: ${commentsResponse.status} ${await commentsResponse.text()}`);
+  }
+
+  const comments = await commentsResponse.json();
+  const existing = comments.find((comment) => comment.body?.includes(COMMENT_MARKER));
+  const response = await fetch(existing ? existing.url : commentsUrl, {
+    method: existing ? 'PATCH' : 'POST',
+    headers,
+    body: JSON.stringify({ body }),
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to ${existing ? 'update' : 'create'} PR comment: ${response.status} ${await response.text()}`);
+  }
+}

src/bin.ts

@@ -1,10 +1,53 @@
 const argv = process.argv.slice(2);
 
-if (argv[0] === 'mcp' && !argv.includes('--help') && !argv.includes('-h')) {
+if (runFastPath(argv)) {
+  // Fast path owns process output and exit behavior.
+} else if (argv[0] === 'mcp' && !argv.includes('--help') && !argv.includes('-h')) {
   import('./mcp/server.ts')
     .then(({ runAgentDeviceMcpServer }) => runAgentDeviceMcpServer())
     .catch(handleStartupError);
 } else {
+  runCli(argv);
+}
+
+function runFastPath(argv: string[]): boolean {
+  if (argv.length === 1 && (argv[0] === '--version' || argv[0] === '-V')) {
+    import('./utils/version.ts')
+      .then(({ readVersion }) => {
+        process.stdout.write(`${readVersion()}\n`);
+      })
+      .catch(handleStartupError);
+    return true;
+  }
+
+  const helpTarget = resolveSimpleHelpTarget(argv);
+  if (helpTarget === undefined) return false;
+
+  import('./utils/args.ts')
+    .then(({ usage, usageForCommand }) => {
+      if (helpTarget === null) {
+        process.stdout.write(`${usage()}\n`);
+        return;
+      }
+      const commandHelp = usageForCommand(helpTarget);
+      if (commandHelp) {
+        process.stdout.write(commandHelp);
+        return;
+      }
+      runCli(argv);
+    })
+    .catch(handleStartupError);
+  return true;
+}
+
+function resolveSimpleHelpTarget(argv: string[]): string | null | undefined {
+  if (argv.length === 1 && (argv[0] === '--help' || argv[0] === '-h')) return null;
+  if (argv[0] === 'help' && argv.length <= 2) return argv[1] ?? null;
+  if (argv.length === 2 && (argv[1] === '--help' || argv[1] === '-h')) return argv[0] ?? null;
+  return undefined;
+}
+
+function runCli(argv: string[]): void {
   import('./cli.ts').then(({ runCli }) => runCli(argv)).catch(handleStartupError);
 }