linkshell-cli 0.3.11 → 0.3.13

package/src/runtime/acp/agent-workspace.ts

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { basename, join, relative } from "node:path";
 import {
@@ -207,6 +208,8 @@ interface PendingStructuredInputWaiter {
 
 const PERMISSION_TIMEOUT_MS = 5 * 60_000;
 const MAX_TIMELINE_ITEMS = 200;
+const MAX_SNAPSHOT_ITEMS = 80;
+const MAX_SNAPSHOT_TEXT_BYTES = 128 * 1024;
 
 function id(prefix: string): string {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -221,6 +224,71 @@ function stringify(value: unknown): string {
   }
 }
 
+function truncateUtf8(value: string | undefined, maxBytes = MAX_SNAPSHOT_TEXT_BYTES): string | undefined {
+  if (!value) return value;
+  if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+  let end = Math.min(value.length, maxBytes);
+  while (end > 0 && Buffer.byteLength(value.slice(0, end), "utf8") > maxBytes) {
+    end = Math.floor(end * 0.9);
+  }
+  return `${value.slice(0, end)}\n\n[truncated by LinkShell: original ${Buffer.byteLength(value, "utf8")} bytes]`;
+}
+
+function snapshotContentBlocks(
+  blocks: AgentContentBlock[] | undefined,
+  options: { stripImages?: boolean } = {},
+): AgentContentBlock[] | undefined {
+  if (!blocks) return undefined;
+  return blocks.map((block) =>
+    block.type === "image" && options.stripImages !== false
+      ? { ...block, data: undefined, text: block.text || "图片附件" }
+      : { ...block, text: truncateUtf8(block.text) },
+  );
+}
+
+function snapshotTimelineItem(
+  item: AgentTimelineItem,
+  options: { stripImages?: boolean } = {},
+): AgentTimelineItem {
+  return {
+    ...item,
+    content: snapshotContentBlocks(item.content, options),
+    text: truncateUtf8(item.text),
+    toolCall: item.toolCall
+      ? {
+          ...item.toolCall,
+          input: truncateUtf8(item.toolCall.input),
+          output: truncateUtf8(item.toolCall.output),
+        }
+      : undefined,
+    commandExecution: item.commandExecution
+      ? {
+          ...item.commandExecution,
+          command: truncateUtf8(item.commandExecution.command, 16 * 1024),
+          output: truncateUtf8(item.commandExecution.output),
+        }
+      : undefined,
+    fileChange: item.fileChange
+      ? {
+          ...item.fileChange,
+          diff: truncateUtf8(item.fileChange.diff),
+          summary: truncateUtf8(item.fileChange.summary),
+        }
+      : undefined,
+    permission: item.permission
+      ? {
+          ...item.permission,
+          toolInput: truncateUtf8(item.permission.toolInput),
+          context: truncateUtf8(item.permission.context),
+        }
+      : undefined,
+  };
+}
+
+function snapshotTimelineItems(items: AgentTimelineItem[]): AgentTimelineItem[] {
+  return items.slice(-MAX_SNAPSHOT_ITEMS).map((item) => snapshotTimelineItem(item));
+}
+
 function asRecord(value: unknown): Record<string, unknown> | undefined {
   return typeof value === "object" && value ? value as Record<string, unknown> : undefined;
 }
@@ -768,6 +836,30 @@ interface ProviderRuntimeCapabilities {
 const ALL_REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh"] as const;
 const CLAUDE_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"] as const;
 const AGENT_PERMISSION_MODES: AgentPermissionMode[] = ["read_only", "workspace_write", "full_access"];
+const COMMAND_OUTPUT_MAX_BYTES = 96 * 1024;
+const LINKSHELL_NATIVE_COMMANDS: Array<{
+  name: string;
+  description: string;
+  category: string;
+  argsMode?: AgentCommandDescriptor["argsMode"];
+  destructive?: boolean;
+  providers?: AgentProvider[];
+}> = [
+  { name: "status", description: "Show current Agent and workspace status", category: "LinkShell", argsMode: "none" },
+  { name: "plan", description: "Enter Plan mode for the next turn", category: "Agent", argsMode: "none" },
+  { name: "exit-plan", description: "Exit Plan mode", category: "Agent", argsMode: "none" },
+  { name: "review", description: "Ask the Agent to review current local changes", category: "Agent", argsMode: "optional" },
+  { name: "subagents", description: "Ask the Agent to split work across subagents when useful", category: "Agent", argsMode: "optional" },
+  { name: "compact", description: "Compact the active Codex context", category: "Codex", argsMode: "none", providers: ["codex"] },
+  { name: "clear", description: "Start a fresh Agent context for this conversation", category: "Agent", argsMode: "none", destructive: true },
+  { name: "git-status", description: "Show branch and working tree status", category: "Git", argsMode: "none" },
+  { name: "git-diff", description: "Show a compact diffstat for current changes", category: "Git", argsMode: "none" },
+  { name: "git-commit", description: "Commit staged changes with the given message", category: "Git", argsMode: "required" },
+  { name: "git-pull", description: "Pull with fast-forward only", category: "Git", argsMode: "none" },
+  { name: "git-push", description: "Push the current branch", category: "Git", argsMode: "none" },
+  { name: "git-stash", description: "Stash current working tree changes", category: "Git", argsMode: "optional" },
+  { name: "git-stash-pop", description: "Pop the latest stash", category: "Git", argsMode: "none" },
+];
 const CLAUDE_REMOTE_HIDDEN_COMMANDS = new Set([
   "add-dir",
   "agents",
@@ -1040,17 +1132,30 @@ function customClaudeCommands(cwd: string): AgentCommandDescriptor[] {
 
 function defaultProviderCommands(provider: AgentProvider, cwd: string, enabled: boolean): AgentCommandDescriptor[] {
   const disabledReason = enabled ? undefined : `${providerLabel(provider)} 未安装或启动失败`;
+  const linkshellCommands = LINKSHELL_NATIVE_COMMANDS
+    .filter((command) => !command.providers || command.providers.includes(provider))
+    .map((command) => makeCommand({
+      provider,
+      name: command.name,
+      description: command.description,
+      source: "linkshell",
+      category: command.category,
+      argsMode: command.argsMode ?? "optional",
+      destructive: command.destructive,
+      disabledReason,
+      executionKind: "native",
+    }));
   if (provider === "codex") {
-    return [];
+    return linkshellCommands;
   }
   if (provider === "claude") {
     const custom = customClaudeCommands(cwd).map((command) => ({
       ...command,
       disabledReason: command.disabledReason ?? disabledReason,
     }));
-    return custom;
+    return [...linkshellCommands, ...custom];
   }
-  return [];
+  return linkshellCommands;
 }
 
 function mergeCommands(...groups: Array<AgentCommandDescriptor[] | undefined>): AgentCommandDescriptor[] {
@@ -1069,6 +1174,81 @@ function mergeCommands(...groups: Array<AgentCommandDescriptor[] | undefined>):
   return [...map.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
 
+function isGitNativeCommand(name: string): boolean {
+  return name === "git-status" ||
+    name === "git-diff" ||
+    name === "git-commit" ||
+    name === "git-pull" ||
+    name === "git-push" ||
+    name === "git-stash" ||
+    name === "git-stash-pop";
+}
+
+function gitCommandArgs(name: string, args?: string): { display: string; argv: string[] } {
+  const message = args?.trim();
+  switch (name) {
+    case "git-status":
+      return { display: "git status --short --branch", argv: ["status", "--short", "--branch"] };
+    case "git-diff":
+      return { display: "git diff --stat", argv: ["diff", "--stat"] };
+    case "git-commit":
+      if (!message) throw new Error("请先输入提交信息，例如 /git-commit fix mobile agent timeline");
+      return { display: `git commit -m ${JSON.stringify(message)}`, argv: ["commit", "-m", message] };
+    case "git-pull":
+      return { display: "git pull --ff-only", argv: ["pull", "--ff-only"] };
+    case "git-push":
+      return { display: "git push", argv: ["push"] };
+    case "git-stash":
+      return {
+        display: "git stash push -u",
+        argv: ["stash", "push", "-u", "-m", message || "LinkShell mobile stash"],
+      };
+    case "git-stash-pop":
+      return { display: "git stash pop", argv: ["stash", "pop"] };
+    default:
+      throw new Error(`未知 Git 命令：/${name}`);
+  }
+}
+
+function runProcess(
+  command: string,
+  args: string[],
+  options: { cwd: string; maxBytes?: number },
+): Promise<{ output: string; exitCode: number | null; signal: NodeJS.Signals | null }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    const maxBytes = options.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES;
+    let output = "";
+    let bytes = 0;
+    let truncated = false;
+    const append = (chunk: Buffer) => {
+      if (bytes >= maxBytes) {
+        truncated = true;
+        return;
+      }
+      const remaining = maxBytes - bytes;
+      const slice = chunk.byteLength > remaining ? chunk.subarray(0, remaining) : chunk;
+      output += slice.toString("utf8");
+      bytes += slice.byteLength;
+      if (slice.byteLength < chunk.byteLength) truncated = true;
+    };
+    child.stdout.on("data", append);
+    child.stderr.on("data", append);
+    child.once("error", reject);
+    child.once("close", (exitCode, signal) => {
+      resolve({
+        output: `${output.trimEnd()}${truncated ? "\n\n[truncated by LinkShell]" : ""}`,
+        exitCode,
+        signal,
+      });
+    });
+  });
+}
+
 function runtimeCommands(provider: AgentProvider, value: unknown): AgentCommandDescriptor[] {
   const raw = asRecord(value);
   const commandsValue =
@@ -1583,7 +1763,7 @@ export class AgentWorkspaceProxy {
         hostDeviceId: this.input.hostDeviceId,
         payload: {
           conversation: existingConversation,
-          snapshot: this.timelines.get(existingConversation.id) ?? [],
+          snapshot: snapshotTimelineItems(this.timelines.get(existingConversation.id) ?? []),
         },
       }));
       return existingConversation;
@@ -1639,7 +1819,7 @@ export class AgentWorkspaceProxy {
       this.input.send(createEnvelope({
         type: "agent.v2.conversation.opened",
         hostDeviceId: this.input.hostDeviceId,
-        payload: { conversation, snapshot: this.timelines.get(conversation.id) ?? [] },
+        payload: { conversation, snapshot: snapshotTimelineItems(this.timelines.get(conversation.id) ?? []) },
       }));
       return conversation;
     } catch (error) {
@@ -1691,7 +1871,7 @@ export class AgentWorkspaceProxy {
     this.input.send(createEnvelope({
       type: "agent.v2.conversation.opened",
       hostDeviceId: this.input.hostDeviceId,
-      payload: { conversation, snapshot: this.timelines.get(conversation.id) ?? [] },
+      payload: { conversation, snapshot: snapshotTimelineItems(this.timelines.get(conversation.id) ?? []) },
     }));
     return conversation;
   }
@@ -1918,14 +2098,8 @@ export class AgentWorkspaceProxy {
         return;
       }
 
-      if (conversation.provider !== "codex") {
-        this.addItem(conversation.id, {
-          id: id("error"),
-          conversationId: conversation.id,
-          type: "error",
-          error: `${command.title} 暂无 ${providerLabel(conversation.provider)} 原生实现。`,
-          createdAt: now,
-        });
+      if (isGitNativeCommand(command.name)) {
+        await this.executeGitNativeCommand(conversation, command.name, args);
         return;
       }
 
@@ -1942,6 +2116,22 @@ export class AgentWorkspaceProxy {
         return;
       }
 
+      if (command.name === "review" || command.name === "subagents") {
+        const prompt = command.name === "review"
+          ? args || "Review the current local changes."
+          : args || "Run subagents for distinct tasks in parallel when useful, then synthesize the results.";
+        await this.sendPrompt({
+          conversationId: conversation.id,
+          clientMessageId: id(command.name),
+          contentBlocks: [{ type: "text", text: prompt }],
+          model: conversation.model,
+          reasoningEffort: conversation.reasoningEffort,
+          permissionMode: conversation.permissionMode,
+          collaborationMode: conversation.collaborationMode,
+        });
+        return;
+      }
+
       if (command.name === "compact") {
         if (!(client instanceof AcpClient)) throw new Error("当前 Codex runtime 不支持原生 compact。");
         conversation.status = "running";
@@ -1979,22 +2169,6 @@ export class AgentWorkspaceProxy {
         return;
       }
 
-      if (command.name === "review" || command.name === "subagents") {
-        const prompt = command.name === "review"
-          ? args || "Review the current local changes."
-          : args || "Run subagents for distinct tasks in parallel when useful, then synthesize the results.";
-        await this.sendPrompt({
-          conversationId: conversation.id,
-          clientMessageId: id(command.name),
-          contentBlocks: [{ type: "text", text: prompt }],
-          model: conversation.model,
-          reasoningEffort: conversation.reasoningEffort,
-          permissionMode: conversation.permissionMode,
-          collaborationMode: conversation.collaborationMode,
-        });
-        return;
-      }
-
       throw new Error(`命令暂未实现：/${command.name}`);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -2009,6 +2183,46 @@ export class AgentWorkspaceProxy {
     }
   }
 
+  private async executeGitNativeCommand(
+    conversation: AgentConversation,
+    commandName: string,
+    args?: string,
+  ): Promise<void> {
+    const git = gitCommandArgs(commandName, args);
+    const toolId = id(commandName);
+    const now = Date.now();
+    conversation.status = "running";
+    conversation.lastMessagePreview = git.display;
+    conversation.lastActivityAt = now;
+    this.emitConversation(conversation);
+    this.upsertTool(conversation.id, {
+      id: toolId,
+      name: "命令",
+      input: `${git.display}\n\ncwd: ${conversation.cwd}`,
+      createdAt: now,
+      status: "running",
+    });
+    const result = await runProcess("git", git.argv, {
+      cwd: conversation.cwd,
+      maxBytes: COMMAND_OUTPUT_MAX_BYTES,
+    });
+    const ok = result.exitCode === 0;
+    this.upsertTool(conversation.id, {
+      id: toolId,
+      name: "命令",
+      input: `${git.display}\n\ncwd: ${conversation.cwd}`,
+      output: result.output || (ok ? "完成" : `退出码 ${result.exitCode ?? "unknown"}`),
+      createdAt: now,
+      status: ok ? "completed" : "failed",
+    });
+    conversation.status = ok ? "idle" : "error";
+    conversation.lastMessagePreview = ok
+      ? `${git.display} 完成`
+      : `${git.display} 失败`;
+    conversation.lastActivityAt = Date.now();
+    this.emitConversation(conversation);
+  }
+
   private handleRequest(method: string, params: unknown): Promise<unknown> | unknown {
     if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
       return this.handleStructuredInput(params, true);
@@ -2935,7 +3149,7 @@ export class AgentWorkspaceProxy {
     this.input.send(createEnvelope({
       type: "agent.v2.event",
       hostDeviceId: this.input.hostDeviceId,
-      payload: { conversationId, conversation, item },
+      payload: { conversationId, conversation, item: snapshotTimelineItem(item, { stripImages: false }) },
     }));
   }
 
@@ -2994,8 +3208,8 @@ export class AgentWorkspaceProxy {
     }
     const conversations = [...this.conversations.values()];
     const items = conversationId
-      ? this.timelines.get(conversationId) ?? []
-      : [...this.timelines.values()].flat();
+      ? snapshotTimelineItems(this.timelines.get(conversationId) ?? [])
+      : [];
     this.input.send(createEnvelope({
       type: "agent.v2.snapshot",
       hostDeviceId: this.input.hostDeviceId,

package/src/runtime/acp/codex-sessions.ts

@@ -62,6 +62,8 @@ interface CodexIndexEntry {
   updatedAt?: number;
 }
 
+type StoredToolStatus = NonNullable<StoredAgentTimelineItem["toolCall"]>["status"];
+
 function asRecord(value: unknown): Record<string, unknown> | undefined {
   return value && typeof value === "object" && !Array.isArray(value)
     ? value as Record<string, unknown>
@@ -366,7 +368,8 @@ function historyToolName(name: string | undefined): string {
   return name;
 }
 
-function historyToolKind(name: string | undefined): "tool_activity" | "command_execution" {
+function historyToolKind(name: string | undefined): "tool_activity" | "command_execution" | "file_change" {
+  if (name === "apply_patch") return "file_change";
   return name?.endsWith("exec_command") || name?.endsWith("write_stdin") ? "command_execution" : "tool_activity";
 }
 
@@ -390,6 +393,75 @@ function commandFromCodexTool(name: string | undefined, rawInput: unknown, outpu
   return { command, cwd, output, status: output === undefined ? "running" : "completed" };
 }
 
+function patchTextFromCodexTool(name: string | undefined, rawInput: unknown, input: string | undefined): string | undefined {
+  if (name !== "apply_patch") return undefined;
+  if (typeof rawInput === "string") return rawInput;
+  const record = asRecord(rawInput);
+  for (const key of ["patch", "input", "text", "content"]) {
+    const value = record?.[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return input;
+}
+
+function fileChangeFromApplyPatch(
+  patchText: string | undefined,
+  status: StoredToolStatus,
+): StoredAgentTimelineItem["fileChange"] | undefined {
+  if (!patchText?.trim()) return undefined;
+  const entries: NonNullable<StoredAgentTimelineItem["fileChange"]>["entries"] = [];
+  let current: NonNullable<StoredAgentTimelineItem["fileChange"]>["entries"][number] | undefined;
+
+  const flush = () => {
+    if (!current?.path) return;
+    const existing = entries.find((entry) => entry.path === current!.path);
+    if (existing) {
+      existing.added = (existing.added ?? 0) + (current.added ?? 0);
+      existing.removed = (existing.removed ?? 0) + (current.removed ?? 0);
+      existing.kind ??= current.kind;
+    } else {
+      entries.push(current);
+    }
+  };
+
+  for (const rawLine of patchText.split(/\r?\n/)) {
+    const add = rawLine.match(/^\*\*\* Add File:\s+(.+)$/);
+    const update = rawLine.match(/^\*\*\* Update File:\s+(.+)$/);
+    const del = rawLine.match(/^\*\*\* Delete File:\s+(.+)$/);
+    const move = rawLine.match(/^\*\*\* Move to:\s+(.+)$/);
+    if (add || update || del) {
+      flush();
+      current = {
+        path: (add?.[1] ?? update?.[1] ?? del?.[1] ?? "").trim(),
+        kind: add ? "create" : del ? "delete" : "update",
+        added: 0,
+        removed: 0,
+      };
+      continue;
+    }
+    if (move?.[1] && current) {
+      current.path = move[1].trim();
+      current.kind = "move";
+      continue;
+    }
+    if (!current) continue;
+    if (rawLine.startsWith("+") && !rawLine.startsWith("+++")) {
+      current.added = (current.added ?? 0) + 1;
+    } else if (rawLine.startsWith("-") && !rawLine.startsWith("---")) {
+      current.removed = (current.removed ?? 0) + 1;
+    }
+  }
+  flush();
+
+  if (entries.length === 0) return undefined;
+  return {
+    entries,
+    diff: patchText,
+    summary: entries.map((entry) => [entry.kind, entry.path].filter(Boolean).join(" ")).join("\n"),
+    status,
+  };
+}
+
 function upsertHistoryTool(
   itemsById: Map<string, StoredAgentTimelineItem>,
   conversationId: string,
@@ -402,21 +474,27 @@ function upsertHistoryTool(
   const id = `history-tool:${callId}`;
   const existing = itemsById.get(id);
   const commandExecution = commandFromCodexTool(name, rawInput, existing?.commandExecution?.output);
+  const status: StoredToolStatus = existing?.toolCall?.status ?? "running";
+  const fileChange = fileChangeFromApplyPatch(patchTextFromCodexTool(name, rawInput, input), status);
   itemsById.set(id, {
     id,
     conversationId,
     type: "tool_call",
-    kind: historyToolKind(name),
+    kind: fileChange ? "file_change" : historyToolKind(name),
     itemId: callId,
     toolCall: {
       id: callId,
-      name: historyToolName(name),
-      input: input ?? existing?.toolCall?.input,
+      name: fileChange ? "文件修改" : historyToolName(name),
+      input: fileChange?.summary ?? input ?? existing?.toolCall?.input,
       output: existing?.toolCall?.output,
       createdAt: existing?.toolCall?.createdAt ?? createdAt,
-      status: existing?.toolCall?.status ?? "running",
+      status,
     },
     commandExecution: commandExecution ?? existing?.commandExecution,
+    fileChange: fileChange ?? existing?.fileChange,
+    text: fileChange
+      ? `已编辑 ${fileChange.entries.length} 个文件`
+      : existing?.text,
     createdAt: existing?.createdAt ?? createdAt,
     updatedAt: createdAt,
     metadata: { source: "device-history", provider: "codex" },
@@ -435,6 +513,9 @@ function completeHistoryTool(
   const commandExecution = existing?.commandExecution
     ? { ...existing.commandExecution, output, status: "completed" as const }
     : undefined;
+  const fileChange = existing?.fileChange
+    ? { ...existing.fileChange, summary: existing.fileChange.summary ?? output, status: "completed" as const }
+    : undefined;
   itemsById.set(id, {
     id,
     conversationId,
@@ -450,6 +531,8 @@ function completeHistoryTool(
       status: "completed",
     },
     commandExecution,
+    fileChange,
+    text: fileChange ? existing?.text ?? `已编辑 ${fileChange.entries.length} 个文件` : existing?.text,
     createdAt: existing?.createdAt ?? createdAt,
     updatedAt: createdAt,
     metadata: { source: "device-history", provider: "codex" },