@raidiant/notifai 1.0.0 → 1.1.0

package/src/credentials.ts

@@ -1,6 +1,7 @@
-import { execFileSync } from 'node:child_process'
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { execFileSync, spawnSync } from 'node:child_process'
+import { existsSync, readFileSync, rmSync } from 'node:fs'
 import path from 'node:path'
+import { atomicWriteFileSync } from './atomic-file.js'
 import { globalConfigDir } from './config.js'
 
 export interface MachineCredential {
@@ -18,7 +19,94 @@ export interface CredentialStore {
   describe(): string
 }
 
+export interface RunCommandSpec {
+  command: string
+  args: readonly string[]
+  input: Buffer
+  timeoutMs?: number
+}
+
+export interface RunCommandResult {
+  status: number
+  stdout: Buffer
+}
+
+/** Injected process seam. Production uses `defaultProcessRunner`. */
+export interface ProcessRunner {
+  run(spec: RunCommandSpec): RunCommandResult
+}
+
+export interface CredentialStoreOptions {
+  env?: NodeJS.ProcessEnv
+  platform?: NodeJS.Platform
+  run?: ProcessRunner
+  keychainAvailable?: boolean
+}
+
 const SERVICE = 'io.notifai.cli'
+const DPAPI_FORMAT = 'notifai.dpapi.current-user.v1'
+const DPAPI_ENTROPY = 'io.notifai.cli'
+const DPAPI_TIMEOUT_MS = 15_000
+const DPAPI_FILE = 'credentials.dpapi'
+
+const PROTECT_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  'Add-Type -AssemblyName System.Security',
+  '$in = New-Object System.IO.MemoryStream',
+  '[Console]::OpenStandardInput().CopyTo($in)',
+  `$entropy = [System.Text.Encoding]::UTF8.GetBytes('${DPAPI_ENTROPY}')`,
+  '$protected = [System.Security.Cryptography.ProtectedData]::Protect($in.ToArray(), $entropy, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)',
+  '$bytes = [System.Text.Encoding]::ASCII.GetBytes([Convert]::ToBase64String($protected))',
+  '[Console]::OpenStandardOutput().Write($bytes, 0, $bytes.Length)',
+].join('; ')
+
+const UNPROTECT_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  'Add-Type -AssemblyName System.Security',
+  '$b64 = [System.Text.Encoding]::ASCII.GetString((& { $in = New-Object System.IO.MemoryStream; [Console]::OpenStandardInput().CopyTo($in); $in.ToArray() })).Trim()',
+  '$protected = [Convert]::FromBase64String($b64)',
+  `$entropy = [System.Text.Encoding]::UTF8.GetBytes('${DPAPI_ENTROPY}')`,
+  '$plain = [System.Security.Cryptography.ProtectedData]::Unprotect($protected, $entropy, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)',
+  '[Console]::OpenStandardOutput().Write($plain, 0, $plain.Length)',
+].join('; ')
+
+const PROTECT_ENCODED = encodePowerShell(PROTECT_SCRIPT)
+const UNPROTECT_ENCODED = encodePowerShell(UNPROTECT_SCRIPT)
+
+function encodePowerShell(script: string): string {
+  return Buffer.from(script, 'utf16le').toString('base64')
+}
+
+function powerShellInvocation(encoded: string, env: NodeJS.ProcessEnv): { command: string; args: string[] } {
+  const root = env['SystemRoot'] || env['SYSTEMROOT'] || 'C:\\Windows'
+  return {
+    command: path.win32.join(root, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+    args: ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded],
+  }
+}
+
+/** Which DPAPI operation a process invocation asked for. Args never carry secrets. */
+export function windowsDpapiOperation(args: readonly string[]): 'protect' | 'unprotect' | null {
+  const index = args.indexOf('-EncodedCommand')
+  const encoded = index >= 0 ? args[index + 1] : undefined
+  if (encoded === PROTECT_ENCODED) return 'protect'
+  if (encoded === UNPROTECT_ENCODED) return 'unprotect'
+  return null
+}
+
+export const defaultProcessRunner: ProcessRunner = {
+  run(spec) {
+    const result = spawnSync(spec.command, [...spec.args], {
+      input: spec.input,
+      timeout: spec.timeoutMs ?? DPAPI_TIMEOUT_MS,
+      maxBuffer: 1024 * 1024,
+      windowsHide: true,
+    })
+    const stdout = Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.alloc(0)
+    if (result.error) return { status: 1, stdout: Buffer.alloc(0) }
+    return { status: result.status ?? 1, stdout }
+  },
+}
 
 /** macOS Keychain via the `security` CLI — no native addons (proposal concern). */
 export class KeychainStore implements CredentialStore {
@@ -31,7 +119,7 @@ export class KeychainStore implements CredentialStore {
       )
         .toString()
         .trim()
-      return JSON.parse(raw) as MachineCredential
+      return parseCredentialJson(raw)
     } catch {
       return null
     }
@@ -69,29 +157,43 @@ export class KeychainStore implements CredentialStore {
   }
 }
 
-/** 0600 file fallback for hosts without a keychain. */
+/**
+ * Explicit plaintext file store.
+ *
+ * Default on Linux, where mode 0600 is a real ACL. Also the
+ * `NOTIFAI_CREDENTIALS=file` development and test escape hatch on every
+ * platform. POSIX mode bits are not an NTFS ACL, so this is not a protected
+ * Windows store.
+ */
 export class FileStore implements CredentialStore {
-  constructor(private readonly env: NodeJS.ProcessEnv = process.env) {}
+  private readonly env: NodeJS.ProcessEnv
+  private readonly platform: NodeJS.Platform
+
+  constructor(env: NodeJS.ProcessEnv = process.env, options: CredentialStoreOptions = {}) {
+    this.env = env
+    this.platform = options.platform ?? process.platform
+  }
 
   private filePath(): string {
-    return path.join(globalConfigDir(this.env), 'credentials.json')
+    return path.join(globalConfigDir(this.env, this.platform), 'credentials.json')
   }
 
   load(): MachineCredential | null {
     const file = this.filePath()
     if (!existsSync(file)) return null
     try {
-      return JSON.parse(readFileSync(file, 'utf8')) as MachineCredential
+      return parseCredentialJson(readFileSync(file, 'utf8'))
     } catch {
       return null
     }
   }
 
   save(credential: MachineCredential): void {
-    const file = this.filePath()
-    mkdirSync(path.dirname(file), { recursive: true })
-    writeFileSync(file, `${JSON.stringify(credential, null, 2)}\n`, { mode: 0o600 })
-    chmodSync(file, 0o600)
+    atomicWriteFileSync(this.filePath(), `${JSON.stringify(credential, null, 2)}\n`, {
+      mode: 0o600,
+      preserveMode: false,
+      requireCurrentUserOwner: true,
+    })
   }
 
   clear(): void {
@@ -99,12 +201,157 @@ export class FileStore implements CredentialStore {
   }
 
   describe(): string {
-    return this.filePath()
+    const file = this.filePath()
+    if (this.platform === 'win32') {
+      return `plaintext file ${file} (NOTIFAI_CREDENTIALS=file; POSIX mode bits are not protection on NTFS)`
+    }
+    return `plaintext file ${file} (mode 0600)`
+  }
+}
+
+/**
+ * Windows default: DPAPI CurrentUser via first-party PowerShell.
+ *
+ * The protected blob lives under LOCALAPPDATA, never roaming APPDATA.
+ * Plaintext crosses the process boundary only on stdin/stdout — never as a
+ * command-line argument.
+ */
+export class WindowsDpapiStore implements CredentialStore {
+  private readonly env: NodeJS.ProcessEnv
+  private readonly run: ProcessRunner
+
+  constructor(env: NodeJS.ProcessEnv = process.env, options: CredentialStoreOptions = {}) {
+    this.env = env
+    this.run = options.run ?? defaultProcessRunner
   }
+
+  private filePath(): string | null {
+    const local = this.env['LOCALAPPDATA']
+    if (typeof local !== 'string' || local.trim() === '') return null
+    return path.join(local, 'notifai', DPAPI_FILE)
+  }
+
+  load(): MachineCredential | null {
+    const file = this.filePath()
+    if (file === null || !existsSync(file)) return null
+    let text: string
+    try {
+      text = readFileSync(file, 'utf8')
+    } catch {
+      return null
+    }
+    const blob = parseDpapiEnvelope(text)
+    if (blob === null) return null
+    const plain = this.unprotect(blob)
+    return plain === null ? null : parseCredentialJson(plain)
+  }
+
+  save(credential: MachineCredential): void {
+    const file = this.filePath()
+    if (file === null) {
+      throw new Error('Windows credential store path is not configured (LOCALAPPDATA is missing)')
+    }
+    const blob = this.protect(Buffer.from(JSON.stringify(credential), 'utf8'))
+    atomicWriteFileSync(file, `${JSON.stringify({ format: DPAPI_FORMAT, data: blob })}\n`, {
+      mode: 0o600,
+      preserveMode: false,
+      requireCurrentUserOwner: true,
+    })
+  }
+
+  clear(): void {
+    const file = this.filePath()
+    if (file === null) return
+    rmSync(file, { force: true })
+  }
+
+  describe(): string {
+    const file = this.filePath()
+    if (file === null) return 'Windows DPAPI current-user (LOCALAPPDATA unset)'
+    return `Windows DPAPI current-user (${file})`
+  }
+
+  private protect(plaintext: Buffer): string {
+    const result = this.invoke('protect', plaintext)
+    if (result.status !== 0) {
+      throw new Error('Windows credential protection failed')
+    }
+    const encoded = result.stdout.toString('utf8').trim()
+    if (!isBase64(encoded)) {
+      throw new Error('Windows credential protection failed')
+    }
+    return encoded
+  }
+
+  private unprotect(blob: string): string | null {
+    const result = this.invoke('unprotect', Buffer.from(blob, 'utf8'))
+    if (result.status !== 0) return null
+    const plain = result.stdout.toString('utf8')
+    return plain === '' ? null : plain
+  }
+
+  private invoke(operation: 'protect' | 'unprotect', input: Buffer): RunCommandResult {
+    const encoded = operation === 'protect' ? PROTECT_ENCODED : UNPROTECT_ENCODED
+    const invocation = powerShellInvocation(encoded, this.env)
+    return this.run.run({
+      command: invocation.command,
+      args: invocation.args,
+      input,
+      timeoutMs: DPAPI_TIMEOUT_MS,
+    })
+  }
+}
+
+function parseCredentialJson(raw: string): MachineCredential | null {
+  try {
+    return parseCredential(JSON.parse(raw) as unknown)
+  } catch {
+    return null
+  }
+}
+
+function parseCredential(raw: unknown): MachineCredential | null {
+  if (raw === null || typeof raw !== 'object') return null
+  const value = raw as Record<string, unknown>
+  const machineId = value['machineId']
+  const secret = value['secret']
+  const baseUrl = value['baseUrl']
+  const machineName = value['machineName']
+  if (
+    typeof machineId !== 'string' ||
+    machineId === '' ||
+    typeof secret !== 'string' ||
+    secret === '' ||
+    typeof baseUrl !== 'string' ||
+    baseUrl === '' ||
+    typeof machineName !== 'string' ||
+    machineName === ''
+  ) {
+    return null
+  }
+  return { machineId, secret, baseUrl, machineName }
+}
+
+function parseDpapiEnvelope(text: string): string | null {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(text)
+  } catch {
+    return null
+  }
+  if (parsed === null || typeof parsed !== 'object') return null
+  const value = parsed as Record<string, unknown>
+  if (value['format'] !== DPAPI_FORMAT) return null
+  const data = value['data']
+  if (typeof data !== 'string' || !isBase64(data)) return null
+  return data
+}
+
+function isBase64(value: string): boolean {
+  return value.length > 0 && value.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(value)
 }
 
-function keychainAvailable(): boolean {
-  if (process.platform !== 'darwin') return false
+function keychainProbeSucceeds(): boolean {
   try {
     execFileSync('security', ['help'], { stdio: 'ignore' })
     return true
@@ -113,7 +360,17 @@ function keychainAvailable(): boolean {
   }
 }
 
-export function defaultCredentialStore(env: NodeJS.ProcessEnv = process.env): CredentialStore {
-  if (env['NOTIFAI_CREDENTIALS'] === 'file') return new FileStore(env)
-  return keychainAvailable() ? new KeychainStore() : new FileStore(env)
+export function defaultCredentialStore(
+  env: NodeJS.ProcessEnv = process.env,
+  options: CredentialStoreOptions = {},
+): CredentialStore {
+  const platform = options.platform ?? process.platform
+  if (env['NOTIFAI_CREDENTIALS'] === 'file') return new FileStore(env, { platform })
+  if (platform === 'win32') return new WindowsDpapiStore(env, options)
+  const keychain =
+    options.keychainAvailable !== undefined
+      ? options.keychainAvailable
+      : platform === 'darwin' && keychainProbeSucceeds()
+  if (keychain) return new KeychainStore()
+  return new FileStore(env, { platform })
 }

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)
+  })
+})