@raidiant/notifai 9.2.2 → 9.3.0

package/src/orca-session-title.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { readOrcaSessionTitle, type OrcaCommand } from './orca-session-title.js'
-
-const worktreeId = 'repo-123::/worktrees/semantic-session-implementation'
-
-function response(overrides: Record<string, unknown> = {}): string {
-  return JSON.stringify({
-    ok: true,
-    result: {
-      worktree: {
-        id: worktreeId,
-        path: '/worktrees/semantic-session-implementation',
-        displayName: 'Worker - semantic session implementation',
-        ...overrides,
-      },
-    },
-  })
-}
-
-describe('Orca semantic session title', () => {
-  it('accepts only the display name returned for the exact managed worktree', () => {
-    const calls: { executable: string; args: readonly string[] }[] = []
-    const command: OrcaCommand = (executable, args) => {
-      calls.push({ executable, args })
-      return response()
-    }
-
-    expect(
-      readOrcaSessionTitle(
-        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId },
-        command,
-      ),
-    ).toBe('Worker - semantic session implementation')
-    expect(calls).toEqual([
-      {
-        executable: 'orca',
-        args: ['worktree', 'show', '--worktree', `id:${worktreeId}`, '--json'],
-      },
-    ])
-  })
-
-  it('uses Orca-provided executable selection without invoking a shell', () => {
-    const calls: string[] = []
-    expect(
-      readOrcaSessionTitle(
-        {
-          TERM_PROGRAM: 'Orca',
-          ORCA_WORKTREE_ID: worktreeId,
-          ORCA_CLI_COMMAND: '/mnt/c/Program Files/Orca/orca.exe',
-        },
-        (executable) => {
-          calls.push(executable)
-          return response()
-        },
-      ),
-    ).toBe('Worker - semantic session implementation')
-    expect(calls).toEqual(['/mnt/c/Program Files/Orca/orca.exe'])
-  })
-
-  it('ignores non-Orca and malformed selectors without running a command', () => {
-    const command: OrcaCommand = () => {
-      throw new Error('must not run')
-    }
-    expect(readOrcaSessionTitle({ ORCA_WORKTREE_ID: worktreeId }, command)).toBeUndefined()
-    expect(
-      readOrcaSessionTitle(
-        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: '/private/untrusted' },
-        command,
-      ),
-    ).toBeUndefined()
-    expect(
-      readOrcaSessionTitle(
-        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: 'repo-123::relative/path' },
-        command,
-      ),
-    ).toBeUndefined()
-  })
-
-  it.each([
-    ['command failure', () => null],
-    ['thrown command failure', () => { throw new Error('offline') }],
-    ['malformed JSON', () => '{not json}'],
-    ['failed response', () => JSON.stringify({ ok: false })],
-    ['different worktree id', () => response({ id: 'repo-123::/worktrees/other' })],
-    ['different worktree path', () => response({ path: '/private/untrusted' })],
-    ['blank display name', () => response({ displayName: '   ' })],
-  ])('fails closed for %s', (_name, command) => {
-    expect(
-      readOrcaSessionTitle(
-        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId },
-        command,
-      ),
-    ).toBeUndefined()
-  })
-})

package/src/orca-session-title.ts

@@ -1,105 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import path from 'node:path'
-
-export type OrcaSessionTitleLookup = (env: NodeJS.ProcessEnv) => string | undefined
-export type OrcaCommand = (executable: string, args: readonly string[]) => string | null
-
-const runOrcaCommand: OrcaCommand = (executable, args) => {
-  try {
-    return execFileSync(executable, args, {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 2_000,
-      maxBuffer: 512 * 1024,
-      windowsHide: true,
-    }).trim()
-  } catch {
-    return null
-  }
-}
-
-function containsControlCharacter(value: string): boolean {
-  return Array.from(value).some((character) => {
-    const codePoint = character.codePointAt(0) ?? 0
-    return codePoint < 32 || codePoint === 127
-  })
-}
-
-function worktreePathFromId(value: string): string | null {
-  if (value.length === 0 || value.length > 4_096 || containsControlCharacter(value)) {
-    return null
-  }
-  const separator = value.indexOf('::')
-  if (separator <= 0) return null
-  const repoId = value.slice(0, separator)
-  const worktreePath = value.slice(separator + 2)
-  if (!/^[A-Za-z0-9._-]+$/u.test(repoId) || worktreePath.length === 0) return null
-  return path.posix.isAbsolute(worktreePath) || path.win32.isAbsolute(worktreePath)
-    ? worktreePath
-    : null
-}
-
-function orcaExecutable(env: NodeJS.ProcessEnv): string | null {
-  const configured = env['ORCA_CLI_COMMAND']?.trim()
-  if (configured !== undefined && configured.length > 0) {
-    return containsControlCharacter(configured) ? null : configured
-  }
-  return env['ORCA_DEV_REPO_ROOT'] === undefined ? 'orca' : 'orca-dev'
-}
-
-/**
- * Read the semantic display name assigned to this exact Orca worktree.
- *
- * The environment contributes only an opaque selector. Orca must return that
- * exact id and its matching path before its display name becomes trusted; no
- * path component or identifier is ever promoted into the User-visible label.
- */
-export function readOrcaSessionTitle(
-  env: NodeJS.ProcessEnv,
-  command: OrcaCommand = runOrcaCommand,
-): string | undefined {
-  if (env['TERM_PROGRAM'] !== 'Orca') return undefined
-  const worktreeId = env['ORCA_WORKTREE_ID']
-  if (worktreeId === undefined) return undefined
-  const expectedPath = worktreePathFromId(worktreeId)
-  if (expectedPath === null) return undefined
-  const executable = orcaExecutable(env)
-  if (executable === null) return undefined
-
-  let output: string | null
-  try {
-    output = command(executable, [
-      'worktree',
-      'show',
-      '--worktree',
-      `id:${worktreeId}`,
-      '--json',
-    ])
-  } catch {
-    return undefined
-  }
-  if (output === null || output === '') return undefined
-
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(output)
-  } catch {
-    return undefined
-  }
-  if (typeof parsed !== 'object' || parsed === null) return undefined
-  const response = parsed as {
-    ok?: unknown
-    result?: { worktree?: { id?: unknown; path?: unknown; displayName?: unknown } }
-  }
-  const worktree = response.result?.worktree
-  if (
-    response.ok !== true ||
-    worktree?.id !== worktreeId ||
-    worktree.path !== expectedPath ||
-    typeof worktree.displayName !== 'string' ||
-    worktree.displayName.trim().length === 0
-  ) {
-    return undefined
-  }
-  return worktree.displayName
-}