@raidiant/notifai 1.0.1 → 2.0.0

package/src/file-lock.ts

@@ -48,6 +48,19 @@ interface FileIdentity {
   ino: number
 }
 
+/**
+ * Identity for one published lock entry.
+ *
+ * Linux can immediately reuse an inode after an unlinked entry is replaced at
+ * the same path. The creation/change timestamp keeps that replacement distinct
+ * even when its device and inode numbers happen to match the removed entry.
+ */
+interface EntryIdentity {
+  dev: bigint
+  ino: bigint
+  ctimeNs: bigint
+}
+
 interface ChoosingEntry {
   kind: 'choosing'
   name: string
@@ -124,10 +137,22 @@ function assertSameDirectory(directory: string, expected: FileIdentity): void {
   }
 }
 
-function sameIdentity(file: string, expected: FileIdentity): boolean {
+function entryIdentity(stat: { dev: bigint; ino: bigint; ctimeNs: bigint }): EntryIdentity {
+  return {
+    dev: stat.dev,
+    ino: stat.ino,
+    ctimeNs: stat.ctimeNs,
+  }
+}
+
+function sameEntryIdentity(file: string, expected: EntryIdentity): boolean {
   try {
-    const current = lstatSync(file)
-    return current.dev === expected.dev && current.ino === expected.ino
+    const current = lstatSync(file, { bigint: true })
+    return (
+      current.dev === expected.dev &&
+      current.ino === expected.ino &&
+      current.ctimeNs === expected.ctimeNs
+    )
   } catch {
     return false
   }
@@ -173,11 +198,10 @@ function liveEntries(
   return live
 }
 
-function publishEmpty(file: string): FileIdentity {
+function publishEmpty(file: string): EntryIdentity {
   const handle = openSync(file, 'wx', 0o600)
   try {
-    const stat = fstatSync(handle)
-    return { dev: stat.dev, ino: stat.ino }
+    return entryIdentity(fstatSync(handle, { bigint: true }))
   } finally {
     closeSync(handle)
   }
@@ -188,7 +212,7 @@ function publishChoosing(
   name: string,
   deadline: number,
   observe: FileLockOptions['observe'],
-): { file: string; fileIdentity: FileIdentity; directoryIdentity: FileIdentity } {
+): { file: string; fileIdentity: EntryIdentity; directoryIdentity: FileIdentity } {
   const file = path.join(directory, name)
   for (;;) {
     try {
@@ -227,7 +251,7 @@ export function withFileLock<T>(file: string, action: () => T, options: FileLock
   const token = randomBytes(FILE_LOCK_TOKEN_BYTES).toString('hex')
   const choosingName = `choosing-${pid}-${token}`
   let ownedPath: string | null = null
-  let ownedIdentity: FileIdentity | null = null
+  let ownedIdentity: EntryIdentity | null = null
   let directoryIdentity: FileIdentity | null = null
   let operationFailed = false
 
@@ -249,6 +273,7 @@ export function withFileLock<T>(file: string, action: () => T, options: FileLock
     // ticket, never a gap in which a live contender has no published state.
     renameSync(ownedPath, ticketPath)
     ownedPath = ticketPath
+    ownedIdentity = entryIdentity(lstatSync(ticketPath, { bigint: true }))
 
     for (;;) {
       const blockers: string[] = []
@@ -273,7 +298,7 @@ export function withFileLock<T>(file: string, action: () => T, options: FileLock
     let releaseChanged = false
     if (ownedPath !== null && ownedIdentity !== null) {
       try {
-        if (sameIdentity(ownedPath, ownedIdentity)) unlinkSync(ownedPath)
+        if (sameEntryIdentity(ownedPath, ownedIdentity)) unlinkSync(ownedPath)
         else releaseChanged = true
       } catch {
         // External cleanup cannot turn a release failure into a caller failure.

package/src/hook-adapter.test.ts

@@ -14,6 +14,7 @@ import path from 'node:path'
 import { describe, expect, it } from 'vitest'
 import {
   hookAdapterPath,
+  hookAdapterSource,
   inspectHookAdapter,
   installHookAdapter,
   isNpxAdapterTarget,
@@ -227,3 +228,138 @@ describe('stable hook adapter', () => {
     expect(run.stderr).toMatch(/target is stale/)
   })
 })
+
+describe('Windows hook adapter', () => {
+  it('keeps POSIX adapter source bytes identical to the trusted /bin/sh form', () => {
+    const target = {
+      execPath: '/usr/local/bin/node',
+      scriptPath: '/opt/notifai/dist/main.js',
+    }
+    expect(hookAdapterSource(target, 'posix')).toBe(`#!/bin/sh
+# notifai managed hook adapter
+# adapter-version: 1
+# target-exec-json: "/usr/local/bin/node"
+# target-script-json: "/opt/notifai/dist/main.js"
+set -eu
+
+registered_exec='/usr/local/bin/node'
+registered_script='/opt/notifai/dist/main.js'
+
+if [ -x "$registered_exec" ] && [ -f "$registered_script" ]; then
+  exec "$registered_exec" "$registered_script" "$@"
+fi
+
+printf '%s
+' 'Notifai hook adapter target is stale; run notifai hooks install.' >&2
+exit 127
+`)
+  })
+
+  it('generates a JavaScript adapter instead of a shebang script', () => {
+    const { root, homeDir } = isolated()
+    const script = path.join(root, 'target.js')
+    writeFileSync(script, '')
+    const installed = installHookAdapter(
+      { execPath: process.execPath, scriptPath: script },
+      homeDir,
+      'win32',
+    )
+    const source = readFileSync(installed.path, 'utf8')
+
+    expect(source.startsWith('// notifai managed hook adapter\n')).toBe(true)
+    expect(source).not.toContain('#!/bin/sh')
+    expect(source).toContain('require("node:child_process")')
+    expect(source).toContain(JSON.stringify(process.execPath))
+    expect(source).toContain(JSON.stringify(script))
+  })
+
+  it('forwards argv through Node without depending on a shebang or executable bit', () => {
+    const { root, homeDir } = isolated()
+    const script = path.join(root, 'target script.js')
+    writeFileSync(script, 'process.stdout.write(JSON.stringify(process.argv.slice(2)))\n')
+    const runtime = path.join(root, 'node-runtime')
+    writeFileSync(runtime, 'dummy-node')
+    chmodSync(runtime, 0o644)
+
+    const installed = installHookAdapter(
+      { execPath: process.execPath, scriptPath: script },
+      homeDir,
+      'win32',
+    )
+    const run = spawnSync(process.execPath, [installed.path, 'hook', 'stop', '--owner', 'notifai'], {
+      encoding: 'utf8',
+    })
+
+    expect(run.status).toBe(0)
+    expect(JSON.parse(run.stdout)).toEqual(['hook', 'stop', '--owner', 'notifai'])
+    expect(() =>
+      installHookAdapter({ execPath: runtime, scriptPath: script }, homeDir, 'win32'),
+    ).not.toThrow()
+  })
+
+  it('does not treat 0666 as a protection or health failure', () => {
+    const { root, homeDir } = isolated()
+    const script = path.join(root, 'target.js')
+    writeFileSync(script, '')
+    const installed = installHookAdapter(
+      { execPath: process.execPath, scriptPath: script },
+      homeDir,
+      'win32',
+    )
+    chmodSync(installed.path, 0o666)
+
+    expect(inspectHookAdapter(homeDir, 'win32').problems).toEqual([])
+    expect(
+      installHookAdapter({ execPath: process.execPath, scriptPath: script }, homeDir, 'win32'),
+    ).toEqual({ path: installed.path, changed: false })
+  })
+
+  it('fails closed when the registered Windows target vanishes', () => {
+    const { root, homeDir } = isolated()
+    const oldNode = path.join(root, 'old-node')
+    const oldCli = path.join(root, 'old-cli.js')
+    writeFileSync(oldNode, '#!/bin/sh\n')
+    writeFileSync(oldCli, '')
+    const installed = installHookAdapter(
+      { execPath: oldNode, scriptPath: oldCli },
+      homeDir,
+      'win32',
+    )
+    rmSync(oldNode)
+    rmSync(oldCli)
+
+    const inspected = inspectHookAdapter(homeDir, 'win32')
+    expect(inspected.problems).toEqual([
+      `registered runtime ${oldNode} is missing`,
+      `registered CLI ${oldCli} is missing`,
+    ])
+    const run = spawnSync(process.execPath, [installed.path, 'hook', 'stop'], {
+      encoding: 'utf8',
+    })
+    expect(run.status).toBe(127)
+    expect(run.stdout).toBe('')
+    expect(run.stderr).toMatch(/target is stale/)
+  })
+
+  it('retargets the CLI without changing the adapter pathname', () => {
+    const { root, homeDir } = isolated()
+    const first = path.join(root, 'first.js')
+    const second = path.join(root, 'second.js')
+    writeFileSync(first, '')
+    writeFileSync(second, '')
+    const firstInstall = installHookAdapter(
+      { execPath: process.execPath, scriptPath: first },
+      homeDir,
+      'win32',
+    )
+    const secondInstall = installHookAdapter(
+      { execPath: process.execPath, scriptPath: second },
+      homeDir,
+      'win32',
+    )
+    const inspected = inspectHookAdapter(homeDir, 'win32').target
+
+    expect(secondInstall.path).toBe(firstInstall.path)
+    expect(inspected && !isNpxAdapterTarget(inspected) ? inspected.scriptPath : null).toBe(second)
+  })
+})

package/src/hook-adapter.ts

@@ -12,8 +12,11 @@ import { atomicWriteFileSync } from './atomic-file.js'
 import { withTargetFileLock } from './file-lock.js'
 
 const ADAPTER_MARKER = '# notifai managed hook adapter'
+const WIN32_ADAPTER_MARKER = '// notifai managed hook adapter'
 const ADAPTER_VERSION = 1
 
+export type HookHostPlatform = 'posix' | 'win32'
+
 export interface HookAdapterFileTarget {
   kind?: 'file'
   execPath: string
@@ -39,6 +42,12 @@ export interface HookAdapterInspection {
   problems: string[]
 }
 
+export function hookHostPlatform(
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
+): HookHostPlatform {
+  return platform === 'win32' ? 'win32' : 'posix'
+}
+
 /**
  * One user-level identity for every harness and every project/global install.
  *
@@ -57,18 +66,21 @@ export function hookAdapterPath(homeDir: string = os.userInfo().homedir): string
 export function installHookAdapter(
   target: HookAdapterTarget,
   homeDir?: string,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
 ): { path: string; changed: boolean } {
-  assertUsableTarget(target)
+  const host = hookHostPlatform(platform)
+  assertUsableTarget(target, host)
   const file = hookAdapterPath(homeDir)
-  ensureManagedDirectories(homeDir ?? os.userInfo().homedir)
-  const source = hookAdapterSource(target)
+  ensureManagedDirectories(homeDir ?? os.userInfo().homedir, host)
+  const source = hookAdapterSource(target, host)
   return withTargetFileLock(file, () => {
     const existing = existsSync(file) ? readSafeManagedFile(file) : null
-    const changed =
-      existing === null || existing.contents !== source || (existing.mode & 0o777) !== 0o700
+    const modeDrift =
+      host === 'posix' && existing !== null && (existing.mode & 0o777) !== 0o700
+    const changed = existing === null || existing.contents !== source || modeDrift
     if (changed) {
       atomicWriteFileSync(file, source, {
-        mode: 0o700,
+        mode: host === 'posix' ? 0o700 : 0o600,
         preserveMode: false,
         requireCurrentUserOwner: true,
       })
@@ -77,14 +89,14 @@ export function installHookAdapter(
   })
 }
 
-function assertUsableTarget(target: HookAdapterTarget): void {
+function assertUsableTarget(target: HookAdapterTarget, host: HookHostPlatform): void {
   let exec
   try {
     exec = statSync(target.execPath)
   } catch {
     throw new Error(`Hook adapter runtime ${target.execPath} does not exist.`)
   }
-  if (!exec.isFile() || (exec.mode & 0o111) === 0) {
+  if (!exec.isFile() || (host === 'posix' && (exec.mode & 0o111) === 0)) {
     throw new Error(`Hook adapter runtime ${target.execPath} is not executable.`)
   }
   if (isNpxAdapterTarget(target)) {
@@ -114,7 +126,9 @@ function assertUsableTarget(target: HookAdapterTarget): void {
 /** Inspect the shared adapter without executing either it or its registered CLI. */
 export function inspectHookAdapter(
   homeDir?: string,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
 ): HookAdapterInspection {
+  const host = hookHostPlatform(platform)
   const file = hookAdapterPath(homeDir)
   if (!existsSync(file)) {
     return { path: file, target: null, problems: [`${file} is missing; rerun \`notifai hooks install\``] }
@@ -135,19 +149,24 @@ export function inspectHookAdapter(
   }
 
   const problems: string[] = []
-  const uid = typeof process.getuid === 'function' ? process.getuid() : undefined
-  if (uid !== undefined && stat.uid !== uid) {
-    problems.push(`${file} is owned by uid ${stat.uid}, not the current user`)
-  }
-  if ((stat.mode & 0o077) !== 0 || (stat.mode & 0o700) !== 0o700) {
-    problems.push(`${file} permissions are ${(stat.mode & 0o777).toString(8)}, expected 700`)
+  if (host === 'posix') {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : undefined
+    if (uid !== undefined && stat.uid !== uid) {
+      problems.push(`${file} is owned by uid ${stat.uid}, not the current user`)
+    }
+    if ((stat.mode & 0o077) !== 0 || (stat.mode & 0o700) !== 0o700) {
+      problems.push(`${file} permissions are ${(stat.mode & 0o777).toString(8)}, expected 700`)
+    }
   }
 
   const contents = readFileSync(file, 'utf8')
-  if (!contents.startsWith(`#!/bin/sh\n${ADAPTER_MARKER}\n`)) {
+  const format = adapterFormat(contents)
+  if (format === null) {
     problems.push(`${file} has no managed adapter marker`)
+  } else if (format !== host) {
+    problems.push(`${file} is not a ${host} managed adapter; rerun \`notifai hooks install\``)
   }
-  const version = Number(/^# adapter-version: (\d+)$/m.exec(contents)?.[1] ?? Number.NaN)
+  const version = Number(meta(contents, 'adapter-version') ?? Number.NaN)
   if (version !== ADAPTER_VERSION) problems.push(`${file} uses obsolete adapter version ${version}`)
   const target = parseTarget(contents)
   if (target === null) {
@@ -155,7 +174,7 @@ export function inspectHookAdapter(
   } else {
     try {
       const exec = statSync(target.execPath)
-      if (!exec.isFile() || (exec.mode & 0o111) === 0) {
+      if (!exec.isFile() || (host === 'posix' && (exec.mode & 0o111) === 0)) {
         problems.push(`registered runtime ${target.execPath} is not executable`)
       }
     } catch {
@@ -183,7 +202,17 @@ export function inspectHookAdapter(
   return { path: file, target, problems }
 }
 
-function hookAdapterSource(target: HookAdapterTarget): string {
+/** Generate the managed adapter source for one host. Exported so tests can pin bytes. */
+export function hookAdapterSource(
+  target: HookAdapterTarget,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
+): string {
+  return hookHostPlatform(platform) === 'win32'
+    ? win32HookAdapterSource(target)
+    : posixHookAdapterSource(target)
+}
+
+function posixHookAdapterSource(target: HookAdapterTarget): string {
   if (isNpxAdapterTarget(target)) {
     return `#!/bin/sh
 ${ADAPTER_MARKER}
@@ -225,16 +254,77 @@ exit 127
 `
 }
 
+function win32HookAdapterSource(target: HookAdapterTarget): string {
+  const header = isNpxAdapterTarget(target)
+    ? `${WIN32_ADAPTER_MARKER}
+// adapter-version: ${ADAPTER_VERSION}
+// target-kind: npx
+// target-exec-json: ${JSON.stringify(target.execPath)}
+// target-npm-cli-json: ${JSON.stringify(target.npmCli)}
+// target-spec-json: ${JSON.stringify(target.spec)}
+`
+    : `${WIN32_ADAPTER_MARKER}
+// adapter-version: ${ADAPTER_VERSION}
+// target-exec-json: ${JSON.stringify(target.execPath)}
+// target-script-json: ${JSON.stringify(target.scriptPath)}
+`
+  const argv = isNpxAdapterTarget(target)
+    ? `[${JSON.stringify(target.npmCli)}, "exec", "--yes", "--package", ${JSON.stringify(target.spec)}, "--", "notifai", ...process.argv.slice(2)]`
+    : `[${JSON.stringify(target.scriptPath)}, ...process.argv.slice(2)]`
+  const companion = isNpxAdapterTarget(target)
+    ? JSON.stringify(target.npmCli)
+    : JSON.stringify(target.scriptPath)
+  return `${header}"use strict";
+const { spawnSync } = require("node:child_process");
+const { statSync } = require("node:fs");
+const registeredExec = ${JSON.stringify(target.execPath)};
+const registeredCompanion = ${companion};
+
+function isFile(file) {
+  try {
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+if (isFile(registeredExec) && isFile(registeredCompanion)) {
+  const result = spawnSync(registeredExec, ${argv}, {
+    stdio: "inherit",
+    windowsHide: true,
+  });
+  if (result.error) {
+    process.stderr.write("Notifai hook adapter target is stale; run notifai hooks install.\\n");
+    process.exit(127);
+  }
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+process.stderr.write("Notifai hook adapter target is stale; run notifai hooks install.\\n");
+process.exit(127);
+`
+}
+
+function adapterFormat(contents: string): HookHostPlatform | null {
+  if (contents.startsWith(`#!/bin/sh\n${ADAPTER_MARKER}\n`)) return 'posix'
+  if (contents.startsWith(`${WIN32_ADAPTER_MARKER}\n`)) return 'win32'
+  return null
+}
+
+function meta(contents: string, key: string): string | undefined {
+  return new RegExp(`^(?:#|//) ${key}: (.+)$`, 'm').exec(contents)?.[1]
+}
+
 function parseTarget(contents: string): HookAdapterTarget | null {
-  const kind = /^# target-kind: (.+)$/m.exec(contents)?.[1]
-  const exec = /^# target-exec-json: (.+)$/m.exec(contents)?.[1]
+  const kind = meta(contents, 'target-kind')
+  const exec = meta(contents, 'target-exec-json')
   if (exec === undefined) return null
   try {
     const execPath: unknown = JSON.parse(exec)
     if (typeof execPath !== 'string') return null
     if (kind === 'npx') {
-      const npmCliRaw = /^# target-npm-cli-json: (.+)$/m.exec(contents)?.[1]
-      const specRaw = /^# target-spec-json: (.+)$/m.exec(contents)?.[1]
+      const npmCliRaw = meta(contents, 'target-npm-cli-json')
+      const specRaw = meta(contents, 'target-spec-json')
       if (npmCliRaw === undefined || specRaw === undefined) return null
       const npmCli: unknown = JSON.parse(npmCliRaw)
       const spec: unknown = JSON.parse(specRaw)
@@ -242,7 +332,7 @@ function parseTarget(contents: string): HookAdapterTarget | null {
         ? { kind: 'npx', execPath, npmCli, spec }
         : null
     }
-    const script = /^# target-script-json: (.+)$/m.exec(contents)?.[1]
+    const script = meta(contents, 'target-script-json')
     if (script === undefined) return null
     const scriptPath: unknown = JSON.parse(script)
     return typeof scriptPath === 'string' ? { execPath, scriptPath } : null
@@ -255,7 +345,7 @@ function quote(value: string): string {
   return `'${value.replaceAll("'", `'\\''`)}'`
 }
 
-function ensureManagedDirectories(homeDir: string): void {
+function ensureManagedDirectories(homeDir: string, host: HookHostPlatform): void {
   if (!existsSync(homeDir)) mkdirSync(homeDir, { recursive: true, mode: 0o700 })
   for (const dir of [path.join(homeDir, '.notifai'), path.join(homeDir, '.notifai', 'bin')]) {
     if (!existsSync(dir)) mkdirSync(dir, { mode: 0o700 })
@@ -263,11 +353,13 @@ function ensureManagedDirectories(homeDir: string): void {
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
       throw new Error(`${dir} is not a regular directory; refusing to install the hook adapter.`)
     }
-    const uid = typeof process.getuid === 'function' ? process.getuid() : undefined
-    if (uid !== undefined && stat.uid !== uid) {
-      throw new Error(`${dir} is owned by uid ${stat.uid}, not the current user.`)
+    if (host === 'posix') {
+      const uid = typeof process.getuid === 'function' ? process.getuid() : undefined
+      if (uid !== undefined && stat.uid !== uid) {
+        throw new Error(`${dir} is owned by uid ${stat.uid}, not the current user.`)
+      }
+      chmodSync(dir, 0o700)
     }
-    chmodSync(dir, 0o700)
   }
 }