@raidiant/notifai 3.0.1 → 5.0.0

package/src/interactive.ts

@@ -132,7 +132,7 @@ export function routingHookActions(input: {
   }
 
   options.push(
-    { value: 'settings', label: 'Change presence settings', hint: 'when a question may leave this terminal' },
+    { value: 'settings', label: 'Change question settings', hint: 'when a question may leave this terminal' },
     { value: 'back', label: '← Back' },
   )
   return options

package/src/invocation-context.test.ts

@@ -0,0 +1,253 @@
+import { describe, expect, it } from 'vitest'
+import { sessionLabelFromId } from '@raidiant/notifai-protocol'
+import {
+  buildSourceContext,
+  inferInvocationContext,
+  portableBasename,
+  projectSlugFrom,
+  truncateContext,
+  type GitCommand,
+} from './invocation-context.js'
+
+function fixtureGit(values: Record<string, string | null>): GitCommand {
+  return (_cwd, args) => values[args.join(' ')] ?? null
+}
+
+describe('projectSlugFrom', () => {
+  it.each([
+    ['My Project', 'my-project'],
+    ['.Hidden Repo', 'hidden-repo'],
+    ['API_v2.0', 'api_v2.0'],
+    ['---', null],
+    ['项目', null],
+  ])('turns %s into %s', (name, expected) => {
+    expect(projectSlugFrom(name)).toBe(expected)
+  })
+
+  it('keeps the Project identifier inside its 64-character bound', () => {
+    expect(projectSlugFrom(`repo-${'x'.repeat(100)}`)).toHaveLength(64)
+  })
+})
+
+describe('portableBasename', () => {
+  it.each([
+    ['/Users/person/code/notifai/', 'notifai'],
+    ['C:\\Users\\Person\\code\\notifai\\', 'notifai'],
+    ['\\\\server\\share\\worktrees\\release\\', 'release'],
+  ])('extracts the basename from %s', (value, expected) => {
+    expect(portableBasename(value)).toBe(expected)
+  })
+})
+
+describe('inferInvocationContext', () => {
+  it('uses the common-directory parent for a repository from a nested cwd', () => {
+    const context = inferInvocationContext(
+      '/code/Signal Garden/packages/api',
+      fixtureGit({
+        'rev-parse --git-common-dir': '../../.git',
+        'rev-parse --git-dir': '../../.git',
+        'rev-parse --show-toplevel': '/code/Signal Garden',
+        'rev-parse --abbrev-ref HEAD': 'feature/alerts',
+      }),
+    )
+    expect(context).toEqual({ project: 'signal-garden', branch: 'feature/alerts' })
+  })
+
+  it('keeps one Project across linked worktrees and exposes only the worktree basename', () => {
+    const context = inferInvocationContext(
+      '/Users/name/worktrees/notifai-release/apps/cli',
+      fixtureGit({
+        'rev-parse --git-common-dir': '/Users/name/code/notifai/.git',
+        'rev-parse --git-dir': '/Users/name/code/notifai/.git/worktrees/notifai-release',
+        'rev-parse --show-toplevel': '/Users/name/worktrees/notifai-release/',
+        'rev-parse --abbrev-ref HEAD': 'release/content',
+      }),
+    )
+    expect(context).toEqual({
+      project: 'notifai',
+      branch: 'release/content',
+      worktree: 'notifai-release',
+    })
+    expect(JSON.stringify(context)).not.toContain('/Users/name')
+  })
+
+  it('handles drive-letter paths and compares them case-insensitively', () => {
+    const context = inferInvocationContext(
+      'D:\\Worktrees\\Alerts\\src',
+      fixtureGit({
+        'rev-parse --git-common-dir': 'C:\\Code\\Notifai\\.git\\',
+        'rev-parse --git-dir': 'c:\\code\\notifai\\.git\\worktrees\\Alerts',
+        'rev-parse --show-toplevel': 'D:\\Worktrees\\Alerts\\',
+        'rev-parse --abbrev-ref HEAD': 'feature/windows',
+      }),
+    )
+    expect(context).toEqual({
+      project: 'notifai',
+      branch: 'feature/windows',
+      worktree: 'Alerts',
+    })
+    expect(JSON.stringify(context)).not.toContain('D:\\Worktrees')
+    expect(JSON.stringify(context)).not.toContain('C:\\Code')
+  })
+
+  it('handles a UNC common directory and trailing separators', () => {
+    const context = inferInvocationContext(
+      '\\\\server\\share\\trees\\topic\\src',
+      fixtureGit({
+        'rev-parse --git-common-dir': '\\\\server\\share\\Notifai\\.git\\',
+        'rev-parse --git-dir': '\\\\server\\share\\Notifai\\.git\\worktrees\\topic\\',
+        'rev-parse --show-toplevel': '\\\\server\\share\\trees\\topic\\',
+        'rev-parse --abbrev-ref HEAD': 'topic',
+      }),
+    )
+    expect(context).toEqual({ project: 'notifai', branch: 'topic', worktree: 'topic' })
+  })
+
+  it('falls back to the cwd basename outside Git', () => {
+    expect(inferInvocationContext('/tmp/My Scratch/', fixtureGit({}))).toEqual({
+      project: 'my-scratch',
+    })
+  })
+
+  it('omits an unusable Project instead of inventing one', () => {
+    expect(inferInvocationContext('/tmp/项目', fixtureGit({}))).toEqual({ project: null })
+  })
+
+  it('omits branch and worktree on detached HEAD in an ordinary checkout', () => {
+    expect(
+      inferInvocationContext(
+        '/code/repo',
+        fixtureGit({
+          'rev-parse --git-common-dir': '.git',
+          'rev-parse --git-dir': '.git',
+          'rev-parse --show-toplevel': '/code/repo',
+          'rev-parse --abbrev-ref HEAD': 'HEAD',
+        }),
+      ),
+    ).toEqual({ project: 'repo' })
+  })
+
+  it('bounds branch and worktree display strings without leaking their parents', () => {
+    const longBranch = `feature/${'界'.repeat(140)}`
+    const longWorktree = `tree-${'x'.repeat(80)}`
+    const context = inferInvocationContext(
+      '/private/work/tree/src',
+      fixtureGit({
+        'rev-parse --git-common-dir': '/private/main/repo/.git',
+        'rev-parse --git-dir': '/private/main/repo/.git/worktrees/tree',
+        'rev-parse --show-toplevel': `/private/work/${longWorktree}`,
+        'rev-parse --abbrev-ref HEAD': longBranch,
+      }),
+    )
+    expect(Array.from(context.branch ?? '')).toHaveLength(128)
+    expect(Array.from(context.worktree ?? '')).toHaveLength(64)
+    expect(context.branch).toMatch(/…$/)
+    expect(context.worktree).toMatch(/…$/)
+    expect(JSON.stringify(context)).not.toContain('/private/')
+  })
+})
+
+describe('truncateContext', () => {
+  it('counts Unicode characters rather than UTF-16 code units', () => {
+    expect(truncateContext('A😀BC', 3)).toBe('A😀…')
+  })
+})
+
+describe('buildSourceContext', () => {
+  const invocation = { project: 'repo', branch: 'main', worktree: 'topic' }
+
+  it('applies flag, environment, then inferred precedence per session field', () => {
+    const built = buildSourceContext({
+      env: {
+        NOTIFAI_SESSION_ID: 'env-id',
+        NOTIFAI_SESSION_LABEL: 'Environment Label',
+      },
+      invocation,
+      sessionId: 'flag-id',
+      sessionLabel: 'Flag Label',
+      activeHarness: { harness: 'claude-code', sessionId: 'inferred-id' },
+    })
+    expect(built).toEqual({
+      ok: true,
+      source: {
+        session_id: 'flag-id',
+        session_label: 'Flag Label',
+        harness: 'claude-code',
+        branch: 'main',
+        worktree: 'topic',
+      },
+    })
+  })
+
+  it('uses environment values ahead of an inferred exact session', () => {
+    expect(
+      buildSourceContext({
+        env: {
+          NOTIFAI_SESSION_ID: 'env-id',
+          NOTIFAI_SESSION_LABEL: 'Environment Label',
+        },
+        invocation: { project: 'repo' },
+        activeHarness: { harness: 'codex', sessionId: 'inferred-id' },
+      }),
+    ).toEqual({
+      ok: true,
+      source: {
+        session_id: 'env-id',
+        session_label: 'Environment Label',
+        harness: 'codex',
+      },
+    })
+  })
+
+  it('generates a stable non-identifying label for an inferred exact session', () => {
+    const sessionId = 'opaque-thread-1234567890'
+    expect(
+      buildSourceContext({
+        env: {},
+        invocation: { project: 'repo', branch: 'main' },
+        activeHarness: { harness: 'opencode', sessionId },
+      }),
+    ).toEqual({
+      ok: true,
+      source: {
+        session_id: sessionId,
+        session_label: sessionLabelFromId(sessionId),
+        harness: 'opencode',
+        branch: 'main',
+      },
+    })
+    expect(sessionLabelFromId(sessionId)).not.toContain('1234567890')
+  })
+
+  it('does not emit a harness or label when no exact session id is available', () => {
+    expect(
+      buildSourceContext({
+        env: {},
+        invocation: { project: 'repo', branch: 'main' },
+        activeHarness: { harness: 'cursor' },
+      }),
+    ).toEqual({ ok: true, source: { branch: 'main' } })
+  })
+
+  it('ignores the deleted NOTIFAI_SESSION variable', () => {
+    expect(
+      buildSourceContext({
+        env: { NOTIFAI_SESSION: 'legacy-id' },
+        invocation: { project: 'repo' },
+      }),
+    ).toEqual({ ok: true })
+  })
+
+  it('rejects a display label without an exact session id', () => {
+    expect(
+      buildSourceContext({
+        env: {},
+        invocation: { project: 'repo' },
+        sessionLabel: 'Unbound Label',
+      }),
+    ).toEqual({
+      ok: false,
+      error: '--session-label (or NOTIFAI_SESSION_LABEL) needs an exact session id.',
+    })
+  })
+})

package/src/invocation-context.ts

@@ -0,0 +1,176 @@
+import { execFileSync } from 'node:child_process'
+import path from 'node:path'
+import {
+  sessionLabelFromId,
+  type SourceContextT,
+} from '@raidiant/notifai-protocol'
+import type { Harness } from './harnesses.js'
+
+export type GitCommand = (cwd: string, args: readonly string[]) => string | null
+
+const runGit: GitCommand = (cwd, args) => {
+  try {
+    return execFileSync('git', ['-C', cwd, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2_000,
+      windowsHide: true,
+    }).trim()
+  } catch {
+    return null
+  }
+}
+
+/** The useful, privacy-safe context inferred from one invocation directory. */
+export interface InvocationContext {
+  project: string | null
+  branch?: string
+  worktree?: string
+}
+
+/** Contract-valid Project slug, or null when the name has no safe characters. */
+export function projectSlugFrom(name: string): string | null {
+  const slug = name
+    .toLowerCase()
+    .replaceAll(/[^a-z0-9._-]+/g, '-')
+    .replaceAll(/^[^a-z0-9]+|[^a-z0-9._-]+$/g, '')
+    .slice(0, 64)
+  return slug.length > 0 && /^[a-z0-9]/.test(slug) ? slug : null
+}
+
+function usesWindowsPaths(...values: string[]): boolean {
+  return values.some((value) => /^[A-Za-z]:[\\/]/.test(value) || /^\\\\/.test(value))
+}
+
+function pathApi(...values: string[]): typeof path.posix | typeof path.win32 {
+  return usesWindowsPaths(...values) ? path.win32 : path.posix
+}
+
+/** Basename that can be fixture-tested for POSIX, drive, and UNC paths on any OS. */
+export function portableBasename(value: string): string {
+  const api = pathApi(value)
+  return api.basename(api.normalize(value))
+}
+
+function resolveGitPath(cwd: string, value: string): string {
+  const api = pathApi(cwd, value)
+  return api.isAbsolute(value) ? api.normalize(value) : api.resolve(cwd, value)
+}
+
+function samePath(left: string, right: string): boolean {
+  const api = pathApi(left, right)
+  const normalizedLeft = api.normalize(left)
+  const normalizedRight = api.normalize(right)
+  return api === path.win32
+    ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+    : normalizedLeft === normalizedRight
+}
+
+/** Truncate a display string by Unicode characters and keep the ellipsis inside the bound. */
+export function truncateContext(value: string, maxLength: number): string {
+  const characters = Array.from(value)
+  if (characters.length <= maxLength) return value
+  return `${characters.slice(0, Math.max(0, maxLength - 1)).join('')}…`
+}
+
+/**
+ * Infer stable Project identity plus branch/worktree display context.
+ *
+ * Linked worktrees share the parent of Git's common directory, while a non-Git
+ * directory falls back to its own basename. Only basenames and branch names are
+ * returned; no absolute path can leave this function.
+ */
+export function inferInvocationContext(
+  cwd: string,
+  git: GitCommand = runGit,
+): InvocationContext {
+  const commonRaw = git(cwd, ['rev-parse', '--git-common-dir'])
+  if (commonRaw === null || commonRaw === '') {
+    return { project: projectSlugFrom(portableBasename(cwd)) }
+  }
+
+  const commonDir = resolveGitPath(cwd, commonRaw)
+  const api = pathApi(cwd, commonDir)
+  const gitDirRaw = git(cwd, ['rev-parse', '--git-dir'])
+  const topLevelRaw = git(cwd, ['rev-parse', '--show-toplevel'])
+  const linked =
+    gitDirRaw !== null &&
+    gitDirRaw !== '' &&
+    !samePath(resolveGitPath(cwd, gitDirRaw), commonDir)
+
+  // In an ordinary checkout the worktree root is the useful Project root. A
+  // linked worktree needs its shared repository identity instead: standard Git
+  // stores that in <main>/.git, while submodules and --separate-git-dir use a
+  // named common directory whose basename is the only stable, path-free label.
+  // Treating every common directory as `.git` would infer `modules` or `public`
+  // for submodules — an implementation detail, not the repository's identity.
+  const commonName = api.basename(commonDir)
+  const projectName = linked
+    ? commonName.toLowerCase() === '.git'
+      ? api.basename(api.dirname(commonDir))
+      : commonName
+    : topLevelRaw !== null && topLevelRaw !== ''
+      ? portableBasename(topLevelRaw)
+      : commonName.toLowerCase() === '.git'
+        ? api.basename(api.dirname(commonDir))
+        : commonName
+  const project = projectSlugFrom(projectName)
+
+  const branchRaw = git(cwd, ['rev-parse', '--abbrev-ref', 'HEAD'])
+  const branch =
+    branchRaw === null || branchRaw === '' || branchRaw === 'HEAD'
+      ? undefined
+      : truncateContext(branchRaw, 128)
+
+  const worktree =
+    linked && topLevelRaw !== null && topLevelRaw !== ''
+      ? truncateContext(portableBasename(topLevelRaw), 64)
+      : undefined
+
+  return {
+    project,
+    ...(branch !== undefined ? { branch } : {}),
+    ...(worktree !== undefined && worktree !== '' ? { worktree } : {}),
+  }
+}
+
+export interface SourceContextInput {
+  env: NodeJS.ProcessEnv
+  invocation: InvocationContext
+  sessionId?: string
+  sessionLabel?: string
+  activeHarness?: { harness: Harness; sessionId?: string }
+}
+
+export type SourceContextBuild =
+  | { ok: true; source?: SourceContextT }
+  | { ok: false; error: string }
+
+/** Resolve per-field source precedence without fabricating session identity. */
+export function buildSourceContext(input: SourceContextInput): SourceContextBuild {
+  const sessionId =
+    input.sessionId ?? input.env['NOTIFAI_SESSION_ID'] ?? input.activeHarness?.sessionId
+  const explicitLabel = input.sessionLabel ?? input.env['NOTIFAI_SESSION_LABEL']
+  if (explicitLabel !== undefined && (sessionId === undefined || sessionId === '')) {
+    return {
+      ok: false,
+      error: '--session-label (or NOTIFAI_SESSION_LABEL) needs an exact session id.',
+    }
+  }
+  if (sessionId === '') {
+    return { ok: false, error: '--session-id must not be empty.' }
+  }
+
+  const sessionLabel =
+    sessionId === undefined ? undefined : (explicitLabel ?? sessionLabelFromId(sessionId))
+  const source: SourceContextT = {
+    ...(sessionId !== undefined ? { session_id: sessionId } : {}),
+    ...(sessionLabel !== undefined ? { session_label: sessionLabel } : {}),
+    ...(sessionId !== undefined && input.activeHarness !== undefined
+      ? { harness: input.activeHarness.harness }
+      : {}),
+    ...(input.invocation.branch !== undefined ? { branch: input.invocation.branch } : {}),
+    ...(input.invocation.worktree !== undefined ? { worktree: input.invocation.worktree } : {}),
+  }
+  return Object.keys(source).length === 0 ? { ok: true } : { ok: true, source }
+}

package/src/logging-process-worker.test.ts

@@ -19,7 +19,10 @@ if (worker === undefined) {
       const maxBytes = Number(process.env['NOTIFAI_ROTATION_MAX_BYTES'])
       const maxFiles = Number(process.env['NOTIFAI_ROTATION_MAX_FILES'])
       writeFileSync(readyPath, 'ready')
-      const startDeadline = Date.now() + 10_000
+      // The parent's absolute deadline, not a countdown of this worker's own:
+      // the barrier fails for everyone at one instant, so a worker that started
+      // early cannot walk out on a parent still waiting for its last sibling.
+      const startDeadline = Number(process.env['NOTIFAI_ROTATION_DEADLINE'])
       while (!existsSync(startPath)) {
         if (Date.now() >= startDeadline) throw new Error('rotation parent never released the barrier')
         await new Promise((resolve) => setTimeout(resolve, 2))
@@ -33,7 +36,10 @@ if (worker === undefined) {
         logger.info('cli.end', { worker, sequence, pad: 'p'.repeat(140) })
         await new Promise((resolve) => setTimeout(resolve, 1))
       }
-      expect(logger.enabled).toBe(true)
+      // The sink switches itself off for the rest of a process the first time a
+      // write throws, so this is the whole point of the worker: every record it
+      // was given reached the shared file through the cross-process lock.
+      expect(logger.enabled, 'the shared-log sink switched itself off mid-run').toBe(true)
     })
   })
 }

package/src/logging.test.ts

@@ -35,22 +35,30 @@ function lines(env: NodeJS.ProcessEnv): LogRecord[] {
     .map((line) => JSON.parse(line) as LogRecord)
 }
 
-async function waitUntil(predicate: () => boolean, timeoutMs = 10_000): Promise<void> {
-  const deadline = Date.now() + timeoutMs
+async function waitUntil(predicate: () => boolean, deadline: number): Promise<void> {
   while (!predicate()) {
     if (Date.now() >= deadline) throw new Error('timed out waiting for rotation workers')
     await new Promise((resolve) => setTimeout(resolve, 5))
   }
 }
 
-function rotationWorker(
-  env: NodeJS.ProcessEnv,
-  worker: number,
-  records: number,
-  maxBytes: number,
-  maxFiles: number,
-  startPath: string,
-): { readyPath: string; done: Promise<void> } {
+interface RotationRun {
+  env: NodeJS.ProcessEnv
+  worker: number
+  records: number
+  maxBytes: number
+  maxFiles: number
+  startPath: string
+  /**
+   * When the rendezvous has failed, as an absolute instant every participant
+   * reads the same way. A per-side countdown would let the first worker to
+   * report ready abandon a parent that is still waiting for the last one.
+   */
+  deadline: number
+}
+
+function rotationWorker(run: RotationRun): { readyPath: string; done: Promise<void> } {
+  const { env, worker } = run
   const readyPath = path.join(env['XDG_STATE_HOME']!, `rotation-ready-${worker}`)
   const vitest = path.join(process.cwd(), 'node_modules', 'vitest', 'vitest.mjs')
   const child = spawn(
@@ -62,11 +70,12 @@ function rotationWorker(
         ...process.env,
         ...env,
         NOTIFAI_ROTATION_WORKER: String(worker),
-        NOTIFAI_ROTATION_RECORDS: String(records),
-        NOTIFAI_ROTATION_MAX_BYTES: String(maxBytes),
-        NOTIFAI_ROTATION_MAX_FILES: String(maxFiles),
+        NOTIFAI_ROTATION_RECORDS: String(run.records),
+        NOTIFAI_ROTATION_MAX_BYTES: String(run.maxBytes),
+        NOTIFAI_ROTATION_MAX_FILES: String(run.maxFiles),
         NOTIFAI_ROTATION_READY: readyPath,
-        NOTIFAI_ROTATION_START: startPath,
+        NOTIFAI_ROTATION_START: run.startPath,
+        NOTIFAI_ROTATION_DEADLINE: String(run.deadline),
       },
       stdio: ['ignore', 'pipe', 'pipe'],
     },
@@ -263,11 +272,15 @@ describe('rotation', () => {
     const maxBytes = 4_000
     const maxFiles = 100
     const startPath = path.join(env['XDG_STATE_HOME']!, 'rotation-start')
+    // Four cold Vitest processes have to reach the barrier before any of them
+    // writes, and a busy CI host schedules them far apart. The budget is shared,
+    // so it bounds the whole rendezvous rather than each side of it.
+    const deadline = Date.now() + 20_000
     const children = Array.from({ length: workers }, (_, worker) =>
-      rotationWorker(env, worker, recordsPerWorker, maxBytes, maxFiles, startPath),
+      rotationWorker({ env, worker, records: recordsPerWorker, maxBytes, maxFiles, startPath, deadline }),
     )
 
-    await waitUntil(() => children.every(({ readyPath }) => existsSync(readyPath)))
+    await waitUntil(() => children.every(({ readyPath }) => existsSync(readyPath)), deadline)
     writeFileSync(startPath, 'go')
     await Promise.all(children.map(({ done }) => done))
 
@@ -293,8 +306,10 @@ describe('rotation', () => {
     // name race may lose or duplicate one.
     expect(retainedRecords).toBe(workers * recordsPerWorker)
     expect(seen.size).toBe(workers * recordsPerWorker)
-    expect([...seen.values()].every((count) => count === 1)).toBe(true)
-  })
+    // Name the offending records: a bare boolean would report a duplication bug
+    // as "expected false to be true" and leave the next reader nothing to go on.
+    expect([...seen].filter(([, count]) => count !== 1)).toEqual([])
+  }, 90_000)
 })
 
 describe('failure isolation', () => {

package/src/logging.ts

@@ -61,6 +61,17 @@ export const LOG_SCHEMA_VERSION = 1
 export { LOG_LEVELS, type LogLevel }
 export type RecordLevel = Exclude<LogLevel, 'off'>
 
+/**
+ * The levels a record can actually carry.
+ *
+ * `off` is a setting that stops writing, never a severity anything is written
+ * at — so offering it as a retrieval filter accepted a query that could only
+ * ever match nothing, and then blamed the result on too narrow a search.
+ */
+export const RECORD_LEVELS: readonly RecordLevel[] = LOG_LEVELS.filter(
+  (level): level is RecordLevel => level !== 'off',
+)
+
 const LEVEL_RANK: Record<LogLevel, number> = { off: 0, error: 1, info: 2, debug: 3 }
 
 /**