throughline 0.6.1 → 0.6.3

package/src/portable-spawn-sync.mjs

@@ -0,0 +1,58 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, delimiter, dirname, extname, isAbsolute, join } from 'node:path';
+
+function windowsPath(env) {
+  return Object.entries(env).find(([key]) => key.toLowerCase() === 'path')?.[1] ?? '';
+}
+
+function pairedPowerShellShim(command) {
+  const extension = extname(command).toLowerCase();
+  if (extension !== '.cmd' && extension !== '.bat') return null;
+  const sibling = join(dirname(command), `${basename(command, extension)}.ps1`);
+  return existsSync(sibling) ? sibling : null;
+}
+
+function resolveWindowsCommand(command, env) {
+  const extension = extname(command).toLowerCase();
+  if (isAbsolute(command) || command.includes('\\') || command.includes('/')) {
+    return pairedPowerShellShim(command) ?? command;
+  }
+  for (const directory of windowsPath(env).split(delimiter).filter(Boolean)) {
+    for (const suffix of ['.exe', '.ps1', '.cmd', '.bat', '']) {
+      const candidate = join(directory, `${command}${suffix}`);
+      if (!existsSync(candidate)) continue;
+      return pairedPowerShellShim(candidate) ?? candidate;
+    }
+  }
+  return command;
+}
+
+export function spawnPortableSync(command, args, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const spawnOptions = { ...options };
+  delete spawnOptions.platform;
+  spawnOptions.shell = false;
+
+  if (platform !== 'win32') return spawnSync(command, args, spawnOptions);
+
+  const env = spawnOptions.env ?? process.env;
+  const resolved = resolveWindowsCommand(command, env);
+  const extension = extname(resolved).toLowerCase();
+  if (['.js', '.cjs', '.mjs'].includes(extension)) {
+    return spawnSync(process.execPath, [resolved, ...args], spawnOptions);
+  }
+  if (extension === '.ps1') {
+    return spawnSync('powershell.exe', [
+      '-NoLogo',
+      '-NoProfile',
+      '-NonInteractive',
+      '-ExecutionPolicy',
+      'Bypass',
+      '-File',
+      resolved,
+      ...args,
+    ], spawnOptions);
+  }
+  return spawnSync(resolved, args, spawnOptions);
+}

package/src/portable-spawn-sync.test.mjs

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnPortableSync } from './portable-spawn-sync.mjs';
+
+test('spawnPortableSync: Windows cmd shim preserves argv boundaries and stdin', {
+  skip: process.platform !== 'win32' ? 'Windows cmd shim contract' : undefined,
+}, () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-portable-spawn-'));
+  try {
+    const child = join(dir, 'child.mjs');
+    const command = join(dir, 'child.cmd');
+    const powerShellShim = join(dir, 'child.ps1');
+    writeFileSync(child, `
+process.stdin.setEncoding('utf8');
+let input = '';
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  process.stdout.write(JSON.stringify({ args: process.argv.slice(2), input }));
+});
+`);
+    writeFileSync(command, `@echo off\r\n${JSON.stringify(process.execPath)} ${JSON.stringify(child)} %*\r\n`);
+    writeFileSync(powerShellShim, `& ${JSON.stringify(process.execPath)} ${JSON.stringify(child)} @args\nexit $LASTEXITCODE\n`);
+
+    const result = spawnPortableSync(command, ['review prompt', 'a&b', '100%'], {
+      encoding: 'utf8',
+      input: 'stdin body',
+    });
+
+    assert.equal(result.status, 0, result.stderr || result.error?.message);
+    assert.deepEqual(JSON.parse(result.stdout), {
+      args: ['review prompt', 'a&b', '100%'],
+      input: 'stdin body',
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/prompt-submit.mjs

@@ -32,6 +32,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } fr
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
+import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 
 // Phase 0-5 spike marker (SessionStart の spike-inject.flag とは別)
 const PROMPT_SPIKE_MARKER_PATH = join(homedir(), '.throughline', 'spike-prompt.flag');
@@ -243,6 +244,7 @@ async function maybeRunPromptSpike({ payload, sessionId, projectPath }) {
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   run().catch((err) => {
+    recordRuntimeErrorBestEffort('HOOK_PROMPT_SUBMIT_FAILED');
     const msg = err instanceof Error ? err.message : 'unknown';
     process.stderr.write(`[prompt-submit] error: ${msg}\n`);
     process.exit(1);

package/src/runtime-error-hook.test.mjs

@@ -0,0 +1,106 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defaultFactoryReporterConfigPath, defaultRuntimeErrorStorePath } from './runtime-error-store.mjs';
+import { applyWindowsPrivateAcl } from './windows-acl-test-helper.mjs';
+
+const BIN = fileURLToPath(new URL('../bin/throughline.mjs', import.meta.url));
+
+function createEnabledEnvironment(prefix) {
+  const root = mkdtempSync(join(tmpdir(), prefix));
+  const env = {
+    ...process.env,
+    HOME: root,
+    USERPROFILE: root,
+    LOCALAPPDATA: root,
+    XDG_CONFIG_HOME: join(root, 'config'),
+    XDG_STATE_HOME: join(root, 'state'),
+  };
+  const configPath = defaultFactoryReporterConfigPath(env);
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify({
+    schema_version: '1.0',
+    host: { id: 'test-host', profile: process.platform === 'win32' ? 'windows-native' : 'mac' },
+    collection: { enabled: true },
+    reporting: { enabled: false },
+  }));
+  applyWindowsPrivateAcl(configPath);
+  return { root, env };
+}
+
+test('top-level hook owners record one fixed aggregate per failure without replacing hook failure', () => {
+  const { env } = createEnabledEnvironment('throughline-runtime-hook-');
+  const cases = [
+    ['session-start'],
+    ['prompt-submit'],
+    ['process-turn'],
+    ['codex-hook', 'stop'],
+  ];
+  for (const args of cases) {
+    const result = spawnSync(process.execPath, [BIN, ...args], {
+      env,
+      input: '{invalid-json',
+      encoding: 'utf8',
+    });
+    assert.notEqual(result.status, 0, args.join(' '));
+    assert.notEqual(result.stderr, '', args.join(' '));
+    assert.doesNotMatch(result.stderr, /store_unavailable/);
+  }
+
+  const storePath = defaultRuntimeErrorStorePath(env);
+  let store = JSON.parse(readFileSync(storePath, 'utf8'));
+  assert.equal(store.records.length, 4);
+  assert.deepEqual(store.records.map((record) => record.error_code).sort(), [
+    'HOOK_CODEX_FAILED',
+    'HOOK_PROCESS_TURN_FAILED',
+    'HOOK_PROMPT_SUBMIT_FAILED',
+    'HOOK_SESSION_START_FAILED',
+  ]);
+  assert.ok(store.records.every((record) => record.count === 1));
+
+  spawnSync(process.execPath, [BIN, 'process-turn'], {
+    env,
+    input: '{invalid-json',
+    encoding: 'utf8',
+  });
+  store = JSON.parse(readFileSync(storePath, 'utf8'));
+  assert.equal(store.records.find((record) => record.error_code === 'HOOK_PROCESS_TURN_FAILED').count, 2);
+});
+
+test('store failure preserves product failure and emits only fixed storage diagnostic', () => {
+  const { env } = createEnabledEnvironment('throughline-runtime-hook-store-fail-');
+  const storePath = defaultRuntimeErrorStorePath(env);
+  mkdirSync(dirname(storePath), { recursive: true });
+  writeFileSync(storePath, '{broken');
+
+  const result = spawnSync(process.execPath, [BIN, 'prompt-submit'], {
+    env,
+    input: '{invalid-json',
+    encoding: 'utf8',
+  });
+  assert.notEqual(result.status, 0);
+  assert.match(result.stderr, /store_unavailable/);
+  assert.match(result.stderr, /SyntaxError|JSON/);
+  assert.doesNotMatch(result.stderr, /runtime error store schema invalid/);
+});
+
+test('FIFO config cannot block the original hook failure', { skip: process.platform === 'win32' }, () => {
+  const { env } = createEnabledEnvironment('throughline-runtime-hook-fifo-');
+  const config = defaultFactoryReporterConfigPath(env);
+  execFileSync('rm', ['-f', config]);
+  execFileSync('mkfifo', [config]);
+  const started = Date.now();
+  const result = spawnSync(process.execPath, [BIN, 'prompt-submit'], {
+    env,
+    input: '{invalid-json',
+    encoding: 'utf8',
+    timeout: 2_000,
+  });
+  assert.notEqual(result.status, 0);
+  assert(Date.now() - started < 1_500);
+  assert.match(result.stderr, /SyntaxError|JSON/);
+});

package/src/runtime-error-observer.mjs

@@ -0,0 +1,8 @@
+import { observeRuntimeError } from './runtime-error-store.mjs';
+
+try {
+  const result = observeRuntimeError({ code: process.argv[2] });
+  process.exitCode = result.status === 'disabled' ? 3 : 0;
+} catch {
+  process.exitCode = 1;
+}