linkshell-cli 0.2.34 → 0.2.36

package/src/runtime/bridge-session.ts

@@ -15,7 +15,6 @@ import {
 import type { Envelope } from "@linkshell/protocol";
 import type { ProviderConfig } from "../providers.js";
 import { ScrollbackBuffer } from "./scrollback.js";
-import { AcpRelay } from "./acp-relay.js";
 import { ScreenFallback } from "./screen-fallback.js";
 import { ScreenShare } from "./screen-share.js";
 import { getLanIp } from "../utils/lan-ip.js";
@@ -42,9 +41,7 @@ const DEFAULT_TERMINAL_ID = "default";
 
 interface TerminalInstance {
   id: string;
-  pty: pty.IPty | null;
-  acpRelay: AcpRelay | null;
-  mode: "pty" | "acp";
+  pty: pty.IPty;
   cwd: string;
   projectName: string;
   provider: string;
@@ -131,6 +128,8 @@ export class BridgeSession {
     permissionRequest: string;
     timestamp: number;
   }>>();
+  // Pending permission responses: requestId → HTTP response callback
+  private pendingPermissions = new Map<string, (decision: "allow" | "deny") => void>();
   private screenCapture: ScreenFallback | undefined;
   private screenShare: ScreenShare | undefined;
 
@@ -284,29 +283,21 @@ export class BridgeSession {
       case "terminal.input": {
         const p = parseTypedPayload("terminal.input", envelope.payload);
         const term = this.terminals.get(tid);
-        if (term && term.status === "running" && term.pty) term.pty.write(p.data);
+        if (term && term.status === "running") term.pty.write(p.data);
         break;
       }
       case "terminal.resize": {
         const p = parseTypedPayload("terminal.resize", envelope.payload);
         const term = this.terminals.get(tid);
-        if (term && term.status === "running" && term.pty) term.pty.resize(p.cols, p.rows);
-        break;
-      }
-      case "acp.rpc": {
-        const term = this.terminals.get(tid);
-        if (term && term.status === "running" && term.acpRelay) {
-          term.acpRelay.write(envelope.payload);
-        }
+        if (term && term.status === "running") term.pty.resize(p.cols, p.rows);
         break;
       }
       case "terminal.spawn": {
         const p = parseTypedPayload("terminal.spawn", envelope.payload);
         const normalizedCwd = resolve(p.cwd);
-        const mode = p.mode ?? "pty";
-        // Dedup: if a running terminal already exists for this cwd and mode, return it
+        // Dedup: if a running terminal already exists for this cwd, return it
         const existing = [...this.terminals.values()].find(
-          (t) => t.status === "running" && resolve(t.cwd) === normalizedCwd && t.mode === mode,
+          (t) => t.status === "running" && resolve(t.cwd) === normalizedCwd,
         );
         if (existing) {
           this.send(createEnvelope({
@@ -318,7 +309,7 @@ export class BridgeSession {
         } else {
           const newId = `term-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
           try {
-            await this.spawnTerminal(newId, normalizedCwd, p.provider, mode);
+            await this.spawnTerminal(newId, normalizedCwd, p.provider);
             this.send(createEnvelope({
               type: "terminal.spawned",
               sessionId: this.sessionId,
@@ -342,8 +333,7 @@ export class BridgeSession {
         const p = parseTypedPayload("terminal.kill", envelope.payload);
         const term = this.terminals.get(p.terminalId);
         if (term && term.status === "running") {
-          if (term.pty) term.pty.kill();
-          if (term.acpRelay) term.acpRelay.kill();
+          term.pty.kill();
         }
         break;
       }
@@ -425,11 +415,32 @@ export class BridgeSession {
         writeFileSync(tempPath, Buffer.from(p.data, "base64"));
         this.log(`image saved to ${tempPath}`);
         const term = this.terminals.get(tid);
-        if (term && term.status === "running" && term.pty) {
+        if (term && term.status === "running") {
           term.pty.write(`\x1b[200~${tempPath}\x1b[201~`);
         }
         break;
       }
+      case "permission.decision": {
+        const p = envelope.payload as { requestId: string; decision: "allow" | "deny" };
+        const resolve = this.pendingPermissions.get(p.requestId);
+        if (resolve) {
+          this.pendingPermissions.delete(p.requestId);
+          resolve(p.decision);
+          this.log(`permission decision for ${p.requestId}: ${p.decision}`);
+          // Pop from permission stack
+          if (p.decision === "allow" || p.decision === "deny") {
+            const stack = this.permissionStacks.get(tid);
+            if (stack) {
+              const idx = stack.findIndex((s) => s.requestId === p.requestId);
+              if (idx >= 0) stack.splice(idx, 1);
+              if (stack.length === 0) this.permissionStacks.delete(tid);
+            }
+          }
+        } else {
+          this.log(`no pending permission for ${p.requestId}`);
+        }
+        break;
+      }
       default:
         break;
     }
@@ -442,7 +453,6 @@ export class BridgeSession {
       projectName: t.projectName,
       provider: t.provider,
       status: t.status,
-      mode: t.mode,
     }));
     this.send(createEnvelope({
       type: "terminal.list",
@@ -473,7 +483,7 @@ export class BridgeSession {
     }
   }
 
-  private async spawnTerminal(terminalId: string, cwd: string, providerOverride?: string, mode: "pty" | "acp" = "pty"): Promise<void> {
+  private async spawnTerminal(terminalId: string, cwd: string, providerOverride?: string): Promise<void> {
     const cleanEnv: Record<string, string> = {};
     for (const [k, v] of Object.entries(this.options.providerConfig.env)) {
       if (v !== undefined) cleanEnv[k] = v;
@@ -482,58 +492,6 @@ export class BridgeSession {
     const provider = providerOverride ?? this.options.providerConfig.provider;
     const args = [...this.options.providerConfig.args];
 
-    // ACP mode: spawn as child process with JSON-RPC over stdio
-    if (mode === "acp") {
-      const term: TerminalInstance = {
-        id: terminalId,
-        pty: null,
-        acpRelay: new AcpRelay({
-          command: this.options.providerConfig.command,
-          args,
-          cwd,
-          env: cleanEnv,
-          sessionId: this.sessionId,
-          terminalId,
-          send: (envelope) => this.send(envelope),
-          log: (msg) => this.log(msg),
-        }),
-        mode: "acp",
-        cwd,
-        projectName: basename(cwd),
-        provider,
-        scrollback: new ScrollbackBuffer(1000),
-        outputSeq: 0,
-        statusSeq: 0,
-        status: "running",
-      };
-
-      term.acpRelay!.onExit((exitCode, signal) => {
-        term.status = "exited";
-        this.send(createEnvelope({
-          type: "terminal.exit",
-          sessionId: this.sessionId,
-          terminalId,
-          payload: { exitCode, signal: signal ? parseInt(signal, 10) || 0 : 0 },
-        }));
-        this.sendTerminalList();
-
-        const allExited = [...this.terminals.values()].every((t) => t.status === "exited");
-        if (allExited) {
-          this.exited = true;
-          setTimeout(() => {
-            this.stopHeartbeat();
-            this.socket?.close();
-          }, 500);
-          process.exitCode = exitCode ?? 0;
-        }
-      });
-
-      this.terminals.set(terminalId, term);
-      this.log(`spawned ACP terminal ${terminalId} in ${cwd}`);
-      return;
-    }
-
-    // PTY mode: existing behavior
     // Set up hook server for structured status (all supported providers)
     // For "custom" shell, set up hooks for all providers since user may launch any of them
     let hookServer: http.Server | undefined;
@@ -570,8 +528,6 @@ export class BridgeSession {
           env: cleanEnv,
         },
       ),
-      acpRelay: null,
-      mode: "pty",
       cwd,
       projectName: basename(cwd),
       provider,
@@ -584,7 +540,7 @@ export class BridgeSession {
       hookConfigPath,
     };
 
-    term.pty!.onData((data) => {
+    term.pty.onData((data) => {
       const seq = term.outputSeq++;
       const envelope = createEnvelope({
         type: "terminal.output",
@@ -603,7 +559,7 @@ export class BridgeSession {
       this.send(envelope);
     });
 
-    term.pty!.onExit(({ exitCode, signal }) => {
+    term.pty.onExit(({ exitCode, signal }) => {
       term.status = "exited";
       this.cleanupHookServer(term);
       this.send(createEnvelope({
@@ -645,13 +601,35 @@ export class BridgeSession {
       let body = "";
       req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
       req.on("end", () => {
-        res.writeHead(200);
-        res.end("ok");
         this.log(`hook body (${body.length} bytes): ${body.slice(0, 200)}`);
         try {
           const event = JSON.parse(body);
-          this.handleHookEvent(terminalId, event, provider);
+          const hookName = (event.hook_event_name ?? event.event_name) as string | undefined;
+
+          // PermissionRequest: hold connection, wait for user decision from mobile app
+          if (hookName === "PermissionRequest") {
+            const requestId = `pr-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            this.pendingPermissions.set(requestId, (decision) => {
+              const responseJson = JSON.stringify({
+                hookSpecificOutput: {
+                  hookEventName: "PermissionRequest",
+                  decision: { behavior: decision },
+                },
+              });
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(responseJson);
+            });
+            // Send status with requestId so app can route decision back
+            this.handleHookEvent(terminalId, event, provider, requestId);
+          } else {
+            // All other hooks: respond immediately
+            res.writeHead(200);
+            res.end("ok");
+            this.handleHookEvent(terminalId, event, provider);
+          }
         } catch (e) {
+          res.writeHead(200);
+          res.end("ok");
           this.log(`hook parse error: ${e}`);
         }
       });
@@ -822,7 +800,7 @@ export class BridgeSession {
     return hooksPath;
   }
 
-  private handleHookEvent(terminalId: string, event: Record<string, unknown>, provider: string): void {
+  private handleHookEvent(terminalId: string, event: Record<string, unknown>, provider: string, permissionRequestId?: string): void {
     const rawHookName = (event.hook_event_name ?? event.event_name) as string | undefined;
     if (!rawHookName) return;
 
@@ -878,11 +856,12 @@ export class BridgeSession {
       case "PostToolUse":
         phase = "thinking";
         toolName = (event.tool_name ?? event.toolName) as string | undefined;
-        // Pop permission stack: tool completed
+        // Pop permission stack + auto-resolve pending HTTP connection
         {
           const stack = this.permissionStacks.get(terminalId);
           if (stack && stack.length > 0) {
-            stack.pop();
+            const popped = stack.pop();
+            if (popped) this.autoResolvePending(popped.requestId);
             if (stack.length === 0) this.permissionStacks.delete(terminalId);
           }
         }
@@ -893,7 +872,8 @@ export class BridgeSession {
         {
           const stack = this.permissionStacks.get(terminalId);
           if (stack && stack.length > 0) {
-            stack.pop();
+            const popped = stack.pop();
+            if (popped) this.autoResolvePending(popped.requestId);
             if (stack.length === 0) this.permissionStacks.delete(terminalId);
           }
         }
@@ -901,6 +881,7 @@ export class BridgeSession {
       case "Stop":
         phase = "idle";
         if (event.stop_reason) summary = String(event.stop_reason);
+        this.drainPendingPermissions(terminalId);
         this.permissionStacks.delete(terminalId);
         break;
       case "PermissionRequest":
@@ -912,14 +893,14 @@ export class BridgeSession {
         } else if (event.toolInput && typeof event.toolInput === "object") {
           permissionRequest = JSON.stringify(event.toolInput).slice(0, 300);
         }
-        // Push to permission stack
+        // Push to permission stack (use requestId from hook server if available)
         {
-          const requestId = `pr-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+          const reqId = permissionRequestId ?? `pr-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
           if (!this.permissionStacks.has(terminalId)) {
             this.permissionStacks.set(terminalId, []);
           }
           this.permissionStacks.get(terminalId)!.push({
-            requestId,
+            requestId: reqId,
             toolName: toolName ?? "unknown",
             toolInput: toolInput ?? (permissionRequest ?? ""),
             permissionRequest: permissionRequest ?? "",
@@ -933,6 +914,7 @@ export class BridgeSession {
         break;
       case "UserPromptSubmit":
         phase = "thinking";
+        this.drainPendingPermissions(terminalId);
         this.permissionStacks.delete(terminalId);
         break;
       default:
@@ -1023,7 +1005,33 @@ export class BridgeSession {
     return undefined;
   }
 
+  /** Auto-resolve a single pending permission (user acted in terminal) */
+  private autoResolvePending(requestId: string): void {
+    const resolve = this.pendingPermissions.get(requestId);
+    if (resolve) {
+      this.pendingPermissions.delete(requestId);
+      resolve("allow");
+      this.log(`auto-resolved pending permission ${requestId} (user acted in terminal)`);
+    }
+  }
+
+  /** Drain all pending permissions for a terminal (session ended, stop, etc.) */
+  private drainPendingPermissions(terminalId: string): void {
+    const stack = this.permissionStacks.get(terminalId);
+    if (!stack) return;
+    for (const entry of stack) {
+      const resolve = this.pendingPermissions.get(entry.requestId);
+      if (resolve) {
+        this.pendingPermissions.delete(entry.requestId);
+        resolve("deny");
+        this.log(`drained pending permission ${entry.requestId}`);
+      }
+    }
+  }
+
   private cleanupHookServer(term: TerminalInstance): void {
+    // Drain any pending permission requests for this terminal
+    this.drainPendingPermissions(term.id);
     if (term.hookServer) {
       term.hookServer.close();
       term.hookServer = undefined;
@@ -1191,10 +1199,7 @@ export class BridgeSession {
     this.socket = undefined;
     for (const term of this.terminals.values()) {
       this.cleanupHookServer(term);
-      if (term.status === "running") {
-        if (term.pty) term.pty.kill();
-        if (term.acpRelay) term.acpRelay.kill();
-      }
+      if (term.status === "running") term.pty.kill();
     }
     this.terminals.clear();
     process.exitCode = exitCode;

package/src/runtime/acp-relay.ts

@@ -1,92 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import { createInterface } from "node:readline";
-import { createEnvelope, serializeEnvelope } from "@linkshell/protocol";
-import type { Envelope } from "@linkshell/protocol";
-
-export interface AcpRelayOptions {
-  command: string;
-  args: string[];
-  cwd: string;
-  env: Record<string, string>;
-  sessionId: string;
-  terminalId: string;
-  send: (envelope: Envelope) => void;
-  log: (msg: string) => void;
-}
-
-export class AcpRelay {
-  private child: ChildProcess;
-  private readonly options: AcpRelayOptions;
-  private exited = false;
-
-  constructor(options: AcpRelayOptions) {
-    this.options = options;
-
-    this.child = spawn(options.command, options.args, {
-      cwd: options.cwd,
-      env: options.env,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    // Read newline-delimited JSON from stdout
-    const rl = createInterface({ input: this.child.stdout! });
-    rl.on("line", (line) => {
-      if (!line.trim()) return;
-      try {
-        const msg = JSON.parse(line);
-        // Wrap JSON-RPC message in acp.rpc envelope and send to gateway
-        this.options.send(createEnvelope({
-          type: "acp.rpc",
-          sessionId: this.options.sessionId,
-          terminalId: this.options.terminalId,
-          payload: msg,
-        }));
-      } catch (e) {
-        this.options.log(`acp-relay: failed to parse stdout line: ${e}`);
-      }
-    });
-
-    // Log stderr
-    this.child.stderr?.on("data", (chunk: Buffer) => {
-      this.options.log(`acp-relay stderr: ${chunk.toString().trimEnd()}`);
-    });
-
-    this.child.on("exit", (code, signal) => {
-      this.exited = true;
-      this.options.log(`acp-relay: process exited (code=${code}, signal=${signal})`);
-    });
-
-    this.child.on("error", (err) => {
-      this.options.log(`acp-relay: process error: ${err.message}`);
-    });
-  }
-
-  /** Forward an acp.rpc envelope payload to the child's stdin */
-  write(payload: unknown): void {
-    if (this.exited || !this.child.stdin?.writable) return;
-    try {
-      const line = JSON.stringify(payload) + "\n";
-      this.child.stdin.write(line);
-    } catch (e) {
-      this.options.log(`acp-relay: failed to write to stdin: ${e}`);
-    }
-  }
-
-  kill(): void {
-    if (!this.exited) {
-      this.child.kill("SIGTERM");
-    }
-  }
-
-  get isExited(): boolean {
-    return this.exited;
-  }
-
-  get pid(): number | undefined {
-    return this.child.pid;
-  }
-
-  onExit(cb: (code: number | null, signal: string | null) => void): void {
-    this.child.on("exit", cb);
-  }
-}