@linzumi/cli 1.0.80 → 1.0.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.80",
+  "version": "1.0.82",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {
@@ -28,7 +28,8 @@
     "replay:agent-backend": "tsx scripts/replay-agent-backend.ts",
     "vendor:codex-app-server-protocol:check": "tsx scripts/vendor-codex-app-server-protocol.ts --check",
     "replay:agent-backend-browser": "tsx scripts/replay-agent-backend-browser.ts",
-    "promote:gstack-claude-smoke-fixture": "tsx scripts/promote-gstack-claude-smoke-fixture.ts"
+    "promote:gstack-claude-smoke-fixture": "tsx scripts/promote-gstack-claude-smoke-fixture.ts",
+    "diagnose:claude-probe": "tsx scripts/diagnose-claude-probe.ts"
   },
   "keywords": [
     "linzumi",

package/scripts/diagnose-claude-probe.ts

@@ -0,0 +1,198 @@
+/*
+- Date: 2026-07-11
+  Spec: audit PR #3019, W17 (William seq 870: "SDK startup 15s timeout x2"
+  while `claude` ran fine when invoked directly).
+  Relationship: Side-by-side diagnostic for the Claude SDK startup probe.
+  Runs (1) a DIRECT invocation of the exact `claude` executable the probe's
+  fallback scan resolves and (2) the real availability probe
+  (probeClaudeCodeAvailabilityStatus - the same code path the runner runs at
+  startup), with IDENTICAL environment preparation
+  (prepareClaudeCodeSpawnEnvironment) and binary resolution, capturing
+  stderr, exit codes, and timing for both. When the probe fails while the
+  direct invocation succeeds, the report shows the probe's captured child
+  stderr tail - the evidence that used to be discarded (the SDK spawns with
+  stdio 'ignore' for stderr unless a callback is passed).
+
+  Usage:
+    npx tsx scripts/diagnose-claude-probe.ts [--claude-bin /path/to/claude]
+
+  Exit code 0 always (this is a reporter, not a gate); read the verdict.
+*/
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import {
+  findClaudeCodeExecutableFallback,
+  prepareClaudeCodeSpawnEnvironment,
+  probeClaudeCodeAvailabilityStatus,
+} from '../src/claudeCodeSession';
+
+const DIRECT_TIMEOUT_MS = 15_000; // mirrors the probe's initializeTimeoutMs
+
+type DirectResult = {
+  readonly command: string;
+  readonly durationMs: number;
+  readonly exitCode: number | null;
+  readonly timedOut: boolean;
+  readonly stdoutTail: string;
+  readonly stderrTail: string;
+  readonly spawnError?: string;
+};
+
+function tail(value: string, max = 600): string {
+  const collapsed = value.replace(/\s+/g, ' ').trim();
+  return collapsed.slice(-max);
+}
+
+async function runDirect(
+  executable: string,
+  args: readonly string[],
+  env: NodeJS.ProcessEnv
+): Promise<DirectResult> {
+  const started = Date.now();
+  return await new Promise((resolvePromise) => {
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const child = spawn(executable, [...args], { env, windowsHide: true });
+    const settle = (partial: Partial<DirectResult>): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(deadline);
+      resolvePromise({
+        command: `${executable} ${args.join(' ')}`,
+        durationMs: Date.now() - started,
+        exitCode: child.exitCode,
+        timedOut: false,
+        stdoutTail: tail(stdout),
+        stderrTail: tail(stderr),
+        ...partial,
+      });
+    };
+    const deadline = setTimeout(() => {
+      child.kill('SIGKILL');
+      settle({ timedOut: true, exitCode: null });
+    }, DIRECT_TIMEOUT_MS);
+    child.stdout?.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+    child.on('error', (error) => {
+      settle({ spawnError: error.message });
+    });
+    child.on('close', (code) => {
+      settle({ exitCode: code });
+    });
+  });
+}
+
+async function main(): Promise<void> {
+  const claudeBinFlagIndex = process.argv.indexOf('--claude-bin');
+  const claudeBin =
+    claudeBinFlagIndex === -1
+      ? undefined
+      : process.argv[claudeBinFlagIndex + 1];
+  // A bare `--claude-bin` with no path must fail loudly, not silently run
+  // as if the flag was never given (Greptile P2, PR #3035).
+  if (claudeBinFlagIndex !== -1 && claudeBin === undefined) {
+    console.error('--claude-bin requires a path argument');
+    process.exit(1);
+  }
+
+  // IDENTICAL env preparation to both the probe and real sessions: the one
+  // shared function (merged login-shell PATH).
+  const env = prepareClaudeCodeSpawnEnvironment();
+
+  // IDENTICAL binary resolution to the probe's fallback scan.
+  const resolvedFallback = findClaudeCodeExecutableFallback({
+    env,
+    platform: process.platform,
+    fileExists: existsSync,
+    homeDir: homedir(),
+  });
+  const directExecutable = claudeBin ?? resolvedFallback;
+
+  console.log('=== W17 claude probe side-by-side diagnostic ===');
+  console.log(`cwd: ${process.cwd()}`);
+  console.log(
+    `resolved user-installed claude: ${resolvedFallback ?? '(none found on PATH or in ~/.local/bin, ~/.claude/local)'}`
+  );
+  console.log(`explicit --claude-bin: ${claudeBin ?? '(not set)'}`);
+  console.log('');
+
+  // --- Side A: direct invocation of the same binary ---
+  console.log('--- A: direct invocation ---');
+  let direct: DirectResult | undefined;
+  if (directExecutable === undefined) {
+    console.log('skipped: no claude executable resolved for a direct run');
+  } else {
+    direct = await runDirect(directExecutable, ['--version'], env);
+    console.log(
+      `direct \`${direct.command}\`: exit=${direct.exitCode} timedOut=${direct.timedOut} in ${direct.durationMs}ms`
+    );
+    if (direct.stdoutTail !== '') {
+      console.log(`  stdout: ${direct.stdoutTail}`);
+    }
+    if (direct.stderrTail !== '') {
+      console.log(`  stderr: ${direct.stderrTail}`);
+    }
+    if (direct.spawnError !== undefined) {
+      console.log(`  spawn error: ${direct.spawnError}`);
+    }
+  }
+  console.log('');
+
+  // --- Side B: the real SDK startup probe (same code path as the runner) ---
+  console.log(
+    '--- B: SDK startup probe (probeClaudeCodeAvailabilityStatus) ---'
+  );
+  const started = Date.now();
+  const outcome = await probeClaudeCodeAvailabilityStatus({
+    cwd: process.cwd(),
+    claudeBin,
+  });
+  const probeMs = Date.now() - started;
+  console.log(
+    `probe verdict: status=${outcome.status} transient=${outcome.transient} in ${probeMs}ms`
+  );
+  if (outcome.detail !== undefined) {
+    console.log(`probe failure detail (SDK error + child stderr tail):`);
+    console.log(`  ${outcome.detail}`);
+  }
+  console.log('');
+
+  console.log('--- verdict ---');
+  // The verdict branches on side A's ACTUAL result: "both failed" is a
+  // uniformly broken setup, not a probe-vs-direct divergence (Greptile P2,
+  // PR #3035).
+  const directSucceeded =
+    direct !== undefined &&
+    direct.exitCode === 0 &&
+    !direct.timedOut &&
+    direct.spawnError === undefined;
+  if (outcome.status === 'logged_in') {
+    console.log(
+      'probe and direct invocation agree: Claude Code is launchable.'
+    );
+  } else if (directSucceeded) {
+    console.log(
+      'DIVERGENCE: the direct invocation succeeded but the probe failed. The failure detail above is the evidence to attach to the issue.'
+    );
+  } else if (direct !== undefined) {
+    console.log(
+      'both the direct invocation AND the probe failed - a uniformly broken claude setup on this machine, not a probe divergence. Fix the direct invocation first (its stderr/exit code above).'
+    );
+  } else {
+    console.log(
+      'no user-installed claude and the probe failed - see detail above.'
+    );
+  }
+  // Reporter, not a gate.
+  process.exit(0);
+}
+
+void main();