linkshell-cli 0.5.30 → 0.5.32

package/dist/cli/src/runtime/acp/agent-workspace.d.ts

@@ -37,12 +37,20 @@ export declare class AgentWorkspaceProxy {
     handleEnvelope(envelope: Envelope): Promise<void>;
     stop(): void;
     private fsWatchers;
+    private watchedRoots;
     private fsSyncTimer;
     private fsSyncRunning;
+    private lastPushedConversationSignature;
     private static readonly FS_SYNC_THROTTLE_MS;
     private startSessionWatchers;
     private scheduleSessionSync;
     private syncAndPushSessions;
+    /** A compact fingerprint of the fields the session tree actually renders, so
+     *  syncAndPushSessions can skip a broadcast when nothing visible changed.
+     *  Deliberately excludes usage token counts / lastActivityAt timestamps that
+     *  tick on every append without altering the tree — status, title, model, and
+     *  membership are what matter. */
+    private conversationListSignature;
     private clientForProvider;
     private shouldRecycleProviderClient;
     private recycleProviderClient;
@@ -62,6 +70,8 @@ export declare class AgentWorkspaceProxy {
     private executeCommand;
     private executeNativeCommand;
     private handleRequest;
+    private mergeMcpServers;
+    private handleMcpStartupStatus;
     private handleNotification;
     private handleAgentMessageDelta;
     private handlePlanUpdated;

package/dist/cli/src/runtime/acp/agent-workspace.js

@@ -7,6 +7,63 @@ import { ClaudeSdkClient } from "./claude-sdk-client.js";
 import { ClaudeStreamJsonClient } from "./claude-stream-json-client.js";
 import { aggregateUsage } from "../usage-report.js";
 import { resolveAgentCommand } from "./provider-resolver.js";
+// Normalize the many status spellings Claude/Codex emit into our enum. Unknown
+// values fall back to "pending" (known-but-not-yet-up) rather than dropping the
+// server. Kept liberal because the real event vocabulary isn't fully pinned.
+function normalizeMcpStatus(raw) {
+    const s = typeof raw === "string" ? raw.trim().toLowerCase().replace(/[\s-]+/g, "_") : "";
+    if (s === "connected" || s === "ok" || s === "ready" || s === "running" || s === "success")
+        return "connected";
+    if (s === "failed" || s === "error" || s === "errored" || s === "disconnected")
+        return "failed";
+    if (s === "connecting" || s === "starting" || s === "pending_connection")
+        return "connecting";
+    if (s === "needs_auth" || s === "unauthorized" || s === "needs_authentication" || s === "auth_required" || s === "pending_auth")
+        return "needs_auth";
+    if (s === "disabled" || s === "off")
+        return "disabled";
+    return "pending";
+}
+// Parse an MCP server list from either an array of {name,status,...} objects or
+// a {name: status} record — Claude's init `mcp_servers` shape isn't fixed.
+function parseMcpServerList(value) {
+    const out = [];
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const rec = asRecord(entry);
+            if (rec) {
+                const name = firstString(rec, ["name", "server", "serverName", "id"]);
+                if (!name)
+                    continue;
+                out.push({
+                    name,
+                    status: normalizeMcpStatus(rec.status ?? rec.state),
+                    error: firstString(rec, ["error", "message", "reason"]),
+                    toolCount: firstNumber(rec, ["toolCount", "tools", "toolsCount"]) ?? (Array.isArray(rec.tools) ? rec.tools.length : undefined),
+                });
+            }
+            else if (typeof entry === "string" && entry) {
+                out.push({ name: entry, status: "pending" });
+            }
+        }
+        return out;
+    }
+    const rec = asRecord(value);
+    if (rec) {
+        for (const [name, raw] of Object.entries(rec)) {
+            if (!name)
+                continue;
+            const inner = asRecord(raw);
+            out.push({
+                name,
+                status: normalizeMcpStatus(inner ? (inner.status ?? inner.state) : raw),
+                error: inner ? firstString(inner, ["error", "message", "reason"]) : undefined,
+                toolCount: inner ? (firstNumber(inner, ["toolCount", "tools", "toolsCount"]) ?? (Array.isArray(inner.tools) ? inner.tools.length : undefined)) : undefined,
+            });
+        }
+    }
+    return out;
+}
 const PERMISSION_TIMEOUT_MS = 5 * 60_000;
 const MAX_TIMELINE_ITEMS = 200;
 function id(prefix) {
@@ -682,6 +739,7 @@ const CLAUDE_REMOTE_HIDDEN_COMMANDS = new Set([
     "fork",
     "hooks",
     "ide",
+    "help",
     "init",
     "install-github-app",
     "install-slack-app",
@@ -711,6 +769,7 @@ const CLAUDE_REMOTE_HIDDEN_COMMANDS = new Set([
     "setup-bedrock",
     "setup-vertex",
     "statusline",
+    "status",
     "stickers",
     "tasks",
     "teleport",
@@ -1093,13 +1152,16 @@ function parseModelListCapabilities(provider, value) {
         ? ALL_REASONING_EFFORTS.filter((effort) => efforts.has(effort))
         : undefined;
     const commands = raw && Array.isArray(raw.commands) ? runtimeCommands(provider, raw.commands) : undefined;
-    if (models.length === 0 && !defaultModel && !reasoningEfforts?.length && !commands?.length)
+    const mcpList = raw ? parseMcpServerList(raw.mcpServers ?? raw.mcp_servers) : [];
+    const mcpServers = mcpList.length > 0 ? new Map(mcpList.map((s) => [s.name, s])) : undefined;
+    if (models.length === 0 && !defaultModel && !reasoningEfforts?.length && !commands?.length && !mcpServers)
         return undefined;
     return {
         ...(models.length > 0 ? { models } : {}),
         ...(defaultModel ? { defaultModel } : {}),
         ...(reasoningEfforts?.length ? { reasoningEfforts } : {}),
         ...(commands?.length ? { commands } : {}),
+        ...(mcpServers ? { mcpServers } : {}),
     };
 }
 function parseTimestamp(value) {
@@ -1759,6 +1821,7 @@ export class AgentWorkspaceProxy {
             catch { /* already closed */ }
         }
         this.fsWatchers = [];
+        this.watchedRoots.clear();
         if (this.fsSyncTimer) {
             clearTimeout(this.fsSyncTimer);
             this.fsSyncTimer = undefined;
@@ -1777,17 +1840,24 @@ export class AgentWorkspaceProxy {
     // zero cost while idle, throttled to at most one re-scan per window during a
     // burst of writes (an active turn appends constantly).
     fsWatchers = [];
+    watchedRoots = new Set();
     fsSyncTimer;
     fsSyncRunning = false;
+    lastPushedConversationSignature;
     static FS_SYNC_THROTTLE_MS = 1500;
     startSessionWatchers() {
-        if (this.fsWatchers.length > 0)
-            return; // already watching
         const roots = [
             join(homedir(), ".claude", "projects"),
             join(homedir(), ".codex", "sessions"),
         ];
         for (const root of roots) {
+            // Retry per-root each time we're called, so a store directory created
+            // AFTER startup (e.g. the user runs `codex` for the first time this
+            // session) gets a watcher attached lazily — instead of being gated out
+            // forever by a single "already watching" flag. Roots that don't exist yet
+            // stay un-added so a later call retries them.
+            if (this.watchedRoots.has(root))
+                continue;
             if (!existsSync(root))
                 continue;
             try {
@@ -1796,6 +1866,7 @@ export class AgentWorkspaceProxy {
                 const watcher = watch(root, { recursive: true, persistent: false }, () => this.scheduleSessionSync());
                 watcher.on("error", () => { });
                 this.fsWatchers.push(watcher);
+                this.watchedRoots.add(root);
             }
             catch {
                 // recursive watch unavailable on this platform — skip silently.
@@ -1816,13 +1887,27 @@ export class AgentWorkspaceProxy {
         this.fsSyncRunning = true;
         try {
             await this.syncProviderSessions();
+            // A store directory may have appeared since the last call — attach a
+            // watcher to it now (no-op for roots already watched).
+            this.startSessionWatchers();
+            const conversations = [...this.conversations.values()].filter((c) => !c.archived);
+            // Only broadcast when the list actually changed since the last push. An
+            // fs-watch fires on every transcript append (once per streamed token for
+            // an active session), but most of those don't change any field the tree
+            // renders — re-sending the whole list each time is wasted relay traffic
+            // and client re-renders. A cheap signature over the render-relevant fields
+            // gates the push.
+            const signature = this.conversationListSignature(conversations);
+            if (signature === this.lastPushedConversationSignature)
+                return;
+            this.lastPushedConversationSignature = signature;
             // Push the conversation list (statuses) — lighter than a full snapshot and
             // exactly what refreshes the tree. The web handles an unsolicited
             // conversation.list.result the same as a requested one.
             this.input.send(createEnvelope({
                 type: "agent.v2.conversation.list.result",
                 sessionId: this.input.sessionId,
-                payload: { conversations: [...this.conversations.values()].filter((c) => !c.archived) },
+                payload: { conversations },
             }));
         }
         catch (error) {
@@ -1834,6 +1919,17 @@ export class AgentWorkspaceProxy {
             this.fsSyncRunning = false;
         }
     }
+    /** A compact fingerprint of the fields the session tree actually renders, so
+     *  syncAndPushSessions can skip a broadcast when nothing visible changed.
+     *  Deliberately excludes usage token counts / lastActivityAt timestamps that
+     *  tick on every append without altering the tree — status, title, model, and
+     *  membership are what matter. */
+    conversationListSignature(conversations) {
+        return conversations
+            .map((c) => `${c.id}
${c.status}
${c.title ?? ""}
${c.model ?? ""}
${c.provider ?? ""}`)
+            .sort()
+            .join("");
+    }
     clientForProvider(provider) {
         return this.clients.get(provider);
     }
@@ -2008,12 +2104,24 @@ export class AgentWorkspaceProxy {
                 commands: runtimeCapabilities?.commands,
                 modes: runtimeCapabilities?.modes,
                 currentMode: runtimeCapabilities?.currentMode,
+                // Preserve any MCP status already accumulated from startupStatus events.
+                mcpServers: runtimeCapabilities?.mcpServers ?? this.providerCapabilities.get(provider)?.mcpServers,
             };
             this.providerCapabilities.set(provider, merged);
             return;
         }
-        if (runtimeCapabilities)
+        if (runtimeCapabilities) {
+            // Don't clobber MCP status that arrived via startupStatus before discovery;
+            // fold both sources into one map.
+            const priorMcp = this.providerCapabilities.get(provider)?.mcpServers;
+            if (priorMcp && priorMcp.size > 0) {
+                const map = new Map(priorMcp);
+                for (const [name, desc] of runtimeCapabilities.mcpServers ?? [])
+                    map.set(name, desc);
+                runtimeCapabilities = { ...runtimeCapabilities, mcpServers: map };
+            }
             this.providerCapabilities.set(provider, runtimeCapabilities);
+        }
     }
     async syncProviderSessions() {
         await this.initialize();
@@ -2288,6 +2396,9 @@ export class AgentWorkspaceProxy {
                     reasoningEffort: supportsReasoningEffort,
                     streamJsonFallback: isClaudeFallback,
                 },
+                mcpServers: runtimeCapabilities?.mcpServers && runtimeCapabilities.mcpServers.size > 0
+                    ? [...runtimeCapabilities.mcpServers.values()]
+                    : undefined,
             };
         });
         const anyEnabled = providers.some((p) => p.enabled);
@@ -2349,6 +2460,44 @@ export class AgentWorkspaceProxy {
             }
             return this.openFailure(payload, message, cwd);
         }
+        // Fork: seed a NEW conversation from an existing one's transcript, truncated
+        // at forkFromTurnId. Claude only — the SDK client exposes forkSession(); the
+        // stream-json fallback and Codex don't, so we notify and fall through to a
+        // plain new conversation rather than pretend. On success we set agentSessionId
+        // to the freshly-written transcript id and let the normal load path hydrate it.
+        if (payload.forkFromConversationId) {
+            const source = this.conversations.get(payload.forkFromConversationId);
+            const sourceSessionId = source?.agentSessionId;
+            const forkable = client.forkSession;
+            if (provider === "claude" && typeof forkable === "function" && sourceSessionId) {
+                if (source?.cwd && !payload.cwd)
+                    cwd = source.cwd;
+                const forked = forkable.call(client, { sourceSessionId, uptoTurnId: payload.forkFromTurnId });
+                if (forked?.sessionId) {
+                    agentSessionId = forked.sessionId;
+                    // Inherit the source's config so the fork opens like its parent.
+                    payload = {
+                        ...payload,
+                        model: payload.model ?? source?.model,
+                        reasoningEffort: payload.reasoningEffort ?? source?.reasoningEffort,
+                        permissionMode: payload.permissionMode ?? source?.permissionMode,
+                        collaborationMode: payload.collaborationMode ?? source?.collaborationMode,
+                        title: payload.title ?? (source?.title ? `${source.title} (分叉)` : undefined),
+                    };
+                    existingConversation = undefined; // force the new-conversation path
+                }
+                else {
+                    this.emitNotice({ kind: "warning", title: "分叉失败", detail: "无法复制该会话的历史记录，已新建空会话。" });
+                }
+            }
+            else {
+                this.emitNotice({
+                    kind: "native_unsupported",
+                    title: "暂不支持分叉",
+                    detail: provider === "claude" ? "该会话无法分叉。" : `${providerLabel(provider)} 暂不支持从历史分叉，已新建空会话。`,
+                });
+            }
+        }
         if (existingConversation && existingConversation.status !== "error" && existingConversation.agentSessionId) {
             const requestedCanonicalId = makeAgentV2RemoteConversationId(provider, existingConversation.agentSessionId);
             if (payload.conversationId &&
@@ -2897,6 +3046,41 @@ export class AgentWorkspaceProxy {
         }
         return {};
     }
+    // Merge MCP server descriptors into a provider's runtime capabilities,
+    // last-writer-wins by server name. Creates the map lazily.
+    mergeMcpServers(provider, servers) {
+        if (servers.length === 0)
+            return;
+        const existing = this.providerCapabilities.get(provider) ?? {};
+        const map = existing.mcpServers ?? new Map();
+        for (const server of servers)
+            map.set(server.name, server);
+        this.providerCapabilities.set(provider, { ...existing, mcpServers: map });
+    }
+    // A live `mcpServer/startupStatus/<name>` notification. The server name is
+    // presumed to be the method suffix (falls back to a name field in params);
+    // the status/error/toolCount shape is parsed defensively since the real event
+    // vocabulary isn't fully pinned. Re-emits capabilities so the console updates.
+    handleMcpStartupStatus(method, params) {
+        // MCP is Claude-only today; target the enabled provider that supports it.
+        const provider = this.input.availableProviders.find((p) => p === "claude" && this.clients.has(p))
+            ?? this.input.availableProviders.find((p) => this.clients.has(p));
+        if (!provider)
+            return;
+        const raw = asRecord(params) ?? {};
+        const suffix = method.slice(method.lastIndexOf("/") + 1);
+        const name = (suffix && suffix !== "startupStatus" ? suffix : undefined)
+            ?? firstString(raw, ["name", "server", "serverName"]);
+        if (!name)
+            return;
+        this.mergeMcpServers(provider, [{
+                name,
+                status: normalizeMcpStatus(raw.status ?? raw.state),
+                error: firstString(raw, ["error", "message", "reason"]),
+                toolCount: firstNumber(raw, ["toolCount", "tools", "toolsCount"]) ?? (Array.isArray(raw.tools) ? raw.tools.length : undefined),
+            }]);
+        this.sendCapabilities();
+    }
     handleNotification(method, params) {
         if (this.input.verbose) {
             process.stderr.write(`[agent:v2] ${method} ${stringify(params).slice(0, 500)}\n`);
@@ -2924,10 +3108,24 @@ export class AgentWorkspaceProxy {
                     this.emitConversation(conversation);
                 }
             }
+            // Seed the MCP server list from the init payload (stream-json carries
+            // `mcp_servers`; the SDK path may carry `mcpServers`). Late per-server
+            // startupStatus events refine this afterward.
+            if (provider) {
+                const initMcp = parseMcpServerList((asRecord(params) ?? {}).mcpServers ??
+                    (asRecord(params) ?? {}).mcp_servers);
+                if (initMcp.length > 0) {
+                    this.mergeMcpServers(provider, initMcp);
+                    this.sendCapabilities();
+                }
+            }
+            return;
+        }
+        if (method.startsWith("mcpServer/startupStatus/")) {
+            this.handleMcpStartupStatus(method, params);
             return;
         }
         if (method.startsWith("account/") ||
-            method.startsWith("mcpServer/startupStatus/") ||
             method === "serverRequest/resolved" ||
             method === "mcpServer/oauthLogin/completed") {
             return;
@@ -3202,6 +3400,14 @@ export class AgentWorkspaceProxy {
         if (bufferedOutput && !toolCall.output)
             toolCall.output = bufferedOutput;
         this.upsertTool(conversationId, toolCall);
+        // The buffer only exists to stitch streaming deltas onto the final item.
+        // Once the tool call reaches a terminal state its output is folded into the
+        // toolCall above and will never be appended to again, so drop the buffer —
+        // otherwise the map grows unbounded across a long-lived workspace (one entry
+        // per tool call / exec ever seen).
+        if (toolCall.status === "completed" || toolCall.status === "failed") {
+            this.toolOutputBuffers.delete(toolCall.id);
+        }
     }
     handleToolDelta(method, params) {
         const raw = asRecord(params);