@fitlab-ai/agent-infra 0.8.1 → 0.8.3

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,4 +1,6 @@
 import type { Adapter, AdapterCtx, AdapterFactory, InboundMessage } from '../_contract.ts';
+import type { OutboundMessage } from '../../display.ts';
+import { renderFeishuMessage } from './renderer.ts';
 import { createFeishuTransport, normalizeMessage } from './transport.ts';
 import type { FeishuTransport } from './transport.ts';
 
@@ -25,7 +27,12 @@ export function createFeishuAdapter(
             text: normalized.text,
             messageId: normalized.messageId,
             raw: normalized.raw,
-            reply: (text) => transport.send(normalized.chatId, text)
+            reply: async (text) => {
+              await transport.send(normalized.chatId, renderFeishuMessage(text));
+            },
+            replyDisplay: async (message: OutboundMessage) => {
+              await transport.send(normalized.chatId, renderFeishuMessage(message));
+            }
           };
           await adapterCtx.dispatch(message);
         } catch (error) {
@@ -37,7 +44,10 @@ export function createFeishuAdapter(
       await transport.stop();
     },
     async sendMessage(target, text) {
-      await transport.send(target.chatId, 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

@@ -10,7 +10,15 @@ export type FeishuTransport = {
   // each inbound im.message.receive_v1.
   start: (onMessage: (raw: unknown) => Promise<void>) => Promise<void>;
   stop: () => Promise<void>;
-  send: (chatId: string, text: string) => Promise<void>;
+  send: (chatId: string, message: FeishuMessagePayload) => Promise<void>;
+};
+
+export type FeishuMessagePayload = { msg_type: 'interactive'; content: string };
+
+type FeishuCreateData = {
+  receive_id: string;
+  msg_type: 'interactive';
+  content: string;
 };
 
 export type NormalizedMessage = {
@@ -69,6 +77,14 @@ function resolveDomain(value: unknown): number {
   return value === 'lark' || value === 'Lark' ? lark.Domain.Lark : lark.Domain.Feishu;
 }
 
+export function toFeishuCreateData(chatId: string, message: FeishuMessagePayload): FeishuCreateData {
+  return {
+    receive_id: chatId,
+    msg_type: message.msg_type,
+    content: message.content
+  };
+}
+
 // Build the real SDK-backed transport from adapter config. appId/appSecret come
 // from server config (appSecret only via server.local.json / env). The WSClient
 // long connection delivers events; the Client REST call sends replies.
@@ -118,10 +134,10 @@ export function createFeishuTransport(config: Record<string, unknown>): FeishuTr
         // Ignore: the daemon is shutting down regardless.
       }
     },
-    async send(chatId, text) {
+    async send(chatId, message) {
       await client.im.message.create({
         params: { receive_id_type: 'chat_id' },
-        data: { receive_id: chatId, msg_type: 'text', content: JSON.stringify({ text }) }
+        data: toFeishuCreateData(chatId, message)
       });
     }
   };

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/protocol.ts

@@ -23,10 +23,26 @@ function taskSubcommand(subcommand: string): string {
 export function commandHelp(): string {
   return [
     `agent-infra ${VERSION}`,
-    'Built-ins: /help, /ping, /version',
-    'Read: /sandbox ls|show|vm status, /task decisions|log|ls|show|status',
-    'Write: /sandbox create|start',
-    'Exec: /decide <task-ref> <HD-id> <decision>, /run create-task <description>, /run <skill> <task-ref> ...'
+    'Built-ins:',
+    '/help',
+    '/ping',
+    '/version',
+    'Read:',
+    '/sandbox ls',
+    '/sandbox show {ref}',
+    '/sandbox vm status',
+    '/task decisions {ref}',
+    '/task log {ref}',
+    '/task ls',
+    '/task show {ref}',
+    '/task status {ref}',
+    'Write:',
+    '/sandbox create {ref}',
+    '/sandbox start {ref}',
+    'Exec:',
+    '/decide {task-ref} {HD-id} {decision}',
+    '/run create-task {description}',
+    '/run {skill} {task-ref}'
   ].join('\n');
 }
 

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;
 }

package/lib/task/commands/log.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { formatTable } from '../../table.ts';
 import { resolveTaskRef } from '../resolve-ref.ts';
-import { parseLedger, HUMAN_DECISION_STATUSES, type LedgerRow } from '../ledger.ts';
+import { parseLedger, type LedgerRow } from '../ledger.ts';
 
 const USAGE = `Usage: ai task log <N | #N | TASK-id>
 
@@ -14,7 +14,7 @@ Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
   A human-executed step shows AGENT as 'human' and, when it has no start marker,
   a '-' STARTED placeholder. Review-step NOTE also carries two human counts in
   the verdict list, right after blockers/major/minor: manual-validation
-  and human-decision (current ledger stage total).
+  and human-decision (current pending ledger stage total).
 `;
 
 const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'] as const;
@@ -108,7 +108,7 @@ function pairEntries(entries: LogEntry[]): StepRow[] {
 function countHumanDecisionsByStage(rows: LedgerRow[]): Map<ReviewStage, number> {
   const counts = new Map<ReviewStage, number>();
   for (const row of rows) {
-    if (!isReviewStage(row.stage) || !HUMAN_DECISION_STATUSES.has(row.status)) continue;
+    if (!isReviewStage(row.stage) || row.status !== 'needs-human-decision') continue;
     counts.set(row.stage, (counts.get(row.stage) ?? 0) + 1);
   }
   return counts;