@fitlab-ai/agent-infra 0.8.2 → 0.8.3

package/lib/sandbox/image-build.ts

@@ -0,0 +1,134 @@
+import { createHash } from 'node:crypto';
+import { detectEngine } from './engine.ts';
+import { resolveBuildUid } from './engines/native.ts';
+import { toEnginePath } from './engines/wsl2-paths.ts';
+import { sandboxImageConfigLabel, sandboxImageRefreshLabel, sandboxLabel } from './constants.ts';
+import { runEngine, runSafeEngine } from './shell.ts';
+import {
+  imageSignatureFields,
+  toolNpmPackagesArg,
+  toolShellInstallScriptBase64
+} from './tools.ts';
+import type { SandboxTool } from './tools.ts';
+
+type PreparedDockerfileSignature = {
+  signature: unknown;
+};
+type BuildImageConfig = {
+  project: string;
+  imageName: string;
+  repoRoot: string;
+  engine?: string | null;
+};
+type EngineRunFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string }) => string;
+type EngineRunSafeFn = EngineRunFn;
+
+export function buildImageSignature(preparedDockerfile: PreparedDockerfileSignature, tools: SandboxTool[]): string {
+  return createHash('sha256')
+    .update(JSON.stringify({
+      dockerfile: preparedDockerfile.signature,
+      tools: imageSignatureFields(tools)
+    }))
+    .digest('hex')
+    .slice(0, 12);
+}
+
+export function buildSandboxImageArgs(
+  config: BuildImageConfig,
+  tools: SandboxTool[],
+  dockerfilePath: string,
+  imageSignature: string,
+  {
+    engine,
+    runFn = runEngine,
+    runSafeFn = runSafeEngine,
+    env = process.env,
+    refresh = false,
+    lastRefresh
+  }: {
+    engine?: string;
+    runFn?: EngineRunFn;
+    runSafeFn?: EngineRunSafeFn;
+    env?: NodeJS.ProcessEnv;
+    refresh?: boolean;
+    lastRefresh?: number;
+  } = {}
+): string[] {
+  const selectedEngine = engine ?? detectEngine({ engine: config.engine });
+  const { uid: hostUid, gid: hostGid } = resolveBuildUid({
+    engine: selectedEngine,
+    runFn,
+    runSafeFn,
+    env
+  });
+
+  const args = [
+    'build',
+    '-t',
+    config.imageName,
+    '--build-arg',
+    `HOST_UID=${hostUid}`,
+    '--build-arg',
+    `HOST_GID=${hostGid}`,
+    '--build-arg',
+    `AI_TOOL_PACKAGES=${toolNpmPackagesArg(tools)}`,
+    '--build-arg',
+    `AI_TOOLS_SHELL_INSTALL_B64=${toolShellInstallScriptBase64(tools)}`,
+    '--label',
+    sandboxLabel(config),
+    '--label',
+    `${sandboxImageConfigLabel(config)}=${imageSignature}`
+  ];
+
+  if (lastRefresh !== undefined) {
+    args.push('--label', `${sandboxImageRefreshLabel(config)}=${lastRefresh}`);
+  }
+
+  args.push(
+    '-f',
+    toEnginePath(selectedEngine, dockerfilePath),
+    toEnginePath(selectedEngine, config.repoRoot)
+  );
+
+  if (refresh) {
+    args.splice(1, 0, '--no-cache', '--pull');
+  }
+
+  return args;
+}
+
+export function parseRefreshTimestamp(value: string): number {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+
+export function parseImageLabels(raw: string): Record<string, string> {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!parsed || typeof parsed !== 'object') {
+      return {};
+    }
+    return Object.fromEntries(
+      Object.entries(parsed).filter((entry): entry is [string, string] => typeof entry[1] === 'string')
+    );
+  } catch {
+    return {};
+  }
+}
+
+export function isRefreshDisabled(env: NodeJS.ProcessEnv, noRefreshFlag: boolean): boolean {
+  if (noRefreshFlag) {
+    return true;
+  }
+
+  const value = env.AI_SANDBOX_NO_REFRESH?.trim().toLowerCase();
+  return value === '1' || value === 'true' || value === 'yes';
+}
+
+export function isRefreshDue(lastRefresh: number, now: number, intervalDays: number): boolean {
+  if (intervalDays <= 0 || lastRefresh > now) {
+    return false;
+  }
+
+  return now - lastRefresh >= intervalDays * 24 * 60 * 60 * 1000;
+}

package/lib/server/adapters/_contract.ts

@@ -1,4 +1,5 @@
 import type { ServerConfig } from '../config.ts';
+import type { OutboundMessage } from '../display.ts';
 import type { Logger } from '../logger.ts';
 
 // Adapter contract for agent-infra-server.
@@ -19,6 +20,7 @@ export type InboundMessage = {
   messageId: string;
   raw: unknown;
   reply: (text: string) => Promise<void>;
+  replyDisplay?: (message: OutboundMessage) => Promise<void>;
 };
 
 // Runtime context passed to every adapter's start(). dispatch() is registered
@@ -36,6 +38,7 @@ export type Adapter = {
   start: (ctx: AdapterCtx) => Promise<void>;
   stop: () => Promise<void>;
   sendMessage: (target: { chatId: string }, text: string) => Promise<void>;
+  sendDisplayMessage?: (target: { chatId: string }, message: OutboundMessage) => Promise<void>;
 };
 
 // The shape of an adapter module's default export (a factory).

package/lib/server/adapters/feishu/index.ts

@@ -1,5 +1,7 @@
 import type { Adapter, AdapterCtx, AdapterFactory, InboundMessage } from '../_contract.ts';
-import { cardMessage, createFeishuTransport, normalizeMessage } from './transport.ts';
+import type { OutboundMessage } from '../../display.ts';
+import { renderFeishuMessage } from './renderer.ts';
+import { createFeishuTransport, normalizeMessage } from './transport.ts';
 import type { FeishuTransport } from './transport.ts';
 
 // Assemble the feishu adapter. The transport is injectable so unit tests can
@@ -26,7 +28,10 @@ export function createFeishuAdapter(
             messageId: normalized.messageId,
             raw: normalized.raw,
             reply: async (text) => {
-              await transport.send(normalized.chatId, cardMessage(text));
+              await transport.send(normalized.chatId, renderFeishuMessage(text));
+            },
+            replyDisplay: async (message: OutboundMessage) => {
+              await transport.send(normalized.chatId, renderFeishuMessage(message));
             }
           };
           await adapterCtx.dispatch(message);
@@ -39,7 +44,10 @@ export function createFeishuAdapter(
       await transport.stop();
     },
     async sendMessage(target, text) {
-      await transport.send(target.chatId, cardMessage(text));
+      await transport.send(target.chatId, renderFeishuMessage(text));
+    },
+    async sendDisplayMessage(target, message) {
+      await transport.send(target.chatId, renderFeishuMessage(message));
     }
   };
 }

package/lib/server/adapters/feishu/renderer.ts

@@ -0,0 +1,99 @@
+import { stripVTControlCharacters } from 'node:util';
+import { normalizeOutbound, outboundToText, type DisplayMessage, type OutboundMessage } from '../../display.ts';
+import type { FeishuMessagePayload } from './transport.ts';
+
+const FEISHU_LARK_MD_MAX_LENGTH = 20_000;
+
+type FeishuElement =
+  | { tag: 'div'; text: { tag: 'lark_md'; content: string } }
+  | { tag: 'div'; fields: Array<{ is_short: boolean; text: { tag: 'lark_md'; content: string } }> };
+
+function templateForTone(tone: 'info' | 'success' | 'warning' | 'danger' | 'running'): string {
+  if (tone === 'success') return 'green';
+  if (tone === 'warning') return 'yellow';
+  if (tone === 'danger') return 'red';
+  return 'blue';
+}
+
+function templateForResult(exitCode: number | null): string {
+  return exitCode === 0 ? 'green' : 'red';
+}
+
+export function cleanFeishuText(text: string): string {
+  return stripVTControlCharacters(text).replace(/\r\n/g, '\n');
+}
+
+function clampLarkMarkdown(text: string): string {
+  const clean = cleanFeishuText(text);
+  if (clean.length <= FEISHU_LARK_MD_MAX_LENGTH) return clean;
+  return `${clean.slice(0, FEISHU_LARK_MD_MAX_LENGTH - 18)}\n\n...(truncated)`;
+}
+
+function div(content: string): FeishuElement {
+  return { tag: 'div', text: { tag: 'lark_md', content: clampLarkMarkdown(content) } };
+}
+
+function fields(rows: [string, string][]): FeishuElement {
+  return {
+    tag: 'div',
+    fields: rows.map(([label, value]) => ({
+      is_short: true,
+      text: { tag: 'lark_md', content: clampLarkMarkdown(`**${label}**\n${value}`) }
+    }))
+  };
+}
+
+function card(title: string, template: string, elements: FeishuElement[]): FeishuMessagePayload {
+  return {
+    msg_type: 'interactive',
+    content: JSON.stringify({
+      config: { wide_screen_mode: true },
+      header: { title: { tag: 'plain_text', content: cleanFeishuText(title) }, template },
+      elements
+    })
+  };
+}
+
+function tableMarkdown(message: Extract<DisplayMessage, { kind: 'table' }>): string {
+  return outboundToText(message);
+}
+
+function renderStatus(message: Extract<DisplayMessage, { kind: 'status-card' }>): FeishuMessagePayload {
+  const elements: FeishuElement[] = [];
+  if (message.fields && message.fields.length > 0) elements.push(fields(message.fields));
+  if (message.body) elements.push(div(message.body));
+  if (elements.length === 0) elements.push(div(message.title));
+  return card(message.title, templateForTone(message.tone), elements);
+}
+
+function renderStream(message: Extract<DisplayMessage, { kind: 'stream-event' }>): FeishuMessagePayload {
+  const template = message.phase === 'finished' ? templateForResult(message.exitCode ?? null) : 'blue';
+  return card(message.title, template, [div(outboundToText(message))]);
+}
+
+function renderCommandResult(message: Extract<DisplayMessage, { kind: 'command-result' }>): FeishuMessagePayload {
+  return card(message.title, templateForResult(message.exitCode), [div(outboundToText(message))]);
+}
+
+function renderUnknownDisplayKind(message: never): FeishuMessagePayload {
+  return card('agent-infra', 'blue', [div(`[unknown display kind: ${String((message as { kind?: unknown }).kind)}]`)]);
+}
+
+export function renderFeishuMessage(message: OutboundMessage): FeishuMessagePayload {
+  const normalized = normalizeOutbound(message);
+  switch (normalized.kind) {
+    case 'text':
+      return card('agent-infra', 'blue', [div(normalized.text)]);
+    case 'markdown':
+      return card('agent-infra', 'blue', [div(normalized.markdown)]);
+    case 'table':
+      return card(normalized.title ?? 'agent-infra', 'blue', [div(tableMarkdown(normalized))]);
+    case 'status-card':
+      return renderStatus(normalized);
+    case 'stream-event':
+      return renderStream(normalized);
+    case 'command-result':
+      return renderCommandResult(normalized);
+  }
+  return renderUnknownDisplayKind(normalized);
+}

package/lib/server/adapters/feishu/transport.ts

@@ -1,5 +1,4 @@
 import * as lark from '@larksuiteoapi/node-sdk';
-import { stripVTControlCharacters } from 'node:util';
 
 // Transport layer for the feishu adapter. All @larksuiteoapi/node-sdk surface is
 // confined here so the adapter body (index.ts) depends only on this narrow
@@ -11,10 +10,10 @@ export type FeishuTransport = {
   // each inbound im.message.receive_v1.
   start: (onMessage: (raw: unknown) => Promise<void>) => Promise<void>;
   stop: () => Promise<void>;
-  send: (chatId: string, message: FeishuOutgoingMessage) => Promise<void>;
+  send: (chatId: string, message: FeishuMessagePayload) => Promise<void>;
 };
 
-export type FeishuOutgoingMessage = { kind: 'interactive'; title: string; text: string };
+export type FeishuMessagePayload = { msg_type: 'interactive'; content: string };
 
 type FeishuCreateData = {
   receive_id: string;
@@ -78,23 +77,11 @@ function resolveDomain(value: unknown): number {
   return value === 'lark' || value === 'Lark' ? lark.Domain.Lark : lark.Domain.Feishu;
 }
 
-export function cleanFeishuText(text: string): string {
-  return stripVTControlCharacters(text).replace(/\r\n/g, '\n');
-}
-
-export function cardMessage(text: string): FeishuOutgoingMessage {
-  return { kind: 'interactive', title: 'agent-infra', text: cleanFeishuText(text) };
-}
-
-export function toFeishuCreateData(chatId: string, message: FeishuOutgoingMessage): FeishuCreateData {
+export function toFeishuCreateData(chatId: string, message: FeishuMessagePayload): FeishuCreateData {
   return {
     receive_id: chatId,
-    msg_type: 'interactive',
-    content: JSON.stringify({
-      config: { wide_screen_mode: true },
-      header: { title: { tag: 'plain_text', content: message.title }, template: 'blue' },
-      elements: [{ tag: 'div', text: { tag: 'lark_md', content: message.text } }]
-    })
+    msg_type: message.msg_type,
+    content: message.content
   };
 }
 

package/lib/server/daemon.ts

@@ -1,87 +1,123 @@
 import { VERSION } from '../version.ts';
 import { loadServerConfig } from './config.ts';
+import type { ServerConfig } from './config.ts';
 import { createLogger } from './logger.ts';
+import type { Logger } from './logger.ts';
 import { loadAdapters, unloadAdapters } from './plugin-loader.ts';
 import type { InboundMessage } from './adapters/_contract.ts';
 import { authorize } from './auth.ts';
 import { commandHelp, parseCommand } from './protocol.ts';
 import { runAi } from './runner.ts';
+import type { RunnerOptions, RunnerResult } from './runner.ts';
 import { streamCommand } from './streamer.ts';
+import { markdownMessage, replyOutbound, textMessage } from './display.ts';
+import { buildStatusModel, statusModelToDisplay, type StatusModel } from '../task/commands/status.ts';
 
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-// The daemon main loop. Runs in the detached child spawned by
-// process-control.start(), or in the foreground for debugging.
-//
-// Lifecycle (keep-alive / shutdown model):
-//   - The heartbeat interval is kept *ref'd*. It is both the keep-alive that
-//     holds the event loop open while subtask A has no adapters, and the
-//     observable signal that `ai server logs -f` shows.
-//   - runDaemon() awaits a shutdown promise that only resolves once a
-//     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
-//     the only keep-alive timer (that would let the process exit immediately).
-export async function runDaemon(): Promise<void> {
-  let config;
-  try {
-    config = loadServerConfig();
-  } catch (error) {
-    process.stderr.write(`${errorMessage(error)}\n`);
-    process.exit(1);
-  }
+type MessageDispatcherOptions = {
+  config: ServerConfig;
+  logger: Pick<Logger, 'info'>;
+  runAi?: (args: string[], options?: RunnerOptions) => Promise<RunnerResult>;
+  buildStatusModel?: (ref: string) => StatusModel;
+  statusModelToDisplay?: (model: StatusModel) => ReturnType<typeof statusModelToDisplay>;
+};
 
-  const logger = createLogger(config.log);
-  logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
+function isTaskStatus(argv: string[]): boolean {
+  return argv[0] === 'task' && argv[1] === 'status' && typeof argv[2] === 'string';
+}
 
-  const abortController = new AbortController();
-  let resolveShutdown: () => void = () => {};
-  const shutdown = new Promise<void>((resolve) => {
-    resolveShutdown = resolve;
-  });
+export function createMessageDispatcher(options: MessageDispatcherOptions): (message: InboundMessage) => Promise<void> {
+  const runAiImpl = options.runAi ?? runAi;
+  const buildStatusModelImpl = options.buildStatusModel ?? buildStatusModel;
+  const statusModelToDisplayImpl = options.statusModelToDisplay ?? statusModelToDisplay;
 
-  const dispatch = async (message: InboundMessage): Promise<void> => {
+  return async (message: InboundMessage): Promise<void> => {
     const plan = parseCommand(message.text);
     if (plan.kind === 'ignore') return;
     if (plan.kind === 'error') {
-      await message.reply(plan.message);
-      logger.info(`command rejected from ${message.adapter}:${message.userId}: ${plan.message}`);
+      await replyOutbound(message, textMessage(plan.message));
+      options.logger.info(`command rejected from ${message.adapter}:${message.userId}: ${plan.message}`);
       return;
     }
     if (plan.kind === 'builtin' && plan.name === 'ping') {
-      await message.reply(`pong ${VERSION}`);
+      await replyOutbound(message, textMessage(`pong ${VERSION}`));
       return;
     }
     if (plan.kind === 'builtin' && plan.name === 'help') {
-      await message.reply(commandHelp());
+      await replyOutbound(message, markdownMessage(commandHelp()));
       return;
     }
     if (plan.kind === 'builtin' && plan.name === 'version') {
-      await message.reply(`agent-infra ${VERSION}`);
+      await replyOutbound(message, textMessage(`agent-infra ${VERSION}`));
       return;
     }
     if (plan.kind === 'ai') {
       const allowed = authorize(
         { adapter: message.adapter, userId: message.userId },
         plan.role,
-        config.auth
+        options.config.auth
       );
       if (!allowed.ok) {
-        await message.reply(allowed.message);
-        logger.info(`unauthorized command from ${message.adapter}:${message.userId}: ${allowed.message}`);
+        await replyOutbound(message, textMessage(allowed.message));
+        options.logger.info(`unauthorized command from ${message.adapter}:${message.userId}: ${allowed.message}`);
         return;
       }
+
+      if (isTaskStatus(plan.argv)) {
+        try {
+          await replyOutbound(message, statusModelToDisplayImpl(buildStatusModelImpl(plan.argv[2]!)));
+          return;
+        } catch {
+          // Fall back to the existing CLI streaming path. This preserves the
+          // old behavior for invalid refs and any status-model collection error.
+        }
+      }
+
       await streamCommand(
         {
           title: `ai ${plan.argv.join(' ')}`,
-          chunkChars: typeof config.stream?.chunkChars === 'number' ? config.stream.chunkChars : 4000,
-          throttleMs: typeof config.stream?.throttleMs === 'number' ? config.stream.throttleMs : 1500
+          chunkChars: typeof options.config.stream?.chunkChars === 'number' ? options.config.stream.chunkChars : 4000,
+          throttleMs: typeof options.config.stream?.throttleMs === 'number' ? options.config.stream.throttleMs : 1500
         },
-        (emit) => runAi(plan.argv, { onChunk: emit }),
-        (text) => message.reply(text)
+        (emit) => runAiImpl(plan.argv, { onChunk: emit }),
+        (outbound) => replyOutbound(message, outbound)
       );
     }
   };
+}
+
+// The daemon main loop. Runs in the detached child spawned by
+// process-control.start(), or in the foreground for debugging.
+//
+// Lifecycle (keep-alive / shutdown model):
+//   - The heartbeat interval is kept *ref'd*. It is both the keep-alive that
+//     holds the event loop open while subtask A has no adapters, and the
+//     observable signal that `ai server logs -f` shows.
+//   - runDaemon() awaits a shutdown promise that only resolves once a
+//     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
+//     the only keep-alive timer (that would let the process exit immediately).
+export async function runDaemon(): Promise<void> {
+  let config;
+  try {
+    config = loadServerConfig();
+  } catch (error) {
+    process.stderr.write(`${errorMessage(error)}\n`);
+    process.exit(1);
+  }
+
+  const logger = createLogger(config.log);
+  logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
+
+  const abortController = new AbortController();
+  let resolveShutdown: () => void = () => {};
+  const shutdown = new Promise<void>((resolve) => {
+    resolveShutdown = resolve;
+  });
+
+  const dispatch = createMessageDispatcher({ config, logger });
 
   const ctx = { config, logger, dispatch, signal: abortController.signal };
   const adapters = await loadAdapters(config, ctx);

package/lib/server/display.ts

@@ -0,0 +1,136 @@
+export type OutboundMessage = string | DisplayMessage;
+
+export type DisplayTone = 'info' | 'success' | 'warning' | 'danger' | 'running';
+
+export type DisplayMessage =
+  | { kind: 'text'; text: string }
+  | { kind: 'markdown'; markdown: string }
+  | { kind: 'table'; title?: string; columns: string[]; rows: string[][] }
+  | { kind: 'status-card'; title: string; tone: DisplayTone; fields?: [string, string][]; body?: string }
+  | {
+      kind: 'stream-event';
+      title: string;
+      phase: 'started' | 'chunk' | 'finished';
+      text?: string;
+      exitCode?: number | null;
+      signal?: NodeJS.Signals | null;
+    }
+  | {
+      kind: 'command-result';
+      title: string;
+      exitCode: number | null;
+      signal: NodeJS.Signals | null;
+      stdout?: string;
+      stderr?: string;
+    };
+
+export function textMessage(text: string): DisplayMessage {
+  return { kind: 'text', text };
+}
+
+export function markdownMessage(markdown: string): DisplayMessage {
+  return { kind: 'markdown', markdown };
+}
+
+export function tableMessage(columns: string[], rows: string[][], title?: string): DisplayMessage {
+  return { kind: 'table', title, columns, rows };
+}
+
+export function statusCard(
+  title: string,
+  tone: DisplayTone,
+  fields?: [string, string][],
+  body?: string
+): DisplayMessage {
+  return { kind: 'status-card', title, tone, fields, body };
+}
+
+export function streamEvent(
+  title: string,
+  phase: 'started' | 'chunk' | 'finished',
+  text?: string,
+  exitCode?: number | null,
+  signal?: NodeJS.Signals | null
+): DisplayMessage {
+  const message: Extract<DisplayMessage, { kind: 'stream-event' }> = { kind: 'stream-event', title, phase };
+  if (text !== undefined) message.text = text;
+  if (exitCode !== undefined) message.exitCode = exitCode;
+  if (signal !== undefined) message.signal = signal;
+  return message;
+}
+
+export function commandResult(
+  title: string,
+  exitCode: number | null,
+  signal: NodeJS.Signals | null,
+  stdout?: string,
+  stderr?: string
+): DisplayMessage {
+  return { kind: 'command-result', title, exitCode, signal, stdout, stderr };
+}
+
+export function normalizeOutbound(message: OutboundMessage): DisplayMessage {
+  return typeof message === 'string' ? textMessage(message) : message;
+}
+
+function tableToText(message: Extract<DisplayMessage, { kind: 'table' }>): string {
+  const lines: string[] = [];
+  if (message.title) lines.push(message.title);
+  lines.push(message.columns.join(' | '));
+  lines.push(message.columns.map(() => '---').join(' | '));
+  for (const row of message.rows) {
+    lines.push(row.join(' | '));
+  }
+  return lines.join('\n');
+}
+
+function compact(lines: Array<string | undefined>): string {
+  return lines.filter((line): line is string => typeof line === 'string' && line !== '').join('\n');
+}
+
+function unknownDisplayKind(message: never): string {
+  return `[unknown: ${String((message as { kind?: unknown }).kind)}]`;
+}
+
+export function outboundToText(message: OutboundMessage): string {
+  const normalized = normalizeOutbound(message);
+  switch (normalized.kind) {
+    case 'text':
+      return normalized.text;
+    case 'markdown':
+      return normalized.markdown;
+    case 'table':
+      return tableToText(normalized);
+    case 'status-card':
+      return compact([
+        normalized.title,
+        ...(normalized.fields ?? []).map(([label, value]) => `${label}: ${value}`),
+        normalized.body
+      ]);
+    case 'stream-event':
+      if (normalized.phase === 'started') return `started ${normalized.title}`;
+      if (normalized.phase === 'chunk') return normalized.text ?? '';
+      return `finished ${normalized.title} exitCode=${normalized.exitCode ?? 'null'} signal=${normalized.signal ?? 'null'}`;
+    case 'command-result':
+      return compact([
+        `finished ${normalized.title} exitCode=${normalized.exitCode ?? 'null'} signal=${normalized.signal ?? 'null'}`,
+        normalized.stdout,
+        normalized.stderr
+      ]);
+  }
+  return unknownDisplayKind(normalized);
+}
+
+export async function replyOutbound(
+  inbound: {
+    reply: (text: string) => Promise<void>;
+    replyDisplay?: (message: OutboundMessage) => Promise<void>;
+  },
+  message: OutboundMessage
+): Promise<void> {
+  if (inbound.replyDisplay) {
+    await inbound.replyDisplay(message);
+    return;
+  }
+  await inbound.reply(outboundToText(message));
+}

package/lib/server/streamer.ts

@@ -1,3 +1,4 @@
+import { streamEvent, type OutboundMessage } from './display.ts';
 import { redactSecrets } from './redact.ts';
 import type { RunnerResult } from './runner.ts';
 
@@ -19,9 +20,9 @@ function chunks(text: string, size: number): string[] {
 export async function streamCommand(
   options: StreamOptions,
   run: (emit?: (chunk: string) => Promise<void>) => Promise<RunnerResult>,
-  send: (text: string) => Promise<void>
+  send: (message: OutboundMessage) => Promise<void>
 ): Promise<RunnerResult> {
-  await send(`started ${options.title}`);
+  await send(streamEvent(options.title, 'started'));
   const size = options.chunkChars ?? 4000;
   const throttleMs = options.throttleMs ?? 0;
   let streamed = false;
@@ -34,7 +35,7 @@ export async function streamCommand(
     buffer = '';
     lastFlush = Date.now();
     for (const chunk of chunks(text, size)) {
-      await send(chunk);
+      await send(streamEvent(options.title, 'chunk', chunk));
     }
   };
 
@@ -52,6 +53,6 @@ export async function streamCommand(
     buffer += [result.stdout, result.stderr].filter(Boolean).join('\n');
   }
   await flush();
-  await send(`finished ${options.title} exitCode=${result.exitCode} signal=${result.signal ?? 'null'}`);
+  await send(streamEvent(options.title, 'finished', undefined, result.exitCode, result.signal));
   return result;
 }