@keyou007/agent-bot 0.1.0

package/src/state/migrations.ts

@@ -0,0 +1,128 @@
+export const migrations = [
+  `
+  CREATE TABLE IF NOT EXISTS user_contexts (
+    context_key TEXT PRIMARY KEY,
+    default_agent TEXT NOT NULL,
+    current_session_id TEXT,
+    previous_session_id TEXT,
+    bound_project_cwd TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS sessions (
+    local_session_id TEXT PRIMARY KEY,
+    context_key TEXT NOT NULL,
+    agent_name TEXT NOT NULL,
+    cwd TEXT NOT NULL,
+    acp_session_id TEXT,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS audit_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    context_key TEXT NOT NULL,
+    event_type TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS turn_snapshots (
+    turn_id TEXT PRIMARY KEY,
+    local_session_id TEXT NOT NULL,
+    context_key TEXT,
+    snapshot_json TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS turn_deliveries (
+    turn_id TEXT PRIMARY KEY,
+    progress_message_id TEXT,
+    final_message_ids_json TEXT NOT NULL DEFAULT '[]',
+    final_delivered_at TEXT,
+    last_card_hash TEXT,
+    updated_at TEXT NOT NULL
+  );
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS inbound_event_receipts (
+    event_id TEXT PRIMARY KEY,
+    event_kind TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS message_reactions (
+    message_id TEXT PRIMARY KEY,
+    context_key TEXT NOT NULL,
+    reaction_id TEXT NOT NULL,
+    emoji_type TEXT NOT NULL,
+    local_session_id TEXT,
+    turn_id TEXT,
+    status TEXT NOT NULL DEFAULT 'pending',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_message_reactions_turn_status
+    ON message_reactions(turn_id, status);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS message_turn_bindings (
+    message_id TEXT PRIMARY KEY,
+    local_session_id TEXT NOT NULL,
+    turn_id TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_message_turn_bindings_turn
+    ON message_turn_bindings(turn_id);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS fork_title_sequences (
+    base_title TEXT PRIMARY KEY,
+    last_sequence INTEGER NOT NULL
+  );
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS context_sessions (
+    context_key TEXT NOT NULL,
+    local_session_id TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (context_key, local_session_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_context_sessions_local_session
+    ON context_sessions(local_session_id);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS chat_contexts (
+    context_key TEXT PRIMARY KEY,
+    chat_type TEXT NOT NULL,
+    last_activity_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_chat_contexts_type
+    ON chat_contexts(chat_type, updated_at);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS queued_prompts (
+    prompt_id TEXT PRIMARY KEY,
+    local_session_id TEXT NOT NULL,
+    context_key TEXT NOT NULL,
+    prompt_text TEXT NOT NULL,
+    local_image_paths_json TEXT NOT NULL DEFAULT '[]',
+    message_id TEXT,
+    reply_message_id TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_queued_prompts_session_order
+    ON queued_prompts(local_session_id, created_at);
+  `,
+] as const;

package/src/supervision/SafeRestartNotifier.ts

@@ -0,0 +1,122 @@
+import type { Logger } from "pino";
+import { CardRenderer } from "../feishu/CardRenderer.js";
+import type { FeishuOutbound } from "../feishu/types.js";
+import type { StateStore } from "../state/StateStore.js";
+import type { SafeRestartStatus } from "./SafeRestartScheduler.js";
+
+const DEFAULT_INITIAL_CARD_DELAY_MS = 3_000;
+
+export interface SafeRestartNotifierOptions {
+  initialCardDelayMs?: number;
+}
+
+export class SafeRestartNotifier {
+  private readonly messageIds = new Map<string, string>();
+  private readonly cardHashes = new Map<string, string>();
+  private activeScheduleId?: number;
+  private pendingInitialStatus?: SafeRestartStatus;
+  private initialCardTimer?: NodeJS.Timeout;
+  private queue = Promise.resolve();
+
+  constructor(
+    private readonly store: StateStore,
+    private readonly outbound: FeishuOutbound,
+    private readonly renderer: CardRenderer,
+    private readonly logger: Pick<Logger, "warn">,
+    private readonly options: SafeRestartNotifierOptions = {},
+  ) {}
+
+  update(status: SafeRestartStatus): Promise<void> {
+    if (this.activeScheduleId !== status.scheduleId) {
+      this.activeScheduleId = status.scheduleId;
+      this.messageIds.clear();
+      this.cardHashes.clear();
+      this.clearInitialCardTimer();
+      this.pendingInitialStatus = status;
+      const delayMs = this.options.initialCardDelayMs ?? DEFAULT_INITIAL_CARD_DELAY_MS;
+      if (delayMs <= 0) return this.publishPendingInitialStatus();
+      this.initialCardTimer = setTimeout(() => {
+        this.initialCardTimer = undefined;
+        void this.publishPendingInitialStatus().catch((error: unknown) => {
+          this.logger.warn({ error }, "Failed to publish delayed safe restart status.");
+        });
+      }, delayMs);
+      return Promise.resolve();
+    }
+    if (this.pendingInitialStatus) {
+      this.pendingInitialStatus = status;
+      return Promise.resolve();
+    }
+    return this.enqueue(status);
+  }
+
+  async flush(): Promise<void> {
+    await this.publishPendingInitialStatus();
+    await this.queue;
+  }
+
+  private publishPendingInitialStatus(): Promise<void> {
+    this.clearInitialCardTimer();
+    const status = this.pendingInitialStatus;
+    this.pendingInitialStatus = undefined;
+    return status ? this.enqueue(status) : this.queue;
+  }
+
+  private enqueue(status: SafeRestartStatus): Promise<void> {
+    const queued = this.queue.catch(() => undefined).then(async () => {
+      if (this.activeScheduleId !== status.scheduleId) return;
+      await this.publish(status);
+    });
+    this.queue = queued;
+    return queued;
+  }
+
+  private clearInitialCardTimer(): void {
+    if (this.initialCardTimer) clearTimeout(this.initialCardTimer);
+    this.initialCardTimer = undefined;
+  }
+
+  private async publish(status: SafeRestartStatus): Promise<void> {
+    const targets = this.store.listChatContexts("p2p");
+    if (targets.length === 0) return;
+    const waitingTasks = this.store.listAllSessions()
+      .filter((session) => session.status === "running" || this.store.countQueuedPrompts(session.localSessionId) > 0)
+      .map((session) => ({
+        id: session.remoteSessionId ?? session.localSessionId,
+        title: session.title,
+      }));
+    const card = this.renderer.renderSafeRestartStatus({
+      reason: status.reason,
+      phase: status.phase,
+      remainingMs: status.remainingMs,
+      pendingFinalDeliveries: status.activity.pendingFinalDeliveries,
+      waitingTasks,
+    });
+    const cardHash = JSON.stringify(card);
+
+    await Promise.all(targets.map(async ({ contextKey }) => {
+      const messageId = this.messageIds.get(contextKey);
+      if (messageId) {
+        if (this.cardHashes.get(contextKey) === cardHash) return;
+        try {
+          await this.outbound.updateInteractiveCard(messageId, card);
+          this.cardHashes.set(contextKey, cardHash);
+          return;
+        } catch (error) {
+          this.logger.warn({ error, contextKey, messageId }, "Failed to update safe restart status card; sending a replacement.");
+          this.messageIds.delete(contextKey);
+          this.cardHashes.delete(contextKey);
+        }
+      }
+      try {
+        const created = await this.outbound.sendInteractiveCard(contextKey, card);
+        if (created && this.activeScheduleId === status.scheduleId) {
+          this.messageIds.set(contextKey, created);
+          this.cardHashes.set(contextKey, cardHash);
+        }
+      } catch (error) {
+        this.logger.warn({ error, contextKey }, "Failed to send safe restart status card.");
+      }
+    }));
+  }
+}

package/src/supervision/SafeRestartScheduler.ts

@@ -0,0 +1,149 @@
+export interface ServerActivityState {
+  runningSessions: number;
+  pendingFinalDeliveries: number;
+  latestInboundAt?: string;
+}
+
+export type SafeRestartPhase = "waiting_tasks" | "waiting_delivery" | "countdown" | "restarting";
+
+export interface SafeRestartStatus {
+  scheduleId: number;
+  reason: string;
+  phase: SafeRestartPhase;
+  activity: ServerActivityState;
+  remainingMs?: number;
+}
+
+export interface SafeRestartSchedulerOptions {
+  readActivity(): ServerActivityState;
+  onReady(reason: string): void | Promise<void>;
+  onStatus?(status: SafeRestartStatus): void | Promise<void>;
+  onStatusError?(error: unknown): void;
+  quietPeriodMs?: number;
+  pollIntervalMs?: number;
+}
+
+export class SafeRestartScheduler {
+  private timer?: NodeJS.Timeout;
+  private polling?: Promise<void>;
+  private pollAgain = false;
+  private reason?: string;
+  private idleSince?: number;
+  private idleInboundAt?: string;
+  private scheduleId = 0;
+
+  constructor(private readonly options: SafeRestartSchedulerOptions) {}
+
+  get scheduled(): boolean {
+    return Boolean(this.reason);
+  }
+
+  get pendingReason(): string | undefined {
+    return this.reason;
+  }
+
+  schedule(reason: string): boolean {
+    const newlyScheduled = !this.reason;
+    if (newlyScheduled) this.scheduleId += 1;
+    this.reason = reason;
+    this.idleSince = undefined;
+    this.idleInboundAt = undefined;
+    if (!this.timer) {
+      this.timer = setInterval(() => this.requestPoll(), this.options.pollIntervalMs ?? 1_000);
+    }
+    this.requestPoll();
+    return newlyScheduled;
+  }
+
+  cancel(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+    this.reason = undefined;
+    this.idleSince = undefined;
+    this.idleInboundAt = undefined;
+  }
+
+  private async poll(): Promise<void> {
+    const reason = this.reason;
+    if (!reason) return;
+    const state = this.options.readActivity();
+    if (state.runningSessions > 0 || state.pendingFinalDeliveries > 0) {
+      this.idleSince = undefined;
+      this.idleInboundAt = undefined;
+      await this.emitStatus({
+        scheduleId: this.scheduleId,
+        reason,
+        phase: state.runningSessions > 0 ? "waiting_tasks" : "waiting_delivery",
+        activity: state,
+      });
+      return;
+    }
+    const quietPeriodMs = this.options.quietPeriodMs ?? 15_000;
+    const latestInboundAt = state.latestInboundAt ?? "";
+    if (this.idleSince === undefined || this.idleInboundAt !== latestInboundAt) {
+      this.idleSince = Date.now();
+      this.idleInboundAt = latestInboundAt;
+      await this.emitStatus({ scheduleId: this.scheduleId, reason, phase: "countdown", activity: state, remainingMs: quietPeriodMs });
+      return;
+    }
+    const remainingMs = Math.max(0, quietPeriodMs - (Date.now() - this.idleSince));
+    if (remainingMs > 0) {
+      await this.emitStatus({ scheduleId: this.scheduleId, reason, phase: "countdown", activity: state, remainingMs });
+      return;
+    }
+    const confirmed = this.options.readActivity();
+    if (
+      confirmed.runningSessions > 0
+      || confirmed.pendingFinalDeliveries > 0
+      || (confirmed.latestInboundAt ?? "") !== this.idleInboundAt
+    ) {
+      this.idleSince = undefined;
+      this.idleInboundAt = undefined;
+      if (confirmed.runningSessions > 0 || confirmed.pendingFinalDeliveries > 0) {
+        await this.emitStatus({
+          scheduleId: this.scheduleId,
+          reason,
+          phase: confirmed.runningSessions > 0 ? "waiting_tasks" : "waiting_delivery",
+          activity: confirmed,
+        });
+      } else {
+        await this.emitStatus({
+          scheduleId: this.scheduleId,
+          reason,
+          phase: "countdown",
+          activity: confirmed,
+          remainingMs: quietPeriodMs,
+        });
+      }
+      return;
+    }
+    await this.emitStatus({ scheduleId: this.scheduleId, reason, phase: "restarting", activity: confirmed, remainingMs: 0 });
+    this.cancel();
+    await this.options.onReady(reason);
+  }
+
+  private requestPoll(): void {
+    if (this.polling) {
+      this.pollAgain = true;
+      return;
+    }
+    this.polling = this.drainPolls().finally(() => {
+      this.polling = undefined;
+      if (this.pollAgain && this.reason) this.requestPoll();
+    });
+  }
+
+  private async drainPolls(): Promise<void> {
+    do {
+      this.pollAgain = false;
+      await this.poll();
+    } while (this.pollAgain && this.reason);
+  }
+
+  private async emitStatus(status: SafeRestartStatus): Promise<void> {
+    if (!this.options.onStatus) return;
+    await Promise.resolve(this.options.onStatus(status)).catch((error: unknown) => {
+      this.options.onStatusError?.(error);
+    });
+  }
+}

package/src/supervision/replacementSupervisor.ts

@@ -0,0 +1,10 @@
+export function replacementSupervisorEnvironment(
+  restartReason: string,
+  environment: NodeJS.ProcessEnv = process.env,
+): NodeJS.ProcessEnv {
+  return {
+    ...environment,
+    AGENT_BOT_START_DELAY_MS: "250",
+    AGENT_BOT_RESTART_REASON: restartReason,
+  };
+}

package/src/supervision/restartPolicy.ts

@@ -0,0 +1,19 @@
+export const RESTART_EXIT_CODE = 75;
+export const STOP_EXIT_CODE = 76;
+export const INTENTIONAL_RESTART_DELAY_MS = 250;
+export const STABLE_UPTIME_MS = 60_000;
+
+export function crashRestartDelayMs(consecutiveFailures: number): number {
+  const exponent = Math.max(0, consecutiveFailures - 1);
+  return Math.min(30_000, 1_000 * (2 ** exponent));
+}
+
+export function describeRestartReason(
+  exitCode: number | null,
+  signal: NodeJS.Signals | null,
+  intentional: boolean,
+): string {
+  if (intentional) return "用户执行 /restart 命令";
+  if (signal) return `进程收到 ${signal} 信号后退出，Supervisor 自动重启`;
+  return `进程退出（exit code ${exitCode ?? "unknown"}），Supervisor 自动重启`;
+}

package/src/supervisor.ts

@@ -0,0 +1,106 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { isServerRunning } from "./cli/LocalControlClient.js";
+import { controlEndpoint } from "./cli/controlProtocol.js";
+import { loadConfig } from "./config/loadConfig.js";
+import {
+  crashRestartDelayMs,
+  describeRestartReason,
+  INTENTIONAL_RESTART_DELAY_MS,
+  RESTART_EXIT_CODE,
+  STABLE_UPTIME_MS,
+  STOP_EXIT_CODE,
+} from "./supervision/restartPolicy.js";
+
+const childEntry = fileURLToPath(new URL("./index.js", import.meta.url));
+const sqlitePath = loadConfig().storage.sqlitePath;
+const serverEndpoint = controlEndpoint(sqlitePath);
+let child: ChildProcess | undefined;
+let restartTimer: NodeJS.Timeout | undefined;
+let stopping = false;
+let consecutiveFailures = 0;
+let nextStartReason = process.env.AGENT_BOT_RESTART_REASON?.trim() || "Supervisor 启动";
+
+async function startChild(): Promise<void> {
+  if (stopping || child) return;
+  if (await isServerRunning(serverEndpoint)) {
+    writeSupervisorLog("existing_server_detected", { endpoint: serverEndpoint });
+    process.exit(0);
+    return;
+  }
+  const startedAt = Date.now();
+  const restartReason = nextStartReason;
+  nextStartReason = "Supervisor 重新拉起进程";
+  child = spawn(process.execPath, [childEntry], {
+    cwd: process.cwd(),
+    env: { ...process.env, AGENT_BOT_SUPERVISED: "1", AGENT_BOT_RESTART_REASON: restartReason },
+    stdio: "inherit",
+    windowsHide: true,
+  });
+  writeSupervisorLog("started", { pid: child.pid, restartReason });
+
+  child.once("error", (error) => {
+    writeSupervisorLog("spawn_error", { error: error.message });
+  });
+  child.once("exit", (code, signal) => {
+    void handleChildExit(code, signal, startedAt);
+  });
+}
+
+async function handleChildExit(
+  code: number | null,
+  signal: NodeJS.Signals | null,
+  startedAt: number,
+): Promise<void> {
+  child = undefined;
+  const uptimeMs = Date.now() - startedAt;
+  writeSupervisorLog("exited", { code, signal, uptimeMs });
+  if (stopping) {
+    process.exit(0);
+    return;
+  }
+  if (code === STOP_EXIT_CODE) {
+    writeSupervisorLog("stopped_by_request", { code });
+    process.exit(0);
+    return;
+  }
+  if (await isServerRunning(serverEndpoint)) {
+    writeSupervisorLog("duplicate_supervisor_stopped", { endpoint: serverEndpoint });
+    process.exit(0);
+    return;
+  }
+
+  const intentional = code === RESTART_EXIT_CODE;
+  nextStartReason = describeRestartReason(code, signal, intentional);
+  if (intentional || uptimeMs >= STABLE_UPTIME_MS) consecutiveFailures = 0;
+  else consecutiveFailures += 1;
+  const delayMs = intentional
+    ? INTENTIONAL_RESTART_DELAY_MS
+    : crashRestartDelayMs(consecutiveFailures);
+  writeSupervisorLog("restarting", { delayMs, consecutiveFailures, intentional });
+  restartTimer = setTimeout(() => void startChild(), delayMs);
+}
+
+function stop(signal: NodeJS.Signals): void {
+  if (stopping) return;
+  stopping = true;
+  if (restartTimer) clearTimeout(restartTimer);
+  if (child && !child.killed) {
+    child.kill(signal);
+    return;
+  }
+  process.exit(0);
+}
+
+function writeSupervisorLog(event: string, data: Record<string, unknown>): void {
+  process.stdout.write(`${JSON.stringify({ component: "agent-bot-supervisor", event, time: new Date().toISOString(), ...data })}\n`);
+}
+
+process.on("SIGINT", () => stop("SIGINT"));
+process.on("SIGTERM", () => stop("SIGTERM"));
+const initialDelayMs = Number(process.env.AGENT_BOT_START_DELAY_MS ?? 0);
+if (Number.isFinite(initialDelayMs) && initialDelayMs > 0) {
+  restartTimer = setTimeout(() => void startChild(), initialDelayMs);
+} else {
+  void startChild();
+}

package/src/utils/executeShellCommand.ts

@@ -0,0 +1,97 @@
+import { spawn } from "node:child_process";
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_MAX_OUTPUT_BYTES = 64 * 1024;
+
+export interface ShellCommandResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  timedOut: boolean;
+  outputTruncated: boolean;
+}
+
+export interface ShellCommandOptions {
+  timeoutMs?: number;
+  maxOutputBytes?: number;
+  platform?: NodeJS.Platform;
+}
+
+export function executeShellCommand(
+  command: string,
+  cwd: string,
+  options: ShellCommandOptions = {},
+): Promise<ShellCommandResult> {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+  const prepared = prepareShellCommand(command, options.platform ?? process.platform);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(prepared.command, prepared.args, {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    const output = new BoundedOutput(maxOutputBytes);
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, timeoutMs);
+
+    child.stdout.on("data", (chunk: Buffer) => output.append("stdout", chunk));
+    child.stderr.on("data", (chunk: Buffer) => output.append("stderr", chunk));
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("close", (exitCode) => {
+      clearTimeout(timeout);
+      resolve({
+        ...output.result(),
+        exitCode,
+        timedOut,
+      });
+    });
+  });
+}
+
+function prepareShellCommand(command: string, platform: NodeJS.Platform): { command: string; args: string[] } {
+  if (platform !== "win32") return { command: "/bin/sh", args: ["-lc", command] };
+  const script = `$ProgressPreference = 'SilentlyContinue'; [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); ${command}`;
+  const encoded = Buffer.from(script, "utf16le").toString("base64");
+  return {
+    command: "powershell.exe",
+    args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-OutputFormat", "Text", "-EncodedCommand", encoded],
+  };
+}
+
+class BoundedOutput {
+  private readonly stdout: Buffer[] = [];
+  private readonly stderr: Buffer[] = [];
+  private retainedBytes = 0;
+  private truncated = false;
+
+  constructor(private readonly maxBytes: number) {}
+
+  append(stream: "stdout" | "stderr", chunk: Buffer): void {
+    const remaining = Math.max(0, this.maxBytes - this.retainedBytes);
+    if (remaining === 0) {
+      this.truncated = true;
+      return;
+    }
+    const retained = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
+    this[stream].push(retained);
+    this.retainedBytes += retained.length;
+    if (retained.length < chunk.length) this.truncated = true;
+  }
+
+  result(): Pick<ShellCommandResult, "stdout" | "stderr" | "outputTruncated"> {
+    return {
+      stdout: Buffer.concat(this.stdout).toString("utf8"),
+      stderr: Buffer.concat(this.stderr).toString("utf8"),
+      outputTruncated: this.truncated,
+    };
+  }
+}

package/src/utils/id.ts

@@ -0,0 +1,5 @@
+import { randomUUID } from "node:crypto";
+
+export function createId(prefix: string): string {
+  return `${prefix}_${randomUUID().replaceAll("-", "").slice(0, 16)}`;
+}

package/src/utils/markdown.ts

@@ -0,0 +1,25 @@
+export function truncateText(text: string, maxLength = 8000): string {
+  if (text.length <= maxLength) return text;
+  if (maxLength <= 0) return "";
+  if (maxLength <= 3) return ".".repeat(maxLength);
+  return `${text.slice(0, maxLength - 3)}...`;
+}
+
+export function truncateMiddle(text: string, maxLength = 8000, marker = "\n...\n"): string {
+  if (text.length <= maxLength) return text;
+  if (maxLength <= 0) return "";
+  if (maxLength <= marker.length) return ".".repeat(maxLength);
+  const retainedLength = maxLength - marker.length;
+  const headLength = Math.ceil(retainedLength / 2);
+  const tailLength = Math.floor(retainedLength / 2);
+  return `${text.slice(0, headLength)}${marker}${text.slice(text.length - tailLength)}`;
+}
+
+export function codeBlock(text: string, language = ""): string {
+  const fenceSafe = text.replaceAll("```", "`\u200b``");
+  return `\`\`\`${language}\n${fenceSafe}\n\`\`\``;
+}
+
+export function asInlineCode(text: string): string {
+  return `\`${text.replaceAll("`", "'")}\``;
+}