@fitlab-ai/agent-infra 0.8.2 → 0.8.4

package/lib/sandbox/commands/rebuild.ts

@@ -1,40 +1,27 @@
 import { parseArgs } from 'node:util';
-import { createHash } from 'node:crypto';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { loadConfig } from '../config.ts';
 import type { SandboxConfig } from '../config.ts';
 import { prepareDockerfile } from '../dockerfile.ts';
-import { sandboxImageConfigLabel, sandboxLabel } from '../constants.ts';
+import { sandboxImageRefreshLabel } from '../constants.ts';
 import { detectEngine, ensureDocker } from '../engine.ts';
-import { runEngine, runSafeEngine, runVerboseEngine } from '../shell.ts';
+import { runEngine, runOkEngine, runSafeEngine, runVerboseEngine } from '../shell.ts';
 import { pruneSandboxDanglingImages } from '../image-prune.ts';
-import {
-  imageSignatureFields,
-  resolveTools,
-  toolNpmPackagesArg,
-  toolShellInstallScriptBase64
-} from '../tools.ts';
+import { resolveTools } from '../tools.ts';
 import type { SandboxTool } from '../tools.ts';
-import { toEnginePath } from '../engines/wsl2-paths.ts';
-import { resolveBuildUid } from '../engines/native.ts';
+import {
+  buildImageSignature,
+  buildSandboxImageArgs,
+  parseImageLabels,
+  parseRefreshTimestamp
+} from '../image-build.ts';
 
 const USAGE = `Usage: ai sandbox rebuild [--quiet] [--refresh]`;
 
-type PreparedDockerfile = ReturnType<typeof prepareDockerfile>;
 type EngineRunFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string }) => string;
 type EngineRunSafeFn = EngineRunFn;
 
-function buildSignature(preparedDockerfile: PreparedDockerfile, tools: SandboxTool[]): string {
-  return createHash('sha256')
-    .update(JSON.stringify({
-      dockerfile: preparedDockerfile.signature,
-      tools: imageSignatureFields(tools)
-    }))
-    .digest('hex')
-    .slice(0, 12);
-}
-
 export function buildArgs(
   config: SandboxConfig,
   tools: SandboxTool[],
@@ -45,49 +32,41 @@ export function buildArgs(
     runFn = runEngine,
     runSafeFn = runSafeEngine,
     env = process.env,
-    refresh = false
+    refresh = false,
+    lastRefresh
   }: {
     engine?: string;
     runFn?: EngineRunFn;
     runSafeFn?: EngineRunSafeFn;
     env?: NodeJS.ProcessEnv;
     refresh?: boolean;
+    lastRefresh?: number;
   } = {}
 ): string[] {
-  const selectedEngine = engine ?? detectEngine(config);
-  const { uid: hostUid, gid: hostGid } = resolveBuildUid({
-    engine: selectedEngine,
+  return buildSandboxImageArgs(config, tools, dockerfilePath, imageSignature, {
+    engine: engine ?? detectEngine(config),
     runFn,
     runSafeFn,
-    env
+    env,
+    refresh,
+    lastRefresh
   });
+}
 
-  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}`,
-    '-f',
-    toEnginePath(selectedEngine, dockerfilePath),
-    toEnginePath(selectedEngine, config.repoRoot)
-  ];
-
-  if (refresh) {
-    args.splice(1, 0, '--no-cache', '--pull');
+function readExistingLastRefresh(config: SandboxConfig, engine: string): number {
+  if (!runOkEngine(engine, 'docker', ['image', 'inspect', config.imageName])) {
+    return 0;
   }
 
-  return args;
+  const labels = parseImageLabels(runSafeEngine(engine, 'docker', [
+    'image',
+    'inspect',
+    '--format',
+    '{{ json .Config.Labels }}',
+    config.imageName
+  ]));
+
+  return parseRefreshTimestamp(labels[sandboxImageRefreshLabel(config)] ?? '');
 }
 
 export async function rebuild(args: string[]): Promise<void> {
@@ -110,19 +89,24 @@ export async function rebuild(args: string[]): Promise<void> {
   const config = loadConfig();
   const tools = resolveTools(config);
   const preparedDockerfile = prepareDockerfile(config);
-  const imageSignature = buildSignature(preparedDockerfile, tools);
+  const imageSignature = buildImageSignature(preparedDockerfile, tools);
   const quiet = values.quiet ?? false;
   const refresh = values.refresh ?? false;
   const engine = detectEngine(config);
 
   await ensureDocker(config, undefined);
+  const lastRefresh = refresh ? Date.now() : readExistingLastRefresh(config, engine);
   p.intro(pc.cyan('Rebuilding sandbox image'));
 
   try {
     if (quiet) {
       const spinner = p.spinner();
       spinner.start('Building image...');
-      runEngine(engine, 'docker', buildArgs(config, tools, preparedDockerfile.path, imageSignature, { engine, refresh }), {
+      runEngine(engine, 'docker', buildArgs(config, tools, preparedDockerfile.path, imageSignature, {
+        engine,
+        refresh,
+        lastRefresh
+      }), {
         cwd: config.repoRoot
       });
       spinner.stop(pc.green('Sandbox image rebuilt'));
@@ -131,7 +115,11 @@ export async function rebuild(args: string[]): Promise<void> {
       runVerboseEngine(
         engine,
         'docker',
-        buildArgs(config, tools, preparedDockerfile.path, imageSignature, { engine, refresh }),
+        buildArgs(config, tools, preparedDockerfile.path, imageSignature, {
+          engine,
+          refresh,
+          lastRefresh
+        }),
         { cwd: config.repoRoot }
       );
       p.log.success(pc.green('Sandbox image rebuilt'));

package/lib/sandbox/config.ts

@@ -13,6 +13,7 @@ const DEFAULTS = Object.freeze({
   engine: null,
   runtimes: ['node22'],
   tools: ['agent-infra', 'claude-code', 'codex', 'gemini-cli', 'opencode'],
+  refreshIntervalDays: 7,
   dockerfile: null,
   vm: {
     cpu: null,
@@ -29,6 +30,7 @@ type SandboxConfigInput = {
   runtimes?: string[];
   tools?: string[];
   customTools?: unknown;
+  refreshIntervalDays?: unknown;
   dockerfile?: string | null;
   vm?: Record<string, unknown>;
 };
@@ -55,6 +57,7 @@ export type SandboxConfig = {
   runtimes: string[];
   tools: string[];
   customTools: SandboxTool[];
+  refreshIntervalDays: number;
   dockerfile: string | null;
   vm: SandboxVmConfig;
 };
@@ -80,11 +83,16 @@ function asPositiveNumberOrNull(value: unknown): number | null {
   return typeof value === 'number' ? value : null;
 }
 
-function cloneDefaults(): SandboxConfigInput & { vm: SandboxVmConfig; runtimes: string[]; tools: string[] } {
+function asNonNegativeIntegerOrDefault(value: unknown, fallback: number): number {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function cloneDefaults(): SandboxConfigInput & { vm: SandboxVmConfig; runtimes: string[]; tools: string[]; refreshIntervalDays: number } {
   return {
     engine: DEFAULTS.engine,
     runtimes: [...DEFAULTS.runtimes],
     tools: [...DEFAULTS.tools],
+    refreshIntervalDays: DEFAULTS.refreshIntervalDays,
     dockerfile: DEFAULTS.dockerfile,
     vm: { ...DEFAULTS.vm }
   };
@@ -160,6 +168,10 @@ export function loadConfig({
       ? [...sandbox.tools]
       : defaults.tools,
     customTools,
+    refreshIntervalDays: asNonNegativeIntegerOrDefault(
+      sandbox.refreshIntervalDays,
+      defaults.refreshIntervalDays
+    ),
     dockerfile,
     vm: {
       cpu: asPositiveNumberOrNull(sandbox.vm?.cpu) ?? defaults.vm.cpu,

package/lib/sandbox/constants.ts

@@ -107,6 +107,10 @@ export function sandboxImageConfigLabel(config: Pick<SandboxPathConfig, 'project
   return `${sandboxLabel(config)}.image-config`;
 }
 
+export function sandboxImageRefreshLabel(config: Pick<SandboxPathConfig, 'project'>): string {
+  return `${sandboxLabel(config)}.last-refresh`;
+}
+
 export function parsePositiveIntegerOption(value: unknown, optionName: string): number | undefined {
   if (value === undefined || value === null) {
     return undefined;

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/sandbox/runtimes/base.dockerfile

@@ -12,6 +12,9 @@ RUN if [ "${HOST_UID}" = "0" ]; then \
         (groupadd -o -g ${HOST_GID} devuser || true) && \
         useradd -o -u ${HOST_UID} -g ${HOST_GID} -m -s /bin/bash devuser; \
     else \
+        if ubuntu_uid="$(id -u ubuntu 2>/dev/null)" && [ "${ubuntu_uid}" = "${HOST_UID}" ]; then \
+            userdel -r ubuntu || exit 1; \
+        fi; \
         (groupadd -g ${HOST_GID} devuser || true) && \
         useradd -u ${HOST_UID} -g ${HOST_GID} -m -s /bin/bash devuser; \
     fi

package/lib/sandbox/shell.ts

@@ -2,6 +2,7 @@ import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import type { ExecFileSyncOptions, StdioOptions, SpawnSyncOptions, SpawnSyncReturns } from 'node:child_process';
+import { getAdapter } from './engines/index.ts';
 
 const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000;
 
@@ -52,7 +53,7 @@ function resolveCommand(cmd: string): string {
   return cmd;
 }
 
-function commandOptions<T extends CommandOptions>(cmd: string, opts: T): T | (T & { shell: true }) {
+function commandOptions<T extends object>(cmd: string, opts: T): T | (T & { shell: true }) {
   if (process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(cmd)) {
     return { ...opts, shell: true };
   }
@@ -143,6 +144,13 @@ export function commandForEngine(engine: string, cmd: string, args: string[] = [
     return { cmd: resolvedWrapper, args: ['--', cmd, ...args] };
   }
 
+  if (cmd === 'docker') {
+    const context = getAdapter(engine).dockerContext;
+    if (context) {
+      return { cmd, args: ['--context', context, ...args] };
+    }
+  }
+
   return { cmd, args };
 }
 
@@ -153,7 +161,8 @@ export function runEngine(engine: string, cmd: string, args: string[], opts: Com
 
 export function execEngine(engine: string, cmd: string, args: string[], opts: ExecFileSyncOptions = {}) {
   const command = commandForEngine(engine, cmd, args);
-  return execFileSync(command.cmd, command.args, opts);
+  const resolved = resolveCommand(command.cmd);
+  return execFileSync(resolved, command.args, commandOptions(resolved, opts));
 }
 
 export function runOkEngine(engine: string, cmd: string, args: string[], opts: CommandOptions = {}): boolean {

package/lib/sandbox/tools.ts

@@ -22,9 +22,9 @@ export type SandboxTool = {
   // When set, containerMount is mounted as an in-container tmpfs (RAM) instead
   // of bind-mounting the host config dir, keeping high-churn tool logs off the
   // host disk. `seed` lists the host-dir entries (relative to the tool's config
-  // dir) to bind back over the tmpfs so seeded config stays visible — it is an
-  // explicit allowlist so runtime files (e.g. logs_2.sqlite, sessions) left in
-  // the host dir are NOT re-mounted, which would defeat the tmpfs.
+  // dir) to copy into the tmpfs when the container starts. It is an explicit
+  // allowlist so runtime files (e.g. logs_2.sqlite, sessions) left in the host
+  // dir stay out of the container and seeded config cannot write back.
   tmpfs?: { size?: string; seed?: string[] };
 };
 
@@ -80,8 +80,8 @@ function createBuiltinTools(home: string, project: string): Record<string, Sandb
       // codex churns ~/.codex/logs_2.sqlite heavily (upstream openai/codex#24275);
       // a bind-mount would write-amplify onto the host SSD via virtiofs. Mount the
       // codex home as tmpfs so those logs stay in RAM and die with the container.
-      // Only the seeded config (config.toml, model-catalogs) is bound back over
-      // the tmpfs; runtime files like logs_2.sqlite must stay in RAM.
+      // Seeded config (config.toml, model-catalogs) is copied into the tmpfs at
+      // startup; runtime files like logs_2.sqlite stay in RAM.
       tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'] },
       hostLiveMounts: [
         { hostPath: hostJoin(home, '.codex', 'auth.json'), containerSubpath: 'auth.json' }

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