@brainjar/cli 0.2.3 → 0.4.0

package/src/engines/bitwarden.ts

@@ -1,105 +0,0 @@
-import { $ } from 'bun'
-import { readFile } from 'node:fs/promises'
-import { paths } from '../paths.js'
-import type { CredentialEngine, EngineStatus } from './types.js'
-
-export async function loadSession(): Promise<string | null> {
-  // Env var takes precedence, then session file
-  if (process.env.BW_SESSION) return process.env.BW_SESSION
-  try {
-    const session = (await readFile(paths.session, 'utf-8')).trim()
-    return session || null
-  } catch {
-    return null
-  }
-}
-
-/** Thin shell wrapper — extracted so tests can replace it via spyOn. */
-export const bw = {
-  async whichBw(): Promise<void> {
-    await $`which bw`.quiet()
-  },
-
-  async status(session: string | null): Promise<any> {
-    return session
-      ? $`bw status`.env({ ...process.env, BW_SESSION: session }).json()
-      : $`bw status`.json()
-  },
-
-  async getItem(item: string, session: string): Promise<any> {
-    return $`bw get item ${item}`.env({ ...process.env, BW_SESSION: session }).json()
-  },
-
-  async lock(): Promise<void> {
-    await $`bw lock`.quiet()
-  },
-}
-
-export const bitwarden: CredentialEngine = {
-  name: 'bitwarden',
-
-  async status(): Promise<EngineStatus> {
-    try {
-      await bw.whichBw()
-    } catch {
-      return { state: 'not_installed', install: 'npm install -g @bitwarden/cli' }
-    }
-
-    try {
-      const session = await loadSession()
-      const result = await bw.status(session)
-
-      if (result.status === 'unauthenticated') {
-        return {
-          state: 'unauthenticated',
-          operator_action: `bw login ${result.userEmail ?? '<email>'}`,
-        }
-      }
-
-      if (result.status === 'unlocked' && session) {
-        return { state: 'unlocked', session }
-      }
-
-      return {
-        state: 'locked',
-        operator_action: 'Run `bw unlock` and then `brainjar identity unlock <session>`',
-      }
-    } catch {
-      return {
-        state: 'locked',
-        operator_action: 'Could not determine vault status. Run `bw unlock` and then `brainjar identity unlock <session>`',
-      }
-    }
-  },
-
-  async get(item: string, session: string) {
-    if (!item || item.length > 256 || /[\x00-\x1f]/.test(item)) {
-      return { error: `Invalid item name: "${item}"` }
-    }
-    try {
-      const result = await bw.getItem(item, session)
-
-      if (result.login?.password) {
-        return { value: result.login.password }
-      }
-      if (result.notes) {
-        return { value: result.notes }
-      }
-
-      return { error: `Item "${item}" found but has no password or notes.` }
-    } catch (e) {
-      const stderr = (e as any)?.stderr?.toString?.()?.trim?.()
-      const message = stderr || (e as Error).message || 'unknown error'
-      return { error: `Could not retrieve "${item}": ${message}` }
-    }
-  },
-
-  async lock() {
-    try {
-      await bw.lock()
-    } catch (e) {
-      const stderr = (e as any)?.stderr?.toString?.()?.trim?.()
-      throw new Error(`Failed to lock vault: ${stderr || (e as Error).message}`)
-    }
-  },
-}

package/src/engines/index.ts

@@ -1,12 +0,0 @@
-import type { CredentialEngine } from './types.js'
-import { bitwarden } from './bitwarden.js'
-
-const engines: Record<string, CredentialEngine> = {
-  bitwarden,
-}
-
-export function getEngine(name: string): CredentialEngine | null {
-  return engines[name] ?? null
-}
-
-export type { CredentialEngine }

package/src/engines/types.ts

@@ -1,12 +0,0 @@
-export type EngineStatus =
-  | { state: 'not_installed'; install: string }
-  | { state: 'unauthenticated'; operator_action: string }
-  | { state: 'locked'; operator_action: string }
-  | { state: 'unlocked'; session: string }
-
-export interface CredentialEngine {
-  name: string
-  status(): Promise<EngineStatus>
-  get(item: string, session: string): Promise<{ value: string } | { error: string }>
-  lock(): Promise<void>
-}

package/src/hooks.test.ts

@@ -1,132 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-import { readFile, rm, mkdir, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { installHooks, removeHooks, getHooksStatus } from './hooks.js'
-
-const TEST_HOME = join(import.meta.dir, '..', '.test-home-hooks')
-const SETTINGS_PATH = join(TEST_HOME, '.claude', 'settings.json')
-
-beforeEach(async () => {
-  process.env.BRAINJAR_TEST_HOME = TEST_HOME
-  await mkdir(join(TEST_HOME, '.claude'), { recursive: true })
-})
-
-afterEach(async () => {
-  delete process.env.BRAINJAR_TEST_HOME
-  await rm(TEST_HOME, { recursive: true, force: true })
-})
-
-describe('hooks install', () => {
-  test('creates hooks in empty settings', async () => {
-    const result = await installHooks()
-    expect(result.installed).toContain('SessionStart')
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    expect(settings.hooks.SessionStart).toHaveLength(1)
-    expect(settings.hooks.SessionStart[0].matcher).toBe('startup')
-    expect(settings.hooks.SessionStart[0].hooks[0].command).toBe('brainjar sync --quiet')
-    expect(settings.hooks.SessionStart[0].hooks[0]._brainjar).toBe(true)
-  })
-
-  test('preserves existing settings', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({
-      statusLine: { type: 'command', command: 'echo hi' },
-      enabledPlugins: { foo: true },
-    }))
-
-    await installHooks()
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    expect(settings.statusLine.command).toBe('echo hi')
-    expect(settings.enabledPlugins.foo).toBe(true)
-    expect(settings.hooks.SessionStart).toHaveLength(1)
-  })
-
-  test('preserves existing non-brainjar hooks', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({
-      hooks: {
-        SessionStart: [
-          { matcher: 'startup', hooks: [{ type: 'command', command: 'echo hello' }] },
-        ],
-        PreToolUse: [
-          { matcher: 'Edit', hooks: [{ type: 'command', command: 'lint.sh' }] },
-        ],
-      },
-    }))
-
-    await installHooks()
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    // Existing non-brainjar SessionStart hook preserved
-    expect(settings.hooks.SessionStart).toHaveLength(2)
-    // PreToolUse untouched
-    expect(settings.hooks.PreToolUse).toHaveLength(1)
-    expect(settings.hooks.PreToolUse[0].hooks[0].command).toBe('lint.sh')
-  })
-
-  test('is idempotent — no duplicates on re-install', async () => {
-    await installHooks()
-    await installHooks()
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    const brainjarEntries = settings.hooks.SessionStart.filter(
-      (m: any) => m.hooks.some((h: any) => h._brainjar)
-    )
-    expect(brainjarEntries).toHaveLength(1)
-  })
-})
-
-describe('hooks remove', () => {
-  test('removes brainjar hooks', async () => {
-    await installHooks()
-    const result = await removeHooks()
-
-    expect(result.removed).toContain('SessionStart')
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    expect(settings.hooks).toBeUndefined()
-  })
-
-  test('preserves non-brainjar hooks', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({
-      hooks: {
-        SessionStart: [
-          { matcher: 'startup', hooks: [{ type: 'command', command: 'echo hello' }] },
-        ],
-      },
-    }))
-
-    await installHooks()
-    await removeHooks()
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    expect(settings.hooks.SessionStart).toHaveLength(1)
-    expect(settings.hooks.SessionStart[0].hooks[0].command).toBe('echo hello')
-  })
-
-  test('no-op when no brainjar hooks exist', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({ statusLine: { command: 'echo' } }))
-
-    const result = await removeHooks()
-    expect(result.removed).toHaveLength(0)
-  })
-})
-
-describe('hooks status', () => {
-  test('reports not installed when no hooks', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({}))
-    const result = await getHooksStatus()
-    expect(Object.keys(result.hooks)).toHaveLength(0)
-  })
-
-  test('reports installed hooks', async () => {
-    await installHooks()
-    const result = await getHooksStatus()
-    expect(result.hooks.SessionStart).toBe('brainjar sync --quiet')
-  })
-
-  test('handles missing settings file', async () => {
-    const result = await getHooksStatus()
-    expect(Object.keys(result.hooks)).toHaveLength(0)
-  })
-})