linkshell-cli 0.8.2 → 0.10.0

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

@@ -1,184 +0,0 @@
-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 = "";
-  private closed = false;
-
-  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.closed = false;
-    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: number | null = 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 = timeoutMs && timeoutMs > 0
-        ? setTimeout(() => {
-            this.pending.delete(id);
-            reject(new Error(`ACP request timed out: ${method}`));
-          }, timeoutMs)
-        : undefined;
-      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);
-      if (pending.timer) 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 {
-    if (this.closed) return;
-    this.closed = true;
-    this.child = undefined;
-    this.onExit(message);
-    for (const [, pending] of this.pending) {
-      if (pending.timer) clearTimeout(pending.timer);
-      pending.reject(new Error(message));
-    }
-    this.pending.clear();
-  }
-}

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

@@ -1,154 +0,0 @@
-import { execSync } from "node:child_process";
-import { createRequire } from "node:module";
-import { homedir } from "node:os";
-import { existsSync } from "node:fs";
-
-import type { KnownAgentProvider } from "./agent-process-discovery.js";
-
-export type AgentProvider = string;
-export type { KnownAgentProvider };
-export type AgentProtocol = "acp" | "codex-app-server" | "claude-agent-sdk" | "claude-stream-json";
-export type AgentFraming = "content-length" | "newline";
-
-const require = createRequire(import.meta.url);
-
-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);
-    const isClaudeCli = input.provider === "claude" && /\bclaude\b/.test(explicit);
-    return {
-      provider: input.provider,
-      command: explicit,
-      protocol: isCodexAppServer ? "codex-app-server" : isClaudeCli ? "claude-stream-json" : "acp",
-      // Gemini --acp, cursor-agent acp, and other ACP CLIs speak NDJSON, not LSP Content-Length.
-      framing: "newline",
-    };
-  }
-
-  if (input.provider === "codex") {
-    return {
-      provider: "codex",
-      command: "codex app-server --listen stdio://",
-      protocol: "codex-app-server",
-      framing: "newline",
-    };
-  }
-
-  if (input.provider === "claude") {
-    if (process.env.LINKSHELL_CLAUDE_PROVIDER !== "stream-json" && hasPackage("@anthropic-ai/claude-agent-sdk")) {
-      return {
-        provider: "claude",
-        command: "claude-agent-sdk",
-        protocol: "claude-agent-sdk",
-        framing: "newline",
-      };
-    }
-    return {
-      provider: "claude",
-      command: "claude --print --output-format stream-json --input-format stream-json --verbose --permission-mode bypassPermissions",
-      protocol: "claude-stream-json",
-      framing: "newline",
-    };
-  }
-
-  if (input.provider === "gemini") {
-    return {
-      provider: "gemini",
-      command: "gemini --acp",
-      protocol: "acp",
-      framing: "newline",
-    };
-  }
-
-  if (input.provider === "cursor") {
-    return {
-      provider: "cursor",
-      command: "cursor-agent acp",
-      protocol: "acp",
-      framing: "newline",
-    };
-  }
-
-  if (input.provider === "grok") {
-    return {
-      provider: "grok",
-      command: "grok agent stdio",
-      protocol: "acp",
-      framing: "newline",
-    };
-  }
-
-  // copilot / opencode / kimi / custom: PTY-only unless caller passes --agent-command
-  return null;
-}
-
-function hasPackage(name: string): boolean {
-  try {
-    require.resolve(name);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function resolveBinary(bin: string): string | null {
-  // 1. Try which (PATH lookup)
-  try {
-    const path = execSync(`which ${bin}`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-    if (path && existsSync(path)) return path;
-  } catch { /* not in PATH */ }
-
-  // 2. Common install locations (daemon may have a stripped PATH)
-  const home = homedir();
-  const candidates = [
-    `${home}/.npm-global/bin/${bin}`,
-    `${home}/.local/bin/${bin}`,
-    `/opt/homebrew/bin/${bin}`,
-    `/usr/local/bin/${bin}`,
-    `${home}/.nvm/versions/node/*/bin/${bin}`,
-  ];
-  for (const candidate of candidates) {
-    // expand glob if present
-    if (candidate.includes("*")) {
-      try {
-        const expanded = execSync(`ls ${candidate} 2>/dev/null`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim().split("\n")[0];
-        if (expanded && existsSync(expanded)) return expanded;
-      } catch { continue; }
-    } else if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-
-  return null;
-}
-
-const INSTALL_BINARIES: Array<{ provider: KnownAgentProvider; binaries: string[] }> = [
-  { provider: "claude", binaries: ["claude"] },
-  { provider: "codex", binaries: ["codex"] },
-  { provider: "gemini", binaries: ["gemini"] },
-  { provider: "copilot", binaries: ["copilot"] },
-  { provider: "opencode", binaries: ["opencode", "opencode-ai"] },
-  { provider: "cursor", binaries: ["cursor-agent"] },
-  { provider: "grok", binaries: ["grok"] },
-  { provider: "kimi", binaries: ["kimi"] },
-];
-
-export function detectAvailableProviders(): AgentProvider[] {
-  const available: AgentProvider[] = [];
-  for (const entry of INSTALL_BINARIES) {
-    if (entry.binaries.some((bin) => resolveBinary(bin))) available.push(entry.provider);
-  }
-  return available;
-}
-