@raidiant/notifai 0.3.0 → 0.4.0

package/src/main.ts

@@ -12,14 +12,17 @@ import {
   configExplainCommand,
   configSetCommand,
   configShowCommand,
+  configUnsetCommand,
   devicesCommand,
   doctorCommand,
+  hookDefersDiagnosticsUntilAfterCleanup,
   hookRunCommand,
   hooksInstallCommand,
   hooksUninstallCommand,
   initCommand,
   loginCommand,
   logoutCommand,
+  logsCommand,
   realIo,
   repliesCommand,
   sendCommand,
@@ -32,42 +35,26 @@ import type { Platform } from '@raidiant/notifai-protocol'
 import { nativeSkills, type SkillScope } from './native-skills.js'
 import { GROUP, SEND_GROUP, helpConfiguration, rootHelpFooter } from './ui/help.js'
 
+import { readStdinWithTimeout } from './hook-input.js'
+import { bootstrapLogger } from './logging.js'
+
+/**
+ * The local record for this invocation.
+ *
+ * Built before the command tree so that the very first thing recorded is the
+ * command starting — including for a command that goes on to fail before it has
+ * resolved anything. It configures itself from disk and disables itself if it
+ * cannot write, so nothing below has to handle it failing.
+ */
+const logger = bootstrapLogger()
+
 const deps: CommandDeps = {
   io: realIo(),
   store: defaultCredentialStore(),
   env: process.env,
   cwd: process.cwd(),
   nativeSkills,
-}
-
-/**
- * Harness hooks deliver their event payload on stdin. Bounded on both time and
- * size: a wrapper that opens the pipe without writing would otherwise hold the
- * read until the harness killed the hook, delaying the user's own prompt.
- */
-async function readStdin(timeoutMs = 2000, maxBytes = 1_000_000): Promise<string> {
-  if (process.stdin.isTTY) return ''
-  return new Promise((resolve) => {
-    const chunks: Buffer[] = []
-    let total = 0
-    let settled = false
-    const finish = (): void => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      process.stdin.destroy()
-      resolve(Buffer.concat(chunks).toString('utf8'))
-    }
-    const timer = setTimeout(finish, timeoutMs)
-    timer.unref?.()
-    process.stdin.on('data', (chunk: Buffer) => {
-      total += chunk.length
-      if (total > maxBytes) return finish()
-      chunks.push(chunk)
-    })
-    process.stdin.on('end', finish)
-    process.stdin.on('error', finish)
-  })
+  logger,
 }
 
 /**
@@ -91,6 +78,39 @@ function version(): string {
   return 'unknown'
 }
 
+/**
+ * The full command path, e.g. `config set`, so a filter on `cmd` distinguishes
+ * subcommands that share a leaf name.
+ */
+function commandPath(command: Command): string {
+  const parts: string[] = []
+  for (let node: Command | null = command; node?.parent != null; node = node.parent) {
+    parts.unshift(node.name())
+  }
+  return parts.join(' ') || 'notifai'
+}
+
+/**
+ * Which flags were passed, without their values.
+ *
+ * The flag names answer nearly every question worth asking of an invocation —
+ * was `--reply` set, was `--all` — while the values are notification content
+ * and user text that has no business being recorded merely because a command
+ * ran. Values are available under `log_level = debug`, which is a deliberate act.
+ */
+function flagNames(argv: readonly string[]): string[] {
+  return argv.filter((token) => token.startsWith('--'))
+}
+
+const startedAt = Date.now()
+process.on('exit', (code) => {
+  logger.info('cli.end', {
+    exit: code,
+    duration_ms: Date.now() - startedAt,
+    flags: flagNames(process.argv.slice(2)),
+  })
+})
+
 const program = new Command('notifai')
   .description('Send native device notifications from agents and local programs')
   .version(version())
@@ -111,6 +131,22 @@ const program = new Command('notifai')
   .helpCommand(true)
   // Where the implicit help command lands; every other command names its own.
   .commandsGroup(GROUP.help)
+  .hook('preAction', (_program, actionCommand) => {
+    logger.bind({ cmd: commandPath(actionCommand) })
+    // SessionEnd uses the hook policy shared with commands.ts: local cleanup
+    // precedes every diagnostic that can wait on the shared log lock.
+    const deferDiagnostics =
+      actionCommand.name() === 'hook' &&
+      hookDefersDiagnosticsUntilAfterCleanup(actionCommand.processedArgs[0])
+    // Values only at `debug`; `cli.end` carries the flag names at every level.
+    if (!deferDiagnostics) {
+      logger.debug('cli.start', {
+        version: version(),
+        argv: process.argv.slice(2),
+        cwd: process.cwd(),
+      })
+    }
+  })
 
 /**
  * Bare `notifai`.
@@ -411,7 +447,7 @@ program
   .action(async (event: string, opts: { harness?: string }) => {
     const harness = HARNESSES.find((candidate) => candidate === opts.harness)
     process.exit(
-      await hookRunCommand(deps, event, readStdin, harness),
+      await hookRunCommand(deps, event, () => readStdinWithTimeout(), harness),
     )
   })
 
@@ -425,7 +461,7 @@ hooks
   .description('Wire this harness to route registered questions to your devices')
   .option(
     '--harness <name>',
-    'claude-code | codex | cursor | opencode (default: detected; OpenCode delivers answers on the next prompt)',
+    'claude-code | codex | cursor | opencode (default: detected)',
   )
   .option('--global', 'install for every project instead of just this one')
   .action((opts: { harness?: string; global?: boolean }) => {
@@ -440,6 +476,34 @@ hooks
     process.exit(hooksUninstallCommand(deps, opts))
   })
 
+program
+  .command('logs')
+  .helpGroup(GROUP.daily)
+  .summary('Show what this machine recorded about what it did')
+  .description(
+    'Read the local record of commands, notifications, and the question decisions harness hooks made. ' +
+      'Bounded and scoped to this project by default; never leaves this machine',
+  )
+  .option('-n, --limit <count>', 'how many records to show (default: 30)', (v: string) => Number(v))
+  .option('--all', 'lift the default limit, up to a hard cap')
+  .option('--since <when>', 'only records newer than this: 10m, 2h, 1d, or an ISO 8601 instant')
+  .option('--level <level>', 'minimum severity: error | info | debug (error shows only failures)')
+  .option('--event <name>', 'only this event; repeatable', (v: string, all: string[]) => [...all, v], [])
+  .option('--run <id>', 'everything one command invocation did')
+  .option('--request <id>', 'everything about one notification request')
+  .option('--session <id>', 'only this harness session')
+  .option('--project <id>', 'only this project')
+  .option('--all-projects', 'do not scope to the project in this directory')
+  .option('--grep <text>', 'only records containing this text')
+  .option('--json', 'one JSON record per line on stdout')
+  .option('--path', 'print the log file paths instead of the records')
+  .option('--clear', 'delete the log files')
+  .action((opts: Record<string, unknown>) => {
+    const flags = { ...opts } as Parameters<typeof logsCommand>[1]
+    if (Array.isArray(flags.event) && flags.event.length === 0) delete flags.event
+    process.exit(logsCommand(deps, flags))
+  })
+
 const config = program
   .command('config')
   .description('Show or change settings')
@@ -479,5 +543,22 @@ config
       process.exit(await configSetCommand(deps, key, value, opts))
     },
   )
+config
+  .command('unset <key>')
+  .description(
+    'Remove a configuration value so the next layer or shipped default applies (choose a layer interactively; unattended defaults machine-global and requires --yes)',
+  )
+  .option('--project', 'remove from the shared .notifai/config.toml instead')
+  .option('--local', 'remove from personal .notifai/config.local.toml')
+  .option('--session <id>', 'remove from one session')
+  .option('--yes', 'skip the confirmation gate')
+  .action(
+    async (
+      key: string,
+      opts: { project?: boolean; local?: boolean; session?: string; yes?: boolean },
+    ) => {
+      process.exit(await configUnsetCommand(deps, key, opts))
+    },
+  )
 
 await program.parseAsync(process.argv)

package/src/opencode-plugin.ts

@@ -30,7 +30,7 @@ export const OPENCODE_PLUGIN_MARKER = '// notifai managed opencode plugin'
 export const OPENCODE_PLUGIN_FILENAME = 'notifai.js'
 
 /** Bump when an installed generated file must be rewritten to remain functional. */
-const OPENCODE_ADAPTER_VERSION = 4
+const OPENCODE_ADAPTER_VERSION = 5
 
 export function opencodePluginDir(
   global: boolean,
@@ -51,8 +51,8 @@ export function opencodePluginPath(
 }
 
 export interface OpencodePluginOptions {
-  execPath: string
-  scriptPath: string
+  /** The same stable user-level adapter every command-hook harness invokes. */
+  adapterPath: string
   /** Child-process lifetime; covers grace, reply wait, and teardown headroom. */
   timeoutSeconds: number
 }
@@ -60,23 +60,23 @@ export interface OpencodePluginOptions {
 /**
  * The generated module.
  *
- * Written as a string rather than compiled from a source file because it has to
- * embed the absolute interpreter and script paths — a bare `notifai` on PATH
- * fails silently under a plugin host the same way it does under a hook shell.
+ * Written as a string rather than compiled from a source file because OpenCode
+ * loads a plugin module rather than a command definition. It embeds only the
+ * stable user-level adapter path; mutable runtime and CLI targets live behind
+ * that adapter exactly as they do for every other harness.
  *
  * Everything it does is build the hook envelope OpenCode's event gives it and
  * hand that to the CLI on stdin. It deliberately fails open: an adapter error
  * never changes OpenCode's own behavior.
  */
 export function opencodePluginSource(options: OpencodePluginOptions): string {
-  const { execPath, scriptPath, timeoutSeconds } = options
+  const { adapterPath, timeoutSeconds } = options
   return `${OPENCODE_PLUGIN_MARKER}
 // Generated by \`notifai hooks install --harness opencode\`. Edits are lost on
 // the next install; change the CLI instead, which is where the logic lives.
 import { spawn } from "node:child_process"
 
-const EXEC = ${JSON.stringify(execPath)}
-const SCRIPT = ${JSON.stringify(scriptPath)}
+const ADAPTER = ${JSON.stringify(adapterPath)}
 const TIMEOUT_MS = ${timeoutSeconds * 1000}
 const ADAPTER_VERSION = ${OPENCODE_ADAPTER_VERSION}
 
@@ -88,7 +88,7 @@ function runHook(event, envelope) {
   return new Promise((resolve) => {
     let child
     try {
-      child = spawn(EXEC, [SCRIPT, "hook", event, "--owner", "notifai", "--harness", "opencode"], {
+      child = spawn(ADAPTER, ["hook", event, "--owner", "notifai", "--harness", "opencode"], {
         env: process.env,
         shell: false,
         stdio: ["pipe", "pipe", "pipe"],
@@ -216,17 +216,16 @@ export function isOurOpencodePlugin(contents: string): boolean {
  */
 export function opencodePluginTarget(
   contents: string,
-): { exec: string; script: string; current: boolean; timeoutSeconds?: number } | null {
+): { adapter: string; current: boolean; timeoutSeconds?: number } | null {
   if (!isOurOpencodePlugin(contents)) return null
-  const exec = /^const EXEC = (".*")$/m.exec(contents)?.[1]
-  const script = /^const SCRIPT = (".*")$/m.exec(contents)?.[1]
+  const adapter = /^const ADAPTER = (".*")$/m.exec(contents)?.[1]
+  const legacyScript = /^const SCRIPT = (".*")$/m.exec(contents)?.[1]
   const version = Number(/^const ADAPTER_VERSION = (\d+)$/m.exec(contents)?.[1] ?? 1)
   const timeoutMs = Number(/^const TIMEOUT_MS = (\d+)$/m.exec(contents)?.[1] ?? Number.NaN)
-  if (exec === undefined || script === undefined) return null
+  if (adapter === undefined && legacyScript === undefined) return null
   try {
     return {
-      exec: JSON.parse(exec) as string,
-      script: JSON.parse(script) as string,
+      adapter: JSON.parse(adapter ?? legacyScript!) as string,
       current: version === OPENCODE_ADAPTER_VERSION,
       ...(Number.isFinite(timeoutMs) ? { timeoutSeconds: timeoutMs / 1000 } : {}),
     }

package/src/session-end-log-lock-worker.test.ts

@@ -0,0 +1,35 @@
+import { existsSync, writeFileSync } from 'node:fs'
+import { describe, expect, it } from 'vitest'
+import { withFileLock } from './file-lock.js'
+
+const workerMode = process.env['NOTIFAI_SESSION_END_LOG_LOCK_WORKER_MODE']
+const sleep = new Int32Array(new SharedArrayBuffer(4))
+
+function waitFor(file: string): void {
+  const deadline = Date.now() + 15_000
+  while (!existsSync(file)) {
+    if (Date.now() >= deadline) throw new Error(`timed out waiting for ${file}`)
+    Atomics.wait(sleep, 0, 0, 2)
+  }
+}
+
+if (workerMode === undefined) {
+  describe('SessionEnd log lock worker', () => {
+    it('stays dormant outside the CLI deadline regression', () => {
+      expect(workerMode).toBeUndefined()
+    })
+  })
+} else {
+  describe('SessionEnd log lock worker', () => {
+    it('holds a live bakery ticket until the parent releases it', () => {
+      withFileLock(
+        process.env['NOTIFAI_SESSION_END_LOG_LOCK_PATH']!,
+        () => {
+          writeFileSync(process.env['NOTIFAI_SESSION_END_LOG_LOCK_READY']!, workerMode)
+          waitFor(process.env['NOTIFAI_SESSION_END_LOG_LOCK_RELEASE']!)
+        },
+        { waitMs: 15_000 },
+      )
+    })
+  })
+}

package/src/skill.test.ts

@@ -34,6 +34,17 @@ describe('Notifai agent skill', () => {
     }
   })
 
+  it('tells the agent where to look when something did not happen', () => {
+    // The log's whole value is diagnostic, so the skill has to name the case
+    // that produces it — a question that was registered and never travelled.
+    expect(skill).toContain('notifai logs')
+    expect(skill).toContain('--request <id>')
+    expect(skill).toContain('hook.gate')
+    expect(skill).toContain('notifications-off')
+    // And that it is the user's data, on the user's machine.
+    expect(skill).toContain('stays on this machine')
+  })
+
   it('moves per-harness mechanics into progressive disclosure', () => {
     expect(skill).toContain('[Harness setup and recovery](references/harness-setup.md)')
     for (const harness of ['Claude Code', 'Codex', 'Cursor', 'OpenCode']) {

package/src/ui/config-view.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 import os from 'node:os'
 import path from 'node:path'
 import { CONFIG_KEYS, loadConfig } from '../config.js'
+import { configInfo } from '../config-schema.js'
 import { renderConfigExplain, renderConfigList, renderConfigPlain } from './config-view.js'
 import { width } from './theme.js'
 
@@ -39,8 +40,9 @@ describe('renderConfigList', () => {
   it('names every non-advanced key and explains it', () => {
     const text = renderConfigList(config).join('\n')
     for (const key of CONFIG_KEYS) {
-      const advanced = key === 'base_url' || key === 'collapse_key'
-      if (advanced) continue
+      // Derived, not listed: a hardcoded set of advanced keys silently becomes
+      // an assertion about yesterday's key list the moment a key is added.
+      if (configInfo(key).advanced === true) continue
       expect(text, key).toContain(key)
     }
     expect(text).toContain('Questions & presence')

package/src/ui/config-view.ts

@@ -116,6 +116,9 @@ export function renderConfigExplain(key: ConfigKey, config: CliConfig): string[]
   lines.push('')
   const example = info.example ?? (info.choices?.[0] ?? 'value')
   lines.push(`  ${style.dim('Change it')} ${style.code(`notifai config set ${key} ${example}`)}`)
+  if (entry.source !== 'default' && entry.source !== 'flag') {
+    lines.push(`  ${style.dim('Inherit it')} ${style.code(`notifai config unset ${key}`)}`)
+  }
   lines.push('')
   return lines
 }