@raidiant/notifai 7.0.2 → 9.0.0

package/src/commands-init.ts

@@ -8,10 +8,11 @@ import { randomBytes } from 'node:crypto'
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { parse as parseToml, stringify as stringifyToml } from 'smol-toml'
+import { ensurePrivateDirectory } from './atomic-file.js'
 import { ApiCallError, NetworkError, type ApiClient } from './client.js'
-import { type CliConfig } from './config.js'
+import { personalProjectConfigPath, type CliConfig } from './config.js'
 import { projectSlugFrom as inferredProjectSlugFrom } from './invocation-context.js'
-import type { SkillScope } from './native-skills.js'
+import { SKILLS_INSTALLER_SPEC, type SkillScope } from './native-skills.js'
 import { firstBlocker, type Readiness, type ReadinessRefresh, type ReadinessState } from './readiness.js'
 import { buildDraft, formatReceipt } from './send.js'
 import { loginCommand } from './commands-auth.js'
@@ -23,11 +24,16 @@ import {
   reportError,
   type CommandDeps,
 } from './commands-core.js'
-import { readyIosDevices, supportPageUrl } from './commands-devices.js'
+import { readyCompanionDevices, supportPageUrl } from './commands-devices.js'
 import { assessReadiness, remedyLine } from './commands-doctor.js'
 import { hooksInstallCommand, pickHarnessesToInstall } from './commands-hooks.js'
-import { observedCompanionReceipt, readSetupProof, writeSetupProof } from './commands-setup-proof.js'
-import { SKILLS_SOURCE } from './commands-skill.js'
+import {
+  observedCompanionReceipt,
+  readSetupProof,
+  setupProofIsStale,
+  writeSetupProof,
+} from './commands-setup-proof.js'
+import { listScopedNotifaiSkills, SKILLS_SOURCE } from './commands-skill.js'
 
 // ---------------------------------------------------------------------------
 // init
@@ -39,6 +45,9 @@ export function projectSlugFrom(name: string): string {
   return inferredProjectSlugFrom(name) ?? 'project'
 }
 
+/** Project checkout vs this machine. Drives skill, hooks, and config together. */
+export type SetupScope = SkillScope
+
 export interface InitFlags {
   projectId?: string
   /**
@@ -48,14 +57,20 @@ export interface InitFlags {
    * never spawn npx against the network by default.
    */
   skills?: boolean
-  /** Scope selected by an unattended caller; humans choose inside npx skills. */
+  /**
+   * One setup-scope for skill, hooks, and config. The unattended answer to
+   * init's single project-vs-machine question. Pairing, devices, and the CLI
+   * binary are not this flag.
+   */
+  setupScope?: SetupScope
+  /** Alias of `--setup-scope` when installing the skill unattended. */
   skillsScope?: SkillScope
   /** Same tri-state, for the harness hooks. */
   hooks?: boolean
 }
 
 
-/** Long enough for a first TestFlight install; keep-waiting extends another budget. */
+/** Long enough for a first controlled Companion install; keep-waiting extends another budget. */
 const DEVICE_BRIDGE_TIMEOUT_MS = 10 * 60 * 1000
 const DEVICE_BRIDGE_POLL_MS = 2_000
 const PROOF_TIMEOUT_MS = 30_000
@@ -97,12 +112,17 @@ async function closeGap(
   flags: InitFlags,
 ): Promise<GapCloseResult> {
   if (state.id === 'project') {
-    const configPath = path.join(deps.cwd, '.notifai', 'config.toml')
+    const slug = projectSlugFrom(flags.projectId ?? path.basename(deps.cwd))
+    const configPath =
+      flags.setupScope === 'global'
+        ? personalProjectConfigPath(deps.cwd, deps.env)
+        : path.join(deps.cwd, '.notifai', 'config.toml')
     const existing = existsSync(configPath)
       ? (parseToml(readFileSync(configPath, 'utf8')) as Record<string, unknown>)
       : {}
-    existing['project'] = projectSlugFrom(flags.projectId ?? path.basename(deps.cwd))
-    mkdirSync(path.dirname(configPath), { recursive: true })
+    existing['project'] = slug
+    if (flags.setupScope === 'global') ensurePrivateDirectory(path.dirname(configPath))
+    else mkdirSync(path.dirname(configPath), { recursive: true })
     writeFileSync(configPath, `${stringifyToml(existing)}\n`)
     return 'closed'
   }
@@ -111,8 +131,9 @@ async function closeGap(
     const harnesses = await pickHarnessesToInstall(deps)
     if (harnesses === null || harnesses.length === 0) return 'failed'
     let ok = true
+    const hookFlags = flags.setupScope === 'global' ? { global: true as const } : {}
     for (const harness of harnesses) {
-      if (hooksInstallCommand(deps, { harness }) !== EXIT.ok) ok = false
+      if (hooksInstallCommand(deps, { harness, ...hookFlags }) !== EXIT.ok) ok = false
     }
     return ok ? 'closed' : 'failed'
   }
@@ -130,22 +151,43 @@ async function closeGap(
       )
       return 'failed'
     }
-    const scopeText = flags.skillsScope === undefined ? 'the scope you choose' : `${flags.skillsScope} scope`
-    deps.io.out(`Starting the native npx skills setup for the notifai agent skill (${scopeText})...`)
-    const addOptions = {
+    const installScope = flags.setupScope ?? flags.skillsScope
+    if (installScope === undefined) {
+      deps.io.err(
+        'Skill installation refused — choose a setup scope: `notifai init --skills --setup-scope project` or `... global`.',
+      )
+      return 'failed'
+    }
+    const { installed } = await listScopedNotifaiSkills(deps)
+    const extras = installed.filter((skill) => skill.scope !== installScope)
+    for (const extra of extras) {
+      const code = await deps.nativeSkills.remove({
+        skill: 'notifai',
+        scope: extra.scope,
+        cwd: deps.cwd,
+        env: deps.env,
+      })
+      if (code !== 0) {
+        deps.io.err(
+          `Skill installation refused — could not uninstall the ${extra.scope} copy (${extra.ref ?? 'unknown pin'}), so installing ${installScope} would leave both active.`,
+        )
+        return 'failed'
+      }
+    }
+    deps.io.out(`Starting the native npx skills setup for the notifai agent skill (${installScope} scope)...`)
+    const code = await deps.nativeSkills.add({
       source: SKILLS_SOURCE,
       skill: 'notifai',
       cwd: deps.cwd,
       env: deps.env,
-      ...(flags.skillsScope === undefined ? {} : { scope: flags.skillsScope }),
-    }
-    const code = await deps.nativeSkills.add(addOptions)
+      scope: installScope,
+    })
     if (code !== 0) {
       deps.io.err('Skill installation failed — run it manually with:')
       deps.io.err(
-        `  npx skills add ${SKILLS_SOURCE} --skill notifai${
-          flags.skillsScope === 'global' ? ' --global' : ''
-        }${flags.skillsScope === undefined ? '' : ' --yes'}`,
+        `  npx -y ${SKILLS_INSTALLER_SPEC} add ${SKILLS_SOURCE} --skill notifai${
+          installScope === 'global' ? ' --global' : ''
+        } --yes`,
       )
     }
     return code === 0 ? 'closed' : 'failed'
@@ -159,20 +201,21 @@ async function closeGap(
 
 function deviceBridgeMessage(devices: readonly RoutableDevice[]): string {
   if (devices.length === 0) {
-    return 'Waiting for the iPhone app to sign in and register…'
+    return 'Waiting for a Companion App to sign in and register…'
   }
   const denied = devices.find((device) => device.permission_status === 'denied')
   if (denied) return `Waiting for notifications to be allowed on ${denied.display_name}…`
   const undecided = devices.find((device) => device.permission_status === 'not_determined')
   if (undecided) return `Waiting for ${undecided.display_name} to allow the notification prompt…`
-  return 'Waiting for an iPhone to become ready…'
+  return 'Waiting for a Companion device to become ready…'
 }
 
 /**
  * Observe the supported Device Installation path while the user finishes the
- * app-side work. The live bridge is the dashboard `/support` page (TestFlight
- * steps). Interactive runs offer to open it so the user never types the URL;
- * non-interactive/agent paths only print plain text and never wait on a prompt.
+ * app-side work. The live bridge is the dashboard `/support` page (controlled
+ * Companion installation steps). Interactive runs offer to open it so the user
+ * never types the URL; non-interactive/agent paths only print plain text and
+ * never wait on a prompt.
  *
  * The wait budget is stated up front. On expiry we say the *timer* expired —
  * not the setup — and offer another budget when a human is present. Agents
@@ -197,9 +240,9 @@ async function waitForReadyDevice(deps: CommandDeps, state: ReadinessState): Pro
       state.detail,
       remedy.summary,
       `Install steps (no typing): ${supportUrl}`,
-      `I will wait up to ${budgetLabel} for your iPhone to become ready.`,
+      `I will wait up to ${budgetLabel} for a Companion device to become ready.`,
     ].join('\n'),
-    'Finish setup on your iPhone',
+    'Finish setup on your Companion device',
   )
 
   // Open the real support page so the user never has to type the URL. Decline
@@ -219,7 +262,9 @@ async function waitForReadyDevice(deps: CommandDeps, state: ReadinessState): Pro
   const sleep =
     deps.sleep ??
     ((milliseconds: number) => new Promise<void>((resolve) => setTimeout(resolve, milliseconds)))
-  const spinner = await deps.io.spinner?.(`Waiting up to ${budgetLabel} for your iPhone…`)
+  const spinner = await deps.io.spinner?.(
+    `Waiting up to ${budgetLabel} for a Companion device…`,
+  )
   let lastDevices: RoutableDevice[] = []
   let deadline = now() + DEVICE_BRIDGE_TIMEOUT_MS
 
@@ -227,14 +272,16 @@ async function waitForReadyDevice(deps: CommandDeps, state: ReadinessState): Pro
     while (now() < deadline) {
       try {
         const response = await authed.client.listDevices()
-        const iphoneDevices = response.devices.filter((device) => device.platform === 'ios')
-        lastDevices = iphoneDevices
-        const ready = readyIosDevices(iphoneDevices)[0]
+        const companionDevices = response.devices.filter(
+          (device) => device.platform === 'ios' || device.platform === 'android',
+        )
+        lastDevices = companionDevices
+        const ready = readyCompanionDevices(companionDevices)[0]
         if (ready) {
           spinner?.stop(`${ready.display_name} is ready to receive`)
           return 'closed'
         }
-        spinner?.message(deviceBridgeMessage(iphoneDevices))
+        spinner?.message(deviceBridgeMessage(companionDevices))
       } catch (err) {
         if (!(err instanceof NetworkError)) {
           spinner?.error('Could not check companion readiness')
@@ -263,10 +310,12 @@ async function waitForReadyDevice(deps: CommandDeps, state: ReadinessState): Pro
       false,
     )
     if (!keepWaiting) {
-      deps.io.out('Stopping the wait. iPhone setup can continue; re-run `notifai init` when ready.')
+      deps.io.out(
+        'Stopping the wait. Companion setup can continue; re-run `notifai init` when ready.',
+      )
       return 'pending'
     }
-    spinner?.message(`Waiting another ${budgetLabel} for your iPhone…`)
+    spinner?.message(`Waiting another ${budgetLabel} for a Companion device…`)
     deadline = now() + DEVICE_BRIDGE_TIMEOUT_MS
   }
 }
@@ -282,12 +331,13 @@ function setupProofDraft(
       project === null
         ? 'This real notification completed setup verification.'
         : `This real notification completed setup verification for ${project}.`,
-    event: 'setup_verified',
     kind: 'update',
-    platform: 'ios',
+    platform: device.platform,
     device: [device.device_id],
     sound: 'none',
-    level: 'passive',
+    // Android has no caller-selected interruption level. Explicit null keeps an
+    // Apple preference in config from leaking into this Android-only proof.
+    level: device.platform === 'ios' ? 'passive' : null,
     collapseKey: 'notifai-setup-verification',
   })
 }
@@ -331,8 +381,8 @@ async function submitSetupProof(
 
 /**
  * Send or resume one real setup probe, then wait for a Companion Receipt.
- * Provider Acceptance is intentionally insufficient: it proves APNs accepted
- * the push, not that a companion process received it.
+ * Provider Acceptance is intentionally insufficient: it proves a push provider
+ * accepted the request, not that a companion process received it.
  */
 async function runSetupProof(deps: CommandDeps): Promise<GapCloseResult> {
   const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
@@ -346,7 +396,7 @@ async function runSetupProof(deps: CommandDeps): Promise<GapCloseResult> {
     reportError(deps, err)
     return 'failed'
   }
-  const candidates = readyIosDevices(devices)
+  const candidates = readyCompanionDevices(devices)
   const existing = readSetupProof(deps)
   const target =
     candidates.find(
@@ -354,7 +404,7 @@ async function runSetupProof(deps: CommandDeps): Promise<GapCloseResult> {
         device.device_id === existing?.device_id && existing.project === config.project.value,
     ) ?? candidates[0]
   if (!target) {
-    deps.io.err('Setup proof needs a receipt-capable iPhone.')
+    deps.io.err('Setup proof needs a receipt-capable iPhone or Android Companion App.')
     return 'pending'
   }
 
@@ -362,6 +412,22 @@ async function runSetupProof(deps: CommandDeps): Promise<GapCloseResult> {
     existing?.device_id === target.device_id && existing.project === config.project.value
       ? existing
       : null
+  const nowMs = (deps.now ?? Date.now)()
+  if (proof !== null && setupProofIsStale(proof, nowMs)) {
+    let keepStale = false
+    try {
+      const snapshot = await authed.client.evidence(proof.request_id)
+      keepStale = observedCompanionReceipt(snapshot, proof.device_id) !== null
+    } catch {
+      keepStale = false
+    }
+    if (!keepStale) {
+      deps.io.out(
+        `The saved proof ${proof.request_id} is older than 24h without a Companion Receipt; sending a replacement.`,
+      )
+      proof = null
+    }
+  }
   if (proof === null) {
     const receipt = await submitSetupProof(deps, authed.client, config, target)
     if (receipt === null) return 'failed'
@@ -494,32 +560,76 @@ function wantsOptional(deps: CommandDeps, state: ReadinessState, flags: InitFlag
  * and a revoked credential are the same code path arriving at different
  * states rather than four branches to enumerate.
  */
-export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<number> {
+function isSetupScope(value: string | undefined): value is SetupScope {
+  return value === 'project' || value === 'global'
+}
+
+async function resolveSetupScope(
+  deps: CommandDeps,
+  flags: InitFlags,
+): Promise<SetupScope | undefined | 'usage'> {
+  if (flags.setupScope !== undefined && !isSetupScope(flags.setupScope)) {
+    deps.io.err('Invalid setup scope. Choose `project` or `global`.')
+    return 'usage'
+  }
+  if (flags.skillsScope !== undefined && !isSetupScope(flags.skillsScope)) {
+    deps.io.err('Invalid skill scope. Choose `project` or `global`.')
+    return 'usage'
+  }
   if (
+    flags.setupScope !== undefined &&
     flags.skillsScope !== undefined &&
-    flags.skillsScope !== 'project' &&
-    flags.skillsScope !== 'global'
+    flags.setupScope !== flags.skillsScope
   ) {
-    deps.io.err('Invalid skill scope. Choose `project` or `global`.')
-    return EXIT.usage
+    deps.io.err('`--setup-scope` and `--skills-scope` disagree. Pass one, or pass the same value twice.')
+    return 'usage'
   }
   if (flags.skillsScope !== undefined && flags.skills !== true) {
-    deps.io.err('`--skills-scope` requires `--skills`. Choose project or global in the native installer.')
-    return EXIT.usage
+    deps.io.err('`--skills-scope` requires `--skills`. Use `--setup-scope` to choose project or machine for the whole setup.')
+    return 'usage'
   }
-  if (
-    flags.skills === true &&
-    deps.io.interactive !== true &&
-    flags.skillsScope === undefined
-  ) {
+  const fromFlags = flags.setupScope ?? flags.skillsScope
+  if (fromFlags !== undefined) return fromFlags
+  if (flags.skills === false && flags.hooks === false) return undefined
+  if (deps.io.interactive === true && deps.io.select) {
+    const selected = await deps.io.select(
+      'Should this Notifai setup apply to this project only, or to every project on this machine?',
+      [
+        {
+          value: 'project',
+          label: 'This project',
+          hint: 'skill, hooks, and shared config stay in this checkout',
+        },
+        {
+          value: 'global',
+          label: 'This machine',
+          hint: 'skill and hooks follow you into every repo',
+        },
+      ],
+    )
+    if (selected === 'project' || selected === 'global') return selected
+    deps.io.err('No setup scope selected. Pass `--setup-scope project` or `--setup-scope global`.')
+    return 'usage'
+  }
+  if (flags.skills === true) {
     deps.io.err(
-      'Unattended skill setup requires an explicit scope: `notifai init --skills --skills-scope project` or `... global`.',
+      'Unattended skill setup requires an explicit scope: `notifai init --skills --setup-scope project` or `... global`.',
     )
-    return EXIT.usage
+    return 'usage'
+  }
+  return undefined
+}
+
+export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<number> {
+  const setupScope = await resolveSetupScope(deps, flags)
+  if (setupScope === 'usage') return EXIT.usage
+  const resolved: InitFlags = {
+    ...flags,
+    ...(setupScope === undefined ? {} : { setupScope, skillsScope: flags.skillsScope ?? setupScope }),
   }
   await deps.io.intro?.('Notifai setup')
 
-  const skillOpts = flags.skillsScope === undefined ? {} : { skillScope: flags.skillsScope }
+  const skillOpts = resolved.setupScope === undefined ? {} : { skillScope: resolved.setupScope }
   let readiness = await assessReadiness(deps, skillOpts)
   const reassess = (refresh?: readonly ReadinessRefresh[]) =>
     assessReadiness(deps, {
@@ -551,9 +661,9 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
       }
 
       if (state.status === 'optional-gap') {
-        if (remedy.by !== 'cli' || !(await wantsOptional(deps, state, flags))) continue
+        if (remedy.by !== 'cli' || !(await wantsOptional(deps, state, resolved))) continue
         attempted.add(state.id)
-        const result = await closeGap(deps, state, flags)
+        const result = await closeGap(deps, state, resolved)
         if (result === 'failed') failed = true
         if (result === 'failed' && state.status === 'optional-gap') {
           readiness = await reassess(refreshAfterClose(state.id))
@@ -571,7 +681,7 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
 
       if (remedy.by === 'cli') {
         attempted.add(state.id)
-        const result = await closeGap(deps, state, flags)
+        const result = await closeGap(deps, state, resolved)
         if (result === 'failed') failed = true
         if (result !== 'closed') {
           stop = true
@@ -626,7 +736,7 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
     if (stop || !advanced) break
   }
 
-  await printInitClose(deps, readiness, flags)
+  await printInitClose(deps, readiness, resolved)
   const blocker = firstBlocker(readiness)
   if (blocker === null) return failed ? EXIT.failed : EXIT.ok
   return failed || deps.io.interactive !== true ? EXIT.failed : EXIT.ok

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

@@ -0,0 +1,156 @@
+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()))
+    }
+  })
+})