@raidiant/notifai 10.1.1 → 10.1.2

package/src/commands-io.ts

@@ -1,108 +0,0 @@
-import { openUrl } from './platform.js'
-import type { CommandIo } from './commands-core.js'
-
-// ---------------------------------------------------------------------------
-// production IO
-// ---------------------------------------------------------------------------
-
-/**
- * Whether a human is driving this terminal.
- *
- * A TTY alone is NOT that evidence: agent harnesses frequently allocate a PTY
- * for the commands they run, and a prompt shown to an agent does not fail — it
- * hangs, because every prompt library waits on stdin rather than erroring. So
- * this also honours `CI` and an explicit `NOTIFAI_NO_INPUT=1` escape hatch,
- * and every interactive affordance stays strictly optional: anything `init`
- * can ask, a flag can answer.
- */
-function isHumanTerminal(env: NodeJS.ProcessEnv): boolean {
-  return (
-    process.stdin.isTTY === true &&
-    process.stdout.isTTY === true &&
-    (env['CI'] ?? '') === '' &&
-    (env['NOTIFAI_NO_INPUT'] ?? '') === ''
-  )
-}
-
-/**
- * Lazy on purpose: the hook path runs in front of every prompt the user types,
- * and must not pay for a prompt library it will never show.
- */
-async function clack() {
-  return await import('@clack/prompts')
-}
-
-export function realIo(env: NodeJS.ProcessEnv = process.env): CommandIo {
-  const interactive = () => isHumanTerminal(env)
-  return {
-    out: (line) => console.log(line),
-    err: (line) => console.error(line),
-    get interactive() {
-      return interactive()
-    },
-    confirm: async (question, fallback = false) => {
-      if (!interactive()) return fallback
-      const p = await clack()
-      const answer = await p.confirm({ message: question, initialValue: fallback })
-      // Ctrl-C mid-prompt arrives as a cancel symbol, not a SIGINT; treat it
-      // as the safe answer rather than letting a Symbol escape into logic.
-      return p.isCancel(answer) ? false : answer
-    },
-    select: async (message, options) => {
-      if (!interactive()) return null
-      const p = await clack()
-      const answer = await p.select({ message, options })
-      return p.isCancel(answer) ? null : (answer as string)
-    },
-    multiselect: async (message, options, initial) => {
-      if (!interactive()) return null
-      const p = await clack()
-      const answer = await p.multiselect({
-        message,
-        options,
-        required: true,
-        ...(initial !== undefined && initial.length > 0 ? { initialValues: initial } : {}),
-      })
-      return p.isCancel(answer) ? null : (answer as string[])
-    },
-    intro: async (title) => {
-      if (!interactive()) return
-      ;(await clack()).intro(title)
-    },
-    outro: async (message) => {
-      if (!interactive()) return
-      ;(await clack()).outro(message)
-    },
-    note: async (message, title) => {
-      if (!interactive()) return
-      ;(await clack()).note(message, title)
-    },
-    spinner: async (message) => {
-      if (!interactive()) return null
-      const progress = (await clack()).spinner()
-      progress.start(message)
-      return {
-        message: (next) => progress.message(next),
-        stop: (next) => progress.stop(next),
-        error: (next) => progress.error(next),
-      }
-    },
-    check: async (ok, message, tone) => {
-      if (!interactive()) return
-      const { log } = await clack()
-      switch (tone ?? (ok ? 'ok' : 'bad')) {
-        case 'ok':
-          return log.success(message)
-        case 'warn':
-          return log.warn(message)
-        case 'pending':
-          // Never checked. `log.info` reads as neutral, which is the honest
-          // rendering for a state no evidence was gathered about.
-          return log.info(message)
-        case 'bad':
-          return log.error(message)
-      }
-    },
-    openUrl,
-  }
-}

package/src/commands-logs.ts

@@ -1,243 +0,0 @@
-import { unlinkSync } from 'node:fs'
-import { type LogLevel } from './config.js'
-import {
-  LOG_EVENTS,
-  RECORD_LEVELS,
-  activeLogPath,
-  archiveLogPaths,
-  logsDiskUsage,
-  readLogRecords,
-  renderRecord,
-  type LogQuery,
-} from './logging.js'
-import { EXIT, loadLoggedConfig, type CommandDeps } from './commands-core.js'
-
-// ---------------------------------------------------------------------------
-// logs
-// ---------------------------------------------------------------------------
-
-export interface LogsFlags {
-  json?: boolean
-  limit?: number
-  all?: boolean
-  since?: string
-  level?: string
-  event?: string[]
-  run?: string
-  request?: string
-  session?: string
-  project?: string
-  allProjects?: boolean
-  grep?: string
-  path?: boolean
-  clear?: boolean
-}
-
-const LOG_RECORD_OPTIONS: readonly (readonly [keyof LogsFlags, string])[] = [
-  ['limit', '--limit'],
-  ['all', '--all'],
-  ['since', '--since'],
-  ['level', '--level'],
-  ['event', '--event'],
-  ['run', '--run'],
-  ['request', '--request'],
-  ['session', '--session'],
-  ['project', '--project'],
-  ['allProjects', '--all-projects'],
-  ['grep', '--grep'],
-]
-
-/**
- * Deliberately small. The reader is usually a model with a finite context, and
- * a log command whose default answer is ten thousand lines gets used once.
- * Everything beyond this is reachable by asking for it.
- */
-const DEFAULT_LOG_LIMIT = 30
-/** Even `--all` stops somewhere; an unbounded dump is never the useful answer. */
-const MAX_LOG_LIMIT = 2_000
-
-/** `10m`, `2h`, `1d`, or an ISO 8601 instant. */
-export function parseSince(raw: string, now: number): number | null {
-  const relative = /^(\d+)([smhd])$/.exec(raw.trim())
-  if (relative !== null) {
-    const amount = Number(relative[1])
-    const unit = relative[2] as 's' | 'm' | 'h' | 'd'
-    const seconds = { s: 1, m: 60, h: 3600, d: 86400 }[unit]
-    return now - amount * seconds * 1000
-  }
-  const absolute = Date.parse(raw)
-  return Number.isNaN(absolute) ? null : absolute
-}
-
-/**
- * What this machine recorded about itself.
- *
- * The retrieval half of the local log, and the half that decides whether the
- * log is worth having. Three things make it usable by an agent rather than
- * merely available to one: the default is bounded and scoped to this project,
- * the filters match the questions actually asked ("that run", "that
- * notification", "just the failures"), and `--json` gives the machine the
- * records untouched on stdout while every word of explanation goes to stderr.
- */
-export function logsCommand(deps: CommandDeps, flags: LogsFlags): number {
-  const selectedRetrievalOptions = LOG_RECORD_OPTIONS
-    .filter(([key]) => {
-      const value = flags[key]
-      return Array.isArray(value) ? value.length > 0 : value !== undefined && value !== false
-    })
-    .map(([, name]) => name)
-
-  if (flags.path === true && flags.clear === true) {
-    deps.io.err('Pass --path or --clear, not both.')
-    return EXIT.usage
-  }
-  if (flags.path === true && selectedRetrievalOptions.length > 0) {
-    deps.io.err(`--path cannot be combined with record options: ${selectedRetrievalOptions.join(', ')}.`)
-    return EXIT.usage
-  }
-  if (flags.clear === true && selectedRetrievalOptions.length > 0) {
-    deps.io.err(`--clear cannot be combined with record options: ${selectedRetrievalOptions.join(', ')}.`)
-    return EXIT.usage
-  }
-  if (flags.project !== undefined && flags.allProjects === true) {
-    deps.io.err('Pass --project or --all-projects, not both.')
-    return EXIT.usage
-  }
-  if (flags.limit !== undefined && flags.all === true) {
-    deps.io.err('Pass --limit or --all, not both.')
-    return EXIT.usage
-  }
-  if (flags.limit !== undefined && (!Number.isInteger(flags.limit) || flags.limit <= 0)) {
-    deps.io.err('--limit must be a positive integer.')
-    return EXIT.usage
-  }
-  if (flags.limit !== undefined && flags.limit > MAX_LOG_LIMIT) {
-    deps.io.err(`--limit cannot exceed ${MAX_LOG_LIMIT}; narrow the result with --since or filters.`)
-    return EXIT.usage
-  }
-
-  const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
-  const now = (deps.now ?? Date.now)()
-
-  if (flags.path === true) {
-    const usage = logsDiskUsage(deps.env)
-    const archives = archiveLogPaths(deps.env)
-    if (flags.json === true) {
-      deps.io.out(
-        JSON.stringify(
-          {
-            active: activeLogPath(deps.env),
-            archives,
-            files: usage.files,
-            bytes: usage.bytes,
-            level: config.log_level.value,
-            max_bytes: config.log_max_bytes.value,
-            max_files: config.log_max_files.value,
-            local_only: true,
-          },
-          null,
-          2,
-        ),
-      )
-      return EXIT.ok
-    }
-    deps.io.out(activeLogPath(deps.env))
-    for (const archive of archives) deps.io.out(archive)
-    deps.io.err(
-      `${usage.files} file(s), ${Math.round(usage.bytes / 1024)} KB, level ${config.log_level.value}. These stay on this machine.`,
-    )
-    return EXIT.ok
-  }
-
-  if (flags.clear === true) {
-    let removed = 0
-    for (const file of [activeLogPath(deps.env), ...archiveLogPaths(deps.env)]) {
-      try {
-        unlinkSync(file)
-        removed += 1
-      } catch {
-        // Absent, or not ours to remove; either way there is nothing to report.
-      }
-    }
-    deps.io.out(
-      flags.json === true
-        ? JSON.stringify({ cleared_files: removed })
-        : `Cleared ${removed} log file${removed === 1 ? '' : 's'}.`,
-    )
-    return EXIT.ok
-  }
-
-  const query: LogQuery = {
-    limit: flags.limit ?? (flags.all === true ? MAX_LOG_LIMIT : DEFAULT_LOG_LIMIT),
-  }
-
-  if (flags.since !== undefined) {
-    const since = parseSince(flags.since, now)
-    if (since === null) {
-      deps.io.err(`Could not read "${flags.since}" as a time. Use 10m, 2h, 1d, or an ISO 8601 instant.`)
-      return EXIT.usage
-    }
-    query.since = since
-  }
-  if (flags.level !== undefined) {
-    if (!(RECORD_LEVELS as readonly string[]).includes(flags.level)) {
-      deps.io.err(`--level takes one of: ${RECORD_LEVELS.join(', ')} — not "${flags.level}".`)
-      return EXIT.usage
-    }
-    query.level = flags.level as LogLevel
-  }
-  if (flags.event !== undefined && flags.event.length > 0) {
-    const unknown = flags.event.filter((name) => !(LOG_EVENTS as readonly string[]).includes(name))
-    if (unknown.length > 0) {
-      deps.io.err(`Unknown event ${unknown.join(', ')}. Valid: ${LOG_EVENTS.join(', ')}`)
-      return EXIT.usage
-    }
-    query.event = flags.event
-  }
-  if (flags.run !== undefined) query.run = flags.run
-  if (flags.session !== undefined) query.session = flags.session
-  if (flags.request !== undefined) query.request = flags.request
-  if (flags.grep !== undefined) query.contains = flags.grep
-
-  // Scoped to this project by default. A machine commonly runs several agents
-  // in several worktrees at once, and the answer to "what just happened" is
-  // useless if three other projects are interleaved through it.
-  const scope =
-    flags.project ?? (flags.allProjects === true ? undefined : (config.project.value ?? undefined))
-  if (scope !== undefined) query.project = scope
-
-  const result = readLogRecords(deps.env, query)
-
-  if (flags.json === true) {
-    for (const record of result.records) deps.io.out(JSON.stringify(record))
-  } else {
-    for (const record of result.records) deps.io.out(renderRecord(record))
-  }
-
-  if (result.records.length === 0) {
-    if (config.log_level.value === 'off') {
-      deps.io.err('Nothing is being recorded: log_level is off.')
-      deps.io.err('Turn it on with `notifai config set log_level info --yes`.')
-    } else if (logsDiskUsage(deps.env).files === 0) {
-      deps.io.err('No log yet. It is written the next time a notifai command or harness hook runs.')
-    } else {
-      deps.io.err('No records matched. Widen it with --all-projects, --since 1d, or --all.')
-    }
-    return EXIT.ok
-  }
-
-  // Everything explanatory goes to stderr so `--json` leaves stdout as clean
-  // JSONL for whatever is parsing it.
-  const notes: string[] = []
-  if (scope !== undefined) notes.push(`project ${scope} (--all-projects for every project)`)
-  if (result.more) {
-    notes.push(
-      query.limit! < MAX_LOG_LIMIT
-        ? `more history behind this (-n ${Math.min(query.limit! * 4, MAX_LOG_LIMIT)} or --all)`
-        : `more history exists beyond the ${MAX_LOG_LIMIT}-record safety cap; narrow with --since or filters`,
-    )
-  }
-  if (config.log_level.value !== 'debug') notes.push('`log_level = debug` records request detail')
-  if (notes.length > 0) deps.io.err(`— ${result.records.length} records; ${notes.join('; ')}`)
-  return EXIT.ok
-}

package/src/commands-project.ts

@@ -1,47 +0,0 @@
-import { loadLoggedConfig, EXIT, type CommandDeps } from './commands-core.js'
-import {
-  disableProject,
-  enableProject,
-  projectBinding,
-  projectEnabled,
-} from './project-enablement.js'
-
-function bindingFor(deps: CommandDeps) {
-  const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
-  return projectBinding(deps.cwd, deps.env, config.project.value)
-}
-
-export function projectEnableCommand(deps: CommandDeps): number {
-  const binding = bindingFor(deps)
-  if (binding === null) {
-    deps.io.err('No Project can be inferred here. Run inside a Project or configure an explicit Project id.')
-    return EXIT.usage
-  }
-  enableProject(binding)
-  deps.io.out(`Notifai lifecycle behavior is enabled for Project "${binding.project}".`)
-  return EXIT.ok
-}
-
-export function projectDisableCommand(deps: CommandDeps): number {
-  const binding = bindingFor(deps)
-  if (binding === null) {
-    deps.io.err('No Project can be inferred here. Run inside a Project or configure an explicit Project id.')
-    return EXIT.usage
-  }
-  disableProject(binding)
-  deps.io.out(`Notifai lifecycle behavior is disabled for Project "${binding.project}".`)
-  return EXIT.ok
-}
-
-export function projectStatusCommand(deps: CommandDeps, json = false): number {
-  const binding = bindingFor(deps)
-  const enabled = projectEnabled(binding)
-  if (json) {
-    deps.io.out(JSON.stringify({ project: binding?.project ?? null, enabled }))
-  } else if (binding === null) {
-    deps.io.out('No Project can be inferred here; lifecycle behavior is disabled.')
-  } else {
-    deps.io.out(`Project "${binding.project}": lifecycle behavior ${enabled ? 'enabled' : 'disabled'}.`)
-  }
-  return EXIT.ok
-}

package/src/commands-send-support.test.ts

@@ -1,156 +0,0 @@
-import { NOTIFICATION_IMAGE_MAX_BYTES } from '@raidiant/notifai-protocol'
-import { createServer, type Server } from 'node:http'
-import type { AddressInfo } from 'node:net'
-import { afterEach, describe, expect, it } from 'vitest'
-import { EXIT, type CommandDeps, type CommandIo } from './commands-core.js'
-import { readCappedBytes, uploadImage } from './commands-send-support.js'
-import type { ApiClient } from './client.js'
-
-let server: Server | undefined
-
-afterEach(async () => {
-  if (server) {
-    const closing = server
-    server = undefined
-    await new Promise<void>((resolve) => closing.close(() => resolve()))
-  }
-})
-
-async function serving(handler: Parameters<typeof createServer>[1]): Promise<string> {
-  server = createServer(handler)
-  await new Promise<void>((resolve) => server?.listen(0, '127.0.0.1', resolve))
-  const { port } = server.address() as AddressInfo
-  return `http://127.0.0.1:${port}`
-}
-
-function io(): CommandIo {
-  return {
-    out: () => undefined,
-    err: () => undefined,
-    confirm: async () => false,
-    openUrl: () => undefined,
-  }
-}
-
-describe('readCappedBytes', () => {
-  it('refuses Content-Length over the cap before reading the body', async () => {
-    const response = new Response(null, { headers: { 'content-length': '64' } })
-    expect(await readCappedBytes(response, 16)).toBe('too-large')
-  })
-
-  it('stops reading once the downloaded bytes exceed the cap', async () => {
-    const response = new Response(
-      new ReadableStream({
-        start(controller) {
-          controller.enqueue(new Uint8Array(12))
-          controller.enqueue(new Uint8Array(12))
-          controller.close()
-        },
-      }),
-    )
-    expect(await readCappedBytes(response, 16)).toBe('too-large')
-  })
-
-  it('returns a payload that fits the cap', async () => {
-    const payload = new Uint8Array([1, 2, 3, 4])
-    expect(await readCappedBytes(new Response(payload), 16)).toEqual(payload)
-  })
-})
-
-function uploadingClient(uploaded: number[]): ApiClient {
-  return {
-    createMediaUpload: async () => ({
-      media_id: 'med_1',
-      upload_url: 'https://upload.invalid/1',
-      upload_headers: {},
-      expires_at: new Date(Date.now() + 60_000).toISOString(),
-    }),
-    uploadMedia: async (_grant: unknown, bytes: Uint8Array) => {
-      uploaded.push(bytes.byteLength)
-    },
-  } as unknown as ApiClient
-}
-
-function refusingClient(): ApiClient {
-  return {
-    createMediaUpload: async () => {
-      throw new Error('must not request an upload')
-    },
-  } as unknown as ApiClient
-}
-
-describe('uploadImage remote fetch', () => {
-  it('uploads bytes under the media limit from an allowed self-hosted origin', async () => {
-    const png = new Uint8Array([0x89, 0x50, 0x4e, 0x47])
-    const baseUrl = await serving((_request, response) => {
-      response.setHeader('content-type', 'image/png')
-      response.end(Buffer.from(png))
-    })
-    const uploaded: number[] = []
-    const deps = { io: io(), env: {}, cwd: '/tmp' } as CommandDeps
-
-    const result = await uploadImage(deps, uploadingClient(uploaded), `${baseUrl}/shot.png`, [
-      baseUrl,
-    ])
-    expect(result).toEqual({ ok: true, mediaId: 'med_1' })
-    expect(uploaded).toEqual([png.byteLength])
-  })
-
-  it('refuses that same loopback origin when the User has not allowed it', async () => {
-    const baseUrl = await serving((_request, response) => {
-      response.setHeader('content-type', 'image/png')
-      response.end(Buffer.from(new Uint8Array([0x89, 0x50, 0x4e, 0x47])))
-    })
-    const deps = { io: io(), env: {}, cwd: '/tmp' } as CommandDeps
-
-    const result = await uploadImage(deps, refusingClient(), `${baseUrl}/shot.png`)
-    expect(result.ok).toBe(false)
-    if (result.ok) throw new Error('expected refusal')
-    expect(result.exit).toBe(EXIT.usage)
-    expect(result.error).toContain('media_origins')
-  })
-
-  it('refuses a remote image whose Content-Length exceeds the server media limit', async () => {
-    const baseUrl = await serving((_request, response) => {
-      response.setHeader('content-type', 'image/png')
-      response.setHeader('content-length', String(NOTIFICATION_IMAGE_MAX_BYTES + 1))
-      response.end()
-    })
-    const deps = { io: io(), env: {}, cwd: '/tmp' } as CommandDeps
-
-    const result = await uploadImage(deps, refusingClient(), `${baseUrl}/huge.png`, [baseUrl])
-    expect(result.ok).toBe(false)
-    if (result.ok) throw new Error('expected refusal')
-    expect(result.exit).toBe(EXIT.usage)
-    expect(result.error).toContain(String(NOTIFICATION_IMAGE_MAX_BYTES))
-  })
-
-  it('refuses a redirect out of an allowed origin into an unallowed one', async () => {
-    const target = await serving((_request, response) => {
-      response.setHeader('content-type', 'image/png')
-      response.end(Buffer.from(new Uint8Array([0x89, 0x50, 0x4e, 0x47])))
-    })
-    // A second loopback origin the User never allowed. The first hop is
-    // trusted; the destination is not, and each hop is checked on its own.
-    const redirector = createServer((_request, response) => {
-      response.writeHead(302, { location: `${target}/shot.png` })
-      response.end()
-    })
-    await new Promise<void>((resolve) => redirector.listen(0, '127.0.0.1', resolve))
-    const { port } = redirector.address() as AddressInfo
-    const redirectOrigin = `http://127.0.0.1:${port}`
-    const deps = { io: io(), env: {}, cwd: '/tmp' } as CommandDeps
-
-    try {
-      const result = await uploadImage(deps, refusingClient(), `${redirectOrigin}/shot.png`, [
-        redirectOrigin,
-      ])
-      expect(result.ok).toBe(false)
-      if (result.ok) throw new Error('expected refusal')
-      expect(result.exit).toBe(EXIT.usage)
-      expect(result.error).toContain('media_origins')
-    } finally {
-      await new Promise<void>((resolve) => redirector.close(() => resolve()))
-    }
-  })
-})