@raidiant/notifai 10.1.1 → 10.1.2

package/src/commands-setup-proof.test.ts

@@ -1,72 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-import type { CommandDeps } from './commands-core.js'
-import type { MachineCredential } from './credentials.js'
-import { readSetupProof, setupProofApplies, writeSetupProof } from './commands-setup-proof.js'
-
-const roots: string[] = []
-afterEach(() => {
-  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function deps(root: string, cwd: string, credential: MachineCredential): CommandDeps {
-  return {
-    cwd,
-    env: { XDG_STATE_HOME: path.join(root, 'state'), XDG_CONFIG_HOME: path.join(root, 'config') },
-    io: { out: () => {}, err: () => {}, confirm: async () => false, openUrl: () => {} },
-    store: {
-      load: () => credential,
-      save: () => {},
-      clear: () => {},
-      describe: () => 'test',
-    },
-  }
-}
-
-describe('stable setup delivery proof identity', () => {
-  it('is shared by linked checkouts of one Project and separated by Project', () => {
-    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-proof-identity-'))
-    roots.push(root)
-    const credential = {
-      machineId: 'mac_one',
-      machineName: 'One',
-      baseUrl: 'https://app.notifai.test',
-      secret: 'approval-one',
-    }
-    const first = deps(root, path.join(root, 'worktree-a'), credential)
-    const second = deps(root, path.join(root, 'worktree-b'), credential)
-    const proof = {
-      request_id: 'req_proof',
-      device_id: 'dev_one',
-      project: 'shared-project',
-      started_at: '2026-08-26T00:00:00.000Z',
-    }
-    expect(writeSetupProof(first, proof)).toBe(true)
-    expect(readSetupProof(second, 'shared-project')).toEqual(proof)
-    expect(readSetupProof(second, 'different-project')).toBeNull()
-  })
-
-  it('invalidates on service, machine approval, machine, or device change', () => {
-    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-proof-invalidation-'))
-    roots.push(root)
-    const credential = {
-      machineId: 'mac_one',
-      machineName: 'One',
-      baseUrl: 'https://app.notifai.test',
-      secret: 'approval-one',
-    }
-    const original = deps(root, root, credential)
-    expect(writeSetupProof(original, {
-      request_id: 'req_proof',
-      device_id: 'dev_one',
-      project: 'project',
-      started_at: '2026-08-26T00:00:00.000Z',
-    })).toBe(true)
-    expect(readSetupProof(deps(root, root, { ...credential, baseUrl: 'https://other.test' }), 'project')).toBeNull()
-    expect(readSetupProof(deps(root, root, { ...credential, machineId: 'mac_two' }), 'project')).toBeNull()
-    expect(readSetupProof(deps(root, root, { ...credential, secret: 'approval-two' }), 'project')).toBeNull()
-    expect(setupProofApplies(readSetupProof(original, 'project'), 'project', ['dev_two'])).toBe(false)
-  })
-})

package/src/commands-setup-proof.ts

@@ -1,124 +0,0 @@
-import { type EvidenceSnapshot } from '@raidiant/notifai-protocol'
-import { createHash } from 'node:crypto'
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from 'node:fs'
-import path from 'node:path'
-import { stateDir } from './config.js'
-import type { CommandDeps } from './commands-core.js'
-import { inferInvocationContext } from './invocation-context.js'
-
-export interface SetupProofRecord {
-  request_id: string
-  device_id: string
-  project: string | null
-  started_at: string
-}
-
-export function setupProofProject(deps: CommandDeps, configured: string | null): string | null {
-  return configured ?? inferInvocationContext(deps.cwd).project
-}
-
-function setupProofPath(deps: CommandDeps, project: string | null): string | null {
-  const credential = deps.store.load()
-  if (credential === null) return null
-  const approval = createHash('sha256')
-    .update('notifai-setup-proof-approval-v1\0')
-    .update(credential.secret)
-    .digest('base64url')
-  const digest = createHash('sha256')
-    .update(JSON.stringify({ project, machine_id: credential.machineId, service: credential.baseUrl, approval }))
-    .digest('hex')
-    .slice(0, 32)
-  return path.join(stateDir(deps.env), 'setup-proofs', `${digest}.json`)
-}
-
-export function readSetupProof(deps: CommandDeps, project: string | null): SetupProofRecord | null {
-  const file = setupProofPath(deps, project)
-  if (file === null) return null
-  if (!existsSync(file)) return null
-  try {
-    const parsed = JSON.parse(readFileSync(file, 'utf8')) as Partial<SetupProofRecord>
-    return typeof parsed.request_id === 'string' &&
-      typeof parsed.device_id === 'string' &&
-      (typeof parsed.project === 'string' || parsed.project === null) &&
-      typeof parsed.started_at === 'string'
-      ? (parsed as SetupProofRecord)
-      : null
-  } catch {
-    // Corrupt local evidence is not readiness. A fresh proof replaces it.
-    return null
-  }
-}
-
-export function writeSetupProof(deps: CommandDeps, proof: SetupProofRecord): boolean {
-  const file = setupProofPath(deps, proof.project)
-  if (file === null) {
-    deps.io.err('Could not save setup proof without an Approved Machine credential.')
-    return false
-  }
-  try {
-    mkdirSync(path.dirname(file), { recursive: true })
-    writeFileSync(file, `${JSON.stringify(proof, null, 2)}\n`, { mode: 0o600 })
-    return true
-  } catch (err) {
-    deps.io.err(
-      `Could not save setup proof ${proof.request_id} at ${file}: ${String(err)}`,
-    )
-    return false
-  }
-}
-
-export function observedCompanionReceipt(
-  snapshot: EvidenceSnapshot,
-  deviceId: string,
-): { delivery: EvidenceSnapshot['deliveries'][number]; observedAt: string } | null {
-  const delivery = snapshot.deliveries.find((candidate) => candidate.device_id === deviceId)
-  if (!delivery) return null
-  if (delivery.companion_receipt.state === 'observed' && delivery.companion_receipt.observed_at) {
-    return { delivery, observedAt: delivery.companion_receipt.observed_at }
-  }
-  const receipt = delivery.events.find((event) => event.stage === 'companion_received')
-  return receipt ? { delivery, observedAt: receipt.occurred_at } : null
-}
-
-/** Replace an unknown setup proof after this age; recent in-flight proofs stay. */
-export const SETUP_PROOF_STALE_MS = 24 * 60 * 60 * 1000
-
-export function setupProofIsStale(proof: SetupProofRecord, now: number): boolean {
-  const started = Date.parse(proof.started_at)
-  return Number.isFinite(started) && now - started > SETUP_PROOF_STALE_MS
-}
-
-export function setupProofApplies(
-  proof: SetupProofRecord | null,
-  project: string | null,
-  deviceIds: readonly string[],
-): proof is SetupProofRecord {
-  return proof !== null && proof.project === project && deviceIds.includes(proof.device_id)
-}
-
-/**
- * Persist ordinary send/status Companion Receipts as the project's delivery
- * proof so doctor does not demand a second verification request.
- */
-export function recordObservedDeliveryProof(
-  deps: CommandDeps,
-  snapshot: EvidenceSnapshot,
-  project: string | null,
-): boolean {
-  for (const delivery of snapshot.deliveries) {
-    const observed = observedCompanionReceipt(snapshot, delivery.device_id)
-    if (observed === null) continue
-    return writeSetupProof(deps, {
-      request_id: snapshot.request_id,
-      device_id: delivery.device_id,
-      project,
-      started_at: observed.observedAt,
-    })
-  }
-  return false
-}

package/src/commands-skill.test.ts

@@ -1,44 +0,0 @@
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import type { CommandDeps } from './commands-core.js'
-import { skillReadiness, SKILLS_SOURCE } from './commands-skill.js'
-
-describe('development CLI skill parity', () => {
-  it('reports an exact gap instead of calling a stale released skill ready', async () => {
-    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-dev-skill-'))
-    const installedPath = path.join(root, 'skills', 'notifai')
-    mkdirSync(installedPath, { recursive: true })
-    writeFileSync(path.join(installedPath, 'SKILL.md'), '# stale released skill\n')
-    const match = /^([^#]+)#(.+)$/.exec(SKILLS_SOURCE ?? '')
-    if (match === null) throw new Error('test build has no skill release pin')
-    const deps = {
-      cwd: root,
-      env: {},
-      io: { out() {}, err() {}, confirm: async () => false, openUrl() {} },
-      store: { load: () => null, save() {}, clear() {}, describe: () => 'test' },
-      nativeSkills: {
-        list: async (scope: 'project' | 'global') => ({
-          skills: scope === 'global'
-            ? [{ name: 'notifai', scope, path: installedPath, source: match[1]!, sourceType: 'github' as const, sourceUrl: `https://github.com/${match[1]}.git`, ref: match[2]! }]
-            : [],
-        }),
-        add: async () => 0,
-        remove: async () => 0,
-      },
-    } satisfies CommandDeps
-
-    const state = await skillReadiness(deps)
-    expect(state).toMatchObject({
-      status: 'gap',
-      technical: {
-        resolution: 'development-cli-skill-mismatch',
-        ref: match[2],
-        checkout_digest: expect.stringMatching(/^sha256:/),
-        installed_digest: expect.stringMatching(/^sha256:/),
-      },
-    })
-    expect(state.remedy).toBeUndefined()
-  })
-})

package/src/commands-skill.ts

@@ -1,204 +0,0 @@
-import { SKILLS_INSTALLER_SPEC, type NativeSkill, type SkillScope } from './native-skills.js'
-import { createHash } from 'node:crypto'
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { type ReadinessState } from './readiness.js'
-import { skillsSource } from './release.js'
-import type { CommandDeps } from './commands-core.js'
-
-/**
- * Where `npx skills add` fetches the optional agent skill from, derived from
- * this build's own version so the pin cannot drift from the release it names.
- * Null when the build cannot establish its version; see `./release.js`.
- */
-export const SKILLS_SOURCE: string | null = skillsSource()
-
-/**
- * How to refer to the pin in user-facing text.
- *
- * Only reached in a corrupted install, where naming the tag is impossible but
- * saying nothing would be worse — the sentence still has to read as English.
- */
-const SKILLS_SOURCE_LABEL = SKILLS_SOURCE ?? 'the public release tag matching this CLI'
-
-const SKILL_SCOPES: readonly SkillScope[] = ['project', 'global']
-
-function markdownTreeDigest(root: string): string | null {
-  if (!existsSync(root)) return null
-  const files: string[] = []
-  const walk = (directory: string): void => {
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
-      const absolute = path.join(directory, entry.name)
-      if (entry.isDirectory()) walk(absolute)
-      else if (entry.isFile() && entry.name.endsWith('.md')) files.push(absolute)
-    }
-  }
-  try {
-    walk(root)
-    const hash = createHash('sha256')
-    for (const file of files.sort()) {
-      hash.update(path.relative(root, file))
-      hash.update('\0')
-      hash.update(readFileSync(file))
-      hash.update('\0')
-    }
-    return `sha256:${hash.digest('hex')}`
-  } catch {
-    return null
-  }
-}
-
-function developmentSkillMismatch(skill: NativeSkill): { checkout: string; installed: string } | null {
-  const checkoutRoot = fileURLToPath(new URL('../../../skills/notifai/', import.meta.url))
-  const checkout = markdownTreeDigest(checkoutRoot)
-  const installed = markdownTreeDigest(skill.path)
-  return checkout !== null && installed !== null && checkout !== installed
-    ? { checkout, installed }
-    : null
-}
-
-function skillSourceParts(): { source: string; ref: string } | null {
-  if (SKILLS_SOURCE === null) return null
-  const match = /^([^#]+)#(.+)$/.exec(SKILLS_SOURCE)
-  return match === null ? null : { source: match[1]!, ref: match[2]! }
-}
-
-function expectedSkill(skill: NativeSkill): boolean {
-  const expected = skillSourceParts()
-  return (
-    expected !== null &&
-    skill.name === 'notifai' &&
-    skill.source === expected.source &&
-    skill.sourceType === 'github' &&
-    skill.ref === expected.ref
-  )
-}
-
-function skillPin(skill: NativeSkill): string {
-  return skill.ref ?? 'unknown pin'
-}
-
-export interface ScopedNotifaiSkills {
-  installed: NativeSkill[]
-  errors: string[]
-}
-
-/**
- * Installer-managed notifai skills in both scopes. Duplicate detection has to
- * see the pair; a selected-scope filter would hide the copy the harness still
- * lists.
- */
-export async function listScopedNotifaiSkills(deps: CommandDeps): Promise<ScopedNotifaiSkills> {
-  const results = await Promise.all(
-    SKILL_SCOPES.map(async (scope) => {
-      if (deps.nativeSkills === undefined) return { scope, skills: [] as NativeSkill[] }
-      try {
-        return { scope, ...(await deps.nativeSkills.list(scope, deps.cwd, deps.env)) }
-      } catch (err) {
-        return { scope, skills: [] as NativeSkill[], error: String(err) }
-      }
-    }),
-  )
-  return {
-    installed: results.flatMap(({ skills }) => skills.filter((skill) => skill.name === 'notifai')),
-    errors: results
-      .filter((result) => result.error !== undefined)
-      .map((result) => `${result.scope}: ${result.error}`),
-  }
-}
-
-function duplicateSkillState(installed: NativeSkill[], selectedScope?: SkillScope): ReadinessState {
-  const project = installed.find((skill) => skill.scope === 'project')
-  const global = installed.find((skill) => skill.scope === 'global')
-  const projectPin = project === undefined ? 'not installed' : skillPin(project)
-  const globalPin = global === undefined ? 'not installed' : skillPin(global)
-  return {
-    id: 'skill',
-    title: 'Agent guidance skill',
-    status: 'gap',
-    detail:
-      `project (${projectPin}) and global (${globalPin}) are both installed, so the harness lists both. ` +
-      'Keep either project or global and uninstall the other.',
-    technical: {
-      project:
-        project === undefined
-          ? null
-          : { ref: project.ref, path: project.path, current: expectedSkill(project) },
-      global:
-        global === undefined
-          ? null
-          : { ref: global.ref, path: global.path, current: expectedSkill(global) },
-      resolution: 'both-listed',
-    },
-    remedy:
-      selectedScope === undefined
-        ? {
-            by: 'user-here',
-            summary:
-              'keep either the project or the machine-global skill and uninstall the other; add --global to remove the machine-global copy',
-            command: `npx -y ${SKILLS_INSTALLER_SPEC} remove notifai`,
-          }
-        : {
-            by: 'cli',
-            summary: `keep the ${selectedScope} skill and uninstall the other`,
-            command: `notifai init --skills --setup-scope ${selectedScope}`,
-          },
-  }
-}
-
-export async function skillReadiness(
-  deps: CommandDeps,
-  selectedScope?: SkillScope,
-): Promise<ReadinessState> {
-  const { installed, errors } = await listScopedNotifaiSkills(deps)
-  if (installed.length > 1) return duplicateSkillState(installed, selectedScope)
-
-  const current = installed.find(expectedSkill)
-  if (current !== undefined) {
-    const mismatch = developmentSkillMismatch(current)
-    if (mismatch !== null) {
-      return {
-        id: 'skill',
-        title: 'Agent guidance skill',
-        status: 'gap',
-        detail:
-          `the active development CLI's shipped guidance differs from the installer-managed ${skillPin(current)} skill. ` +
-          'Released installs remain immutable; publish a new CLI/skill release before treating this combination as ready.',
-        technical: {
-          resolution: 'development-cli-skill-mismatch',
-          scope: current.scope,
-          ref: current.ref,
-          path: current.path,
-          checkout_digest: mismatch.checkout,
-          installed_digest: mismatch.installed,
-        },
-      }
-    }
-    return {
-      id: 'skill',
-      title: 'Agent guidance skill',
-      status: 'ready',
-      detail: `installed from ${SKILLS_SOURCE_LABEL} in the ${current.scope} scope`,
-    }
-  }
-
-  const scopeText = selectedScope === undefined ? 'project or machine-global scope' : `${selectedScope} scope`
-  return {
-    id: 'skill',
-    title: 'Agent guidance skill',
-    status: 'optional-gap',
-    detail:
-      errors.length > 0
-        ? `could not verify installer-managed state in ${scopeText} (${errors.join('; ')})`
-        : `not installed from ${SKILLS_SOURCE_LABEL} in ${scopeText}`,
-    remedy: {
-      by: 'cli',
-      summary: 'install the skill agents follow when deciding to notify',
-      command:
-        selectedScope === undefined
-          ? 'notifai init --skills --setup-scope project'
-          : `notifai init --skills --setup-scope ${selectedScope}`,
-    },
-  }
-}

package/src/commands-sounds.test.ts

@@ -1,106 +0,0 @@
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import type { ApiClient } from './client.js'
-import { EXIT, type CommandDeps, type CommandIo } from './commands-core.js'
-import { soundsCommand } from './commands-sounds.js'
-
-class CapturedIo implements CommandIo {
-  readonly outLines: string[] = []
-  readonly errLines: string[] = []
-  out(line: string): void {
-    this.outLines.push(line)
-  }
-  err(line: string): void {
-    this.errLines.push(line)
-  }
-  async confirm(): Promise<boolean> {
-    return true
-  }
-  openUrl(): void {}
-}
-
-function makeDeps(io: CapturedIo, client: ApiClient): CommandDeps {
-  const testRoot = path.join(os.tmpdir(), 'notifai-cli-sounds-tests')
-  return {
-    io,
-    store: {
-      load: () => ({
-        machineId: 'mac_test',
-        secret: 'test-secret',
-        baseUrl: 'https://test.notifai.invalid',
-        machineName: 'test-machine',
-      }),
-      save: () => {},
-      clear: () => {},
-      describe: () => 'test credential store',
-    },
-    env: {
-      XDG_CONFIG_HOME: testRoot,
-      XDG_STATE_HOME: path.join(os.tmpdir(), 'notifai-cli-sounds-tests-state'),
-    },
-    cwd: os.tmpdir(),
-    clientFactory: () => client,
-  }
-}
-
-const kitchenTimer = {
-  sound_id: 'snd_kitchen',
-  name: 'Kitchen timer',
-  duration_ms: 2400,
-  content_hash: 'a'.repeat(64),
-  url: 'https://wav.example/kitchen.wav',
-}
-
-describe('soundsCommand', () => {
-  it('lists shipped names and Account custom sounds', async () => {
-    const io = new CapturedIo()
-    const client = {
-      listSounds: async () => ({ sounds: [kitchenTimer] }),
-    } as unknown as ApiClient
-
-    expect(await soundsCommand(makeDeps(io, client), {})).toBe(EXIT.ok)
-    expect(io.outLines[0]).toBe('default  Device default')
-    expect(io.outLines).toContain('done  completion chime')
-    expect(io.outLines).toContain('none  silent')
-    expect(io.outLines.at(-1)).toBe('snd_kitchen  Kitchen timer  2.4s')
-  })
-
-  it('prints the catalog as JSON when asked', async () => {
-    const io = new CapturedIo()
-    const client = {
-      listSounds: async () => ({ sounds: [kitchenTimer] }),
-    } as unknown as ApiClient
-
-    expect(await soundsCommand(makeDeps(io, client), { json: true })).toBe(EXIT.ok)
-    const parsed = JSON.parse(io.outLines.join('\n')) as {
-      shipped: { ref: string; name: string }[]
-      custom: typeof kitchenTimer[]
-    }
-    expect(parsed.shipped[0]).toEqual({ ref: 'default', name: 'Device default' })
-    expect(parsed.custom).toEqual([kitchenTimer])
-  })
-
-  it('refuses to list custom sounds when this machine is not signed in', async () => {
-    const io = new CapturedIo()
-    let calls = 0
-    const deps: CommandDeps = {
-      ...makeDeps(io, {
-        listSounds: async () => {
-          calls += 1
-          return { sounds: [] }
-        },
-      } as unknown as ApiClient),
-      store: {
-        load: () => null,
-        save: () => {},
-        clear: () => {},
-        describe: () => 'empty store',
-      },
-    }
-
-    expect(await soundsCommand(deps, {})).toBe(EXIT.auth)
-    expect(calls).toBe(0)
-    expect(io.errLines.join('\n')).toMatch(/not signed in/i)
-  })
-})

package/src/commands-sounds.ts

@@ -1,49 +0,0 @@
-import type { ListSoundsResponse, SoundView } from '@raidiant/notifai-protocol'
-import {
-  EXIT,
-  authedClient,
-  loadLoggedConfig,
-  reportError,
-  type CommandDeps,
-} from './commands-core.js'
-import { SHIPPED_SOUND_LISTING } from './sound-ref.js'
-
-export interface SoundsListing {
-  shipped: readonly { ref: string; name: string }[]
-  custom: SoundView[]
-}
-
-function formatSoundDuration(ms: number): string {
-  const seconds = ms / 1000
-  const text = Number.isInteger(seconds) ? String(seconds) : seconds.toFixed(1)
-  return `${text}s`
-}
-
-export async function soundsCommand(
-  deps: CommandDeps,
-  flags: { json?: boolean },
-): Promise<number> {
-  const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
-  const authed = authedClient(deps, config)
-  if (!authed) return EXIT.auth
-  try {
-    const result: ListSoundsResponse = await authed.client.listSounds()
-    const listing: SoundsListing = {
-      shipped: SHIPPED_SOUND_LISTING,
-      custom: result.sounds,
-    }
-    if (flags.json) {
-      deps.io.out(JSON.stringify(listing, null, 2))
-      return EXIT.ok
-    }
-    for (const sound of listing.shipped) {
-      deps.io.out(`${sound.ref}  ${sound.name}`)
-    }
-    for (const sound of listing.custom) {
-      deps.io.out(`${sound.sound_id}  ${sound.name}  ${formatSoundDuration(sound.duration_ms)}`)
-    }
-    return EXIT.ok
-  } catch (err) {
-    return reportError(deps, err)
-  }
-}