linkshell-cli 0.3.15 → 0.3.16

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

@@ -3,6 +3,7 @@ import type { AgentProvider } from "./provider-resolver.js";
 export declare class AgentWorkspaceProxy {
     private readonly input;
     private clients;
+    private codexRpcBridge;
     private agentProtocols;
     private providerCapabilities;
     private providerCapabilityErrors;
@@ -37,6 +38,7 @@ export declare class AgentWorkspaceProxy {
     handleEnvelope(envelope: Envelope): Promise<void>;
     stop(): void;
     private clientForProvider;
+    private codexRpc;
     private protocolForProvider;
     private initialize;
     private ensureProviderClient;

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

@@ -6,8 +6,9 @@ import { createEnvelope, parseTypedPayload, } from "@linkshell/protocol";
 import { AcpClient } from "./acp-client.js";
 import { ClaudeSdkClient } from "./claude-sdk-client.js";
 import { ClaudeStreamJsonClient } from "./claude-stream-json-client.js";
+import { CodexRpcBridge } from "./codex-rpc-bridge.js";
 import { listClaudeStoredSessions, loadClaudeStoredTimeline } from "./claude-sessions.js";
-import { listCodexStoredSessions, loadCodexStoredTimeline } from "./codex-sessions.js";
+import { loadCodexStoredTimeline } from "./codex-sessions.js";
 import { resolveAgentCommand } from "./provider-resolver.js";
 const PERMISSION_TIMEOUT_MS = 5 * 60_000;
 const MAX_TIMELINE_ITEMS = 200;
@@ -1176,6 +1177,7 @@ function normalizeAgentStatus(value) {
 export class AgentWorkspaceProxy {
     input;
     clients = new Map();
+    codexRpcBridge;
     agentProtocols = new Map();
     providerCapabilities = new Map();
     providerCapabilityErrors = new Map();
@@ -1204,6 +1206,32 @@ export class AgentWorkspaceProxy {
     }
     async handleEnvelope(envelope) {
         switch (envelope.type) {
+            case "agent.codex.rpc": {
+                const payload = parseTypedPayload("agent.codex.rpc", envelope.payload);
+                try {
+                    this.codexRpc().send(payload);
+                }
+                catch (error) {
+                    const idValue = payload && typeof payload === "object" && "id" in payload
+                        ? payload.id
+                        : undefined;
+                    if (typeof idValue === "string" || typeof idValue === "number") {
+                        this.input.send(createEnvelope({
+                            type: "agent.codex.rpc",
+                            hostDeviceId: this.input.hostDeviceId,
+                            payload: {
+                                jsonrpc: "2.0",
+                                id: idValue,
+                                error: {
+                                    code: -32000,
+                                    message: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        }));
+                    }
+                }
+                break;
+            }
             case "agent.v2.capabilities.request":
                 await this.initialize();
                 this.sendCapabilities();
@@ -1276,6 +1304,8 @@ export class AgentWorkspaceProxy {
         }
     }
     stop() {
+        this.codexRpcBridge?.stop();
+        this.codexRpcBridge = undefined;
         for (const client of this.clients.values()) {
             client.stop();
         }
@@ -1284,6 +1314,16 @@ export class AgentWorkspaceProxy {
     clientForProvider(provider) {
         return this.clients.get(provider);
     }
+    codexRpc() {
+        this.codexRpcBridge ??= new CodexRpcBridge({
+            command: this.input.command,
+            cwd: this.input.cwd,
+            hostDeviceId: this.input.hostDeviceId,
+            send: this.input.send,
+            verbose: this.input.verbose,
+        });
+        return this.codexRpcBridge;
+    }
     protocolForProvider(provider) {
         return this.agentProtocols.get(provider);
     }
@@ -1292,7 +1332,9 @@ export class AgentWorkspaceProxy {
             return;
         this.initialized = true;
         // Eagerly start all detected providers so capabilities report real status
-        const startPromises = this.input.availableProviders.map((p) => this.ensureProviderClient(p));
+        const startPromises = this.input.availableProviders
+            .filter((provider) => provider !== "codex")
+            .map((p) => this.ensureProviderClient(p));
         await Promise.allSettled(startPromises);
         this.status = "idle";
         this.error = undefined;
@@ -1412,7 +1454,6 @@ export class AgentWorkspaceProxy {
     }
     async syncProviderSessions() {
         await this.initialize();
-        this.upsertProviderSessions("codex", listCodexStoredSessions(this.input.cwd));
         this.upsertProviderSessions("claude", listClaudeStoredSessions(this.input.cwd));
         for (const [provider, client] of this.clients) {
             try {
@@ -1465,13 +1506,14 @@ export class AgentWorkspaceProxy {
     sendCapabilities() {
         const providers = this.input.availableProviders.map((provider) => {
             const client = this.clients.get(provider);
-            const protocol = this.agentProtocols.get(provider);
+            const protocol = provider === "codex" ? "codex-app-server" : this.agentProtocols.get(provider);
             const runtimeCapabilities = this.providerCapabilities.get(provider);
-            const enabled = Boolean(client);
+            const enabled = provider === "codex" ? true : Boolean(client);
             const hasRuntimeModels = Boolean(runtimeCapabilities?.models?.length);
             const supportsImages = enabled && protocolSupportsImages(protocol);
+            const isClaudeSdk = protocol === "claude-agent-sdk";
             const isClaudeFallback = protocol === "claude-stream-json";
-            const supportsPermission = enabled && !isClaudeFallback;
+            const supportsPermission = enabled && (isClaudeSdk || !isClaudeFallback);
             const supportsReasoningEffort = enabled;
             const commands = mergeCommands(defaultProviderCommands(provider, this.input.cwd, enabled), runtimeCapabilities?.commands);
             const currentMode = [...this.conversations.values()].find((conversation) => conversation.provider === provider)?.collaborationMode;
@@ -1502,6 +1544,7 @@ export class AgentWorkspaceProxy {
                     plan: enabled,
                     cancel: enabled,
                     reasoningEffort: supportsReasoningEffort,
+                    claudeSdk: isClaudeSdk,
                     streamJsonFallback: isClaudeFallback,
                 },
             };
@@ -2031,6 +2074,9 @@ export class AgentWorkspaceProxy {
                 this.conversationByAgentSessionId.set(agentSessionId, conversationId);
                 const conversation = this.conversations.get(conversationId);
                 if (conversation) {
+                    if (conversation.agentSessionId && conversation.agentSessionId !== agentSessionId) {
+                        this.conversationByAgentSessionId.delete(conversation.agentSessionId);
+                    }
                     conversation.agentSessionId = agentSessionId;
                     conversation.lastActivityAt = Date.now();
                     this.emitConversation(conversation);
@@ -2945,6 +2991,8 @@ export class AgentWorkspaceProxy {
             ...existing,
             ...toolCall,
             id: targetToolId,
+            input: toolCall.input ?? existing?.input,
+            output: toolCall.output ?? existing?.output,
             createdAt: existing?.createdAt ?? toolCall.createdAt ?? Date.now(),
         };
         this.toolConversationIds.set(toolCall.id, conversationId);