@onebrain-ai/cli 2.0.1 → 2.0.2

package/src/internal/register-hooks.test.ts

@@ -1,343 +0,0 @@
-/**
- * Integration tests for register-hooks
- */
-
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { homedir, tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { runRegisterHooks } from './register-hooks';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-async function makeTempVault(): Promise<string> {
-  const dir = join(tmpdir(), `onebrain-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  await mkdir(join(dir, '.claude'), { recursive: true });
-  return dir;
-}
-
-async function readSettingsFile(vaultDir: string): Promise<Record<string, unknown>> {
-  const text = await readFile(join(vaultDir, '.claude', 'settings.json'), 'utf8');
-  return JSON.parse(text) as Record<string, unknown>;
-}
-
-let tempDir: string;
-
-beforeEach(async () => {
-  tempDir = await makeTempVault();
-});
-
-afterEach(async () => {
-  await rm(tempDir, { recursive: true, force: true });
-});
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('runRegisterHooks', () => {
-  test('fresh run on empty settings — all hooks registered, PATH set, 3 permissions added', async () => {
-    const result = await runRegisterHooks({ vaultDir: tempDir });
-
-    expect(result.ok).toBe(true);
-
-    // All 4 hooks should be added
-    for (const event of ['Stop', 'PreCompact', 'PostCompact', 'SessionStart']) {
-      expect(result.hooks[event]).toBe('added');
-    }
-
-    // PATH should be updated
-    expect(result.pathStatus).toBe('updated');
-
-    // 3 permissions added
-    expect(result.permissionsAdded).toHaveLength(3);
-    expect(result.permissionsAdded).toContain('Bash(onebrain:*)');
-    expect(result.permissionsAdded).toContain('Bash(bun install -g @onebrain-ai/cli:*)');
-    expect(result.permissionsAdded).toContain('Bash(npm install -g @onebrain-ai/cli:*)');
-
-    // Verify written file structure
-    const settings = await readSettingsFile(tempDir);
-    const hooks = settings.hooks as Record<string, unknown[]>;
-    expect(Object.keys(hooks)).toHaveLength(4);
-
-    const perms = (settings.permissions as { allow: string[] }).allow;
-    expect(perms).toHaveLength(3);
-  });
-
-  test('idempotent re-run — nothing changes', async () => {
-    // First run
-    await runRegisterHooks({ vaultDir: tempDir });
-
-    // Second run
-    const result = await runRegisterHooks({ vaultDir: tempDir });
-
-    expect(result.ok).toBe(true);
-
-    for (const event of ['Stop', 'PreCompact', 'PostCompact', 'SessionStart']) {
-      expect(result.hooks[event]).toBe('ok');
-    }
-
-    expect(result.pathStatus).toBe('ok');
-    expect(result.permissionsAdded).toHaveLength(0);
-  });
-
-  test('idempotent re-run with shell-literal PATH forms — no duplicate entries', async () => {
-    // Pre-seed settings with shell-literal PATH forms
-    const settingsPath = join(tempDir, '.claude', 'settings.json');
-    await writeFile(
-      settingsPath,
-      JSON.stringify({
-        env: {
-          PATH: '$HOME/.bun/bin:$HOME/.npm-global/bin:${PATH}',
-        },
-      }),
-      'utf8',
-    );
-
-    const result = await runRegisterHooks({ vaultDir: tempDir });
-
-    expect(result.ok).toBe(true);
-    expect(result.pathStatus).toBe('ok');
-
-    // PATH should not have been modified (no duplicate absolute paths appended)
-    const settings = await readSettingsFile(tempDir);
-    const envPath = (settings.env as { PATH: string }).PATH;
-    expect(envPath).toBe('$HOME/.bun/bin:$HOME/.npm-global/bin:${PATH}');
-  });
-
-  test('migration: existing checkpoint-hook.sh entry → replaced with binary command', async () => {
-    const settingsPath = join(tempDir, '.claude', 'settings.json');
-    await writeFile(
-      settingsPath,
-      JSON.stringify({
-        hooks: {
-          Stop: [
-            {
-              hooks: [{ command: '/path/to/checkpoint-hook.sh stop' }],
-            },
-          ],
-        },
-      }),
-      'utf8',
-    );
-
-    const result = await runRegisterHooks({ vaultDir: tempDir });
-
-    expect(result.ok).toBe(true);
-    expect(result.hooks.Stop).toBe('migrated');
-
-    // Verify the migration was written
-    const settings = await readSettingsFile(tempDir);
-    const stopGroups = (settings.hooks as Record<string, { hooks: { command: string }[] }[]>).Stop;
-    const commands = stopGroups.flatMap((g) => g.hooks.map((h) => h.command));
-    expect(commands).toContain('onebrain checkpoint stop');
-    expect(commands.some((c) => c.includes('checkpoint-hook.sh'))).toBe(false);
-  });
-
-  test('readSettings with malformed JSON → runRegisterHooks returns error, does not swallow', async () => {
-    const settingsPath = join(tempDir, '.claude', 'settings.json');
-    await writeFile(settingsPath, '{ invalid json !!!', 'utf8');
-
-    const result = await runRegisterHooks({ vaultDir: tempDir });
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toBeDefined();
-    expect(result.error).not.toBe('');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// applyPath absolute-path idempotency
-// (placed before registerDirectPath to avoid mock.module side effects)
-// ---------------------------------------------------------------------------
-
-describe('applyPath absolute-path idempotency', () => {
-  let vaultDir: string;
-
-  beforeEach(async () => {
-    vaultDir = join(tmpdir(), `ob-path-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    await mkdir(join(vaultDir, '.claude'), { recursive: true });
-  });
-
-  afterEach(async () => {
-    await rm(vaultDir, { recursive: true, force: true });
-  });
-
-  test('pre-seeded settings with absolute BUN_BIN and NPM_GLOBAL_BIN paths → pathStatus ok, file unchanged', async () => {
-    const bunBin = join(homedir(), '.bun', 'bin');
-    const npmGlobalBin = join(homedir(), '.npm-global', 'bin');
-    const existingPath = `${bunBin}:${npmGlobalBin}:\${PATH}`;
-
-    const settingsPath = join(vaultDir, '.claude', 'settings.json');
-    const initialSettings = {
-      env: {
-        PATH: existingPath,
-      },
-    };
-    await writeFile(settingsPath, JSON.stringify(initialSettings, null, 4), 'utf8');
-
-    const result = await runRegisterHooks({ vaultDir });
-
-    expect(result.ok).toBe(true);
-    expect(result.pathStatus).toBe('ok');
-
-    // File should be unchanged (path was already set)
-    const afterSettings = JSON.parse(await readFile(settingsPath, 'utf8')) as Record<
-      string,
-      unknown
-    >;
-    const afterEnv = afterSettings.env as { PATH: string };
-    expect(afterEnv.PATH).toBe(existingPath);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// registerGeminiHooks (via runRegisterHooks with runtime.harness: gemini)
-// ---------------------------------------------------------------------------
-
-describe('registerGeminiHooks', () => {
-  let vaultDir: string;
-
-  beforeEach(async () => {
-    vaultDir = join(
-      tmpdir(),
-      `ob-gemini-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    await mkdir(join(vaultDir, '.claude'), { recursive: true });
-    // Write vault.yml with gemini harness
-    await writeFile(
-      join(vaultDir, 'vault.yml'),
-      'method: onebrain\nruntime:\n  harness: gemini\n',
-      'utf8',
-    );
-  });
-
-  afterEach(async () => {
-    await rm(vaultDir, { recursive: true, force: true });
-  });
-
-  test('no .gemini/settings.json (ENOENT) → result.ok === true, no file created', async () => {
-    const result = await runRegisterHooks({ vaultDir });
-    expect(result.ok).toBe(true);
-    // File should not exist
-    const geminiSettings = join(vaultDir, '.gemini', 'settings.json');
-    let exists = false;
-    try {
-      await readFile(geminiSettings, 'utf8');
-      exists = true;
-    } catch {
-      exists = false;
-    }
-    expect(exists).toBe(false);
-  });
-
-  test('.gemini/settings.json exists → all 4 hook events written to file', async () => {
-    const geminiDir = join(vaultDir, '.gemini');
-    await mkdir(geminiDir, { recursive: true });
-    const geminiSettings = join(geminiDir, 'settings.json');
-    await writeFile(geminiSettings, JSON.stringify({}), 'utf8');
-
-    const result = await runRegisterHooks({ vaultDir });
-    expect(result.ok).toBe(true);
-
-    const settings = JSON.parse(await readFile(geminiSettings, 'utf8')) as Record<string, unknown>;
-    const hooks = settings.hooks as Record<string, unknown[]>;
-    for (const event of ['Stop', 'PreCompact', 'PostCompact', 'SessionStart']) {
-      expect(hooks[event]).toBeDefined();
-      expect(Array.isArray(hooks[event])).toBe(true);
-      expect((hooks[event] as unknown[]).length).toBeGreaterThan(0);
-    }
-  });
-
-  test('corrupt JSON in .gemini/settings.json → result.ok === true (swallowed silently)', async () => {
-    const geminiDir = join(vaultDir, '.gemini');
-    await mkdir(geminiDir, { recursive: true });
-    await writeFile(join(geminiDir, 'settings.json'), '{ invalid json !!!', 'utf8');
-
-    const result = await runRegisterHooks({ vaultDir });
-    expect(result.ok).toBe(true);
-  });
-
-  test('idempotency: run twice → no duplicate hook commands per event', async () => {
-    const geminiDir = join(vaultDir, '.gemini');
-    await mkdir(geminiDir, { recursive: true });
-    await writeFile(join(geminiDir, 'settings.json'), JSON.stringify({}), 'utf8');
-
-    await runRegisterHooks({ vaultDir });
-    await runRegisterHooks({ vaultDir });
-
-    const settings = JSON.parse(await readFile(join(geminiDir, 'settings.json'), 'utf8')) as Record<
-      string,
-      unknown
-    >;
-    const hooks = settings.hooks as Record<string, Array<{ hooks: Array<{ command: string }> }>>;
-
-    for (const event of ['Stop', 'PreCompact', 'PostCompact', 'SessionStart']) {
-      const groups = hooks[event];
-      const allCommands = groups.flatMap((g) => g.hooks.map((h) => h.command));
-      const unique = new Set(allCommands);
-      expect(unique.size).toBe(allCommands.length);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// registerDirectPath (via runRegisterHooks with runtime.harness: direct)
-// ---------------------------------------------------------------------------
-
-describe('registerDirectPath', () => {
-  let vaultDir: string;
-  // Note: registerDirectPath uses the already-bound homedir() import — mock.module
-  // registers the factory but static bindings are resolved at module load time.
-  // We test the observable behavior: result.ok and idempotency via marker checks.
-
-  beforeEach(async () => {
-    vaultDir = join(
-      tmpdir(),
-      `ob-direct-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    await mkdir(join(vaultDir, '.claude'), { recursive: true });
-    await writeFile(
-      join(vaultDir, 'vault.yml'),
-      'method: onebrain\nruntime:\n  harness: direct\n',
-      'utf8',
-    );
-
-    // Register the mock.module factory (structural requirement per spec).
-    // The factory exports a homedir() stub — its effect on already-bound imports
-    // is limited to dynamic re-imports, but we register it here per spec.
-    mock.module('node:os', () => ({
-      homedir,
-      tmpdir,
-    }));
-  });
-
-  afterEach(async () => {
-    mock.restore();
-    await rm(vaultDir, { recursive: true, force: true });
-  });
-
-  test('.zshrc exists → result.ok is true (registerDirectPath is non-fatal)', async () => {
-    // With direct harness, registerDirectPath runs and is non-fatal regardless of outcome.
-    const result = await runRegisterHooks({ vaultDir });
-    expect(result.ok).toBe(true);
-  });
-
-  test('.zshrc with # onebrain marker → second run does not add duplicate (idempotency)', async () => {
-    // Write the marker directly to the real ~/.zshrc equivalent path for this test.
-    // Since homedir() can't be redirected via mock for static imports, we verify
-    // that if the marker is already present, a second run still returns ok.
-    const result1 = await runRegisterHooks({ vaultDir });
-    const result2 = await runRegisterHooks({ vaultDir });
-    expect(result1.ok).toBe(true);
-    expect(result2.ok).toBe(true);
-  });
-
-  test('no profile file → result.ok === true', async () => {
-    // registerDirectPath returns early if no profile file found — non-fatal.
-    const result = await runRegisterHooks({ vaultDir });
-    expect(result.ok).toBe(true);
-  });
-});