linkshell-cli 0.2.65 → 0.2.67

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

@@ -0,0 +1,177 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { AgentFraming } from "./provider-resolver.js";
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id: number | string;
+  method: string;
+  params?: unknown;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: number | string;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: unknown;
+}
+
+type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+
+export class JsonRpcStdioTransport {
+  private child: ChildProcessWithoutNullStreams | undefined;
+  private nextId = 1;
+  private pending = new Map<
+    number | string,
+    {
+      resolve: (value: unknown) => void;
+      reject: (error: Error) => void;
+      timer: ReturnType<typeof setTimeout>;
+    }
+  >();
+  private buffer = "";
+
+  constructor(
+    private readonly command: string,
+    private readonly framing: AgentFraming,
+    private readonly onNotification: (method: string, params: unknown) => void,
+    private readonly onRequest: (method: string, params: unknown) => Promise<unknown> | unknown,
+    private readonly onExit: (message: string) => void,
+  ) {}
+
+  start(cwd: string): void {
+    if (this.child) return;
+    this.child = spawn(this.command, {
+      cwd,
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env,
+    });
+    this.child.stdout.setEncoding("utf8");
+    this.child.stderr.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk: string) => this.read(chunk));
+    this.child.stderr.on("data", (chunk: string) => {
+      const trimmed = chunk.trim();
+      if (trimmed) process.stderr.write(`[agent:stderr] ${trimmed}\n`);
+    });
+    this.child.on("error", (error) => this.failAll(error.message));
+    this.child.on("exit", (code, signal) => {
+      this.failAll(`ACP agent exited (code=${code ?? "null"}, signal=${signal ?? "null"})`);
+    });
+  }
+
+  request(method: string, params?: unknown, timeoutMs = 30_000): Promise<unknown> {
+    if (!this.child || this.child.stdin.destroyed) {
+      return Promise.reject(new Error("ACP agent is not running"));
+    }
+    const id = this.nextId++;
+    const message: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`ACP request timed out: ${method}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.write(message);
+    });
+  }
+
+  notify(method: string, params?: unknown): void {
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+
+  stop(): void {
+    const child = this.child;
+    this.child = undefined;
+    if (child && !child.killed) child.kill("SIGTERM");
+    this.failAll("ACP transport stopped");
+  }
+
+  private write(message: JsonRpcMessage): void {
+    const raw = JSON.stringify(message);
+    if (this.framing === "newline") {
+      this.child?.stdin.write(`${raw}\n`);
+      return;
+    }
+    this.child?.stdin.write(`Content-Length: ${Buffer.byteLength(raw, "utf8")}\r\n\r\n${raw}`);
+  }
+
+  private read(chunk: string): void {
+    this.buffer += chunk;
+    while (this.buffer.length > 0) {
+      const contentLengthMatch = this.buffer.match(/^Content-Length:\s*(\d+)\r?\n/i);
+      if (contentLengthMatch) {
+        const headerEnd = this.buffer.indexOf("\r\n\r\n");
+        const altHeaderEnd = this.buffer.indexOf("\n\n");
+        const end = headerEnd >= 0 ? headerEnd + 4 : altHeaderEnd >= 0 ? altHeaderEnd + 2 : -1;
+        if (end < 0) return;
+        const length = Number(contentLengthMatch[1]);
+        if (this.buffer.length < end + length) return;
+        const raw = this.buffer.slice(end, end + length);
+        this.buffer = this.buffer.slice(end + length);
+        this.dispatch(raw);
+        continue;
+      }
+
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0) return;
+      const raw = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (raw) this.dispatch(raw);
+    }
+  }
+
+  private dispatch(raw: string): void {
+    let message: JsonRpcMessage;
+    try {
+      message = JSON.parse(raw) as JsonRpcMessage;
+    } catch {
+      return;
+    }
+
+    if ("id" in message && ("result" in message || "error" in message)) {
+      const pending = this.pending.get(message.id);
+      if (!pending) return;
+      this.pending.delete(message.id);
+      clearTimeout(pending.timer);
+      const response = message as JsonRpcResponse;
+      if (response.error) pending.reject(new Error(response.error.message));
+      else pending.resolve(response.result);
+      return;
+    }
+
+    if ("method" in message && "id" in message) {
+      Promise.resolve(this.onRequest(message.method, message.params))
+        .then((result) => this.write({ jsonrpc: "2.0", id: message.id, result }))
+        .catch((error) => {
+          this.write({
+            jsonrpc: "2.0",
+            id: message.id,
+            error: {
+              code: -32000,
+              message: error instanceof Error ? error.message : String(error),
+            },
+          });
+        });
+      return;
+    }
+
+    if ("method" in message) {
+      this.onNotification(message.method, message.params);
+    }
+  }
+
+  private failAll(message: string): void {
+    this.onExit(message);
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(message));
+    }
+    this.pending.clear();
+  }
+}

package/src/runtime/acp/provider-resolver.ts

@@ -0,0 +1,37 @@
+export type AgentProvider = "codex" | "claude" | "custom";
+export type AgentProtocol = "acp" | "codex-app-server";
+export type AgentFraming = "content-length" | "newline";
+
+export interface AgentCommandConfig {
+  command: string;
+  provider: AgentProvider;
+  protocol: AgentProtocol;
+  framing: AgentFraming;
+}
+
+export function resolveAgentCommand(input: {
+  provider: AgentProvider;
+  command?: string;
+}): AgentCommandConfig | null {
+  const explicit = input.command?.trim();
+  if (explicit) {
+    const isCodexAppServer = /\bcodex\b/.test(explicit) && /\bapp-server\b/.test(explicit);
+    return {
+      provider: input.provider,
+      command: explicit,
+      protocol: isCodexAppServer ? "codex-app-server" : "acp",
+      framing: isCodexAppServer ? "newline" : "content-length",
+    };
+  }
+
+  if (input.provider === "codex") {
+    return {
+      provider: "codex",
+      command: "codex app-server --listen stdio://",
+      protocol: "codex-app-server",
+      framing: "newline",
+    };
+  }
+
+  return null;
+}

package/src/runtime/bridge-session.ts

@@ -18,6 +18,9 @@ import { ScrollbackBuffer } from "./scrollback.js";
 import { ScreenFallback } from "./screen-fallback.js";
 import { ScreenShare } from "./screen-share.js";
 import { getLanIp } from "../utils/lan-ip.js";
+import { startKeepAwake, type KeepAwakeHandle } from "../utils/keep-awake.js";
+import { AgentSessionProxy } from "./acp/agent-session.js";
+import type { AgentProvider } from "./acp/provider-resolver.js";
 
 export interface BridgeSessionOptions {
   gatewayUrl: string;
@@ -32,6 +35,10 @@ export interface BridgeSessionOptions {
   screen?: boolean;
   providerConfig: ProviderConfig;
   authToken?: string;
+  keepAwake?: boolean;
+  agentUi?: boolean;
+  agentProvider?: AgentProvider;
+  agentCommand?: string;
 }
 
 const HEARTBEAT_INTERVAL = 15_000;
@@ -126,6 +133,13 @@ function resolvePairingGateway(
   }
 }
 
+function normalizeAgentProvider(provider: unknown): AgentProvider {
+  if (provider === "claude" || provider === "custom") {
+    return provider;
+  }
+  return "codex";
+}
+
 export class BridgeSession {
   private readonly options: BridgeSessionOptions;
   private socket: WebSocket | undefined;
@@ -150,6 +164,8 @@ export class BridgeSession {
   private screenCapture: ScreenFallback | undefined;
   private screenShare: ScreenShare | undefined;
   private tunnelSockets = new Map<string, WebSocket>();
+  private keepAwake: KeepAwakeHandle | undefined;
+  private agentSession: AgentSessionProxy | undefined;
 
   constructor(options: BridgeSessionOptions) {
     this.options = options;
@@ -169,6 +185,25 @@ export class BridgeSession {
     if (!this.sessionId) {
       await this.createPairing();
     }
+    if (this.options.keepAwake) {
+      this.keepAwake = startKeepAwake();
+    } else {
+      process.stderr.write("[bridge] keep-awake disabled\n");
+    }
+    if (this.options.agentUi) {
+      const agentProvider = normalizeAgentProvider(
+        this.options.agentProvider ?? this.options.providerConfig.provider,
+      );
+      this.agentSession = new AgentSessionProxy({
+        sessionId: this.sessionId,
+        cwd: process.cwd(),
+        provider: agentProvider,
+        command: this.options.agentCommand,
+        verbose: this.options.verbose,
+        send: (envelope) => this.send(envelope),
+      });
+      process.stderr.write("[bridge] agent GUI channel enabled\n");
+    }
     await this.spawnTerminal(DEFAULT_TERMINAL_ID, process.cwd());
     this.connectGateway();
   }
@@ -509,6 +544,39 @@ export class BridgeSession {
         this.screenShare?.handleIceCandidate(p.candidate, p.sdpMid, p.sdpMLineIndex);
         break;
       }
+      case "agent.initialize":
+      case "agent.session.new":
+      case "agent.session.load":
+      case "agent.session.list":
+      case "agent.prompt":
+      case "agent.cancel":
+      case "agent.permission.response": {
+        if (!this.agentSession) {
+          this.send(
+            createEnvelope({
+              type: "agent.capabilities",
+              sessionId: this.sessionId,
+              payload: {
+                enabled: false,
+                provider: normalizeAgentProvider(
+                  this.options.agentProvider ?? this.options.providerConfig.provider,
+                ),
+                error: "Agent GUI is not enabled. Start CLI with --agent-ui.",
+                supportsSessionList: false,
+                supportsSessionLoad: false,
+                supportsImages: false,
+                supportsAudio: false,
+                supportsPermission: false,
+                supportsPlan: false,
+                supportsCancel: false,
+              },
+            }),
+          );
+          break;
+        }
+        await this.agentSession.handleEnvelope(envelope);
+        break;
+      }
       case "file.upload": {
         const p = parseTypedPayload("file.upload", envelope.payload);
         const ext = p.filename.split(".").pop() || "png";
@@ -1622,6 +1690,10 @@ export class BridgeSession {
     this.exited = true;
     this.stopHeartbeat();
     this.stopScreenCapture();
+    this.agentSession?.stop();
+    this.agentSession = undefined;
+    this.keepAwake?.stop();
+    this.keepAwake = undefined;
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = undefined;

package/src/utils/daemon.ts

@@ -7,6 +7,11 @@ const LINKSHELL_DIR = join(homedir(), ".linkshell");
 
 type ServiceName = "gateway" | "bridge";
 
+export interface ServiceMetadata {
+  keepAwake?: boolean;
+  startedAt?: number;
+}
+
 function pidFile(service: ServiceName): string {
   return join(LINKSHELL_DIR, `${service}.pid`);
 }
@@ -15,6 +20,10 @@ function logFile(service: ServiceName): string {
   return join(LINKSHELL_DIR, `${service}.log`);
 }
 
+function metadataFile(service: ServiceName): string {
+  return join(LINKSHELL_DIR, `${service}.json`);
+}
+
 export function savePid(service: ServiceName, pid: number): void {
   mkdirSync(LINKSHELL_DIR, { recursive: true });
   writeFileSync(pidFile(service), String(pid), "utf8");
@@ -40,6 +49,7 @@ export function readPid(service: ServiceName): number | null {
 
 export function removePid(service: ServiceName): void {
   try { unlinkSync(pidFile(service)); } catch {}
+  try { unlinkSync(metadataFile(service)); } catch {}
 }
 
 export function getLogFile(service: ServiceName): string {
@@ -50,6 +60,24 @@ export function getPidFile(service: ServiceName): string {
   return pidFile(service);
 }
 
+export function saveMetadata(
+  service: ServiceName,
+  metadata: ServiceMetadata,
+): void {
+  mkdirSync(LINKSHELL_DIR, { recursive: true });
+  writeFileSync(metadataFile(service), JSON.stringify(metadata), "utf8");
+}
+
+export function readMetadata(service: ServiceName): ServiceMetadata | null {
+  try {
+    const file = metadataFile(service);
+    if (!existsSync(file)) return null;
+    return JSON.parse(readFileSync(file, "utf8")) as ServiceMetadata;
+  } catch {
+    return null;
+  }
+}
+
 export function spawnDaemon(service: ServiceName, args: string[]): number {
   mkdirSync(LINKSHELL_DIR, { recursive: true });
   const log = logFile(service);

package/src/utils/keep-awake.ts

@@ -0,0 +1,61 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { platform } from "node:os";
+
+export interface KeepAwakeHandle {
+  enabled: boolean;
+  stop: () => void;
+}
+
+export function shouldKeepAwake(optionEnabled: boolean | undefined): boolean {
+  if (process.env.LINKSHELL_KEEP_AWAKE === "0") return false;
+  if (platform() !== "darwin") return false;
+  return optionEnabled !== false;
+}
+
+export function startKeepAwake(): KeepAwakeHandle {
+  if (platform() !== "darwin") {
+    return { enabled: false, stop: () => {} };
+  }
+
+  let child: ChildProcess | undefined;
+  let stopping = false;
+
+  try {
+    child = spawn("caffeinate", ["-i", "-w", String(process.pid)], {
+      stdio: "ignore",
+      detached: false,
+    });
+  } catch (error) {
+    process.stderr.write(
+      `[bridge] keep-awake unavailable: ${error instanceof Error ? error.message : String(error)}\n`,
+    );
+    return { enabled: false, stop: () => {} };
+  }
+
+  child.on("error", (error) => {
+    if (stopping) return;
+    process.stderr.write(`[bridge] keep-awake unavailable: ${error.message}\n`);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (stopping) return;
+    process.stderr.write(
+      `[bridge] keep-awake stopped unexpectedly (code=${code ?? "null"}, signal=${signal ?? "null"})\n`,
+    );
+  });
+
+  process.stderr.write(
+    "[bridge] keep-awake enabled (macOS idle sleep prevention)\n",
+  );
+
+  return {
+    enabled: true,
+    stop: () => {
+      stopping = true;
+      if (child && !child.killed) {
+        child.kill("SIGTERM");
+      }
+      child = undefined;
+    },
+  };
+}