@raidiant/notifai 1.0.1 → 1.1.0

package/src/opencode-plugin.ts

@@ -1,4 +1,5 @@
 import path from 'node:path'
+import { hookHostPlatform, type HookHostPlatform } from './hook-adapter.js'
 import { configHome } from './install-hooks.js'
 
 /**
@@ -36,9 +37,10 @@ export function opencodePluginDir(
   global: boolean,
   cwd: string,
   env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
 ): string {
   return global
-    ? path.join(configHome(env, 'OPENCODE_CONFIG_DIR', '.config/opencode'), 'plugins')
+    ? path.join(configHome(env, 'OPENCODE_CONFIG_DIR', '.config/opencode', platform), 'plugins')
     : path.join(cwd, '.opencode', 'plugins')
 }
 
@@ -46,8 +48,9 @@ export function opencodePluginPath(
   global: boolean,
   cwd: string,
   env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
 ): string {
-  return path.join(opencodePluginDir(global, cwd, env), OPENCODE_PLUGIN_FILENAME)
+  return path.join(opencodePluginDir(global, cwd, env, platform), OPENCODE_PLUGIN_FILENAME)
 }
 
 export interface OpencodePluginOptions {
@@ -55,6 +58,9 @@ export interface OpencodePluginOptions {
   adapterPath: string
   /** Child-process lifetime; covers grace, reply wait, and teardown headroom. */
   timeoutSeconds: number
+  platform?: NodeJS.Platform | HookHostPlatform
+  /** Registered Node used to interpret the Windows adapter. Ignored on POSIX. */
+  nodePath?: string
 }
 
 /**
@@ -70,6 +76,13 @@ export interface OpencodePluginOptions {
  * never changes OpenCode's own behavior.
  */
 export function opencodePluginSource(options: OpencodePluginOptions): string {
+  if (hookHostPlatform(options.platform) === 'win32') {
+    return win32OpencodePluginSource(options)
+  }
+  return posixOpencodePluginSource(options)
+}
+
+function posixOpencodePluginSource(options: OpencodePluginOptions): string {
   const { adapterPath, timeoutSeconds } = options
   return `${OPENCODE_PLUGIN_MARKER}
 // Generated by \`notifai hooks install --harness opencode\`. Edits are lost on
@@ -196,6 +209,136 @@ export const NotifAIPlugin = async ({ directory }) => {
 `
 }
 
+function win32OpencodePluginSource(options: OpencodePluginOptions): string {
+  const { adapterPath, timeoutSeconds } = options
+  const nodePath = options.nodePath ?? process.execPath
+  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 NODE = ${JSON.stringify(nodePath)}
+const ADAPTER = ${JSON.stringify(adapterPath)}
+const TIMEOUT_MS = ${timeoutSeconds * 1000}
+const ADAPTER_VERSION = ${OPENCODE_ADAPTER_VERSION}
+
+/**
+ * Runs \`notifai hook <event>\`, feeding it the same JSON envelope the other
+ * harnesses send. Resolves to stdout, or null if anything at all went wrong.
+ */
+function runHook(event, envelope) {
+  return new Promise((resolve) => {
+    let child
+    try {
+      child = spawn(NODE, [ADAPTER, "hook", event, "--owner", "notifai", "--harness", "opencode"], {
+        env: process.env,
+        shell: false,
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"],
+      })
+    } catch {
+      resolve(null)
+      return
+    }
+
+    let stdout = ""
+    let settled = false
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(value)
+    }
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM")
+      finish(null)
+    }, TIMEOUT_MS)
+
+    child.stdout?.setEncoding("utf-8")
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk
+    })
+    // Hook stderr is diagnostics, not plugin output; discard it here.
+    child.stderr?.resume()
+    child.on("error", () => finish(null))
+    child.on("close", () => finish(stdout))
+
+    try {
+      child.stdin?.end(JSON.stringify(envelope))
+    } catch {
+      finish(null)
+    }
+  })
+}
+
+function additionalContext(stdout) {
+  if (typeof stdout !== "string" || stdout.trim() === "") return null
+  try {
+    const parsed = JSON.parse(stdout)
+    const context = parsed?.hookSpecificOutput?.additionalContext
+    return typeof context === "string" && context.length > 0 ? context : null
+  } catch {
+    return null
+  }
+}
+
+export const NotifAIPlugin = async ({ directory }) => {
+  const cwd = typeof directory === "string" && directory.length > 0 ? directory : process.cwd()
+
+  return {
+    /** Exact active-harness identity for shell commands such as \`notifai ask\`. */
+    "shell.env": async (input, output) => {
+      output.env.NOTIFAI_ACTIVE_HARNESS = "opencode"
+      const sessionID = input?.sessionID
+      if (typeof sessionID === "string" && sessionID.length > 0) {
+        output.env.NOTIFAI_ACTIVE_SESSION_ID = sessionID
+      }
+    },
+
+    /**
+     * Presence. The user typing is the signal every harness shares, and it is
+     * also what publishes the project -> session pointer \`notifai ask\` reads.
+     */
+    "chat.message": async (input, output) => {
+      const stdout = await runHook("user-prompt-submit", {
+        session_id: input?.sessionID ?? input?.info?.sessionID,
+        cwd,
+        hook_event_name: "UserPromptSubmit",
+      })
+      const context = additionalContext(stdout)
+      if (context !== null) {
+        output.parts.push({
+          id: "prt_notifai_" + Date.now(),
+          sessionID: input.sessionID,
+          messageID: output.message.id,
+          type: "text",
+          text: context,
+          synthetic: true,
+        })
+      }
+    },
+
+    /** Session lifecycle events are delivered through OpenCode's event bus. */
+    event: async ({ event }) => {
+      if (event?.type === "session.idle") {
+        await runHook("stop", {
+          session_id: event?.properties?.sessionID,
+          cwd,
+          hook_event_name: "Stop",
+        })
+      } else if (event?.type === "session.deleted") {
+        await runHook("session-end", {
+          session_id: event?.properties?.info?.id,
+          cwd,
+          hook_event_name: "SessionEnd",
+        })
+      }
+    },
+  }
+}
+`
+}
+
 /** True when a plugin file on disk is one of ours, whoever installed it. */
 export function isOurOpencodePlugin(contents: string): boolean {
   return contents.includes(OPENCODE_PLUGIN_MARKER)
@@ -216,10 +359,11 @@ export function isOurOpencodePlugin(contents: string): boolean {
  */
 export function opencodePluginTarget(
   contents: string,
-): { adapter: string; current: boolean; timeoutSeconds?: number } | null {
+): { adapter: string; current: boolean; timeoutSeconds?: number; nodePath?: string } | null {
   if (!isOurOpencodePlugin(contents)) return null
   const adapter = /^const ADAPTER = (".*")$/m.exec(contents)?.[1]
   const legacyScript = /^const SCRIPT = (".*")$/m.exec(contents)?.[1]
+  const node = /^const NODE = (".*")$/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 (adapter === undefined && legacyScript === undefined) return null
@@ -228,6 +372,7 @@ export function opencodePluginTarget(
       adapter: JSON.parse(adapter ?? legacyScript!) as string,
       current: version === OPENCODE_ADAPTER_VERSION,
       ...(Number.isFinite(timeoutMs) ? { timeoutSeconds: timeoutMs / 1000 } : {}),
+      ...(node === undefined ? {} : { nodePath: JSON.parse(node) as string }),
     }
   } catch {
     return null

package/src/platform.test.ts

@@ -0,0 +1,152 @@
+import os from 'node:os'
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+import {
+  accountHome,
+  cmdScript,
+  configHome,
+  isWindowsAbsolute,
+  npxLaunch,
+  quoteCmdArgument,
+  stateHome,
+  urlOpenLaunch,
+} from './platform.js'
+import { globalConfigDir, stateDir } from './config.js'
+
+const PAIRING_URL = 'https://notifai.example/approve?code=AB&next=1|calc'
+
+describe('urlOpenLaunch', () => {
+  it('keeps a metacharacter pairing URL as one Windows argument and hides the console', () => {
+    const launch = urlOpenLaunch(PAIRING_URL, 'win32')
+    expect(launch.file.toLowerCase()).not.toMatch(/^cmd(\.exe)?$/)
+    expect(launch.args).toEqual(['url.dll,FileProtocolHandler', PAIRING_URL])
+    expect(launch.options.windowsHide).toBe(true)
+    expect(launch.options.detached).toBe(true)
+    expect(launch.options.stdio).toBe('ignore')
+  })
+
+  it('preserves best-effort open and xdg-open on POSIX', () => {
+    expect(urlOpenLaunch(PAIRING_URL, 'darwin')).toEqual({
+      file: 'open',
+      args: [PAIRING_URL],
+      options: { stdio: 'ignore', detached: true },
+    })
+    expect(urlOpenLaunch(PAIRING_URL, 'linux')).toEqual({
+      file: 'xdg-open',
+      args: [PAIRING_URL],
+      options: { stdio: 'ignore', detached: true },
+    })
+  })
+})
+
+describe('npxLaunch', () => {
+  const source = 'Raidiant-io/notifai#v1.0.1'
+  const args = ['-y', 'skills', 'add', source, '--skill', 'notifai', '--yes']
+
+  it('runs the .cmd shim through cmd on Windows with quoted arguments', () => {
+    const launch = npxLaunch(args, {
+      cwd: 'C:\\proj',
+      env: { ComSpec: 'C:\\Windows\\system32\\cmd.exe' },
+      platform: 'win32',
+    })
+    expect(launch.file).toBe('C:\\Windows\\system32\\cmd.exe')
+    expect(launch.args.slice(0, 4)).toEqual(['/d', '/s', '/v:off', '/c'])
+    expect(launch.args).toHaveLength(5)
+    expect(launch.args[4]).toBe(cmdScript('npx.cmd', args))
+    expect(launch.args[4]).toContain('npx.cmd')
+    expect(launch.args[4]).toContain(quoteCmdArgument(source))
+    expect(launch.options.windowsVerbatimArguments).toBe(true)
+    expect(launch.options.windowsHide).toBe(true)
+    expect(launch.options.stdio).toBe('inherit')
+    expect(launch.options.cwd).toBe('C:\\proj')
+  })
+
+  it('quotes a hostile source so cmd cannot treat & as a second command', () => {
+    const hostile = 'evil&calc.exe'
+    const launch = npxLaunch(['-y', 'skills', 'add', hostile, '--skill', 'notifai'], {
+      cwd: 'C:\\proj',
+      env: {},
+      platform: 'win32',
+    })
+    const script = launch.args[4] ?? ''
+    expect(script).toContain(quoteCmdArgument(hostile))
+    expect(script.startsWith('"') && script.endsWith('"')).toBe(true)
+    expect(launch.file).toBe('cmd.exe')
+  })
+
+  it('spawns npx directly on POSIX without a shell', () => {
+    const launch = npxLaunch(args, { cwd: '/tmp/proj', env: { PATH: '/usr/bin' }, platform: 'linux' })
+    expect(launch).toEqual({
+      file: 'npx',
+      args,
+      options: { cwd: '/tmp/proj', env: { PATH: '/usr/bin' }, stdio: 'inherit' },
+    })
+    expect(launch.options.windowsVerbatimArguments).toBeUndefined()
+  })
+})
+
+describe('accountHome', () => {
+  it('rejects an MSYS HOME on Windows and uses a Windows-absolute USERPROFILE', () => {
+    expect(
+      accountHome({ HOME: '/c/Users/rafael', USERPROFILE: 'C:\\Users\\rafael' }, 'win32'),
+    ).toBe('C:\\Users\\rafael')
+    expect(accountHome({ HOME: '/home/rafael', USERPROFILE: 'C:/Users/rafael' }, 'win32')).toBe(
+      'C:/Users/rafael',
+    )
+    expect(isWindowsAbsolute('/c/Users/rafael')).toBe(false)
+    expect(isWindowsAbsolute('C:\\Users\\rafael')).toBe(true)
+  })
+
+  it('honours a Windows-absolute HOME and falls back to os.homedir()', () => {
+    expect(accountHome({ HOME: 'D:\\homes\\dev', USERPROFILE: 'C:\\Users\\rafael' }, 'win32')).toBe(
+      'D:\\homes\\dev',
+    )
+    expect(accountHome({ HOME: '/c/Users/rafael' }, 'win32')).toBe(os.homedir())
+  })
+
+  it('preserves POSIX HOME, including a POSIX-looking value', () => {
+    expect(accountHome({ HOME: '/home/rafael', USERPROFILE: 'C:\\Users\\rafael' }, 'linux')).toBe(
+      '/home/rafael',
+    )
+    expect(accountHome({ HOME: '/c/Users/rafael' }, 'darwin')).toBe('/c/Users/rafael')
+    expect(accountHome({}, 'linux')).toBe(os.homedir())
+  })
+})
+
+describe('known-folder roots', () => {
+  it('defaults Windows config to APPDATA/notifai and state to LOCALAPPDATA/notifai', () => {
+    const env = {
+      APPDATA: 'C:\\Users\\rafael\\AppData\\Roaming',
+      LOCALAPPDATA: 'C:\\Users\\rafael\\AppData\\Local',
+      HOME: '/c/Users/rafael',
+      USERPROFILE: 'C:\\Users\\rafael',
+    }
+    expect(configHome(env, 'win32')).toBe(env.APPDATA)
+    expect(stateHome(env, 'win32')).toBe(env.LOCALAPPDATA)
+    expect(globalConfigDir(env, 'win32')).toBe(path.join(env.APPDATA, 'notifai'))
+    expect(stateDir(env, 'win32')).toBe(path.join(env.LOCALAPPDATA, 'notifai'))
+  })
+
+  it('lets explicit XDG roots override Windows known folders', () => {
+    const env = {
+      XDG_CONFIG_HOME: 'D:\\xdg\\config',
+      XDG_STATE_HOME: 'D:\\xdg\\state',
+      APPDATA: 'C:\\Users\\rafael\\AppData\\Roaming',
+      LOCALAPPDATA: 'C:\\Users\\rafael\\AppData\\Local',
+    }
+    expect(globalConfigDir(env, 'win32')).toBe(path.join('D:\\xdg\\config', 'notifai'))
+    expect(stateDir(env, 'win32')).toBe(path.join('D:\\xdg\\state', 'notifai'))
+  })
+
+  it('keeps POSIX XDG defaults under the account home', () => {
+    const env = { HOME: '/home/rafael' }
+    expect(globalConfigDir(env, 'linux')).toBe(path.join('/home/rafael', '.config', 'notifai'))
+    expect(stateDir(env, 'linux')).toBe(path.join('/home/rafael', '.local', 'state', 'notifai'))
+    expect(globalConfigDir({ XDG_CONFIG_HOME: '/custom/config' }, 'darwin')).toBe(
+      path.join('/custom/config', 'notifai'),
+    )
+    expect(stateDir({ XDG_STATE_HOME: '/custom/state' }, 'linux')).toBe(
+      path.join('/custom/state', 'notifai'),
+    )
+  })
+})

package/src/platform.ts

@@ -0,0 +1,173 @@
+import { spawn, type SpawnOptions } from 'node:child_process'
+import os from 'node:os'
+import path from 'node:path'
+
+/**
+ * How this process should launch one child. Tests inspect the plan instead of
+ * opening a browser or running npx; production hands it to `spawn`.
+ */
+export interface ProcessLaunch {
+  file: string
+  args: string[]
+  options: SpawnOptions
+}
+
+/** Drive letter or UNC. MSYS `/c/Users/…` is not a Windows account home. */
+export function isWindowsAbsolute(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith('\\\\')
+}
+
+/**
+ * The account home used for Notifai's own defaults.
+ *
+ * On Windows, Git Bash and MSYS overwrite `HOME` with a POSIX path that is not
+ * a usable NTFS root. Those values are ignored; a Windows-absolute
+ * `USERPROFILE` or `os.homedir()` wins. A Windows-absolute `HOME` is still
+ * honoured. POSIX keeps `HOME` as the override it has always been.
+ */
+export function accountHome(
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  if (platform === 'win32') {
+    const home = env['HOME']
+    if (typeof home === 'string' && isWindowsAbsolute(home)) return home
+    const profile = env['USERPROFILE']
+    if (typeof profile === 'string' && isWindowsAbsolute(profile)) return profile
+    return os.homedir()
+  }
+  const home = env['HOME']
+  if (typeof home === 'string' && home !== '') return home
+  return os.homedir()
+}
+
+/**
+ * Directory that contains the `notifai/` configuration folder.
+ *
+ * An explicit `XDG_CONFIG_HOME` always wins, including on Windows. Otherwise
+ * Windows uses `%APPDATA%` and POSIX uses `~/.config`.
+ */
+export function configHome(
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const xdg = env['XDG_CONFIG_HOME']
+  if (typeof xdg === 'string' && xdg !== '') return xdg
+  if (platform === 'win32') {
+    const appdata = env['APPDATA']
+    if (typeof appdata === 'string' && appdata !== '') return appdata
+  }
+  return path.join(accountHome(env, platform), '.config')
+}
+
+/**
+ * Directory that contains the `notifai/` machine-local state folder.
+ *
+ * An explicit `XDG_STATE_HOME` always wins. Otherwise Windows uses
+ * `%LOCALAPPDATA%` and POSIX uses `~/.local/state`.
+ */
+export function stateHome(
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const xdg = env['XDG_STATE_HOME']
+  if (typeof xdg === 'string' && xdg !== '') return xdg
+  if (platform === 'win32') {
+    const local = env['LOCALAPPDATA']
+    if (typeof local === 'string' && local !== '') return local
+  }
+  return path.join(accountHome(env, platform), '.local', 'state')
+}
+
+/**
+ * Open a pairing or support URL.
+ *
+ * Windows goes through `rundll32` so the URL is one CreateProcess argument and
+ * `cmd` never reparses `?a=1&b=2`. `windowsHide` keeps the helper from flashing
+ * a console. macOS and Linux stay best-effort `open` / `xdg-open`.
+ */
+export function urlOpenLaunch(
+  url: string,
+  platform: NodeJS.Platform = process.platform,
+): ProcessLaunch {
+  if (platform === 'darwin') {
+    return { file: 'open', args: [url], options: { stdio: 'ignore', detached: true } }
+  }
+  if (platform === 'win32') {
+    return {
+      file: 'rundll32.exe',
+      args: ['url.dll,FileProtocolHandler', url],
+      options: { stdio: 'ignore', detached: true, windowsHide: true },
+    }
+  }
+  return { file: 'xdg-open', args: [url], options: { stdio: 'ignore', detached: true } }
+}
+
+/** Best-effort browser open. Failure is silent: the URL is printed either way. */
+export function openUrl(url: string, platform: NodeJS.Platform = process.platform): void {
+  try {
+    const launch = urlOpenLaunch(url, platform)
+    spawn(launch.file, launch.args, launch.options).unref()
+  } catch {
+    // The caller already printed the URL.
+  }
+}
+
+/**
+ * Quote one cmd.exe argument so it cannot start a second command.
+ *
+ * `%` expands even inside quotes, so it is doubled. Quotes themselves are
+ * doubled. Everything else is inert once quoted, including `& | > < ^`.
+ */
+export function quoteCmdArgument(value: string): string {
+  return `"${value.replace(/%/g, '%%').replace(/"/g, '""')}"`
+}
+
+/**
+ * A single `/c` argument for `cmd /d /s /c`.
+ *
+ * `/s` strips the first and last quote when both ends are quotes, so the
+ * payload is wrapped once more around the already-quoted argv. What cmd then
+ * runs is `"npx.cmd" "-y" …` with no unquoted metacharacters.
+ */
+export function cmdScript(command: string, args: readonly string[]): string {
+  return `"${[command, ...args].map(quoteCmdArgument).join(' ')}"`
+}
+
+/**
+ * Launch `npx` so Windows can run the `.cmd` shim.
+ *
+ * `spawn('npx', …)` is CreateProcess of a file named `npx`, which does not
+ * exist — npm installs `npx.cmd`. cmd.exe can run that shim; CreateProcess
+ * cannot. Arguments stay in one quoted `/c` string rather than `shell: true`.
+ */
+export function npxLaunch(
+  args: readonly string[],
+  options: {
+    cwd: string
+    env: NodeJS.ProcessEnv
+    platform?: NodeJS.Platform
+    stdio?: SpawnOptions['stdio']
+  },
+): ProcessLaunch {
+  const platform = options.platform ?? process.platform
+  const stdio = options.stdio ?? 'inherit'
+  if (platform === 'win32') {
+    return {
+      file: options.env['ComSpec'] && options.env['ComSpec'] !== '' ? options.env['ComSpec'] : 'cmd.exe',
+      args: ['/d', '/s', '/v:off', '/c', cmdScript('npx.cmd', args)],
+      options: {
+        cwd: options.cwd,
+        env: options.env,
+        stdio,
+        windowsHide: true,
+        windowsVerbatimArguments: true,
+      },
+    }
+  }
+  return {
+    file: 'npx',
+    args: [...args],
+    options: { cwd: options.cwd, env: options.env, stdio },
+  }
+}

package/src/ui/config-view.ts

@@ -64,11 +64,11 @@ export function renderConfigList(
   }
 
   lines.push('')
-  lines.push(
-    style.dim(
-      `${glyph.arrow} ${style.code('notifai config explain <key>')} for what one of these means and how to change it.`,
-    ),
-  )
+  const command = 'notifai config explain <key>'
+  const help = `${glyph.arrow} ${command} for what one of these means and how to change it.`
+  for (const line of wrap(help, columns)) {
+    lines.push(style.dim(line.replace(command, style.code(command))))
+  }
   return lines
 }