@justjoshn/pi-pstack 0.15.36-pi.1 → 0.15.36-pi.7

package/src/subscriptions/supervisor-main.ts

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+
+import { PACKAGE_ROOT } from '../paths.ts';
+import { createSupervisor } from './supervisor.ts';
+
+function usage(): never {
+  console.error('Usage: pstack-routines-supervisor --workspace <cwd>');
+  process.exit(2);
+}
+
+function parseArgs(argv: string[]): { workspace: string } {
+  let workspace: string | undefined;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--workspace') {
+      workspace = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') usage();
+    console.error(`Unknown argument: ${arg}`);
+    usage();
+  }
+  if (workspace === undefined || workspace.trim() === '') usage();
+  return { workspace: resolve(workspace) };
+}
+
+/** Spawns a headless Pi print run; resolves only when the child exits 0. */
+function runFresh(prompt: string, name: string, meta: { subscriptionId: string; cwd: string }): Promise<void> {
+  return new Promise((resolvePromise, reject) => {
+    const raw: unknown = JSON.parse(process.env['PI_PSTACK_PI_COMMAND'] ?? '["pi"]');
+    if (!Array.isArray(raw) || raw.length === 0 || !raw.every((part) => typeof part === 'string' && part !== '')) {
+      reject(new Error('Invalid Pi command supplied to the subscription supervisor.'));
+      return;
+    }
+    const [executable, ...prefix] = raw as string[];
+    if (executable === undefined) {
+      reject(new Error(`Could not spawn fire for "${name}" (${meta.subscriptionId}): no pi command`));
+      return;
+    }
+    const child = spawn(executable, [...prefix, '--mode', 'json', '-e', PACKAGE_ROOT, '-p', '--', prompt], {
+      cwd: meta.cwd,
+      env: process.env,
+      stdio: 'ignore',
+    });
+    child.once('error', (error) => reject(new Error(`Could not spawn fire for "${name}" (${meta.subscriptionId}): ${error.message}`)));
+    child.once('exit', (code, signal) => {
+      if (signal != null) {
+        reject(new Error(`Fire for "${name}" (${meta.subscriptionId}) exited from signal ${signal}`));
+        return;
+      }
+      if (code !== 0) {
+        reject(new Error(`Fire for "${name}" (${meta.subscriptionId}) exited with code ${code ?? 'null'}`));
+        return;
+      }
+      resolvePromise();
+    });
+  });
+}
+
+async function main(): Promise<void> {
+  const { workspace } = parseArgs(process.argv.slice(2));
+  const supervisor = createSupervisor({ workspaceCwd: workspace, runFresh, isDaemon: true });
+  const result = await supervisor.start();
+  if (!result.started) {
+    console.log(`pstack-routines-supervisor already running for ${workspace} (pid ${result.pid}).`);
+    process.exit(0);
+  }
+  console.log(`pstack-routines-supervisor started for ${workspace} (pid ${process.pid}).`);
+  await new Promise<void>((resolve) => {
+    const shutdown = () => {
+      supervisor.stop();
+      resolve();
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    process.on('SIGHUP', () => {
+      void supervisor.reconcile();
+    });
+  });
+}
+
+main().catch((error: unknown) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/src/subscriptions/supervisor.ts

@@ -0,0 +1,271 @@
+import { randomUUID } from 'node:crypto';
+
+import { routinesDir } from '../paths.ts';
+import { cronMatches, parseCron } from './cron.ts';
+import { acceptEvent, acquireSupervisorLock, alive, canonicalPath, clearError, expireDesired, finishFresh, isDesired, readLock, readRegistry, recordError, releaseSupervisorLock, startFresh, writeArm } from './durable-store.ts';
+import type { DurableSubscription, StoredSubscription } from './durable-types.ts';
+import { defaultGhRunner, fetchPrs, type GhRunner, type PrSnapshot, pollChanges } from './github.ts';
+import { credentialFile, DEFAULT_ROUTINES_PORT, ensureCredentials, RoutineServer, type WebhookEvent, webhookEventBlock } from './webhook.ts';
+
+const MAX_STEP_MS = 24 * 24 * 3_600_000;
+const MINUTE_MS = 60_000;
+export type RunFresh = (prompt: string, name: string, meta: { subscriptionId: string; cwd: string }) => Promise<void> | void;
+export interface SupervisorOptions {
+  workspaceCwd: string;
+  runFresh: RunFresh;
+  now?: () => number;
+  routinesPort?: number;
+  routinesDir?: string;
+  pollIntervalMs?: number;
+  gh?: GhRunner;
+  reconcileIntervalMs?: number;
+  onAccepted?: () => void;
+  isDaemon?: boolean;
+  ownerSessionId?: string;
+}
+type TimerConfig = Extract<DurableSubscription['config'], { kind: 'timer' }>;
+type Armed = { sub: StoredSubscription; timers: Set<ReturnType<typeof setTimeout>>; baseline?: Map<number, PrSnapshot>; polling?: boolean };
+
+function envPort(): number {
+  const raw = process.env['PSTACK_ROUTINES_PORT'];
+  const port = raw === undefined || raw === '' ? DEFAULT_ROUTINES_PORT : Number(raw);
+  return Number.isInteger(port) && port >= 0 && port < 65536 ? port : DEFAULT_ROUTINES_PORT;
+}
+export function delayFireIndex(createdAt: number, delaySeconds: number, at: number): number {
+  return Math.floor(Math.max(0, at - createdAt) / (Math.max(1, delaySeconds) * 1_000));
+}
+export function timerClaimKey(sub: DurableSubscription, config: TimerConfig, at: number): string {
+  if (config.once) return `${sub.id}:once`;
+  return `${sub.id}:${config.cron === undefined ? delayFireIndex(sub.createdAt, config.delaySeconds ?? 1, at) : Math.floor(at / MINUTE_MS)}`;
+}
+
+export function createSupervisor(options: SupervisorOptions) {
+  const cwd = canonicalPath(options.workspaceCwd);
+  const now = options.now ?? Date.now;
+  const gh = options.gh ?? defaultGhRunner;
+  const pollMs = options.pollIntervalMs ?? MINUTE_MS;
+  const dir = options.routinesDir ?? routinesDir();
+  const server = new RoutineServer(options.routinesPort ?? envPort());
+  const armed = new Map<string, Armed>();
+  const isDaemon = options.isDaemon ?? true;
+  let active = false;
+  let epoch: string | undefined;
+  let watchTimer: ReturnType<typeof setTimeout> | undefined;
+  let reconciling: Promise<void> | undefined;
+
+  const owns = (entry: Armed) => active && armed.get(entry.sub.id) === entry;
+  const at = (entry: Armed, when: number, fn: () => void) => {
+    const handle = setTimeout(
+      () => {
+        entry.timers.delete(handle);
+        if (!owns(entry)) return;
+        if (now() < when) at(entry, when, fn);
+        else fn();
+      },
+      Math.min(Math.max(0, when - now()), MAX_STEP_MS),
+    );
+    handle.unref?.();
+    entry.timers.add(handle);
+  };
+  const disarm = (entry: Armed) => {
+    for (const handle of entry.timers) clearTimeout(handle);
+    entry.timers.clear();
+    if (entry.sub.config.kind === 'webhook') {
+      server.routes.delete(entry.sub.config.slug);
+      if (server.routes.size === 0) server.close(false);
+    }
+  };
+  const error = (id: string, cause: unknown) => recordError(cwd, id, cause);
+  const offlineFresh = () => {
+    if (!active) return;
+    const registry = readRegistry(cwd);
+    const eligible = registry.pending.filter((event) => {
+      if (event.claim !== undefined && alive(event.claim.pid)) return false;
+      if (event.retryAt !== undefined && now() < event.retryAt) return false;
+      const sub = registry.subscriptions.find((s) => s.id === event.subscriptionId);
+      if (sub === undefined || sub.lifecycle === 'cancelled' || sub.config.kind !== 'timer' || sub.config.strategy !== 'new_session') return false;
+      if (!isDaemon && (options.ownerSessionId === undefined || sub.ownerSessionId !== options.ownerSessionId)) return false;
+      return true;
+    });
+    for (const event of eligible) {
+      const claim = startFresh(
+        cwd,
+        event.id,
+        undefined,
+        () => active,
+        (sub, pending) => options.runFresh(pending.content, sub.name, { subscriptionId: sub.id, cwd }),
+      );
+      if (claim !== undefined)
+        void claim.result
+          .then(
+            () => finishFresh(cwd, event.id, claim.token),
+            (cause: unknown) => finishFresh(cwd, event.id, claim.token, cause),
+          )
+          .catch((cause: unknown) => {
+            console.error(`Subscription delivery status failed. ${String(cause)}`);
+          });
+    }
+  };
+  const accepted = () => {
+    options.onAccepted?.();
+    offlineFresh();
+  };
+  const fireTimer = (entry: Armed, config: TimerConfig) => {
+    if (!owns(entry)) return;
+    try {
+      const prompt = config.strategy === 'wake_self' ? `[timer] ${entry.sub.name}\n\n${config.prompt}` : config.prompt;
+      if (acceptEvent(cwd, entry.sub.id, timerClaimKey(entry.sub, config, now()), prompt, now()) === 'accepted') accepted();
+    } catch (cause) {
+      error(entry.sub.id, cause);
+    }
+  };
+  const armTimer = (entry: Armed, config: TimerConfig) => {
+    if (config.cron !== undefined) {
+      const schedule = parseCron(config.cron);
+      const tick = () => {
+        if (cronMatches(schedule, new Date(now()))) fireTimer(entry, config);
+        const current = readRegistry(cwd).subscriptions.find((sub) => sub.id === entry.sub.id);
+        if (current !== undefined && isDesired(current, now())) at(entry, (Math.floor(now() / MINUTE_MS) + 1) * MINUTE_MS, tick);
+      };
+      at(entry, (Math.floor(now() / MINUTE_MS) + 1) * MINUTE_MS, tick);
+    } else {
+      const period = (config.delaySeconds ?? 1) * 1_000;
+      const next = () => (config.once ? entry.sub.createdAt + period : entry.sub.createdAt + (Math.floor(Math.max(0, now() - entry.sub.createdAt) / period) + 1) * period);
+      const fire = () => {
+        fireTimer(entry, config);
+        const current = readRegistry(cwd).subscriptions.find((sub) => sub.id === entry.sub.id);
+        if (current !== undefined && isDesired(current, now())) at(entry, config.once ? now() + 1_000 : next(), fire);
+      };
+      at(entry, next(), fire);
+    }
+  };
+  const onWebhook =
+    (entry: Armed, prompt: string) =>
+    async (event: WebhookEvent): Promise<boolean> => {
+      if (!owns(entry)) return false;
+      const content = [`[routine] ${entry.sub.name}`, prompt, webhookEventBlock(event)].join('\n\n');
+      const result = acceptEvent(cwd, entry.sub.id, event.eventId, content, now());
+      if (result === 'inactive') return false;
+      if (result === 'accepted') accepted();
+      return true;
+    };
+  const poll = async (entry: Armed, target: Extract<DurableSubscription['config'], { kind: 'github' }>['target']) => {
+    if (entry.polling || !owns(entry)) return;
+    entry.polling = true;
+    try {
+      const after = await fetchPrs(gh, target);
+      if (!owns(entry)) return;
+      if (entry.baseline !== undefined) {
+        const blocks = await pollChanges(gh, target, entry.baseline, after);
+        if (!owns(entry)) return;
+        if (blocks.length > 0 && acceptEvent(cwd, entry.sub.id, randomUUID(), [`[github] ${entry.sub.name}`, ...blocks].join('\n\n'), now()) === 'accepted') accepted();
+      }
+      entry.baseline = after;
+      clearError(cwd, entry.sub.id);
+    } finally {
+      entry.polling = false;
+    }
+  };
+  const arm = async (entry: Armed): Promise<string | undefined> => {
+    if (entry.sub.ownerSessionId === undefined) throw new Error('Owner session ID unavailable. Recreate this subscription.');
+    at(entry, entry.sub.expiresAt, () => {
+      expireDesired(cwd, now());
+      void reconcile().catch((cause: unknown) => error(entry.sub.id, cause));
+    });
+    const config = entry.sub.config;
+    if (config.kind === 'timer') armTimer(entry, config);
+    else if (config.kind === 'webhook') {
+      server.routes.set(config.slug, { slug: config.slug, credentialFile: ensureCredentials(dir, config.slug), onEvent: onWebhook(entry, config.prompt) });
+      return await server.url(config.slug);
+    } else {
+      const loop = () => {
+        void poll(entry, config.target).then(
+          () => {
+            if (owns(entry)) at(entry, now() + pollMs, loop);
+          },
+          (cause: unknown) => {
+            error(entry.sub.id, cause);
+            if (owns(entry)) at(entry, now() + pollMs, loop);
+          },
+        );
+      };
+      loop();
+    }
+    return undefined;
+  };
+  const reconcile = (): Promise<void> => {
+    if (!active) return Promise.resolve();
+    if (reconciling !== undefined) return reconciling;
+    reconciling = (async () => {
+      const registry = readRegistry(cwd);
+      if (registry.subscriptions.some((sub) => sub.lifecycle === 'active' && sub.expiresAt <= now())) expireDesired(cwd, now());
+      const desired = registry.subscriptions.filter((sub) => isDesired(sub, now()));
+      for (const [id, entry] of armed)
+        if (!desired.some((sub) => sub.id === id && sub.revision === entry.sub.revision)) {
+          disarm(entry);
+          armed.delete(id);
+        }
+      for (const sub of desired) {
+        if (!active) return;
+        if (armed.has(sub.id)) continue;
+        const entry: Armed = { sub, timers: new Set() };
+        armed.set(sub.id, entry);
+        try {
+          const url = await arm(entry);
+          if (!owns(entry) || epoch === undefined) continue;
+          clearError(cwd, sub.id);
+          writeArm(cwd, { state: 'ready', subscriptionId: sub.id, revision: sub.revision, epoch, ...(url === undefined ? {} : { url }) });
+        } catch (cause) {
+          disarm(entry);
+          armed.delete(sub.id);
+          if (!active || epoch === undefined) return;
+          const message = cause instanceof Error ? cause.message : String(cause);
+          error(sub.id, cause);
+          writeArm(cwd, { state: 'error', subscriptionId: sub.id, revision: sub.revision, epoch, message });
+        }
+      }
+      offlineFresh();
+    })().finally(() => {
+      reconciling = undefined;
+    });
+    return reconciling;
+  };
+  const watch = () => {
+    if (!active) return;
+    watchTimer = setTimeout(() => {
+      void reconcile()
+        .catch((cause: unknown) => console.error(`Subscription supervisor reconcile failed. ${String(cause)}`))
+        .finally(watch);
+    }, options.reconcileIntervalMs ?? 250);
+  };
+  return {
+    start: async (): Promise<{ started: boolean; alreadyRunning?: boolean; pid?: number }> => {
+      const lock = acquireSupervisorLock(cwd);
+      if (!lock.acquired) return { started: false, alreadyRunning: true, pid: lock.pid };
+      epoch = readLock(cwd)?.epoch;
+      active = true;
+      try {
+        await reconcile();
+        watch();
+        return { started: true };
+      } catch (cause) {
+        active = false;
+        releaseSupervisorLock(cwd, process.pid, epoch);
+        throw cause;
+      }
+    },
+    reconcile,
+    stop: () => {
+      active = false;
+      if (watchTimer !== undefined) clearTimeout(watchTimer);
+      for (const entry of armed.values()) disarm(entry);
+      armed.clear();
+      server.close();
+      if (epoch !== undefined) releaseSupervisorLock(cwd, process.pid, epoch);
+      epoch = undefined;
+    },
+    isListening: () => server.isListening(),
+    credentialFile: (slug: string) => credentialFile(dir, slug),
+  };
+}
+export type Supervisor = ReturnType<typeof createSupervisor>;

package/src/subscriptions/webhook.ts

@@ -1,4 +1,4 @@
-import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
 import type { AddressInfo } from 'node:net';
@@ -83,6 +83,7 @@ function presentedKey(request: IncomingMessage): string | undefined {
 }
 
 export interface WebhookEvent {
+  eventId: string;
   headers: Record<string, string>;
   bodyDigest: string;
   body: string;
@@ -99,7 +100,7 @@ export function webhookEventBlock(event: WebhookEvent): string {
 export interface RoutineRoute {
   slug: string;
   credentialFile: string;
-  onEvent: (event: WebhookEvent) => void;
+  onEvent: (event: WebhookEvent) => Promise<boolean>;
 }
 
 const reply = (response: ServerResponse, status: number, message: string) => {
@@ -111,6 +112,7 @@ const reply = (response: ServerResponse, status: number, message: string) => {
 export class RoutineServer {
   private server: Server | undefined;
   private listening: Promise<number> | undefined;
+  private readonly closing = new Set<Server>();
   readonly routes = new Map<string, RoutineRoute>();
   private readonly port: number;
 
@@ -144,9 +146,13 @@ export class RoutineServer {
     return this.server?.listening === true;
   }
 
-  close(): void {
-    this.server?.close();
-    this.server?.closeAllConnections();
+  close(force = true): void {
+    const server = this.server;
+    if (server !== undefined) {
+      this.closing.add(server);
+      server.close(() => this.closing.delete(server));
+    }
+    if (force) for (const closing of this.closing) closing.closeAllConnections();
     this.server = undefined;
     this.listening = undefined;
   }
@@ -179,13 +185,15 @@ export class RoutineServer {
       size += chunk.length;
       if (size > MAX_BODY_BYTES) {
         done = true;
-        reply(response, 413, `Body over ${MAX_BODY_BYTES} bytes.`);
+        response.writeHead(413, { 'content-type': 'application/json', connection: 'close' });
+        response.write(`${JSON.stringify({ error: `Body over ${MAX_BODY_BYTES} bytes.` })}\n`);
+        request.once('end', () => response.end());
         request.resume();
         return;
       }
       chunks.push(chunk);
     });
-    request.on('end', () => {
+    request.on('end', async () => {
       if (done) return;
       done = true;
       const raw = Buffer.concat(chunks);
@@ -202,8 +210,13 @@ export class RoutineServer {
         const header = request.headers[name];
         if (typeof header === 'string') headers[name] = header;
       }
-      route.onEvent({ headers, bodyDigest: createHash('sha256').update(raw).digest('hex'), body, timestampMs: Date.now() });
-      reply(response, 200, 'ok');
+      if (this.routes.get(route.slug) !== route) return reply(response, 404, 'No such routine.');
+      try {
+        const accepted = await route.onEvent({ eventId: randomUUID(), headers, bodyDigest: createHash('sha256').update(raw).digest('hex'), body, timestampMs: Date.now() });
+        reply(response, accepted ? 200 : 404, accepted ? 'ok' : 'No such routine.');
+      } catch {
+        reply(response, 503, 'Could not durably accept this event. Retry later.');
+      }
     });
   }
 }

package/src/task/card.ts

@@ -30,3 +30,32 @@ export function taskCardText(result: Pick<AgentToolResult<unknown>, 'content' |
 export function renderTaskCard(result: AgentToolResult<unknown>, options: { expanded: boolean }): Text {
   return new Text(taskCardText(result, options.expanded), 0, 0);
 }
+
+interface NotificationCardDetails {
+  status: 'success' | 'error';
+  agentId: string;
+  title: string;
+  detail: string;
+}
+
+function isNotificationCardDetails(details: unknown): details is NotificationCardDetails {
+  const value = details as Partial<NotificationCardDetails> | null;
+  return typeof value === 'object' && value !== null && (value.status === 'success' || value.status === 'error') && typeof value.agentId === 'string' && typeof value.title === 'string' && typeof value.detail === 'string';
+}
+
+export function taskNotificationCardText(message: { content: string | { type: string; text?: string }[]; details?: unknown }, expanded: boolean): string {
+  if (!isNotificationCardDetails(message.details)) {
+    const raw = typeof message.content === 'string' ? message.content : message.content.map((part) => (part.type === 'text' ? (part.text ?? '') : '')).join('\n');
+    const lines = raw.split('\n');
+    return (expanded || lines.length <= COLLAPSED_LINES ? lines : [...lines.slice(0, COLLAPSED_LINES), `… ${lines.length - COLLAPSED_LINES} more lines`]).join('\n');
+  }
+  const { title, status, agentId, detail } = message.details;
+  const lines = detail.split('\n');
+  const body = expanded || lines.length <= COLLAPSED_LINES ? lines : [...lines.slice(0, COLLAPSED_LINES), `… ${lines.length - COLLAPSED_LINES} more lines`];
+  const head = `${title.trim() === '' ? 'subagent' : title.trim()} · ${status} · agent ${agentId}`;
+  return [head, ...body].join('\n');
+}
+
+export function renderTaskNotification(message: { content: string | { type: string; text?: string }[]; details?: unknown }, options: { expanded: boolean }): Text {
+  return new Text(taskNotificationCardText(message, options.expanded), 0, 0);
+}

package/src/task/records.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { SessionManager } from '@earendil-works/pi-coding-agent';
+import { parseSessionEntries, SessionManager } from '@earendil-works/pi-coding-agent';
 import type { ModelSpec } from './models.ts';
 import type { Worktree } from './worktree.ts';
 
@@ -81,13 +81,8 @@ export function transcriptFor(dir: string, agentId: string): string | undefined
 
 /** The working directory a Pi session file's header names, or undefined without a readable header. */
 function sessionCwd(file: string): string | undefined {
-  try {
-    const header = JSON.parse(readFileSync(file, 'utf8').split('\n', 1)[0] ?? '') as { type?: unknown; cwd?: unknown } | null;
-    return header?.type === 'session' && typeof header.cwd === 'string' ? header.cwd : undefined;
-  } catch (error) {
-    if (error instanceof SyntaxError) return undefined;
-    throw error;
-  }
+  const [header] = parseSessionEntries(readFileSync(file, 'utf8').split('\n', 1)[0] ?? '');
+  return header?.type === 'session' && typeof header.cwd === 'string' && header.cwd !== '' ? header.cwd : undefined;
 }
 
 /**

package/src/task/runner.ts

@@ -2,8 +2,10 @@ import { spawn } from 'node:child_process';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
 
 import type { ImageContent, Usage } from '@earendil-works/pi-ai';
+import { detectSupportedImageMimeTypeFromFile } from '@earendil-works/pi-coding-agent';
 import { PACKAGE_ROOT } from '../paths.ts';
 import type { ModelSpec } from './models.ts';
 
@@ -61,15 +63,6 @@ export function resolveAttachments(paths: readonly string[], cwd: string, home:
   });
 }
 
-const isBmp = (bytes: Buffer) => bytes.length >= 30 && bytes.toString('latin1', 0, 2) === 'BM' && [12, 40, 52, 56, 108, 124].includes(bytes.readUInt32LE(14));
-const IMAGE_TYPES: [string, (bytes: Buffer) => boolean][] = [
-  ['image/png', (bytes) => bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))],
-  ['image/jpeg', (bytes) => bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff && bytes[3] !== 0xf7],
-  ['image/gif', (bytes) => /^GIF8[79]a/.test(bytes.toString('latin1', 0, 6))],
-  ['image/webp', (bytes) => bytes.toString('latin1', 0, 4) === 'RIFF' && bytes.toString('latin1', 8, 12) === 'WEBP'],
-  ['image/bmp', isBmp],
-];
-
 export interface ChildInput {
   text: string;
   images: ImageContent[];
@@ -79,14 +72,14 @@ export interface ChildInput {
  * The first message Pi builds from piped input and `@file` arguments, which RPC mode does not accept: the trimmed
  * prompt, then each non-empty text file in a <file> block, and each image as an attachment with an empty <file> block.
  */
-export function withAttachments(prompt: string, attachments: readonly string[]): ChildInput {
+export async function withAttachments(prompt: string, attachments: readonly string[]): Promise<ChildInput> {
   let text = prompt.trim();
   const images: ImageContent[] = [];
   for (const path of attachments) {
     const bytes = readFileSync(path);
     if (bytes.length === 0) continue;
-    const mimeType = IMAGE_TYPES.find(([, matches]) => matches(bytes))?.[0];
-    if (mimeType === undefined) {
+    const mimeType = await detectSupportedImageMimeTypeFromFile(path);
+    if (mimeType === null) {
       text += `<file name="${path}">\n${bytes.toString('utf8').replace(/^\uFEFF/, '')}\n</file>\n`;
       continue;
     }
@@ -125,7 +118,7 @@ export interface ChildHandle {
   pid: number | undefined;
 }
 
-export const zeroUsage = (): Usage => ({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } });
+export const zeroUsage = (): Usage => ({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, totalFromProvider: true } });
 
 export function addUsage(left: Usage, right: Usage): Usage {
   return {
@@ -140,6 +133,7 @@ export function addUsage(left: Usage, right: Usage): Usage {
       cacheRead: left.cost.cacheRead + right.cost.cacheRead,
       cacheWrite: left.cost.cacheWrite + right.cost.cacheWrite,
       total: left.cost.total + right.cost.total,
+      totalFromProvider: left.cost.totalFromProvider === true && right.cost.totalFromProvider === true,
     },
   };
 }
@@ -176,9 +170,10 @@ function readAssistant(event: Record<string, unknown>): AssistantRecord | undefi
 }
 
 function lineReader(onLine: (line: string) => void): (chunk: Buffer) => void {
+  const decoder = new StringDecoder('utf8');
   let buffer = '';
   return (chunk) => {
-    buffer += chunk.toString('utf8');
+    buffer += decoder.write(chunk);
     for (let index = buffer.indexOf('\n'); index !== -1; index = buffer.indexOf('\n')) {
       const line = buffer.slice(0, index).trim();
       buffer = buffer.slice(index + 1);