@raidiant/notifai 1.0.1 → 2.0.0

package/src/install-hooks.test.ts

@@ -10,6 +10,7 @@ import {
 } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import { parse as parseToml, stringify as stringifyToml } from 'smol-toml'
 import { describe, expect, it } from 'vitest'
 import { parseChoices } from './send.js'
 import {
@@ -19,7 +20,9 @@ import {
   opencodePluginSource,
   opencodePluginTarget,
 } from './opencode-plugin.js'
+import { hookAdapterPath, installHookAdapter } from './hook-adapter.js'
 import {
+  BLOCKING_STOP_TIMEOUT_SECONDS,
   HARNESSES,
   applyPlan,
   detectHarness,
@@ -33,7 +36,9 @@ import {
   codexTrustKey,
   codexTrustProblems,
   handlerEvent,
+  harnessAccountHome,
   hookCommand,
+  quoteWindowsArg,
   loadSettings,
   mergeHooks,
   removeHooks,
@@ -126,7 +131,7 @@ describe('hook config', () => {
     })
   })
 
-  it('gives Claude Code an asynchronous Stop with an explicit waiter budget', () => {
+  it('gives Claude Code an asynchronous Stop with an explicit waiter budget on POSIX', () => {
     const claude = buildHookConfig({ adapterPath: ADAPTER, harness: 'claude-code' })
 
     // `async: true` is what frees the turn: the handler returns at once and the
@@ -143,6 +148,22 @@ describe('hook config', () => {
     expect(claude['SessionEnd']?.[0]?.hooks[0]?.async).toBeUndefined()
   })
 
+  it('gives Claude Code a blocking Stop continuation on Windows', () => {
+    const options = {
+      adapterPath: 'C:\\Users\\Ada\\.notifai\\bin\\hook-adapter',
+      harness: 'claude-code' as const,
+      platform: 'win32' as const,
+      nodePath: 'C:\\Program Files\\nodejs\\node.exe',
+    }
+    const claude = buildHookConfig(options)
+
+    expect(claude['Stop']?.[0]?.hooks[0]).toEqual({
+      type: 'command',
+      command: hookCommand(options.adapterPath, 'stop', 'claude-code', options),
+      timeout: BLOCKING_STOP_TIMEOUT_SECONDS,
+    })
+  })
+
   it('leaves exactly one handler per event when an old blocking shape is reinstalled over', () => {
     const old = mergeHooks({}, buildHookConfig({ adapterPath: ADAPTER }), SCRIPT)
     const migrated = mergeHooks(
@@ -226,18 +247,37 @@ describe('settings locations', () => {
     )
   })
 
-  it('uses config.toml for Codex, not the legacy hooks.json', () => {
-    expect(settingsFile('codex', false, '/repo', {})).toBe('/repo/.codex/config.toml')
+  it('keeps ambient global settings inside the test account', () => {
+    expect(os.homedir()).toBe(process.env['HOME'])
+    expect(os.homedir()).toBe(process.env['NOTIFAI_TEST_HOME'])
+    expect(settingsFile('claude-code', true, '/repo', {})).toBe(
+      path.join(process.env['HOME']!, '.claude', 'settings.json'),
+    )
     expect(settingsFile('codex', true, '/repo', {})).toBe(
-      path.join(os.homedir(), '.codex', 'config.toml'),
+      path.join(process.env['HOME']!, '.codex', 'hooks.json'),
     )
   })
 
-  it('migrates a leftover Notifai-only hooks.json onto config.toml', () => {
-    const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-migrate-json-'))
+  it('uses the dedicated Codex hooks file for a new layer', () => {
+    expect(settingsFile('codex', false, '/repo', {})).toBe('/repo/.codex/hooks.json')
+    expect(settingsFile('codex', true, '/repo', {})).toBe(
+      path.join(os.homedir(), '.codex', 'hooks.json'),
+    )
+  })
+
+  it('keeps a Notifai-only hooks.json instead of rewriting config.toml', () => {
+    const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-json-'))
     mkdirSync(path.join(repo, '.codex'), { recursive: true })
     applyPlan(path.join(repo, '.codex', 'hooks.json'), { hooks: ours() })
 
+    expect(settingsFile('codex', false, repo, {})).toBe(path.join(repo, '.codex', 'hooks.json'))
+  })
+
+  it('keeps a Notifai-only inline representation so existing trust remains valid', () => {
+    const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-ours-toml-'))
+    mkdirSync(path.join(repo, '.codex'), { recursive: true })
+    applyPlan(path.join(repo, '.codex', 'config.toml'), { hooks: ours() })
+
     expect(settingsFile('codex', false, repo, {})).toBe(path.join(repo, '.codex', 'config.toml'))
   })
 
@@ -282,17 +322,18 @@ describe('settings locations', () => {
 
   it('does not treat the Codex trust store as an inline hook representation', () => {
     const home = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-trust-only-'))
+    mkdirSync(path.join(home, '.codex'), { recursive: true })
     writeFileSync(
-      path.join(home, 'config.toml'),
-      `[hooks.state."${home}/hooks.json:stop:0:0"]\ntrusted_hash = "sha256:abc"\n`,
+      path.join(home, '.codex', 'config.toml'),
+      `[hooks.state."${home}/.codex/hooks.json:stop:0:0"]\ntrusted_hash = "sha256:abc"\n`,
     )
 
-    expect(settingsFile('codex', true, '/repo', { CODEX_HOME: home })).toBe(
-      path.join(home, 'config.toml'),
+    expect(settingsFile('codex', true, '/repo', { HOME: home, CODEX_HOME: path.join(home, '.codex') })).toBe(
+      path.join(home, '.codex', 'hooks.json'),
     )
   })
 
-  it('keeps writing to inline [hooks] when a leftover hooks.json only holds Notifai', () => {
+  it('preserves foreign inline hooks when both representations exist', () => {
     const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-both-'))
     const layer = path.join(repo, '.codex')
     mkdirSync(layer, { recursive: true })
@@ -330,7 +371,7 @@ describe('a Codex install run inside a git worktree', () => {
   it('targets the main repository, which is the file Codex actually reads', () => {
     const { main, worktree } = repoWithWorktree()
 
-    expect(settingsFile('codex', false, worktree, {})).toBe(path.join(main, '.codex', 'config.toml'))
+    expect(settingsFile('codex', false, worktree, {})).toBe(path.join(main, '.codex', 'hooks.json'))
     expect(codexProjectRoot(worktree)).toBe(main)
   })
 
@@ -395,19 +436,13 @@ describe('a Codex install run inside a git worktree', () => {
     )
   })
 
-  it('follows a relocated config home rather than installing where nothing reads', () => {
-    // Orca points CODEX_HOME at a per-account home; writing to ~/.codex there
-    // produced hooks Codex never loaded, and nothing reported a problem.
-    expect(settingsFile('codex', true, '/repo', { CODEX_HOME: '/managed/codex' })).toBe(
-      '/managed/codex/config.toml',
+  it('follows the active harness home for global hook install', () => {
+    expect(settingsFile('codex', true, '/repo', { HOME: '/user', CODEX_HOME: '/managed/codex' })).toBe(
+      '/managed/codex/hooks.json',
     )
     expect(settingsFile('claude-code', true, '/repo', { CLAUDE_CONFIG_DIR: '/managed/claude' })).toBe(
       '/managed/claude/settings.json',
     )
-    // An empty value is not a relocation.
-    expect(settingsFile('codex', true, '/repo', { CODEX_HOME: '' })).toBe(
-      path.join(os.homedir(), '.codex', 'config.toml'),
-    )
   })
 })
 
@@ -560,7 +595,7 @@ describe('finding what is installed', () => {
       ].join('\n'),
     )
 
-    const found = findInstallations(cwd, { CODEX_HOME: path.join(cwd, 'no-codex-here') })
+    const found = findInstallations(cwd, { HOME: path.join(cwd, 'isolated-home') })
     const codex = found.find((installation) => installation.harness === 'codex' && !installation.global)
     expect(codex?.file).toBe(file)
     expect(codex?.handlers.map((handler) => handler.event)).toEqual(['Stop'])
@@ -580,7 +615,7 @@ describe('finding what is installed', () => {
       ),
     )
 
-    const problems = codexRepresentationProblems(cwd, { CODEX_HOME: path.join(cwd, 'no-codex-here') })
+    const problems = codexRepresentationProblems(cwd, { HOME: path.join(cwd, 'isolated-home') })
     expect(problems).toHaveLength(1)
     expect(problems[0]).toContain('loading hooks from both')
     expect(problems[0]).toContain(path.join(layer, 'hooks.json'))
@@ -594,7 +629,7 @@ describe('finding what is installed', () => {
     mkdirSync(path.join(cwd, '.claude'), { recursive: true })
     applyPlan(path.join(cwd, '.claude', 'settings.local.json'), { hooks: ours() })
 
-    const found = findInstallations(cwd, { CODEX_HOME: path.join(cwd, 'no-codex-here') })
+    const found = findInstallations(cwd, { HOME: path.join(cwd, 'isolated-home') })
     const claude = found.find((i) => i.harness === 'claude-code' && !i.global)
 
     expect(claude).toBeDefined()
@@ -615,39 +650,41 @@ describe('finding what is installed', () => {
 
   it('detects when Codex still trusts an older definition of an installed hook', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-trust-'))
-    const codexHome = path.join(cwd, 'codex-home')
+    const home = path.join(cwd, 'home')
+    const env = { HOME: home }
     const hookFile = path.join(cwd, '.codex', 'hooks.json')
     mkdirSync(path.dirname(hookFile), { recursive: true })
     applyPlan(hookFile, { hooks: ours() })
-    const installations = findInstallations(cwd, { CODEX_HOME: codexHome })
+    const installations = findInstallations(cwd, env)
     const codex = installations.find((installation) => installation.harness === 'codex')
     const stop = codex?.handlers.find((handler) => handler.event === 'Stop')
     expect(stop).toBeDefined()
 
-    mkdirSync(codexHome, { recursive: true })
+    const trustFile = path.join(home, '.codex', 'config.toml')
+    mkdirSync(path.dirname(trustFile), { recursive: true })
     writeFileSync(
-      path.join(codexHome, 'config.toml'),
+      trustFile,
       `[hooks.state.${JSON.stringify(codexTrustKey(codex!, stop!))}]\ntrusted_hash = "sha256:obsolete"\n`,
     )
 
-    const stale = codexTrustProblems(installations, { CODEX_HOME: codexHome })
+    const stale = codexTrustProblems(installations, env)
     expect(stale).toHaveLength(3)
     expect(stale).toEqual(expect.arrayContaining([expect.stringMatching(/Stop.*changed.*\/hooks/i)]))
 
     writeFileSync(
-      path.join(codexHome, 'config.toml'),
+      trustFile,
       `[hooks.state.${JSON.stringify(codexTrustKey(codex!, stop!))}]\ntrusted_hash = "${codexHookIdentityHash(stop!)}"\n`,
     )
-    expect(codexTrustProblems(installations, { CODEX_HOME: codexHome })).toEqual([
+    expect(codexTrustProblems(installations, env)).toEqual([
       expect.stringMatching(/UserPromptSubmit.*not trusted.*\/hooks/i),
       expect.stringMatching(/SessionEnd.*not trusted.*\/hooks/i),
     ])
 
     writeFileSync(
-      path.join(codexHome, 'config.toml'),
+      trustFile,
       `[hooks.state.${JSON.stringify(codexTrustKey(codex!, stop!))}]\ntrusted_hash = "${codexHookIdentityHash(stop!)}"\nenabled = false\n`,
     )
-    expect(codexTrustProblems(installations, { CODEX_HOME: codexHome })).toEqual(
+    expect(codexTrustProblems(installations, env)).toEqual(
       expect.arrayContaining([expect.stringMatching(/Stop.*disabled.*\/hooks/i)]),
     )
   })
@@ -843,6 +880,14 @@ describe('detectHarness', () => {
     ])
   })
 
+  it('detects Codex from the active custom CODEX_HOME', () => {
+    const home = mkdtempSync(path.join(os.tmpdir(), 'notifai-detect-home-'))
+    const codexHome = path.join(home, 'managed', 'codex')
+    mkdirSync(codexHome, { recursive: true })
+
+    expect(detectedHarnesses(project(), { HOME: home, CODEX_HOME: codexHome })).toEqual(['codex'])
+  })
+
   it('prefers project evidence over anything installed on the machine', () => {
     // The regression. Machine-global markers used to be OR-ed in per harness,
     // so a developer with several agent tools installed got a candidate for
@@ -865,3 +910,99 @@ describe('detectHarness', () => {
     expect(answer === null || HARNESSES.includes(answer)).toBe(true)
   })
 })
+
+describe('Windows hook commands and discovery', () => {
+  const winNode = 'C:\\Program Files\\nodejs\\node.exe'
+  const winAdapter = 'C:\\Users\\Ada Lovelace\\.notifai\\bin\\hook-adapter'
+  const winOpts = { platform: 'win32' as const, nodePath: winNode }
+
+  it('keeps POSIX command bytes unchanged', () => {
+    expect(hookCommand(ADAPTER, 'stop', undefined, { platform: 'posix' })).toBe(
+      `'${ADAPTER}' hook stop --owner notifai`,
+    )
+    expect(hookCommand(ADAPTER, 'stop', 'codex', { platform: 'posix' })).toBe(
+      `'${ADAPTER}' hook stop --owner notifai --harness codex`,
+    )
+  })
+
+  it('emits a Windows-safe command with no POSIX single quotes', () => {
+    const command = hookCommand(winAdapter, 'stop', 'codex', winOpts)
+    expect(command).toBe(
+      `"${winNode}" "${winAdapter}" hook stop --owner notifai --harness codex`,
+    )
+    expect(command).not.toContain("'")
+    expect(quoteWindowsArg('C:\\ends\\with\\')).toBe('"C:\\ends\\with\\\\"')
+    expect(quoteWindowsArg('say "hi"')).toBe('"say \\"hi\\""')
+  })
+
+  it('round-trips the Windows command through JSON and TOML documents', () => {
+    const command = hookCommand(winAdapter, 'stop', 'cursor', winOpts)
+    expect(JSON.parse(JSON.stringify({ command }))).toEqual({ command })
+    expect(parseToml(stringifyToml({ command }))).toEqual({ command })
+  })
+
+  it('discovers a Windows-quoted installation as the stable adapter', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-win-discover-'))
+    const homeDir = path.join(cwd, 'home')
+    const script = path.join(cwd, 'cli.js')
+    writeFileSync(script, '')
+    installHookAdapter({ execPath: process.execPath, scriptPath: script }, homeDir, 'win32')
+    const adapter = hookAdapterPath(homeDir)
+    mkdirSync(path.join(cwd, '.claude'), { recursive: true })
+    applyPlan(path.join(cwd, '.claude', 'settings.local.json'), {
+      hooks: buildHookConfig({
+        adapterPath: adapter,
+        harness: 'claude-code',
+        platform: 'win32',
+        nodePath: process.execPath,
+      }),
+    })
+
+    const found = findInstallations(
+      cwd,
+      { HOME: homeDir, USERPROFILE: 'C:\\Users\\Ada' },
+      homeDir,
+      'win32',
+    )
+    expect(found).toHaveLength(1)
+    expect(found[0]?.harness).toBe('claude-code')
+    expect(found[0]?.problems ?? []).toEqual([])
+    expect(found[0]?.handlers[0]?.command.startsWith(`${quoteWindowsArg(process.execPath)} `)).toBe(
+      true,
+    )
+  })
+
+  it('prefers a Windows-absolute USERPROFILE over an MSYS HOME', () => {
+    const env = { HOME: '/c/Users/msys', USERPROFILE: 'C:\\Users\\Ada' }
+    expect(harnessAccountHome(env, 'win32')).toBe('C:\\Users\\Ada')
+    expect(settingsFile('cursor', true, '/repo', env, 'win32')).toBe(
+      path.join('C:\\Users\\Ada', '.cursor', 'hooks.json'),
+    )
+    expect(settingsFile('claude-code', true, '/repo', env, 'win32')).toBe(
+      path.join('C:\\Users\\Ada', '.claude', 'settings.json'),
+    )
+    expect(opencodePluginPath(true, '/repo', env, 'win32')).toBe(
+      path.join('C:\\Users\\Ada', '.config', 'opencode', 'plugins', 'notifai.js'),
+    )
+  })
+
+  it('makes OpenCode spawn the adapter through Node on Windows with shell:false', () => {
+    const source = opencodePluginSource({
+      adapterPath: winAdapter,
+      timeoutSeconds: 240,
+      platform: 'win32',
+      nodePath: winNode,
+    })
+    expect(source).toContain(`const NODE = ${JSON.stringify(winNode)}`)
+    expect(source).toContain('spawn(NODE, [ADAPTER, "hook", event, "--owner", "notifai", "--harness", "opencode"]')
+    expect(source).toContain('shell: false')
+    expect(source).toContain('windowsHide: true')
+    expect(source).not.toContain('spawn(ADAPTER,')
+    expect(opencodePluginTarget(source)).toEqual({
+      adapter: winAdapter,
+      current: true,
+      timeoutSeconds: 240,
+      nodePath: winNode,
+    })
+  })
+})