throughline 0.6.0 → 0.6.2

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

@@ -0,0 +1,307 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { chmodSync, mkdtempSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import {
+  acknowledgeRuntimeErrors,
+  compactRuntimeErrors,
+  defaultFactoryReporterConfigPath,
+  defaultRuntimeErrorStorePath,
+  getRuntimeErrorDiagnostics,
+  observeRuntimeError,
+  readRuntimeErrorSnapshot,
+  reopenRuntimeError,
+  resolveRuntimeError,
+} from './runtime-error-store.mjs';
+import { applyWindowsPrivateAcl } from './windows-acl-test-helper.mjs';
+
+const TEST_PLATFORM = process.platform === 'win32' ? 'win32' : 'darwin';
+
+function sandbox() {
+  const root = mkdtempSync(join(tmpdir(), 'throughline-runtime-errors-'));
+  const env = {
+    HOME: root,
+    USERPROFILE: root,
+    LOCALAPPDATA: root,
+    XDG_CONFIG_HOME: join(root, 'config'),
+    XDG_STATE_HOME: join(root, 'state'),
+  };
+  const configPath = defaultFactoryReporterConfigPath(env);
+  const storePath = defaultRuntimeErrorStorePath(env);
+  return { root, env, configPath, storePath };
+}
+
+function enableCollection(box, reporting = { enabled: false }) {
+  mkdirSync(dirname(box.configPath), { recursive: true });
+  writeFileSync(box.configPath, JSON.stringify({
+    schema_version: '1.0',
+    host: { id: 'test-host', profile: process.platform === 'win32' ? 'windows-native' : 'mac' },
+    collection: { enabled: true },
+    reporting,
+  }));
+  applyWindowsPrivateAcl(box.configPath);
+}
+
+test('runtime error store: missing/false/malformed config is fail-closed and creates no state', () => {
+  for (const config of [
+    null,
+    { collection: { enabled: true } },
+    { collection: { enabled: false } },
+    { collection: { enabled: 'true' } },
+    '{malformed',
+  ]) {
+    const box = sandbox();
+    if (config !== null) {
+      mkdirSync(dirname(box.configPath), { recursive: true });
+      writeFileSync(box.configPath, typeof config === 'string' ? config : JSON.stringify(config));
+      applyWindowsPrivateAcl(box.configPath);
+    }
+    assert.deepEqual(observeRuntimeError({ code: 'HOOK_PROCESS_TURN_FAILED' }, { env: box.env }), {
+      status: 'disabled',
+    });
+    assert.equal(getRuntimeErrorDiagnostics({ env: box.env }).collection, 'disabled');
+    assert.throws(() => statSync(box.storePath), { code: 'ENOENT' });
+  }
+});
+
+test('runtime error store: Windows native uses the canonical LocalAppData paths', () => {
+  const env = {
+    OS: 'Windows_NT',
+    USERPROFILE: 'C:\\Users\\kite_',
+    LOCALAPPDATA: 'C:\\Users\\kite_\\AppData\\Local',
+  };
+  assert.equal(
+    defaultFactoryReporterConfigPath(env),
+    join(env.LOCALAPPDATA, 'dotagents', 'factory-reporter', 'config.json'),
+  );
+  assert.equal(
+    defaultRuntimeErrorStorePath(env),
+    join(env.LOCALAPPDATA, 'throughline', 'runtime-errors.json'),
+  );
+});
+
+test('runtime error store: reporting config and credentials are ignored and no network API is accepted', () => {
+  const box = sandbox();
+  enableCollection(box, {
+    enabled: true,
+    endpoint: 'https://should-never-be-read.invalid/private',
+    credential_file: process.platform === 'win32' ? 'C:\\private\\token' : '/private/token',
+  });
+  const result = observeRuntimeError(
+    { code: 'HOOK_PROCESS_TURN_FAILED', now: '2026-07-13T00:00:00.000Z' },
+    { env: box.env, version: '0.6.1', platform: TEST_PLATFORM, arch: 'arm64' },
+  );
+  assert.equal(result.status, 'recorded');
+  const bytes = readFileSync(box.storePath, 'utf8');
+  assert.doesNotMatch(bytes, /should-never-be-read|private\/token|endpoint|credential/i);
+});
+
+test('runtime error store: observation API rejects raw or arbitrary fields', () => {
+  const box = sandbox();
+  enableCollection(box);
+  for (const forbidden of [
+    { exception: new Error('secret') },
+    { stderr: 'raw stderr' },
+    { stack: 'raw stack' },
+    { prompt: 'private prompt' },
+    { session: 'session-id' },
+    { path: '/Users/private/file' },
+    { context: { arbitrary: true } },
+  ]) {
+    assert.throws(
+      () => observeRuntimeError({ code: 'HOOK_PROCESS_TURN_FAILED', ...forbidden }, { env: box.env }),
+      /固定 code と時刻だけ/,
+    );
+  }
+  assert.throws(
+    () => observeRuntimeError(
+      { code: 'HOOK_PROCESS_TURN_FAILED' },
+      { env: box.env, stderr: 'raw stderr' },
+    ),
+    /未定義 option/,
+  );
+  assert.throws(
+    () => observeRuntimeError({ code: 'UNKNOWN_FAILURE' }, { env: box.env }),
+    /未登録の runtime error code/,
+  );
+  assert.throws(() => statSync(box.storePath), { code: 'ENOENT' });
+});
+
+test('runtime error store: fixed template SHA-256 fingerprint aggregates and reopens', () => {
+  const box = sandbox();
+  enableCollection(box);
+  const options = { env: box.env, version: '0.6.1', platform: TEST_PLATFORM, arch: 'arm64' };
+  const first = observeRuntimeError(
+    { code: 'HOOK_PROCESS_TURN_FAILED', now: '2026-07-13T00:00:00.000Z' }, options,
+  );
+  const second = observeRuntimeError(
+    { code: 'HOOK_PROCESS_TURN_FAILED', now: '2026-07-13T00:01:00.000Z' }, options,
+  );
+  assert.match(first.fingerprint, /^[0-9a-f]{64}$/);
+  assert.equal(second.fingerprint, first.fingerprint);
+
+  let snapshot = readRuntimeErrorSnapshot({ env: box.env });
+  assert.equal(snapshot.runtime_errors.length, 1);
+  assert.deepEqual(snapshot.runtime_errors[0], {
+    error_code: 'HOOK_PROCESS_TURN_FAILED',
+    component: 'claude_stop_hook',
+    status: 'open',
+    severity: 'high',
+    fingerprint: first.fingerprint,
+    message_template: 'Throughline Claude Stop hook processing failed',
+    occurrence_count: 2,
+    first_seen: '2026-07-13T00:00:00.000Z',
+    last_seen: '2026-07-13T00:01:00.000Z',
+    state_schema_version: '1.0',
+  });
+
+  const resolved = resolveRuntimeError(first.fingerprint, {
+    env: box.env,
+    now: '2026-07-13T00:02:00.000Z',
+  });
+  assert.equal(resolved.status, 'resolved');
+  snapshot = readRuntimeErrorSnapshot({ env: box.env });
+  assert.equal(snapshot.runtime_errors.length, 0);
+  assert.deepEqual(snapshot.resolutions, [{
+    fingerprint: first.fingerprint,
+    resolved_at: '2026-07-13T00:02:00.000Z',
+    reason_code: 'manual',
+  }]);
+  assert.equal(reopenRuntimeError(first.fingerprint, { env: box.env }).status, 'open');
+  assert.equal(readRuntimeErrorSnapshot({ env: box.env }).resolutions.length, 0);
+  resolveRuntimeError(first.fingerprint, { env: box.env, now: '2026-07-13T00:02:30.000Z', reasonCode: 'recovered' });
+
+  observeRuntimeError(
+    { code: 'HOOK_PROCESS_TURN_FAILED', now: '2026-07-13T00:03:00.000Z' }, options,
+  );
+  snapshot = readRuntimeErrorSnapshot({ env: box.env });
+  assert.equal(snapshot.runtime_errors[0].status, 'open');
+  assert.equal(snapshot.runtime_errors[0].occurrence_count, 3);
+  assert.equal(snapshot.runtime_errors[0].last_seen, '2026-07-13T00:03:00.000Z');
+});
+
+test('runtime error store: cursor/ack are monotonic and snapshots are bounded', () => {
+  const box = sandbox();
+  enableCollection(box);
+  const options = { env: box.env, version: '0.6.1' };
+  observeRuntimeError({ code: 'HOOK_PROCESS_TURN_FAILED', now: '2026-07-13T00:00:00.000Z' }, options);
+  observeRuntimeError({ code: 'HOOK_SESSION_START_FAILED', now: '2026-07-13T00:01:00.000Z' }, options);
+  observeRuntimeError({ code: 'HOOK_PROMPT_SUBMIT_FAILED', now: '2026-07-13T00:02:00.000Z' }, options);
+
+  const page = readRuntimeErrorSnapshot({ env: box.env, afterCursor: 0, limit: 2 });
+  assert.equal(page.runtime_errors.length, 2);
+  assert.equal(page.diagnostics.truncated, true);
+  assert.equal(page.cursor.high_watermark, 3);
+  assert.equal(page.cursor.acknowledged_through, 0);
+  assert.equal(acknowledgeRuntimeErrors(2, { env: box.env }).acknowledgedThrough, 2);
+  assert.equal(acknowledgeRuntimeErrors(1, { env: box.env }).acknowledgedThrough, 2);
+  assert.throws(() => acknowledgeRuntimeErrors(999, { env: box.env }), /high watermark/);
+  assert.equal(readRuntimeErrorSnapshot({ env: box.env }).cursor.acknowledged_through, 2);
+});
+
+test('runtime error store: compact removes only acknowledged resolved expired records', () => {
+  const box = sandbox();
+  enableCollection(box);
+  const options = { env: box.env, version: '0.6.1' };
+  const old = observeRuntimeError(
+    { code: 'HOOK_PROCESS_TURN_FAILED', now: '2026-06-01T00:00:00.000Z' }, options,
+  );
+  const pending = observeRuntimeError(
+    { code: 'HOOK_SESSION_START_FAILED', now: '2026-06-01T00:00:00.000Z' }, options,
+  );
+  resolveRuntimeError(old.fingerprint, { env: box.env, now: '2026-06-02T00:00:00.000Z' });
+  resolveRuntimeError(pending.fingerprint, { env: box.env, now: '2026-06-02T00:00:00.000Z' });
+  acknowledgeRuntimeErrors(3, { env: box.env });
+
+  const result = compactRuntimeErrors({
+    env: box.env,
+    now: '2026-07-13T00:00:00.000Z',
+    retentionMs: 30 * 24 * 60 * 60 * 1000,
+  });
+  assert.equal(result.removed, 1);
+  const snapshot = readRuntimeErrorSnapshot({ env: box.env });
+  assert.equal(snapshot.runtime_errors.length, 0);
+  assert.equal(snapshot.resolutions.length, 1);
+  assert.equal(snapshot.resolutions[0].fingerprint, pending.fingerprint);
+});
+
+test('runtime error store: atomic private store has owner-only modes and bounded diagnostics', () => {
+  const box = sandbox();
+  enableCollection(box);
+  observeRuntimeError({ code: 'HOOK_CODEX_FAILED' }, { env: box.env, version: '0.6.1' });
+  if (process.platform !== 'win32') {
+    assert.equal(statSync(dirname(box.storePath)).mode & 0o777, 0o700);
+    assert.equal(statSync(box.storePath).mode & 0o777, 0o600);
+  }
+  assert.doesNotThrow(() => JSON.parse(readFileSync(box.storePath, 'utf8')));
+
+  const diagnostics = getRuntimeErrorDiagnostics({ env: box.env });
+  assert.deepEqual(Object.keys(diagnostics).sort(), [
+    'acknowledged_through', 'collection', 'high_watermark', 'open_count',
+    'pending_count', 'schema', 'status', 'total_count',
+  ]);
+  assert.doesNotMatch(JSON.stringify(diagnostics), /Users|\\|\.throughline|runtime-errors\.json/);
+});
+
+test('runtime error store: non-canonical reporting values keep collection fail-closed', () => {
+  const box = sandbox();
+  enableCollection(box, { enabled: true, endpoint: 'ftp://invalid', credential_file: '' });
+  assert.deepEqual(observeRuntimeError({ code: 'HOOK_CODEX_FAILED' }, { env: box.env }), { status: 'disabled' });
+});
+
+test('runtime error store: unknown top-level fields and future ack are rejected before compaction', () => {
+  const box = sandbox();
+  enableCollection(box);
+  const captured = observeRuntimeError({ code: 'HOOK_CODEX_FAILED', now: '2026-06-01T00:00:00.000Z' }, { env: box.env });
+  resolveRuntimeError(captured.fingerprint, { env: box.env, now: '2026-06-02T00:00:00.000Z' });
+  const store = JSON.parse(readFileSync(box.storePath, 'utf8'));
+  store.secret = '/Users/private Bearer secret-token';
+  store.acknowledged_through = 999;
+  writeFileSync(box.storePath, JSON.stringify(store), { mode: 0o600 });
+  assert.equal(getRuntimeErrorDiagnostics({ env: box.env }).status, 'unavailable');
+  assert.throws(() => compactRuntimeErrors({ env: box.env, now: '2026-07-13T00:00:00.000Z', retentionMs: 0 }));
+});
+
+test('runtime error store: mode drift is unavailable and a crashed SQLite lock owner is released by the OS', { skip: process.platform === 'win32' }, async () => {
+  const box = sandbox();
+  enableCollection(box);
+  observeRuntimeError({ code: 'HOOK_CODEX_FAILED' }, { env: box.env });
+  chmodSync(box.storePath, 0o644);
+  assert.equal(getRuntimeErrorDiagnostics({ env: box.env }).status, 'unavailable');
+  chmodSync(box.storePath, 0o600);
+  const lockPath = `${box.storePath}.lock.sqlite`;
+  const script = `import {DatabaseSync} from 'node:sqlite'; const db=new DatabaseSync(${JSON.stringify(lockPath)}); db.exec('BEGIN IMMEDIATE'); console.log('READY'); setInterval(()=>{},1000);`;
+  const child = spawn(process.execPath, ['--input-type=module', '-e', script], { stdio: ['ignore', 'pipe', 'ignore'] });
+  await new Promise((resolve, reject) => {
+    child.stdout.setEncoding('utf8');
+    child.stdout.once('data', (chunk) => String(chunk).includes('READY') ? resolve() : reject(new Error('lock fixture did not start')));
+    child.once('error', reject);
+  });
+  child.kill('SIGKILL');
+  await new Promise((resolve) => child.once('exit', resolve));
+  assert.equal(observeRuntimeError({ code: 'HOOK_CODEX_FAILED' }, { env: box.env }).status, 'recorded');
+});
+
+test('runtime error store: atomic lock publication preserves all concurrent process observations', {
+  skip: process.platform === 'win32' ? 'SQLite排他はPOSIX matrix、Windowsはnative ACL/store試験で固定' : undefined,
+}, async () => {
+  const box = sandbox();
+  enableCollection(box);
+  const modulePath = new URL('./runtime-error-store.mjs', import.meta.url).href;
+  const script = `import {observeRuntimeError} from ${JSON.stringify(modulePath)}; observeRuntimeError({code:'HOOK_CODEX_FAILED'});`;
+  const results = await Promise.all(Array.from({ length: 20 }, () => new Promise((resolve) => {
+    const child = spawn(process.execPath, ['--input-type=module', '-e', script], {
+      env: { ...process.env, ...box.env }, stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    let stderr = '';
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.once('exit', (code) => resolve({ code, stderr }));
+  })));
+  assert.deepEqual(results, Array.from({ length: 20 }, () => ({ code: 0, stderr: '' })));
+  const snapshot = readRuntimeErrorSnapshot({ env: box.env });
+  assert.equal(snapshot.runtime_errors[0].occurrence_count, 20);
+});

package/src/session-start.mjs

@@ -37,6 +37,7 @@ import { randomBytes } from 'node:crypto';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
+import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 
 // SPIKE ONLY — Phase 0-2 / 0-4 検証用。marker file 削除で無効化される。
 // docs/10_transcript_injection_plan.md §3 Phase 0-2 参照。
@@ -318,6 +319,7 @@ export async function run() {
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   run().catch((err) => {
+    recordRuntimeErrorBestEffort('HOOK_SESSION_START_FAILED');
     process.stderr.write(`[session-start] error: ${err.message}\n`);
     process.exit(1);
   });

package/src/test-env.mjs

@@ -1,4 +1,61 @@
 // Keep tests hermetic when they are run from inside a live Codex session.
 // Individual tests that need these values set them explicitly in child env.
-delete process.env.THROUGHLINE_CODEX_THREAD_ID;
-delete process.env.CODEX_THREAD_ID;
+if (process.env.THROUGHLINE_TEST_ENV_ACTIVE !== '1') {
+  delete process.env.THROUGHLINE_CODEX_THREAD_ID;
+  delete process.env.CODEX_THREAD_ID;
+  process.env.THROUGHLINE_TEST_ENV_ACTIVE = '1';
+}
+
+// node:sqlite emits an ExperimentalWarning on Node 22.  Several CLI tests
+// intentionally assert their child process stderr contract, so suppress the
+// runtime warning for test children without changing production stderr.
+process.env.NODE_NO_WARNINGS = '1';
+
+// Windows cannot execute the POSIX shebang used by the ephemeral fake Codex
+// app-server fixtures.  Run their .mjs bodies with this test runner's Node
+// executable, preserving the command arguments the production code sends.
+import childProcess from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
+
+const { spawn: nativeSpawn, spawnSync: nativeSpawnSync } = childProcess;
+
+function normalizeNodeFixture(command, args = []) {
+  if (process.platform !== 'win32' || typeof command !== 'string' || !Array.isArray(args)) {
+    return [command, args];
+  }
+  if (command.endsWith('.mjs')) return [process.execPath, [command, ...args]];
+  try {
+    const header = readFileSync(command, 'utf8').slice(0, 128);
+    if (/^#!.*\bnode(?:\.exe)?\b/.test(header)) return [process.execPath, [command, ...args]];
+    if (/^#!.*\b(?:ba)?sh\b/.test(header)) return ['bash', [command, ...args]];
+  } catch {
+    // Missing/non-file commands must retain their native spawn error contract.
+  }
+  return [command, args];
+}
+
+childProcess.spawn = function spawn(command, args, options) {
+  const [normalizedCommand, normalizedArgs] = normalizeNodeFixture(command, args);
+  return nativeSpawn(normalizedCommand, normalizedArgs, options);
+};
+
+childProcess.spawnSync = function spawnSync(command, args, options) {
+  const [normalizedCommand, normalizedArgs] = normalizeNodeFixture(command, args);
+  return nativeSpawnSync(normalizedCommand, normalizedArgs, {
+    maxBuffer: 16 * 1024 * 1024,
+    ...options,
+  });
+};
+
+syncBuiltinESMExports();
+
+// CLI tests start nested Node processes which in turn launch the fixture
+// executable.  Carry this test-only adapter into those children on Windows.
+if (process.platform === 'win32') {
+  const importOption = `--import=${import.meta.url}`;
+  const current = process.env.NODE_OPTIONS?.trim() ?? '';
+  if (!current.includes(importOption)) {
+    process.env.NODE_OPTIONS = current ? `${current} ${importOption}` : importOption;
+  }
+}

package/src/turn-backfill.test.mjs

@@ -207,7 +207,7 @@ test('backfillBodies: sidechain entries and missing or empty paths produce no gr
 
 test('deriveTranscriptPath munges slash and dot characters with one leading dash', () => {
   assert.equal(
-    deriveTranscriptPath('/Users/kite/Developer/Through.line', 'session-id'),
-    join(homedir(), '.claude', 'projects', '-Users-kite-Developer-Through-line', 'session-id.jsonl'),
+    deriveTranscriptPath('/Users/example/Developer/Through.line', 'session-id'),
+    join(homedir(), '.claude', 'projects', '-Users-example-Developer-Through-line', 'session-id.jsonl'),
   );
 });

package/src/turn-processor.mjs

@@ -43,6 +43,7 @@ import { summarizeToL1 } from './haiku-summarizer.mjs';
 import { ensureMonitorTaskFile } from './vscode-task.mjs';
 import { readLatestUsage } from './transcript-usage.mjs';
 import { pathToFileURL } from 'node:url';
+import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 
 /** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
 export const L2_WINDOW = 20;
@@ -291,6 +292,7 @@ export async function run() {
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   run().catch((err) => {
+    recordRuntimeErrorBestEffort('HOOK_PROCESS_TURN_FAILED');
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[turn-processor] error: ${msg}\n`);
     process.exit(1);

package/src/windows-acl-test-helper.mjs

@@ -0,0 +1,29 @@
+import { spawnSync } from 'node:child_process';
+
+export function applyWindowsPrivateAcl(path, directory = false) {
+  if (process.platform !== 'win32') return;
+  const script = String.raw`
+$ErrorActionPreference='Stop'
+$target=$env:THROUGHLINE_TEST_ACL_PATH; $isDir=$env:THROUGHLINE_TEST_ACL_DIRECTORY -eq '1'
+$sid=[System.Security.Principal.WindowsIdentity]::GetCurrent().User
+$acl=if($isDir){New-Object System.Security.AccessControl.DirectorySecurity}else{New-Object System.Security.AccessControl.FileSecurity}
+$acl.SetOwner($sid); $acl.SetAccessRuleProtection($true,$false)
+$inherit=if($isDir){[System.Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'}else{[System.Security.AccessControl.InheritanceFlags]::None}
+$rule=New-Object System.Security.AccessControl.FileSystemAccessRule($sid,'FullControl',$inherit,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow)
+$acl.AddAccessRule($rule)
+if($isDir){[System.IO.Directory]::SetAccessControl($target,$acl)}else{[System.IO.File]::SetAccessControl($target,$acl)}
+`;
+  const result = spawnSync('powershell.exe', [
+    '-NoProfile', '-NonInteractive', '-Command', script,
+  ], {
+    encoding: 'utf8',
+    timeout: 3_000,
+    windowsHide: true,
+    env: {
+      ...process.env,
+      THROUGHLINE_TEST_ACL_PATH: path,
+      THROUGHLINE_TEST_ACL_DIRECTORY: directory ? '1' : '0',
+    },
+  });
+  if (result.status !== 0) throw new Error(result.stderr || 'Windows ACL fixture setup failed');
+}