chatccc 0.2.6 → 0.2.7

package/src/adapters/cursor-session-meta-store.ts

@@ -0,0 +1,154 @@
+// =============================================================================
+// cursor-session-meta-store.ts — Cursor 会话 sessionId → meta 持久化映射
+// =============================================================================
+// 背景：Claude Adapter 通过 SDK 的 getSessionInfo 能拿到会话的真实 cwd（SDK
+// 内部已持久化）。Cursor CLI 没有等价机制，因此 ChatCCC 必须自己维护一份
+// sessionId → { cwd, model } 映射，否则：
+//   1. /git、/cd 等需要"会话真实工作目录"的命令将在 Cursor 会话上 100% 失败
+//   2. /status、/sessions 显示的"模型"只能硬塞 ChatCCC 的 ANTHROPIC 环境变量，
+//      与 Cursor 实际跑的 Composer 2 Fast 等真实模型无关
+//
+// 存储：
+//   文件 .claude/cursor-session-meta.json，结构：
+//     { "<sessionId>": { "cwd": "...", "model": "..." } }
+//
+// API 设计：
+//   set(sid, partial) → 部分合并写入；只更新非空字段，不会清空其他字段
+//   这样 createSession（拿到 cwd+model）与 prompt（resume 时再次学习）都用同一
+//   接口，但若某次 init 事件少了某字段也不会破坏已记录值。
+//
+// 鲁棒性：文件不存在/损坏/IO 失败一律视为空映射，仅打日志，不阻断主流程。
+// =============================================================================
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import { PROJECT_ROOT } from "../config.ts";
+
+/** 持久化文件默认路径（生产）。测试可通过 createCursorSessionMetaStore(filePath) 注入。 */
+export const CURSOR_SESSION_META_FILE = join(
+  PROJECT_ROOT,
+  ".claude",
+  "cursor-session-meta.json",
+);
+
+/**
+ * 单条会话元数据。cwd 为必填（无 cwd 的记录视为不完整，get 返回 undefined）；
+ * model 可选（cursor agent init 事件理论上一定带，留可选是为防御性兜底）。
+ */
+export interface CursorSessionMeta {
+  cwd: string;
+  model?: string;
+}
+
+export interface CursorSessionMetaStore {
+  /** 查询某 sessionId 对应的元数据；未记录或 cwd 缺失返回 undefined。 */
+  get(sessionId: string): Promise<CursorSessionMeta | undefined>;
+  /**
+   * 部分合并写入：仅写入非 undefined / 非空字段；其他字段保持原值。
+   * - 第一次写入若不含 cwd，记录视为不完整，get 仍返回 undefined
+   * - 同 sessionId 重复写入完全相同值时跳过 IO（性能优化）
+   */
+  set(sessionId: string, partial: Partial<CursorSessionMeta>): Promise<void>;
+}
+
+interface RawEntry {
+  cwd?: string;
+  model?: string;
+}
+
+function isNonEmptyString(v: unknown): v is string {
+  return typeof v === "string" && v.length > 0;
+}
+
+/**
+ * 解析持久化文件中的单条记录，兼容历史 schema：
+ *   - 新版：{ cwd: string, model?: string }
+ *   - 历史 v1：纯字符串（直接是 cwd 值）—— 升级前旧数据兼容
+ * 非法形态返回 null。
+ */
+function parseEntry(raw: unknown): RawEntry | null {
+  if (typeof raw === "string" && raw.length > 0) {
+    return { cwd: raw };
+  }
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const obj = raw as Record<string, unknown>;
+    const out: RawEntry = {};
+    if (isNonEmptyString(obj.cwd)) out.cwd = obj.cwd;
+    if (isNonEmptyString(obj.model)) out.model = obj.model;
+    return out;
+  }
+  return null;
+}
+
+/**
+ * 创建一个基于 JSON 文件的 store 实例。
+ *
+ * - 首次访问时懒加载文件到内存缓存；后续读全部走缓存
+ * - 写时先合并到缓存再落盘（写失败仅 console.error，不抛异常）
+ * - 同一 sessionId 重复 set 完全相同值时跳过 IO
+ */
+export function createCursorSessionMetaStore(
+  filePath: string = CURSOR_SESSION_META_FILE,
+): CursorSessionMetaStore {
+  let cache: Record<string, RawEntry> | null = null;
+
+  async function load(): Promise<Record<string, RawEntry>> {
+    if (cache) return cache;
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const out: Record<string, RawEntry> = {};
+        for (const [k, v] of Object.entries(parsed as Record<string, unknown>)) {
+          const entry = parseEntry(v);
+          if (entry) out[k] = entry;
+        }
+        cache = out;
+        return out;
+      }
+    } catch {
+      // 文件不存在 / JSON 损坏 / 读权限失败 → 视为空映射，不阻断主流程
+    }
+    cache = {};
+    return cache;
+  }
+
+  return {
+    async get(sessionId: string): Promise<CursorSessionMeta | undefined> {
+      const map = await load();
+      const entry = map[sessionId];
+      if (!entry || !isNonEmptyString(entry.cwd)) return undefined;
+      return entry.model
+        ? { cwd: entry.cwd, model: entry.model }
+        : { cwd: entry.cwd };
+    },
+
+    async set(
+      sessionId: string,
+      partial: Partial<CursorSessionMeta>,
+    ): Promise<void> {
+      const map = await load();
+      const existing = map[sessionId] ?? {};
+      const merged: RawEntry = { ...existing };
+      if (isNonEmptyString(partial.cwd)) merged.cwd = partial.cwd;
+      if (isNonEmptyString(partial.model)) merged.model = partial.model;
+
+      // 与原值完全相同时跳过 IO
+      if (existing.cwd === merged.cwd && existing.model === merged.model) return;
+
+      map[sessionId] = merged;
+      try {
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, JSON.stringify(map, null, 2), "utf-8");
+      } catch (err) {
+        console.error(
+          `[cursor-session-meta] failed to persist ${filePath}: ${(err as Error).message}`,
+        );
+      }
+    },
+  };
+}
+
+/** 生产环境共享的全局默认实例（指向 .claude/cursor-session-meta.json）。 */
+export const defaultCursorSessionMetaStore = createCursorSessionMetaStore();

package/src/cards.ts

@@ -119,7 +119,7 @@ export function buildHelpCard(userText: string): string {
         { text: "新建 Claude Code 会话（/new claude）", value: JSON.stringify({ cmd: "new" }), type: "primary" },
         { text: "新建 Cursor 会话（/new cursor）", value: JSON.stringify({ cmd: "new cursor" }), type: "primary" },
         { text: "重启 ChatCCC（/restart）", value: JSON.stringify({ cmd: "restart" }), type: "danger" },
-        { text: "查看/切换工作路径及最近使用（/cd）", value: JSON.stringify({ cmd: "cd" }), type: "default" },
+        { text: "切换工作路径（/cd）", value: JSON.stringify({ cmd: "cd" }), type: "default" },
       ]),
     ],
   });
@@ -162,6 +162,15 @@ export function buildCdContent(
 }
 
 // 工作路径卡片（/cd 无参数时使用，含最近使用路径按钮）
+//
+// 必须使用 v1 卡片格式（无 schema 字段、elements 放顶层）。原因：
+// 此卡片通过 `/im/v1/messages?msg_type=interactive` 端点直接发出，content
+// 字段就是卡片 JSON。该端点不接受 schema 2.0 的原始 JSON 作为 content
+// （schema 2.0 卡片必须先通过 CardKit /cardkit/v1/cards 创建得到 card_id，
+// 再以 `{type:"card", data:{card_id}}` 包装发出，参见 sendCardKitMessage）。
+// 之前用过 schema 2.0 + body.elements 的结构，飞书会静默拒绝该消息，
+// 导致 /cd 无任何回复——故此处与 buildSessionsCard/buildStatusCard 保持
+// 同一 v1 结构。
 export function buildCdCard(
   dirPath: string,
   entries: { name: string; isDir: boolean }[],
@@ -173,24 +182,28 @@ export function buildCdCard(
   const overflow = entries.length > maxFiles ? `\n...（共 ${entries.length} 个条目，仅显示前 ${maxFiles} 个）` : "";
   const listing = display.map(e => e.isDir ? `📁 ${e.name}/` : `📄 ${e.name}`).join("\n");
 
-  const currentLine = sessionCwd
-    ? `**当前会话工作路径:** \`${sessionCwd}\``
-    : "";
-
   const elements: object[] = [];
 
-  if (currentLine) {
-    elements.push({ tag: "markdown", content: currentLine });
+  if (sessionCwd) {
+    elements.push({
+      tag: "div",
+      text: { tag: "lark_md", content: `**当前会话工作路径:** \`${sessionCwd}\`` },
+    });
   }
-  elements.push({ tag: "markdown", content: `**新会话默认工作路径:** \`${dirPath}\`` });
+  elements.push({
+    tag: "div",
+    text: { tag: "lark_md", content: `**新会话默认工作路径:** \`${dirPath}\`` },
+  });
 
   if (recentDirs.length > 0) {
     elements.push({ tag: "hr" });
-    elements.push({ tag: "markdown", content: "**最近使用过的路径（点击切换）:**" });
+    elements.push({
+      tag: "div",
+      text: { tag: "lark_md", content: "**最近使用过的路径（点击切换）:**" },
+    });
     elements.push({
       tag: "action",
       actions: recentDirs.map(d => {
-        const name = d.split(/[\\/]/).filter(Boolean).pop() ?? d;
         const label = d.length > 36 ? `...${d.slice(-33)}` : d;
         return {
           tag: "button",
@@ -204,25 +217,24 @@ export function buildCdCard(
 
   elements.push({ tag: "hr" });
   elements.push({
-    tag: "markdown",
-    content: [
-      `**目录内容** (最多 ${maxFiles} 个):`,
-      listing,
-      overflow,
-    ].join("\n"),
+    tag: "div",
+    text: {
+      tag: "lark_md",
+      content: [
+        `**目录内容** (最多 ${maxFiles} 个):`,
+        listing,
+        overflow,
+      ].join("\n"),
+    },
   });
 
   return JSON.stringify({
-    schema: "2.0",
     config: { wide_screen_mode: true },
     header: {
       template: "blue",
       title: { tag: "plain_text", content: "工作路径" },
     },
-    body: {
-      direction: "vertical",
-      elements,
-    },
+    elements,
   });
 }
 

package/src/config.ts

@@ -62,6 +62,59 @@ export const CLAUDE_MODEL = process.env.CHATCCC_ANTHROPIC_MODEL?.trim() || "defa
 
 export const CLAUDE_EFFORT = process.env.CHATCCC_ANTHROPIC_EFFORT?.trim() || "default";
 
+// ---------------------------------------------------------------------------
+// /git 超时配置（CHATCCC_GIT_TIMEOUT_SECONDS）
+// ---------------------------------------------------------------------------
+
+/** /git 命令默认超时秒数（用户未配置时使用） */
+export const DEFAULT_GIT_TIMEOUT_SECONDS = 180;
+/** /git 超时允许的下限/上限（防止 0、负数、过大值导致行为异常） */
+export const MIN_GIT_TIMEOUT_SECONDS = 1;
+export const MAX_GIT_TIMEOUT_SECONDS = 3600; // 1 小时
+
+export interface ParsedGitTimeout {
+  /** 实际使用的超时秒数（无效时回退为 default） */
+  seconds: number;
+  /** 用户提供的原始字符串是否为合法整数秒（true 表示采纳了用户值或未提供） */
+  valid: boolean;
+  /** 用户原始输入；未设置时为 undefined */
+  raw?: string;
+  /** 是否使用了内置默认值（即用户未提供有效值） */
+  usingDefault: boolean;
+}
+
+/**
+ * 解析 CHATCCC_GIT_TIMEOUT_SECONDS 字符串为有效秒数。
+ * - 未设置 / 空 → 使用默认值，valid=true、usingDefault=true
+ * - 有效整数且在 [MIN, MAX] 区间 → 使用用户值，valid=true、usingDefault=false
+ * - 非整数 / 越界 / NaN → 使用默认值，valid=false、usingDefault=true（同时保留原始字符串供报错）
+ */
+export function parseGitTimeoutSeconds(
+  raw: string | undefined,
+  defaultSeconds = DEFAULT_GIT_TIMEOUT_SECONDS,
+): ParsedGitTimeout {
+  const trimmed = raw?.trim();
+  if (!trimmed) {
+    return { seconds: defaultSeconds, valid: true, usingDefault: true };
+  }
+  const n = Number(trimmed);
+  if (
+    !Number.isFinite(n) ||
+    !Number.isInteger(n) ||
+    n < MIN_GIT_TIMEOUT_SECONDS ||
+    n > MAX_GIT_TIMEOUT_SECONDS
+  ) {
+    return { seconds: defaultSeconds, valid: false, raw: trimmed, usingDefault: true };
+  }
+  return { seconds: n, valid: true, raw: trimmed, usingDefault: false };
+}
+
+const gitTimeoutParsed = parseGitTimeoutSeconds(process.env.CHATCCC_GIT_TIMEOUT_SECONDS);
+/** /git 命令实际使用的超时秒数 */
+export const GIT_TIMEOUT_SECONDS = gitTimeoutParsed.seconds;
+/** /git 命令实际使用的超时毫秒数（runGitCommand 直接使用） */
+export const GIT_TIMEOUT_MS = GIT_TIMEOUT_SECONDS * 1000;
+
 /** 探测 cursor-agent 安装路径（优先环境变量，其次 LocalAppData，最后默认 agent） */
 function detectCursorAgent(): string {
   if (process.env.CHATCCC_CURSOR_COMMAND?.trim()) return process.env.CHATCCC_CURSOR_COMMAND.trim();
@@ -73,8 +126,21 @@ function detectCursorAgent(): string {
   return "agent";
 }
 export const CURSOR_AGENT_COMMAND = detectCursorAgent();
-/** Cursor agent 参数：-p 非交互模式，stream-json 流式 JSONL 输出 */
-export const CURSOR_AGENT_ARGS = (process.env.CHATCCC_CURSOR_ARGS?.trim() || "-p --output-format stream-json --stream-partial-output").split(/\s+/).filter(Boolean);
+
+function resolveCursorAgentArgs(): string[] {
+  const custom = process.env.CHATCCC_CURSOR_ARGS?.trim();
+  if (custom) return custom.split(/\s+/).filter(Boolean);
+
+  let args = "-p --force --output-format stream-json --stream-partial-output";
+  const model = process.env.CHATCCC_CURSOR_MODEL?.trim();
+  if (model && model !== "default") {
+    args += ` --model ${model}`;
+  }
+  return args.split(/\s+/).filter(Boolean);
+}
+
+/** Cursor agent 参数：-p 非交互模式，--force 强制允许命令（yolo），stream-json 流式 JSONL 输出 */
+export const CURSOR_AGENT_ARGS = resolveCursorAgentArgs();
 
 // 新建会话的默认工作路径（/cd 命令设置，持久化到本地文件）
 // 该路径仅影响通过 /new 新建的会话，不影响已有会话的 resume。
@@ -227,6 +293,30 @@ export function reportEnvironmentVariableReadout(): void {
     );
   }
 
+  const rawGitTimeout = process.env.CHATCCC_GIT_TIMEOUT_SECONDS?.trim();
+  if (!rawGitTimeout) {
+    console.log(`  [默认] [可选] CHATCCC_GIT_TIMEOUT_SECONDS`);
+    console.log(
+      `         /git 命令超时: 未设置 → 使用内置默认 ${DEFAULT_GIT_TIMEOUT_SECONDS}s`
+    );
+  } else if (!gitTimeoutParsed.valid) {
+    row(
+      "/git 命令超时",
+      "CHATCCC_GIT_TIMEOUT_SECONDS",
+      "可选",
+      false,
+      `值无效 "${rawGitTimeout}"，需为 ${MIN_GIT_TIMEOUT_SECONDS}–${MAX_GIT_TIMEOUT_SECONDS} 的整数秒；已回退为默认 ${DEFAULT_GIT_TIMEOUT_SECONDS}s`,
+    );
+  } else {
+    row(
+      "/git 命令超时",
+      "CHATCCC_GIT_TIMEOUT_SECONDS",
+      "可选",
+      true,
+      `已读入 → ${GIT_TIMEOUT_SECONDS}s`,
+    );
+  }
+
   console.log("  ------------------------------------------------------------------");
 }
 

package/src/feishu-api.ts

@@ -343,7 +343,7 @@ export async function sendRestartCard(token: string): Promise<void> {
           { text: "新建 Claude Code 会话（/new claude）", value: JSON.stringify({ cmd: "new" }), type: "primary" },
           { text: "新建 Cursor 会话（/new cursor）", value: JSON.stringify({ cmd: "new cursor" }), type: "primary" },
           { text: "重启Chat CCC（/restart）", value: JSON.stringify({ cmd: "restart" }), type: "danger" },
-          { text: "查看/切换工作路径（/cd）", value: JSON.stringify({ cmd: "cd" }), type: "default" },
+          { text: "切换工作路径（/cd）", value: JSON.stringify({ cmd: "cd" }), type: "default" },
         ]),
       ],
     });

package/src/git-command.ts

@@ -0,0 +1,202 @@
+// =============================================================================
+// git-command.ts — /git 命令的执行与结果格式化
+// =============================================================================
+// 解析自 /git 后的原始字符串作为 shell 参数，在指定 cwd 下通过 shell 调起
+// `git ...`，收集 stdout/stderr 与退出码。带超时（kill）与逐路输出字节上限
+// （超过即截断），避免长输出撑爆内存或刷屏。
+//
+// 抽成独立模块是为了便于在不依赖飞书 SDK / 网络的前提下跑单元测试。
+// =============================================================================
+
+import { spawn } from "node:child_process";
+
+import { truncateContent } from "./cards.ts";
+
+// ---------------------------------------------------------------------------
+// 类型
+// ---------------------------------------------------------------------------
+
+export interface GitCommandResult {
+  /** 进程退出码；spawn 失败或被 kill 时为 null */
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  durationMs: number;
+  /** 任意一路输出超过 maxBytes 上限，已被截断 */
+  truncated: boolean;
+  /** 命令超过 timeoutMs 被强制终止 */
+  timedOut: boolean;
+  /** spawn 自身错误（如 git 不在 PATH）；正常退出（含非 0）时为 undefined */
+  spawnError?: string;
+}
+
+export interface RunGitOptions {
+  /** 命令最大允许执行毫秒数；超过则 SIGKILL，默认 60_000 */
+  timeoutMs?: number;
+  /** stdout 与 stderr 各自最多采集多少字节；默认 64 KiB */
+  maxBytes?: number;
+  /** 注入测试桩用：自定义 spawn 函数；默认使用 node:child_process 的 spawn */
+  spawnImpl?: typeof spawn;
+}
+
+// ---------------------------------------------------------------------------
+// runGitCommand —— 在 cwd 下执行 `git <args>`
+// ---------------------------------------------------------------------------
+
+/**
+ * 在 `cwd` 目录下执行 `git <args>`。
+ * - 通过 shell 执行（`shell: true`），允许用户使用引号、管道等 shell 语法
+ * - stdout/stderr 各自最多采集 `maxBytes` 字节，超过则置 truncated=true 并丢弃后续片段
+ * - 超时则 SIGKILL 并置 timedOut=true，仍返回已收集的部分输出
+ *
+ * 注意：本函数 **不会抛错**——任何失败都通过返回值传递（退出码、spawnError 等），
+ * 调用方需通过 exitCode/spawnError/timedOut/truncated 判断结果。
+ */
+export function runGitCommand(
+  args: string,
+  cwd: string,
+  opts: RunGitOptions = {},
+): Promise<GitCommandResult> {
+  const timeoutMs = opts.timeoutMs ?? 60_000;
+  const maxBytes = opts.maxBytes ?? 64 * 1024;
+  const spawnImpl = opts.spawnImpl ?? spawn;
+  const startTime = Date.now();
+
+  return new Promise<GitCommandResult>((resolve) => {
+    let child: ReturnType<typeof spawn>;
+    try {
+      child = spawnImpl(`git ${args}`, {
+        cwd,
+        shell: true,
+        windowsHide: true,
+      });
+    } catch (err) {
+      resolve({
+        exitCode: null,
+        stdout: "",
+        stderr: "",
+        durationMs: Date.now() - startTime,
+        truncated: false,
+        timedOut: false,
+        spawnError: err instanceof Error ? err.message : String(err),
+      });
+      return;
+    }
+
+    let stdout = "";
+    let stderr = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let truncated = false;
+    let timedOut = false;
+    let spawnError: string | undefined;
+
+    const collect = (chunk: Buffer, current: { bytes: number; text: string }): void => {
+      const room = maxBytes - current.bytes;
+      if (room <= 0) {
+        truncated = true;
+        return;
+      }
+      const slice = chunk.length <= room ? chunk : chunk.subarray(0, room);
+      current.text += slice.toString("utf-8");
+      current.bytes += slice.length;
+      if (chunk.length > room) truncated = true;
+    };
+
+    const stdoutState = { bytes: 0, text: "" };
+    const stderrState = { bytes: 0, text: "" };
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      collect(chunk, stdoutState);
+      stdout = stdoutState.text;
+      stdoutBytes = stdoutState.bytes;
+    });
+    child.stderr?.on("data", (chunk: Buffer) => {
+      collect(chunk, stderrState);
+      stderr = stderrState.text;
+      stderrBytes = stderrState.bytes;
+    });
+
+    const killTimer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // ignore: 进程可能已退出
+      }
+    }, timeoutMs);
+
+    child.on("error", (err: Error) => {
+      spawnError = err.message;
+    });
+
+    child.on("close", (code: number | null) => {
+      clearTimeout(killTimer);
+      // 仅引用未直接使用的字节计数变量以避免编译告警
+      void stdoutBytes; void stderrBytes;
+      resolve({
+        exitCode: code,
+        stdout,
+        stderr,
+        durationMs: Date.now() - startTime,
+        truncated,
+        timedOut,
+        spawnError,
+      });
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// formatGitResult —— 把执行结果渲染为飞书卡片用的 markdown
+// ---------------------------------------------------------------------------
+
+/**
+ * 渲染 `/git` 执行结果为发送给用户的 markdown 字符串。
+ * stdout/stderr 单路各最多保留 `maxLines` 行 / `maxChars` 字符（沿用 truncateContent），
+ * 命令本身的截断状态（truncated/timedOut/spawnError）也会在头部说明。
+ */
+export function formatGitResult(
+  args: string,
+  cwd: string,
+  result: GitCommandResult,
+  opts: { maxLines?: number; maxChars?: number } = {},
+): string {
+  const maxLines = opts.maxLines ?? 50;
+  const maxChars = opts.maxChars ?? 6000;
+  const sec = (result.durationMs / 1000).toFixed(2);
+  const lines: string[] = [];
+
+  lines.push(`**\$ git ${args}**`);
+  lines.push(`工作目录: \`${cwd}\``);
+  const exitDisplay = result.exitCode === null ? "(无)" : String(result.exitCode);
+  lines.push(`退出码: \`${exitDisplay}\` | 用时: \`${sec}s\``);
+  if (result.timedOut) lines.push(`⏱️ 命令超时被强制终止`);
+  if (result.truncated) lines.push(`⚠️ 输出超出采集上限，已截断`);
+  if (result.spawnError) lines.push(`❌ 启动失败: ${result.spawnError}`);
+
+  const stdoutTrim = result.stdout.trim();
+  const stderrTrim = result.stderr.trim();
+
+  if (stdoutTrim) {
+    lines.push("", "**stdout:**", "```", truncateContent(stdoutTrim, maxLines, maxChars), "```");
+  }
+  if (stderrTrim) {
+    lines.push("", "**stderr:**", "```", truncateContent(stderrTrim, maxLines, maxChars), "```");
+  }
+  if (!stdoutTrim && !stderrTrim && !result.spawnError) {
+    lines.push("", "_(命令无输出)_");
+  }
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// 头部颜色：成功绿色，失败红色，超时黄色
+// ---------------------------------------------------------------------------
+
+export function gitResultHeaderTemplate(result: GitCommandResult): string {
+  if (result.timedOut || result.spawnError) return "yellow";
+  if (result.exitCode === 0) return "green";
+  return "red";
+}