linkshell-cli 0.3.9 → 0.3.11

package/src/runtime/acp/claude-stream-json-client.ts

@@ -4,6 +4,7 @@ import { listClaudeStoredSessions } from "./claude-sessions.js";
 import type { AgentFraming, AgentProtocol } from "./provider-resolver.js";
 
 type AgentPermissionMode = "read_only" | "workspace_write" | "full_access";
+type AgentCollaborationMode = "default" | "plan";
 
 type AgentInputContentBlock = {
   type?: string;
@@ -69,6 +70,23 @@ function splitImageDataUrl(value: string, fallbackMimeType = "image/png"): { dat
   };
 }
 
+function claudeEffort(value: string | undefined): "low" | "medium" | "high" | "xhigh" | undefined {
+  if (value === "low" || value === "medium" || value === "high" || value === "xhigh") return value;
+  if (value === "minimal") return "low";
+  return undefined;
+}
+
+function claudePermissionMode(
+  permissionMode: AgentPermissionMode | undefined,
+  collaborationMode: AgentCollaborationMode | undefined,
+): "default" | "acceptEdits" | "bypassPermissions" | "plan" | "dontAsk" {
+  if (collaborationMode === "plan") return "plan";
+  if (permissionMode === "full_access") return "bypassPermissions";
+  if (permissionMode === "workspace_write") return "acceptEdits";
+  if (permissionMode === "read_only") return "dontAsk";
+  return "default";
+}
+
 export class ClaudeStreamJsonClient {
   private child: ChildProcessWithoutNullStreams | undefined;
   private claudeSessionId: string | undefined;
@@ -118,7 +136,7 @@ export class ClaudeStreamJsonClient {
     model?: string;
     reasoningEffort?: string;
     permissionMode?: AgentPermissionMode;
-    collaborationMode?: "default" | "plan";
+    collaborationMode?: AgentCollaborationMode;
     cwd: string;
   }): Promise<unknown> {
     if (this.child) {
@@ -133,8 +151,11 @@ export class ClaudeStreamJsonClient {
       "--output-format", "stream-json",
       "--input-format", "stream-json",
       "--verbose",
-      "--permission-mode", "bypassPermissions",
+      "--permission-mode", claudePermissionMode(input.permissionMode, input.collaborationMode),
     ];
+    if (input.permissionMode === "read_only") {
+      args.push("--disallowedTools", "Bash,Write,Edit,MultiEdit,NotebookEdit");
+    }
 
     // Use stored session for --resume (only when we have a real session ID from system.init)
     if (this.claudeSessionId) {
@@ -148,6 +169,10 @@ export class ClaudeStreamJsonClient {
     if (input.model) {
       args.push("--model", input.model);
     }
+    const effort = claudeEffort(input.reasoningEffort);
+    if (effort) {
+      args.push("--effort", effort);
+    }
 
     // Build the user message
     const contentBlocks = (input.content as AgentInputContentBlock[]).map(
@@ -468,6 +493,7 @@ export class ClaudeStreamJsonClient {
   async listModels(): Promise<unknown> {
     return {
       defaultModel: "default",
+      reasoningEfforts: ["low", "medium", "high", "xhigh"],
       models: [
         { id: "sonnet", label: "Sonnet" },
         { id: "opus", label: "Opus" },

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

@@ -19,10 +19,38 @@ export interface CodexStoredSession {
 export interface StoredAgentTimelineItem {
   id: string;
   conversationId: string;
-  type: "message";
-  role: "user" | "assistant" | "system";
-  content: Array<{ type: "text"; text: string }>;
-  text: string;
+  type: "message" | "tool_call";
+  kind?: "tool_activity" | "command_execution" | "file_change";
+  itemId?: string;
+  role?: "user" | "assistant" | "system";
+  content?: Array<{ type: "text"; text: string }>;
+  text?: string;
+  toolCall?: {
+    id: string;
+    name: string;
+    input?: string;
+    output?: string;
+    createdAt?: number;
+    status: "pending" | "running" | "completed" | "failed";
+  };
+  commandExecution?: {
+    command?: string;
+    cwd?: string;
+    output?: string;
+    exitCode?: number | null;
+    status?: "pending" | "running" | "completed" | "failed";
+  };
+  fileChange?: {
+    entries: Array<{
+      path: string;
+      kind?: string;
+      added?: number;
+      removed?: number;
+    }>;
+    diff?: string;
+    summary?: string;
+    status?: "pending" | "running" | "completed" | "failed";
+  };
   createdAt: number;
   updatedAt?: number;
   metadata?: Record<string, unknown>;
@@ -276,6 +304,40 @@ function normalizeHistoryText(value: unknown): string | undefined {
   return normalizeHistoryText(record.content ?? record.text ?? record.message);
 }
 
+function stringifyHistoryValue(value: unknown): string | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+function visibleCodexRole(value: unknown): "user" | "assistant" | undefined {
+  return value === "user" || value === "assistant" ? value : undefined;
+}
+
+function isInjectedCodexContext(text: string): boolean {
+  const trimmed = text.trimStart();
+  return (
+    trimmed.startsWith("<permissions instructions>") ||
+    trimmed.startsWith("<app-context>") ||
+    trimmed.startsWith("<environment_context>") ||
+    trimmed.startsWith("<skill>") ||
+    trimmed.startsWith("<turn_aborted>") ||
+    trimmed.startsWith("<developer") ||
+    trimmed.startsWith("# AGENTS.md instructions") ||
+    trimmed.startsWith("AGENTS.md instructions for ") ||
+    trimmed.includes("\n# AGENTS.md\n") ||
+    trimmed.includes("\n<INSTRUCTIONS>")
+  );
+}
+
+function messageDedupeKey(role: "user" | "assistant" | "system", text: string): string {
+  return `${role}:${text.replace(/\s+/g, " ").trim().slice(0, 400)}`;
+}
+
 function historyMessage(
   conversationId: string,
   index: number,
@@ -297,6 +359,207 @@ function historyMessage(
   };
 }
 
+function historyToolName(name: string | undefined): string {
+  if (!name) return "工具";
+  if (name.endsWith("exec_command") || name.endsWith("write_stdin")) return "命令";
+  if (name === "apply_patch") return "文件修改";
+  return name;
+}
+
+function historyToolKind(name: string | undefined): "tool_activity" | "command_execution" {
+  return name?.endsWith("exec_command") || name?.endsWith("write_stdin") ? "command_execution" : "tool_activity";
+}
+
+function commandFromCodexTool(name: string | undefined, rawInput: unknown, output?: string): StoredAgentTimelineItem["commandExecution"] {
+  if (!name?.endsWith("exec_command") && !name?.endsWith("write_stdin")) return undefined;
+  let input = asRecord(rawInput);
+  if (!input && typeof rawInput === "string" && rawInput.trim().startsWith("{")) {
+    try {
+      input = asRecord(JSON.parse(rawInput));
+    } catch {
+      input = undefined;
+    }
+  }
+  const command = typeof input?.cmd === "string"
+    ? input.cmd
+    : typeof input?.chars === "string"
+    ? input.chars
+    : undefined;
+  const cwd = typeof input?.workdir === "string" ? input.workdir : undefined;
+  if (!command && !cwd && !output) return undefined;
+  return { command, cwd, output, status: output === undefined ? "running" : "completed" };
+}
+
+function upsertHistoryTool(
+  itemsById: Map<string, StoredAgentTimelineItem>,
+  conversationId: string,
+  callId: string,
+  name: string | undefined,
+  rawInput: unknown,
+  input: string | undefined,
+  createdAt: number,
+): void {
+  const id = `history-tool:${callId}`;
+  const existing = itemsById.get(id);
+  const commandExecution = commandFromCodexTool(name, rawInput, existing?.commandExecution?.output);
+  itemsById.set(id, {
+    id,
+    conversationId,
+    type: "tool_call",
+    kind: historyToolKind(name),
+    itemId: callId,
+    toolCall: {
+      id: callId,
+      name: historyToolName(name),
+      input: input ?? existing?.toolCall?.input,
+      output: existing?.toolCall?.output,
+      createdAt: existing?.toolCall?.createdAt ?? createdAt,
+      status: existing?.toolCall?.status ?? "running",
+    },
+    commandExecution: commandExecution ?? existing?.commandExecution,
+    createdAt: existing?.createdAt ?? createdAt,
+    updatedAt: createdAt,
+    metadata: { source: "device-history", provider: "codex" },
+  });
+}
+
+function completeHistoryTool(
+  itemsById: Map<string, StoredAgentTimelineItem>,
+  conversationId: string,
+  callId: string,
+  output: string | undefined,
+  createdAt: number,
+): void {
+  const id = `history-tool:${callId}`;
+  const existing = itemsById.get(id);
+  const commandExecution = existing?.commandExecution
+    ? { ...existing.commandExecution, output, status: "completed" as const }
+    : undefined;
+  itemsById.set(id, {
+    id,
+    conversationId,
+    type: "tool_call",
+    kind: existing?.kind ?? "tool_activity",
+    itemId: callId,
+    toolCall: {
+      id: callId,
+      name: existing?.toolCall?.name ?? "工具",
+      input: existing?.toolCall?.input,
+      output,
+      createdAt: existing?.toolCall?.createdAt ?? createdAt,
+      status: "completed",
+    },
+    commandExecution,
+    createdAt: existing?.createdAt ?? createdAt,
+    updatedAt: createdAt,
+    metadata: { source: "device-history", provider: "codex" },
+  });
+}
+
+function relativeHistoryPath(path: string, cwd: string): string {
+  const normalized = path.replace(/\\/g, "/").replace(/^["']|["']$/g, "");
+  const normalizedCwd = cwd.replace(/\\/g, "/").replace(/\/+$/, "");
+  return normalized.startsWith(`${normalizedCwd}/`)
+    ? normalized.slice(normalizedCwd.length + 1)
+    : normalized;
+}
+
+function countDiffLines(diff: string | undefined): { added: number; removed: number } {
+  if (!diff) return { added: 0, removed: 0 };
+  let added = 0;
+  let removed = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) added += 1;
+    else if (line.startsWith("-") && !line.startsWith("---")) removed += 1;
+  }
+  return { added, removed };
+}
+
+function countContentLines(content: unknown): number {
+  if (typeof content !== "string") return 0;
+  if (!content) return 0;
+  return content.split(/\r?\n/).filter((line) => line.length > 0).length;
+}
+
+function changeKind(value: string | undefined): string | undefined {
+  if (value === "add") return "create";
+  if (value === "delete") return "delete";
+  if (value === "update" || value === "move") return "update";
+  return value;
+}
+
+function patchApplyFileChange(
+  conversationId: string,
+  payload: Record<string, unknown>,
+  cwd: string,
+  createdAt: number,
+): StoredAgentTimelineItem | undefined {
+  const changes = asRecord(payload.changes);
+  if (!changes) return undefined;
+  const entries: NonNullable<StoredAgentTimelineItem["fileChange"]>["entries"] = [];
+  const diffParts: string[] = [];
+  for (const [absolutePath, rawChange] of Object.entries(changes)) {
+    const change = asRecord(rawChange);
+    if (!change) continue;
+    const path = relativeHistoryPath(absolutePath, cwd);
+    const kind = changeKind(typeof change.type === "string" ? change.type : undefined);
+    const diff = typeof change.unified_diff === "string" ? change.unified_diff : undefined;
+    const stats = countDiffLines(diff);
+    const added = stats.added || (kind === "create" ? countContentLines(change.content) : 0);
+    const removed = stats.removed;
+    const entry: NonNullable<StoredAgentTimelineItem["fileChange"]>["entries"][number] = { path };
+    if (kind) entry.kind = kind;
+    if (added > 0) entry.added = added;
+    if (removed > 0) entry.removed = removed;
+    entries.push(entry);
+    if (diff) {
+      diffParts.push([
+        `Path: ${path}`,
+        kind ? `Kind: ${kind}` : undefined,
+        `Totals: +${added} -${removed}`,
+        "",
+        "```diff",
+        diff.trimEnd(),
+        "```",
+      ].filter((line): line is string => line !== undefined).join("\n"));
+    }
+  }
+  if (entries.length === 0) return undefined;
+  const callId = typeof payload.call_id === "string" ? payload.call_id : `patch-${createdAt}`;
+  const status = payload.success === false ? "failed" : "completed";
+  const totalAdded = entries.reduce((sum, entry) => sum + (entry.added ?? 0), 0);
+  const totalRemoved = entries.reduce((sum, entry) => sum + (entry.removed ?? 0), 0);
+  const summary = entries
+    .map((entry) => [entry.kind, entry.path].filter(Boolean).join(" "))
+    .join("\n");
+  const diff = diffParts.length > 0 ? diffParts.join("\n\n---\n\n") : undefined;
+  return {
+    id: `history-file-change:${callId}`,
+    conversationId,
+    type: "tool_call",
+    kind: "file_change",
+    itemId: callId,
+    toolCall: {
+      id: callId,
+      name: "文件修改",
+      input: summary,
+      output: diff ?? (typeof payload.stdout === "string" ? payload.stdout : undefined),
+      createdAt,
+      status,
+    },
+    fileChange: {
+      entries,
+      diff,
+      summary,
+      status,
+    },
+    text: `已编辑 ${entries.length} 个文件 +${totalAdded} -${totalRemoved}`,
+    createdAt,
+    updatedAt: createdAt,
+    metadata: { source: "device-history", provider: "codex" },
+  };
+}
+
 export function listCodexStoredSessions(inputCwd: string): { sessions: CodexStoredSession[] } {
   const root = join(homedir(), ".codex");
   if (!existsSync(root)) return { sessions: [] };
@@ -360,7 +623,8 @@ export function loadCodexStoredTimeline(
     return { items: [] };
   }
 
-  const items: StoredAgentTimelineItem[] = [];
+  const itemsById = new Map<string, StoredAgentTimelineItem>();
+  const seenMessages = new Set<string>();
   let index = 0;
   for (const line of readHistorySample(file.path, statSize).split(/\r?\n/)) {
     const trimmed = line.trim();
@@ -368,21 +632,76 @@ export function loadCodexStoredTimeline(
     try {
       const entry = asRecord(JSON.parse(trimmed));
       const payload = asRecord(entry?.payload);
-      if (entry?.type !== "event_msg" || !payload) continue;
-      const eventType = typeof payload.type === "string" ? payload.type : undefined;
       const createdAt =
-        parseTimestamp(entry.timestamp ?? payload.created_at ?? payload.started_at ?? payload.completed_at) ??
+        parseTimestamp(entry?.timestamp ?? payload?.created_at ?? payload?.started_at ?? payload?.completed_at) ??
         statMtime + index;
-      if (eventType === "user_message") {
-        const text = normalizeHistoryText(payload.message);
-        if (!text || text.startsWith("<turn_aborted>")) continue;
-        items.push(historyMessage(conversationId, index, "user", text, createdAt, sessionId));
-        index += 1;
-      } else if (eventType === "agent_message") {
+      if (entry?.type === "event_msg" && payload) {
+        const eventType = typeof payload.type === "string" ? payload.type : undefined;
+        if (eventType === "user_message") {
+          const text = normalizeHistoryText(payload.message);
+          if (!text || isInjectedCodexContext(text)) continue;
+          const dedupeKey = messageDedupeKey("user", text);
+          if (seenMessages.has(dedupeKey)) continue;
+          seenMessages.add(dedupeKey);
+          itemsById.set(`history:${sessionId}:${index}`, historyMessage(conversationId, index, "user", text, createdAt, sessionId));
+          index += 1;
+        } else if (eventType === "agent_message") {
+          const text = normalizeHistoryText(payload.message);
+          if (!text || isInjectedCodexContext(text)) continue;
+          const dedupeKey = messageDedupeKey("assistant", text);
+          if (seenMessages.has(dedupeKey)) continue;
+          seenMessages.add(dedupeKey);
+          itemsById.set(`history:${sessionId}:${index}`, historyMessage(conversationId, index, "assistant", text, createdAt, sessionId));
+          index += 1;
+        } else if (eventType === "patch_apply_end") {
+          const item = patchApplyFileChange(conversationId, payload, inputCwd, createdAt);
+          if (item) itemsById.set(item.id, item);
+        }
+        continue;
+      }
+
+      if (entry?.type !== "response_item" || !payload) continue;
+      const responseType = typeof payload.type === "string" ? payload.type : undefined;
+      if (responseType === "message") {
+        const role = visibleCodexRole(payload.role);
+        if (!role) continue;
         const text = normalizeHistoryText(payload.message);
-        if (!text) continue;
-        items.push(historyMessage(conversationId, index, "assistant", text, createdAt, sessionId));
+        const contentText = text ?? normalizeHistoryText(payload.content);
+        if (!contentText || isInjectedCodexContext(contentText)) continue;
+        const dedupeKey = messageDedupeKey(role, contentText);
+        if (seenMessages.has(dedupeKey)) continue;
+        seenMessages.add(dedupeKey);
+        itemsById.set(`history:${sessionId}:${index}`, historyMessage(conversationId, index, role, contentText, createdAt, sessionId));
         index += 1;
+        continue;
+      }
+      if (responseType === "function_call") {
+        const callId = typeof payload.call_id === "string"
+          ? payload.call_id
+          : typeof payload.id === "string"
+          ? payload.id
+          : undefined;
+        if (!callId) continue;
+        const name = typeof payload.name === "string" ? payload.name : undefined;
+        upsertHistoryTool(
+          itemsById,
+          conversationId,
+          callId,
+          name,
+          payload.arguments,
+          stringifyHistoryValue(payload.arguments),
+          createdAt,
+        );
+        continue;
+      }
+      if (responseType === "function_call_output") {
+        const callId = typeof payload.call_id === "string"
+          ? payload.call_id
+          : typeof payload.id === "string"
+          ? payload.id
+          : undefined;
+        if (!callId) continue;
+        completeHistoryTool(itemsById, conversationId, callId, stringifyHistoryValue(payload.output), createdAt);
       }
     } catch {
       // Ignore malformed or partial JSONL lines in the history window.
@@ -390,7 +709,7 @@ export function loadCodexStoredTimeline(
   }
 
   return {
-    items: items
+    items: [...itemsById.values()]
       .sort((a, b) => a.createdAt - b.createdAt)
       .slice(-MAX_HISTORY_ITEMS),
   };