linkshell-cli 0.3.14 → 0.3.16

package/src/runtime/acp/codex-rpc-bridge.ts

@@ -0,0 +1,70 @@
+import { createEnvelope } from "@linkshell/protocol";
+import type { Envelope } from "@linkshell/protocol";
+import { JsonRpcStdioTransport, type JsonRpcMessage } from "./json-rpc.js";
+import { resolveAgentCommand } from "./provider-resolver.js";
+
+export class CodexRpcBridge {
+  private transport: JsonRpcStdioTransport | undefined;
+
+  constructor(
+    private readonly input: {
+      command?: string;
+      cwd: string;
+      hostDeviceId: string;
+      send: (envelope: Envelope) => void;
+      verbose?: boolean;
+    },
+  ) {}
+
+  send(message: unknown): void {
+    this.ensureTransport();
+    this.transport?.send(message as JsonRpcMessage);
+  }
+
+  stop(): void {
+    this.transport?.stop();
+    this.transport = undefined;
+  }
+
+  private ensureTransport(): void {
+    if (this.transport) return;
+    const config = resolveAgentCommand({
+      provider: "codex",
+      command: this.input.command,
+    });
+    if (!config || config.protocol !== "codex-app-server") {
+      throw new Error("Codex app-server command is unavailable.");
+    }
+    this.transport = new JsonRpcStdioTransport(
+      config.command,
+      config.framing,
+      () => {},
+      () => ({}),
+      (message) => this.emitError(message),
+      (message) => {
+        this.input.send(createEnvelope({
+          type: "agent.codex.rpc",
+          hostDeviceId: this.input.hostDeviceId,
+          payload: message,
+        }));
+        return true;
+      },
+    );
+    this.transport.start(this.input.cwd);
+    if (this.input.verbose) {
+      process.stderr.write(`[agent:codex-rpc] started ${config.command}\n`);
+    }
+  }
+
+  private emitError(message: string): void {
+    this.input.send(createEnvelope({
+      type: "agent.codex.rpc",
+      hostDeviceId: this.input.hostDeviceId,
+      payload: {
+        jsonrpc: "2.0",
+        id: "linkshell-codex-rpc-error",
+        error: { code: -32000, message },
+      },
+    }));
+  }
+}

package/src/runtime/acp/json-rpc.ts

@@ -1,27 +1,27 @@
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { AgentFraming } from "./provider-resolver.js";
 
-interface JsonRpcRequest {
+export interface JsonRpcRequest {
   jsonrpc: "2.0";
   id: number | string;
   method: string;
   params?: unknown;
 }
 
-interface JsonRpcResponse {
+export interface JsonRpcResponse {
   jsonrpc: "2.0";
   id: number | string;
   result?: unknown;
   error?: { code: number; message: string; data?: unknown };
 }
 
-interface JsonRpcNotification {
+export interface JsonRpcNotification {
   jsonrpc: "2.0";
   method: string;
   params?: unknown;
 }
 
-type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
 
 export class JsonRpcStdioTransport {
   private child: ChildProcessWithoutNullStreams | undefined;
@@ -42,6 +42,7 @@ export class JsonRpcStdioTransport {
     private readonly onNotification: (method: string, params: unknown) => void,
     private readonly onRequest: (method: string, params: unknown) => Promise<unknown> | unknown,
     private readonly onExit: (message: string) => void,
+    private readonly onMessage?: (message: JsonRpcMessage) => boolean | void,
   ) {}
 
   start(cwd: string): void {
@@ -87,6 +88,10 @@ export class JsonRpcStdioTransport {
     this.write({ jsonrpc: "2.0", method, params });
   }
 
+  send(message: JsonRpcMessage): void {
+    this.write(message);
+  }
+
   stop(): void {
     const child = this.child;
     this.child = undefined;
@@ -136,6 +141,10 @@ export class JsonRpcStdioTransport {
       return;
     }
 
+    if (this.onMessage?.(message)) {
+      return;
+    }
+
     if ("id" in message && ("result" in message || "error" in message)) {
       const pending = this.pending.get(message.id);
       if (!pending) return;

package/src/runtime/bridge-session.ts

@@ -603,6 +603,33 @@ export class BridgeSession {
         this.screenShare?.handleIceCandidate(p.candidate, p.sdpMid, p.sdpMLineIndex);
         break;
       }
+      case "agent.codex.rpc": {
+        if (!this.agentWorkspace) {
+          const payload = parseTypedPayload("agent.codex.rpc", envelope.payload);
+          const idValue = payload && typeof payload === "object" && "id" in payload
+            ? (payload as { id?: unknown }).id
+            : undefined;
+          if (typeof idValue === "string" || typeof idValue === "number") {
+            this.send(
+              createEnvelope({
+                type: "agent.codex.rpc",
+                hostDeviceId: this.sessionId,
+                payload: {
+                  jsonrpc: "2.0",
+                  id: idValue,
+                  error: {
+                    code: -32000,
+                    message: "Codex RPC is not enabled. Start CLI with --agent-ui.",
+                  },
+                },
+              }),
+            );
+          }
+          break;
+        }
+        await this.agentWorkspace.handleEnvelope(envelope);
+        break;
+      }
       case "agent.v2.capabilities.request":
       case "agent.v2.conversation.open":
       case "agent.v2.conversation.list":