linkshell-cli 0.5.2 → 0.5.4

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

@@ -1597,6 +1597,9 @@ export class AgentWorkspaceProxy {
   private conversations = new Map<string, AgentConversation>();
   private conversationByAgentSessionId = new Map<string, string>();
   private timelines = new Map<string, AgentTimelineItem[]>();
+  // Opaque codex turns cursor per conversation, pointing at OLDER history to
+  // page through (captured at hydration, advanced on each history.request).
+  private historyCursors = new Map<string, string | undefined>();
   private toolOutputBuffers = new Map<string, string>();
   private pendingPermissions = new Map<string, AgentPermission>();
   private permissionWaiters = new Map<string, PendingPermissionWaiter>();
@@ -1647,6 +1650,11 @@ export class AgentWorkspaceProxy {
         this.sendSnapshot(payload.conversationId);
         break;
       }
+      case "agent.v2.history.request": {
+        const payload = parseTypedPayload("agent.v2.history.request", envelope.payload);
+        await this.loadOlderHistory(payload);
+        break;
+      }
       case "agent.v2.prompt": {
         const payload = parseTypedPayload("agent.v2.prompt", envelope.payload);
         await this.sendPrompt(payload);
@@ -1705,6 +1713,28 @@ export class AgentWorkspaceProxy {
     return this.clients.get(provider);
   }
 
+  private shouldRecycleProviderClient(provider: AgentProvider, error: unknown): boolean {
+    if (provider !== "codex") return false;
+    const message = error instanceof Error ? error.message : String(error);
+    return /ACP agent is not running|ACP request timed out|Transport channel closed|TokenRefreshFailed|Failed to parse server response|channel closed|EPIPE|ECONNRESET/i.test(message);
+  }
+
+  private async recycleProviderClient(
+    provider: AgentProvider,
+    error: unknown,
+  ): Promise<AcpClient | ClaudeSdkClient | ClaudeStreamJsonClient | undefined> {
+    if (!this.shouldRecycleProviderClient(provider, error)) return undefined;
+    const message = error instanceof Error ? error.message : String(error);
+    const existing = this.clients.get(provider);
+    if (existing) {
+      try { existing.stop(); } catch {}
+    }
+    this.clients.delete(provider);
+    this.agentProtocols.delete(provider);
+    this.providerErrors.set(provider, message);
+    return this.ensureProviderClient(provider);
+  }
+
   private protocolForProvider(provider: AgentProvider): AgentProtocol | undefined {
     return this.agentProtocols.get(provider);
   }
@@ -1866,7 +1896,16 @@ export class AgentWorkspaceProxy {
     await this.initialize();
     for (const [provider, client] of this.clients) {
       try {
-        const result = await client.listSessions();
+        let activeClient = client;
+        let result: unknown;
+        try {
+          result = await activeClient.listSessions();
+        } catch (error) {
+          const recovered = await this.recycleProviderClient(provider, error);
+          if (!recovered) throw error;
+          activeClient = recovered;
+          result = await activeClient.listSessions();
+        }
         for (const remote of parseRemoteSessions(result)) {
           const agentSessionId = remote.id;
           const existingId = this.conversationByAgentSessionId.get(agentSessionId);
@@ -1906,7 +1945,7 @@ export class AgentWorkspaceProxy {
     conversation: AgentConversation,
     seedResult?: unknown,
   ): Promise<void> {
-    const client = this.clientForProvider(conversation.provider);
+    let client = this.clientForProvider(conversation.provider);
     if (!client || !conversation.agentSessionId) return;
     let source = seedResult;
     const hasSeedTurns = turnItemsFromThread(threadFromProviderResult(seedResult)).length > 0;
@@ -1919,6 +1958,8 @@ export class AgentWorkspaceProxy {
             includeTurns: true,
           });
         } catch (error) {
+          const recovered = await this.recycleProviderClient(conversation.provider, error);
+          if (recovered) client = recovered;
           if (this.input.verbose) {
             process.stderr.write(`[agent:v2] thread/read hydration failed for ${conversation.provider}: ${error instanceof Error ? error.message : String(error)}\n`);
           }
@@ -1934,14 +1975,33 @@ export class AgentWorkspaceProxy {
         }) => Promise<unknown> }).listTurns;
         if (typeof listTurns === "function") {
           try {
-            const turnsResult = await listTurns.call(client, {
-              sessionId: conversation.agentSessionId,
-              limit: MAX_TIMELINE_ITEMS,
-              sortDirection: "desc",
-              itemsView: "full",
-            });
+            let turnsResult: unknown;
+            try {
+              turnsResult = await listTurns.call(client, {
+                sessionId: conversation.agentSessionId,
+                limit: MAX_TIMELINE_ITEMS,
+                sortDirection: "desc",
+                itemsView: "full",
+              });
+            } catch (error) {
+              const recovered = await this.recycleProviderClient(conversation.provider, error);
+              if (!recovered) throw error;
+              client = recovered;
+              const recoveredListTurns = (client as { listTurns?: typeof listTurns }).listTurns;
+              if (typeof recoveredListTurns !== "function") throw error;
+              turnsResult = await recoveredListTurns.call(client, {
+                sessionId: conversation.agentSessionId,
+                limit: MAX_TIMELINE_ITEMS,
+                sortDirection: "desc",
+                itemsView: "full",
+              });
+            }
             const turnsThread = threadFromTurnsListResult(conversation.agentSessionId, turnsResult);
             if (turnsThread) source = { thread: turnsThread };
+            // Capture the opaque cursor pointing at OLDER turns so the client
+            // can page further back via agent.v2.history.request.
+            const olderCursor = firstString(asRecord(turnsResult), ["nextCursor", "next_cursor", "cursor"]);
+            this.historyCursors.set(conversation.id, olderCursor);
           } catch (error) {
             if (this.input.verbose) {
               process.stderr.write(`[agent:v2] thread/turns/list hydration failed for ${conversation.provider}: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -2077,7 +2137,7 @@ export class AgentWorkspaceProxy {
       (agentSessionId ? this.conversations.get(this.conversationByAgentSessionId.get(agentSessionId) ?? "") : undefined);
     if (!payload.cwd && existingConversation?.cwd) cwd = existingConversation.cwd;
 
-    const client = await this.ensureProviderClient(provider);
+    let client = await this.ensureProviderClient(provider);
     if (!client) {
       const message = this.providerErrors.get(provider) ?? `${providerLabel(provider)} 启动失败。请确认 CLI 已安装并可用。`;
       if (existingConversation) {
@@ -2113,7 +2173,15 @@ export class AgentWorkspaceProxy {
       if ((this.timelines.get(existingConversation.id) ?? []).length === 0 && existingConversation.status !== "running") {
         try {
           const existingAgentSessionId = existingConversation.agentSessionId!;
-          const result = await client.loadSession({ sessionId: existingAgentSessionId, cwd });
+          let result: unknown;
+          try {
+            result = await client.loadSession({ sessionId: existingAgentSessionId, cwd });
+          } catch (error) {
+            const recovered = await this.recycleProviderClient(provider, error);
+            if (!recovered) throw error;
+            client = recovered;
+            result = await client.loadSession({ sessionId: existingAgentSessionId, cwd });
+          }
           const nextAgentSessionId = this.extractSessionId(result);
           if (nextAgentSessionId && nextAgentSessionId !== existingAgentSessionId) {
             this.conversationByAgentSessionId.delete(existingAgentSessionId);
@@ -2141,9 +2209,19 @@ export class AgentWorkspaceProxy {
     }
 
     try {
-      const result = agentSessionId
-        ? await client.loadSession({ sessionId: agentSessionId, cwd })
-        : await client.newSession({ cwd });
+      let result: unknown;
+      try {
+        result = agentSessionId
+          ? await client.loadSession({ sessionId: agentSessionId, cwd })
+          : await client.newSession({ cwd });
+      } catch (error) {
+        const recovered = await this.recycleProviderClient(provider, error);
+        if (!recovered) throw error;
+        client = recovered;
+        result = agentSessionId
+          ? await client.loadSession({ sessionId: agentSessionId, cwd })
+          : await client.newSession({ cwd });
+      }
       agentSessionId = this.extractSessionId(result) ?? agentSessionId ?? id("agent-session");
       const now = Date.now();
       const conversationId = makeAgentV2RemoteConversationId(provider, agentSessionId);
@@ -3348,11 +3426,20 @@ export class AgentWorkspaceProxy {
     if (!conversationId) return waitForResponse ? Promise.resolve({ outcome: { outcome: "cancelled" } }) : undefined;
     const requestId = firstString(raw, ["requestId", "id", "permissionId"]) ?? id("perm");
     const rawToolCall = asRecord(raw.toolCall) ?? raw;
+    // Codex app-server command/file approvals carry `command`/`reason`/`cwd`
+    // (not toolCall/context). Surface them so the card actually shows what's
+    // being approved; fall back to the Claude/MCP shape otherwise.
+    const codexCommand = firstString(raw, ["command"]);
+    const codexCwd = firstString(raw, ["cwd"]);
     const permission: AgentPermission = {
       requestId,
-      toolName: firstString(rawToolCall, ["toolName", "tool", "name", "title", "kind"]),
-      toolInput: stringify(rawToolCall.input ?? rawToolCall.toolInput ?? rawToolCall),
-      context: firstString(raw, ["context", "description", "message", "title"]),
+      toolName:
+        firstString(rawToolCall, ["toolName", "tool", "name", "title", "kind"]) ??
+        (codexCommand ? "shell" : undefined),
+      toolInput: codexCommand
+        ? (codexCwd ? `$ ${codexCommand}\n# cwd: ${codexCwd}` : `$ ${codexCommand}`)
+        : stringify(rawToolCall.input ?? rawToolCall.toolInput ?? rawToolCall),
+      context: firstString(raw, ["context", "description", "message", "title", "reason"]),
       options: parsePermissionOptions(raw.options),
     };
     this.pendingPermissions.set(requestId, permission);
@@ -3761,6 +3848,76 @@ export class AgentWorkspaceProxy {
     }));
   }
 
+  /** Page OLDER transcript history for a conversation (client scrolling up).
+   *  Only Codex's app-server exposes paginated reads; other providers report
+   *  no more history. Pure pass-through — does not touch the bounded live
+   *  timeline. The client prepends the returned (ascending) items. */
+  private async loadOlderHistory(payload: {
+    conversationId: string;
+    cursor?: string;
+    limit: number;
+  }): Promise<void> {
+    const sendResult = (
+      items: AgentTimelineItem[],
+      nextCursor?: string,
+    ): void => {
+      this.input.send(createEnvelope({
+        type: "agent.v2.history.result",
+        sessionId: this.input.sessionId,
+        payload: {
+          conversationId: payload.conversationId,
+          items,
+          nextCursor,
+          hasMore: Boolean(nextCursor),
+        },
+      }));
+    };
+
+    const conversation = this.conversations.get(payload.conversationId);
+    if (!conversation?.agentSessionId) return sendResult([], undefined);
+
+    const client = this.clientForProvider(conversation.provider);
+    const listTurns = (client as {
+      listTurns?: (input: {
+        sessionId: string;
+        limit?: number;
+        cursor?: string;
+        sortDirection?: "asc" | "desc";
+        itemsView?: "summary" | "full";
+      }) => Promise<unknown>;
+    } | undefined)?.listTurns;
+    if (typeof listTurns !== "function") return sendResult([], undefined);
+
+    // Client-supplied cursor wins; else the one captured at hydration. Absent
+    // cursor means we're already at the start of history.
+    const cursor = payload.cursor ?? this.historyCursors.get(payload.conversationId);
+    if (!cursor) return sendResult([], undefined);
+
+    try {
+      const turnsResult = await listTurns.call(client, {
+        sessionId: conversation.agentSessionId,
+        limit: payload.limit,
+        cursor,
+        sortDirection: "desc",
+        itemsView: "full",
+      });
+      const turnsThread = threadFromTurnsListResult(conversation.agentSessionId, turnsResult);
+      const items = turnsThread
+        ? timelineItemsFromProviderThread({ thread: turnsThread }, payload.conversationId)
+        : [];
+      const nextCursor = firstString(asRecord(turnsResult), ["nextCursor", "next_cursor", "cursor"]);
+      this.historyCursors.set(payload.conversationId, nextCursor);
+      sendResult(items, nextCursor);
+    } catch (error) {
+      if (this.input.verbose) {
+        process.stderr.write(
+          `[agent:v2] history page failed for ${conversation.provider}: ${error instanceof Error ? error.message : String(error)}\n`,
+        );
+      }
+      sendResult([], undefined);
+    }
+  }
+
   private conversationIdFromParams(params: unknown): string | undefined {
     const raw = asRecord(params);
     if (!raw) return undefined;

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

@@ -120,6 +120,7 @@ function splitImageDataUrl(value: string, fallbackMimeType = "image/png"): { dat
 }
 
 export class ClaudeStreamJsonClient {
+  private static warnedBypass = false;
   private child: ChildProcessWithoutNullStreams | undefined;
   private claudeSessionId: string | undefined;
   private pendingCancel = false;
@@ -177,6 +178,28 @@ export class ClaudeStreamJsonClient {
 
     this.pendingCancel = false;
 
+    // SECURITY: the headless stream-json fallback can only run with
+    // --permission-mode bypassPermissions (there is no TTY to prompt on), so
+    // remotely-submitted prompts execute tools — including shell — without
+    // confirmation. The SDK path (preferred when @anthropic-ai/claude-agent-sdk
+    // is installed) routes tool approvals to the mobile UI instead.
+    if (/^(1|true|yes)$/i.test(process.env.LINKSHELL_REQUIRE_AGENT_PERMISSIONS ?? "")) {
+      throw new Error(
+        "Agent permission enforcement is required (LINKSHELL_REQUIRE_AGENT_PERMISSIONS) " +
+        "but the Claude stream-json fallback can only run with bypassPermissions. " +
+        "Install @anthropic-ai/claude-agent-sdk to enable permission-gated tool approvals.",
+      );
+    }
+    if (!ClaudeStreamJsonClient.warnedBypass) {
+      ClaudeStreamJsonClient.warnedBypass = true;
+      process.stderr.write(
+        "[bridge] WARNING: Claude stream-json fallback runs with bypassPermissions — " +
+        "remotely submitted prompts can execute tools (including shell) without confirmation. " +
+        "Install @anthropic-ai/claude-agent-sdk for permission-gated control, or set " +
+        "LINKSHELL_REQUIRE_AGENT_PERMISSIONS=true to refuse the unsafe fallback.\n",
+      );
+    }
+
     // Build Claude args
     const args: string[] = [
       "--print",