@onebrain-ai/cli 2.0.1 → 2.0.3

package/src/internal/session-init.test.ts

@@ -1,318 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, spyOn } from 'bun:test';
-import { mkdtemp, rm, stat, utimes, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-// We test the runSessionInit function which returns the payload rather than printing it,
-// so we can assert against the returned value in tests.
-import { formatDatetime, resolveSessionToken, runSessionInit } from './session-init.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-async function makeTmpDir(): Promise<string> {
-  return mkdtemp(join(tmpdir(), 'onebrain-si-test-'));
-}
-
-/** Set process.ppid (read-only property) for testing. Returns the original value. */
-function setPpid(value: number): number {
-  const original = process.ppid;
-  Object.defineProperty(process, 'ppid', { value, configurable: true });
-  return original;
-}
-
-/** Restore process.ppid to its original value. */
-function restorePpid(original: number): void {
-  Object.defineProperty(process, 'ppid', { value: original, configurable: true });
-}
-
-const VALID_VAULT_YML = `
-method: onebrain
-update_channel: stable
-folders:
-  inbox: 00-inbox
-  logs: 07-logs
-`.trim();
-
-const MALFORMED_YAML = `
-folders: [
-  - broken: yaml
-`.trim();
-
-// ---------------------------------------------------------------------------
-// formatDatetime
-// ---------------------------------------------------------------------------
-
-describe('formatDatetime', () => {
-  it('formats a date as "Ddd · DD Mon YYYY · HH:MM"', () => {
-    // 2026-04-23 18:04 Thursday
-    const d = new Date('2026-04-23T18:04:00');
-    const result = formatDatetime(d);
-    // Should match pattern like "Thu · 23 Apr 2026 · 18:04"
-    expect(result).toMatch(/^[A-Z][a-z]{2} · \d{2} [A-Z][a-z]{2} \d{4} · \d{2}:\d{2}$/);
-  });
-
-  it('zero-pads day and hour', () => {
-    // 2026-01-03 09:05 Saturday
-    const d = new Date('2026-01-03T09:05:00');
-    const result = formatDatetime(d);
-    expect(result).toContain('· 03 Jan 2026 ·');
-    expect(result).toContain('· 09:05');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveSessionToken
-// ---------------------------------------------------------------------------
-
-describe('resolveSessionToken', () => {
-  let originalEnv: NodeJS.ProcessEnv;
-  let originalPpid: number;
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    originalEnv = { ...process.env };
-    originalPpid = process.ppid;
-    tmpDir = await makeTmpDir();
-  });
-
-  afterEach(async () => {
-    process.env = originalEnv;
-    restorePpid(originalPpid);
-    await rm(tmpDir, { recursive: true, force: true });
-  });
-
-  it('uses PPID when > 1', async () => {
-    process.env.WT_SESSION = undefined;
-    setPpid(12345);
-    const token = await resolveSessionToken(tmpDir);
-    expect(token).toBe('12345');
-  });
-
-  it('ignores PPID when = 1', async () => {
-    process.env.WT_SESSION = undefined;
-    setPpid(1);
-    // Should fall through to cache
-    const token = await resolveSessionToken(tmpDir);
-    // Token should be a 5-digit number or numeric string from cache
-    expect(token).toMatch(/^\d+$/);
-  });
-
-  it('prefers WT_SESSION over PPID', async () => {
-    process.env.WT_SESSION = 'abc-123-def-456-ghi';
-    setPpid(99999);
-    const token = await resolveSessionToken(tmpDir);
-    // WT_SESSION stripped to alphanumeric, first 8 chars: 'abc123de'
-    expect(token).toBe('abc123de');
-  });
-
-  it('strips non-alphanumeric from WT_SESSION and takes first 8 chars', async () => {
-    process.env.WT_SESSION = '{a1b2c3d4-e5f6-7890-abcd-ef1234567890}';
-    setPpid(1); // force PPID fallthrough if WT_SESSION somehow fails
-    const token = await resolveSessionToken(tmpDir);
-    expect(token).toBe('a1b2c3d4');
-    expect(token.length).toBe(8);
-  });
-
-  it('reads cached token from day-scoped cache file', async () => {
-    process.env.WT_SESSION = undefined;
-    setPpid(1); // force fallthrough
-    const today = new Date().toISOString().slice(0, 10).replace(/-/g, '');
-    const cacheFile = join(tmpDir, `onebrain-day-${today}.token`);
-    await writeFile(cacheFile, '54321', 'utf8');
-    const token = await resolveSessionToken(tmpDir);
-    expect(token).toBe('54321');
-  });
-
-  it('writes new cache file when none exists', async () => {
-    process.env.WT_SESSION = undefined;
-    setPpid(1); // force fallthrough
-    const token = await resolveSessionToken(tmpDir);
-    // Should be a 5-digit number
-    expect(token).toMatch(/^\d{5}$/);
-    // Cache file should exist
-    const today = new Date().toISOString().slice(0, 10).replace(/-/g, '');
-    const cacheFile = join(tmpDir, `onebrain-day-${today}.token`);
-    const cached = await Bun.file(cacheFile).text();
-    expect(cached.trim()).toBe(token);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// runSessionInit
-// ---------------------------------------------------------------------------
-
-describe('runSessionInit', () => {
-  let tmpDir: string;
-  let originalEnv: NodeJS.ProcessEnv;
-  let originalPpid: number;
-
-  beforeEach(async () => {
-    originalEnv = { ...process.env };
-    originalPpid = process.ppid;
-    tmpDir = await makeTmpDir();
-    // Ensure predictable token resolution in most tests
-    process.env.WT_SESSION = undefined;
-    setPpid(77777);
-  });
-
-  afterEach(async () => {
-    process.env = originalEnv;
-    restorePpid(originalPpid);
-    await rm(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns block decision when vault.yml is missing', async () => {
-    const result = await runSessionInit(tmpDir, tmpDir);
-    expect(result).toEqual({ decision: 'block', reason: 'onebrain-init-required' });
-  });
-
-  it('returns block decision when vault.yml is malformed YAML', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), MALFORMED_YAML, 'utf8');
-    const result = await runSessionInit(tmpDir, tmpDir);
-    expect(result).toEqual({ decision: 'block', reason: 'onebrain-init-required' });
-  });
-
-  it('returns normal payload when vault.yml is present and valid', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-    const result = await runSessionInit(tmpDir, tmpDir);
-    expect(result).toHaveProperty('datetime');
-    expect(result).toHaveProperty('session_token');
-    expect(result).toHaveProperty('qmd_unembedded', 0);
-    // Datetime format check
-    expect((result as Record<string, unknown>).datetime).toMatch(
-      /^[A-Z][a-z]{2} · \d{2} [A-Z][a-z]{2} \d{4} · \d{2}:\d{2}$/,
-    );
-  });
-
-  it('uses PPID as session_token', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-    setPpid(42001);
-    const result = (await runSessionInit(tmpDir, tmpDir)) as Record<string, unknown>;
-    expect(result.session_token).toBe('42001');
-  });
-
-  it('qmd_unembedded is 0 when qmd is not in PATH / errors', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-    const result = (await runSessionInit(tmpDir, tmpDir)) as Record<string, unknown>;
-    // qmd is not expected to be installed in test env
-    expect(result.qmd_unembedded).toBe(0);
-  });
-
-  // Update snapshots: bun test --update-snapshots
-  it('normal payload output shape matches snapshot', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-    setPpid(55555);
-    const result = (await runSessionInit(tmpDir, tmpDir)) as Record<string, unknown>;
-
-    // Lock the exact field names of the SessionInitPayload shape.
-    // The values are dynamic (datetime, session_token vary), so we assert structure only.
-    expect(Object.keys(result).sort()).toMatchSnapshot();
-    expect(typeof result.datetime).toMatchSnapshot();
-    expect(typeof result.session_token).toMatchSnapshot();
-    expect(typeof result.qmd_unembedded).toMatchSnapshot();
-  });
-
-  it('cleanStaleStateFile — no state file → resolves normally with payload', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-    // No state file exists in tmpDir
-    const result = await runSessionInit(tmpDir, tmpDir);
-    expect(result).toHaveProperty('datetime');
-    expect(result).toHaveProperty('session_token');
-  });
-
-  it('cleanStaleStateFile — fresh mtime → file NOT deleted (still exists after stat)', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-    // Create a state file with a fresh mtime (just written = after process start)
-    const stateFile = join(tmpDir, 'onebrain-77777.state');
-    await writeFile(stateFile, '1:0:00', 'utf8');
-    // Fresh file should NOT be deleted
-    await runSessionInit(tmpDir, tmpDir);
-    // File should still exist (mtime is fresh, after process start)
-    const s = await stat(stateFile);
-    expect(s).toBeDefined();
-  });
-
-  it('cleanStaleStateFile — stale mtime (utimes sets to epoch 0) → file deleted', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-    const stateFile = join(tmpDir, 'onebrain-77777.state');
-    await writeFile(stateFile, '1:0:00', 'utf8');
-    // Set mtime to epoch (far in the past) — definitely before process start
-    await utimes(stateFile, 0, 0);
-    // Run session init — stale file should be cleaned up
-    await runSessionInit(tmpDir, tmpDir);
-    // File should be gone
-    await expect(stat(stateFile)).rejects.toThrow();
-  });
-
-  it('cleanStaleStateFile — EACCES from Bun.file().stat() → caught silently, result still has datetime', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-    // Spy on Bun.file to simulate stat() throwing EACCES
-    const originalBunFile = Bun.file.bind(Bun);
-    const bunFileSpy = spyOn(Bun, 'file').mockImplementation((path: unknown) => {
-      const f = originalBunFile(path as string);
-      if (typeof path === 'string' && path.endsWith('.state')) {
-        return {
-          ...f,
-          exists: async () => true,
-          stat: async () => {
-            const err = new Error('Permission denied') as NodeJS.ErrnoException;
-            err.code = 'EACCES';
-            throw err;
-          },
-          text: f.text.bind(f),
-        } as unknown as ReturnType<typeof Bun.file>;
-      }
-      return f;
-    });
-
-    try {
-      const result = await runSessionInit(tmpDir, tmpDir);
-      expect(result).toHaveProperty('datetime');
-    } finally {
-      bunFileSpy.mockRestore();
-    }
-  });
-
-  it('qmd_unembedded reflects unembedded count from qmd status --json', async () => {
-    await writeFile(join(tmpDir, 'vault.yml'), VALID_VAULT_YML, 'utf8');
-
-    const qmdJson = JSON.stringify({ unembedded: 5 });
-    const encoded = new TextEncoder().encode(qmdJson);
-
-    // Build a minimal fake subprocess: exited resolves to 0, stdout is readable
-    const fakeStdout = new ReadableStream<Uint8Array>({
-      start(controller) {
-        controller.enqueue(encoded);
-        controller.close();
-      },
-    });
-
-    const fakeProc = {
-      exited: Promise.resolve(0),
-      stdout: fakeStdout,
-      stderr: new ReadableStream({
-        start(c) {
-          c.close();
-        },
-      }),
-      kill: () => {},
-    };
-
-    const spawnSpy = spyOn(Bun, 'spawn').mockImplementation((cmd: unknown) => {
-      if (Array.isArray(cmd) && cmd[0] === 'qmd') {
-        return fakeProc as unknown as ReturnType<typeof Bun.spawn>;
-      }
-      // PowerShell or other spawns — throw so they fall through gracefully
-      throw new Error('not on Windows');
-    });
-
-    try {
-      const result = (await runSessionInit(tmpDir, tmpDir)) as Record<string, unknown>;
-      expect(result.qmd_unembedded).toBe(5);
-    } finally {
-      spawnSpy.mockRestore();
-    }
-  });
-});

package/src/internal/session-init.ts

@@ -1,264 +0,0 @@
-/**
- * session-init — internal command
- *
- * Outputs JSON to stdout with session token, datetime, and qmd_unembedded.
- * If vault.yml is missing or invalid, outputs a block decision JSON.
- *
- * Exit code is always 0 (never crashes Claude Code).
- */
-
-import { unlink } from 'node:fs/promises';
-import { tmpdir as osTmpdir } from 'node:os';
-import { join } from 'node:path';
-import { loadVaultConfig } from '@onebrain/core';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type SessionInitPayload = {
-  datetime: string;
-  session_token: string;
-  qmd_unembedded: number;
-};
-
-export type SessionInitBlock = {
-  decision: 'block';
-  reason: 'onebrain-init-required';
-};
-
-export type SessionInitResult = SessionInitPayload | SessionInitBlock;
-
-// ---------------------------------------------------------------------------
-// formatDatetime
-// ---------------------------------------------------------------------------
-
-const DAY_NAMES = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
-const MONTH_NAMES = [
-  'Jan',
-  'Feb',
-  'Mar',
-  'Apr',
-  'May',
-  'Jun',
-  'Jul',
-  'Aug',
-  'Sep',
-  'Oct',
-  'Nov',
-  'Dec',
-];
-
-/**
- * Format a Date as "Ddd · DD Mon YYYY · HH:MM" (24h, zero-padded).
- * Example: "Thu · 23 Apr 2026 · 18:04"
- */
-export function formatDatetime(date: Date): string {
-  const dow = DAY_NAMES[date.getDay()];
-  const day = String(date.getDate()).padStart(2, '0');
-  const mon = MONTH_NAMES[date.getMonth()];
-  const year = date.getFullYear();
-  const hh = String(date.getHours()).padStart(2, '0');
-  const mm = String(date.getMinutes()).padStart(2, '0');
-  return `${dow} · ${day} ${mon} ${year} · ${hh}:${mm}`;
-}
-
-// ---------------------------------------------------------------------------
-// resolveSessionToken
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve session token using priority order:
- * 1. WT_SESSION env var (strip non-alphanumeric, first 8 chars)
- * 2. process.ppid if > 1
- * 3. PowerShell parent PID (Windows fallback — not tested on Mac)
- * 4. Day-scoped cache file: $tmpDir/onebrain-day-YYYYMMDD.token
- */
-export async function resolveSessionToken(tmpDir: string = osTmpdir()): Promise<string> {
-  // 1. WT_SESSION
-  const wtSession = process.env.WT_SESSION;
-  if (wtSession) {
-    const stripped = wtSession.replace(/[^a-zA-Z0-9]/g, '').slice(0, 8);
-    if (stripped.length > 0) return stripped;
-  }
-
-  // 2. PPID
-  const ppid = process.ppid;
-  if (ppid !== undefined && ppid > 1) return String(ppid);
-
-  // 3. PowerShell fallback (Windows only)
-  try {
-    const ps = Bun.spawn(
-      [
-        'powershell.exe',
-        '-NoProfile',
-        '-NonInteractive',
-        '-Command',
-        '(Get-Process -Id $PID).Parent.Id',
-      ],
-      {
-        stdout: 'pipe',
-        stderr: 'pipe',
-      },
-    );
-    const timeoutMs = 3000;
-    let timerId: ReturnType<typeof setTimeout> | undefined;
-    const race = await Promise.race([
-      ps.exited,
-      new Promise<'timeout'>((resolve) => {
-        timerId = setTimeout(() => resolve('timeout'), timeoutMs);
-      }),
-    ]);
-    if (timerId !== undefined) clearTimeout(timerId);
-    if (race !== 'timeout') {
-      const out = (await new Response(ps.stdout).text()).replace(/\D/g, '').trim();
-      if (out && Number(out) > 1) return out;
-    } else {
-      ps.kill();
-    }
-  } catch {
-    // Not on Windows or powershell.exe not available — fall through
-  }
-
-  // 4. Day-scoped cache
-  const today = new Date();
-  const yyyymmdd = [
-    today.getFullYear(),
-    String(today.getMonth() + 1).padStart(2, '0'),
-    String(today.getDate()).padStart(2, '0'),
-  ].join('');
-  const cacheFile = join(tmpDir, `onebrain-day-${yyyymmdd}.token`);
-
-  const f = Bun.file(cacheFile);
-  const exists = await f.exists();
-  if (exists) {
-    const cached = (await f.text()).trim();
-    const n = Number(cached);
-    if (!Number.isNaN(n) && n > 1) return cached;
-  }
-
-  // Generate and cache a random 5-digit token (10000–99999)
-  const token = String(Math.floor(Math.random() * 90000) + 10000);
-  await Bun.write(cacheFile, token);
-  return token;
-}
-
-// ---------------------------------------------------------------------------
-// cleanStaleStateFile
-// ---------------------------------------------------------------------------
-
-/**
- * Delete $tmpDir/onebrain-{token}.state if it exists and its mtime is before
- * this process started.
- */
-async function cleanStaleStateFile(token: string, tmpDir: string): Promise<void> {
-  try {
-    // Approximate process start time
-    const processStartMs = Date.now() - performance.now();
-    const stateFile = join(tmpDir, `onebrain-${token}.state`);
-    const f = Bun.file(stateFile);
-    const exists = await f.exists();
-    if (!exists) return;
-
-    const { mtime } = await f.stat();
-    const mtimeMs = mtime instanceof Date ? mtime.getTime() : Number(mtime) * 1000;
-    if (mtimeMs < processStartMs) {
-      try {
-        await unlink(stateFile);
-      } catch {
-        // Already deleted or never existed — non-fatal
-      }
-    }
-  } catch {
-    // Non-fatal — stale cleanup is best-effort
-  }
-}
-
-// ---------------------------------------------------------------------------
-// queryQmdUnembedded
-// ---------------------------------------------------------------------------
-
-/**
- * Spawn `qmd status --json` and extract the `unembedded` count.
- * Returns 0 on any error, timeout, or missing binary.
- */
-async function queryQmdUnembedded(): Promise<number> {
-  try {
-    const proc = Bun.spawn(['qmd', 'status', '--json'], {
-      stdout: 'pipe',
-      stderr: 'pipe',
-    });
-
-    const timeoutMs = 2000;
-    let timerId: ReturnType<typeof setTimeout> | undefined;
-    const race = await Promise.race([
-      proc.exited,
-      new Promise<'timeout'>((resolve) => {
-        timerId = setTimeout(() => resolve('timeout'), timeoutMs);
-      }),
-    ]);
-    if (timerId !== undefined) clearTimeout(timerId);
-
-    if (race === 'timeout') {
-      proc.kill();
-      return 0;
-    }
-
-    const stdout = await new Response(proc.stdout).text();
-    const parsed = JSON.parse(stdout) as Record<string, unknown>;
-    const unembedded = parsed.unembedded;
-    return typeof unembedded === 'number' ? unembedded : 0;
-  } catch {
-    return 0;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// runSessionInit (testable core)
-// ---------------------------------------------------------------------------
-
-/**
- * Core logic for session-init.
- * @param vaultRoot - root of the vault (where vault.yml lives)
- * @param tmpDir - override tmpdir (for tests)
- * @returns SessionInitResult
- */
-export async function runSessionInit(
-  vaultRoot: string,
-  tmpDir: string = osTmpdir(),
-): Promise<SessionInitResult> {
-  // Validate vault.yml — block if missing or malformed
-  try {
-    await loadVaultConfig(vaultRoot);
-  } catch {
-    return { decision: 'block', reason: 'onebrain-init-required' };
-  }
-
-  // Resolve session token and clean up stale state
-  const sessionToken = await resolveSessionToken(tmpDir);
-  await cleanStaleStateFile(sessionToken, tmpDir);
-
-  // Format datetime
-  const datetime = formatDatetime(new Date());
-
-  // Query qmd
-  const qmdUnembedded = await queryQmdUnembedded();
-
-  return {
-    datetime,
-    session_token: sessionToken,
-    qmd_unembedded: qmdUnembedded,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// CLI entry point
-// ---------------------------------------------------------------------------
-
-/**
- * Run session-init as a CLI command: print JSON to stdout, always exit 0.
- */
-export async function sessionInitCommand(vaultRoot: string): Promise<void> {
-  const result = await runSessionInit(vaultRoot);
-  process.stdout.write(`${JSON.stringify(result)}\n`);
-}