linkshell-cli 0.2.93 → 0.2.94

package/src/runtime/acp/agent-workspace.ts

@@ -5,6 +5,7 @@ import {
   type Envelope,
 } from "@linkshell/protocol";
 import { AcpClient } from "./acp-client.js";
+import { ClaudeStreamJsonClient } from "./claude-stream-json-client.js";
 import type { AgentProtocol, AgentProvider } from "./provider-resolver.js";
 import { resolveAgentCommand } from "./provider-resolver.js";
 
@@ -657,7 +658,7 @@ function providerLabel(provider: AgentProvider): string {
 }
 
 export class AgentWorkspaceProxy {
-  private clients = new Map<AgentProvider, AcpClient>();
+  private clients = new Map<AgentProvider, AcpClient | ClaudeStreamJsonClient>();
   private agentProtocols = new Map<AgentProvider, AgentProtocol>();
   private initialized = false;
   private status: AgentStatus = "unavailable";
@@ -753,7 +754,7 @@ export class AgentWorkspaceProxy {
     this.clients.clear();
   }
 
-  private clientForProvider(provider: AgentProvider): AcpClient | undefined {
+  private clientForProvider(provider: AgentProvider): AcpClient | ClaudeStreamJsonClient | undefined {
     return this.clients.get(provider);
   }
 
@@ -772,7 +773,7 @@ export class AgentWorkspaceProxy {
     this.sendCapabilities();
   }
 
-  private async ensureProviderClient(provider: AgentProvider): Promise<AcpClient | undefined> {
+  private async ensureProviderClient(provider: AgentProvider): Promise<AcpClient | ClaudeStreamJsonClient | undefined> {
     const existing = this.clients.get(provider);
     if (existing) return existing;
 
@@ -789,15 +790,26 @@ export class AgentWorkspaceProxy {
 
     try {
       this.agentProtocols.set(provider, resolved.protocol);
-      const client = new AcpClient({
-        command: resolved.command,
-        protocol: resolved.protocol,
-        framing: resolved.framing,
-        cwd: this.input.cwd,
-        onNotification: (method, params) => this.handleNotification(method, params),
-        onRequest: (method, params) => this.handleRequest(method, params),
-        onExit: (message) => this.handleProviderExit(provider, message),
-      });
+      const isClaudeStreamJson = resolved.protocol === "claude-stream-json";
+      const client = isClaudeStreamJson
+        ? new ClaudeStreamJsonClient({
+            command: resolved.command,
+            protocol: resolved.protocol,
+            framing: resolved.framing,
+            cwd: this.input.cwd,
+            onNotification: (method, params) => this.handleNotification(method, params),
+            onRequest: (method, params) => this.handleRequest(method, params),
+            onExit: (message) => this.handleProviderExit(provider, message),
+          })
+        : new AcpClient({
+            command: resolved.command,
+            protocol: resolved.protocol,
+            framing: resolved.framing,
+            cwd: this.input.cwd,
+            onNotification: (method, params) => this.handleNotification(method, params),
+            onRequest: (method, params) => this.handleRequest(method, params),
+            onExit: (message) => this.handleProviderExit(provider, message),
+          });
       await client.initialize();
       this.clients.set(provider, client);
       this.status = "idle";

package/src/runtime/acp/claude-stream-json-client.ts

@@ -0,0 +1,372 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { createInterface } from "node:readline";
+import { homedir } from "node:os";
+import { readdirSync, existsSync } from "node:fs";
+import { join, basename, relative, resolve } from "node:path";
+import type { AgentFraming, AgentProtocol } from "./provider-resolver.js";
+
+type AgentPermissionMode = "read_only" | "workspace_write" | "full_access";
+
+interface ClaudeStreamEvent {
+  type: string;
+  subtype?: string;
+  message?: Record<string, unknown>;
+  session_id?: string;
+  parent_tool_use_id?: string | null;
+  uuid?: string;
+  [key: string]: unknown;
+}
+
+interface ClaudeContentBlock {
+  type: string;
+  text?: string;
+  thinking?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: string;
+  is_error?: boolean;
+  signature?: string;
+}
+
+// Hash a directory path the same way Claude Code does for project storage
+function projectHash(cwd: string): string {
+  return (
+    "-" +
+    resolve(cwd)
+      .replace(/\/$/, "")
+      .replace(/\//g, "-")
+  );
+}
+
+function id(prefix: string): string {
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export class ClaudeStreamJsonClient {
+  private child: ChildProcessWithoutNullStreams | undefined;
+  private claudeSessionId: string | undefined;
+  private pendingCancel = false;
+  private messageBuffer = "";
+
+  constructor(
+    private readonly input: {
+      command: string;
+      protocol: AgentProtocol;
+      framing: AgentFraming;
+      cwd: string;
+      onNotification: (method: string, params: unknown) => void;
+      onRequest: (method: string, params: unknown) => Promise<unknown> | unknown;
+      onExit: (message: string) => void;
+    },
+  ) {}
+
+  async initialize(): Promise<unknown> {
+    // No persistent process to start — we'll capture session on first prompt.
+    // But we can verify the binary exists by running a quick --help.
+    try {
+      const { execSync } = await import("node:child_process");
+      execSync("claude --version", { stdio: "ignore", timeout: 5000 });
+    } catch {
+      throw new Error("Claude Code CLI not found or not executable");
+    }
+    return { status: "ok" };
+  }
+
+  async newSession(input: { cwd: string; mcpServers?: unknown }): Promise<unknown> {
+    // Start a dry-run prompt to get a session_id, then cancel.
+    // Actually, we just store that there's no session yet — the real session
+    // will be created on the first prompt() call.
+    this.claudeSessionId = undefined;
+    return { sessionId: undefined, status: "ready" };
+  }
+
+  async loadSession(input: { sessionId: string; cwd: string; mcpServers?: unknown }): Promise<unknown> {
+    this.claudeSessionId = input.sessionId;
+    return { sessionId: input.sessionId, status: "loaded" };
+  }
+
+  async prompt(input: {
+    sessionId?: string;
+    content: unknown[];
+    clientMessageId: string;
+    model?: string;
+    reasoningEffort?: string;
+    permissionMode?: AgentPermissionMode;
+    cwd: string;
+  }): Promise<unknown> {
+    if (this.child) {
+      this.stop();
+    }
+
+    this.pendingCancel = false;
+
+    // Build Claude args
+    const args: string[] = [
+      "--print",
+      "--output-format", "stream-json",
+      "--input-format", "stream-json",
+      "--verbose",
+      "--permission-mode", "bypassPermissions",
+    ];
+
+    // Use stored session for --continue or --resume
+    if (input.sessionId || this.claudeSessionId) {
+      const sid = input.sessionId ?? this.claudeSessionId;
+      if (sid) {
+        args.push("--resume", sid);
+      }
+    }
+
+    if (input.model) {
+      args.push("--model", input.model);
+    }
+
+    // Build the user message
+    const contentBlocks = (input.content as Array<{ type: string; text?: string; data?: string; mimeType?: string }>).map(
+      (block) => {
+        if (block.type === "image" && block.data) {
+          return { type: "image", source: { type: "base64", media_type: block.mimeType ?? "image/png", data: block.data } };
+        }
+        return { type: "text", text: block.text ?? "" };
+      },
+    );
+
+    const userMessage = {
+      type: "user",
+      message: {
+        role: "user",
+        content: contentBlocks,
+      },
+    };
+
+    return new Promise((resolve, reject) => {
+      const cwd = input.cwd ?? this.input.cwd;
+      const child = spawn("claude", args, {
+        cwd,
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      this.child = child;
+      let settled = false;
+
+      const finish = (err: Error | null, result: unknown) => {
+        if (settled) return;
+        settled = true;
+        this.child = undefined;
+        if (err) {
+          this.input.onExit(err.message);
+          reject(err);
+        } else {
+          resolve(result);
+        }
+      };
+
+      // Send the prompt
+      child.stdin.write(JSON.stringify(userMessage) + "\n");
+      child.stdin.end();
+
+      // Read stdout line by line (stream-json is newline-delimited)
+      const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+      let currentToolId: string | undefined;
+
+      rl.on("line", (line: string) => {
+        if (this.pendingCancel) {
+          child.kill("SIGTERM");
+          return;
+        }
+
+        let event: ClaudeStreamEvent;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          return; // skip unparseable lines
+        }
+
+        switch (event.type) {
+          case "system": {
+            if (event.subtype === "init") {
+              // Capture session ID
+              if (event.session_id) {
+                this.claudeSessionId = event.session_id;
+              }
+              // Send as initialized notification — workspace needs this
+              const initParams: Record<string, unknown> = {
+                sessionId: event.session_id,
+                cwd: event.cwd ?? cwd,
+                model: event.model,
+              };
+              if (event.tools) initParams.tools = event.tools;
+              if (event.mcp_servers) initParams.mcpServers = event.mcp_servers;
+              this.input.onNotification("initialized", initParams);
+            }
+            // Hook events and other system messages are informational, skip
+            break;
+          }
+
+          case "assistant": {
+            const message = event.message;
+            if (!message) break;
+            const content = (message.content ?? []) as ClaudeContentBlock[];
+
+            for (const block of content) {
+              switch (block.type) {
+                case "thinking":
+                  this.input.onNotification("item/started", {
+                    sessionId: this.claudeSessionId,
+                    item: {
+                      id: event.uuid ?? id("thinking"),
+                      type: "thinking",
+                      text: block.thinking,
+                      status: "completed",
+                    },
+                  });
+                  break;
+
+                case "text":
+                  this.input.onNotification("item/agentMessage/delta", {
+                    sessionId: this.claudeSessionId,
+                    itemId: message.id ?? event.uuid ?? id("msg"),
+                    delta: block.text,
+                  });
+                  break;
+
+                case "tool_use": {
+                  currentToolId = block.id;
+                  const toolName = block.name ?? "tool";
+                  this.input.onNotification("item/started", {
+                    sessionId: this.claudeSessionId,
+                    item: {
+                      id: block.id ?? id("tool"),
+                      type: toolName === "Bash" ? "commandExecution" : toolName === "Write" || toolName === "Edit" ? "fileChange" : "toolCall",
+                      toolName: block.name,
+                      tool: block.name,
+                      input: block.input,
+                      command: block.input?.command as string | undefined,
+                      cwd: block.input?.cwd as string | undefined ?? cwd,
+                      status: "running",
+                    },
+                  });
+                  break;
+                }
+
+                case "tool_result":
+                  // tool_result comes in user messages, not assistant
+                  break;
+              }
+            }
+            break;
+          }
+
+          case "user": {
+            // User messages in stream-json contain tool results
+            const message = event.message;
+            if (!message) break;
+            const content = (message.content ?? []) as ClaudeContentBlock[];
+
+            for (const block of content) {
+              if (block.type === "tool_result") {
+                const toolId = block.tool_use_id ?? currentToolId;
+                const isError = block.is_error === true;
+                this.input.onNotification("item/completed", {
+                  sessionId: this.claudeSessionId,
+                  item: {
+                    id: toolId ?? id("tool"),
+                    type: "toolCall",
+                    status: isError ? "failed" : "completed",
+                    output: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+                    aggregatedOutput: typeof block.content === "string" ? block.content : undefined,
+                    isError,
+                  },
+                });
+              }
+            }
+            break;
+          }
+
+          case "result": {
+            // Turn complete
+            const isError = event.subtype === "error" || event.is_error === true;
+            this.input.onNotification("turn/completed", {
+              sessionId: this.claudeSessionId,
+              stopReason: event.stop_reason ?? (isError ? "error" : "end_turn"),
+              durationMs: event.duration_ms,
+              totalCostUsd: event.total_cost_usd,
+              usage: event.usage,
+              isError,
+            });
+            finish(null, { sessionId: this.claudeSessionId, status: isError ? "error" : "completed" });
+            break;
+          }
+        }
+      });
+
+      child.stderr.on("data", (chunk: Buffer) => {
+        const trimmed = chunk.toString().trim();
+        if (trimmed) process.stderr.write(`[claude:stderr] ${trimmed}\n`);
+      });
+
+      child.on("error", (err) => {
+        finish(err, undefined);
+      });
+
+      child.on("exit", (code, signal) => {
+        if (!settled) {
+          finish(
+            new Error(`Claude exited unexpectedly (code=${code ?? "null"}, signal=${signal ?? "null"})`),
+            undefined,
+          );
+        }
+      });
+    });
+  }
+
+  cancel(input: { sessionId?: string; turnId?: string }): void {
+    this.pendingCancel = true;
+    if (this.child && !this.child.killed) {
+      this.child.kill("SIGTERM");
+    }
+    this.child = undefined;
+  }
+
+  respondPermission(input: { sessionId?: string; requestId: string; outcome: "allow" | "deny"; optionId?: string }): void {
+    // In bypassPermissions mode, permission requests don't occur.
+    // If we later switch to hook-based permissions, we'd send the response via a hook.
+  }
+
+  async listSessions(): Promise<unknown> {
+    const home = homedir();
+    const projectDir = join(home, ".claude", "projects", projectHash(this.input.cwd));
+
+    if (!existsSync(projectDir)) {
+      return { sessions: [] };
+    }
+
+    const sessions: Array<{ id: string; cwd: string; lastModified: number }> = [];
+    try {
+      for (const entry of readdirSync(projectDir)) {
+        if (entry.endsWith(".jsonl")) {
+          const sessionId = entry.replace(".jsonl", "");
+          sessions.push({
+            id: sessionId,
+            cwd: this.input.cwd,
+            lastModified: 0, // would need fs.statSync for accurate time
+          });
+        }
+      }
+    } catch {
+      // directory read failed
+    }
+
+    return { sessions };
+  }
+
+  stop(): void {
+    if (this.child && !this.child.killed) {
+      this.child.kill("SIGTERM");
+    }
+    this.child = undefined;
+  }
+}

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

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { existsSync } from "node:fs";
 
 export type AgentProvider = "codex" | "claude" | "custom";
-export type AgentProtocol = "acp" | "codex-app-server";
+export type AgentProtocol = "acp" | "codex-app-server" | "claude-stream-json";
 export type AgentFraming = "content-length" | "newline";
 
 export interface AgentCommandConfig {
@@ -40,9 +40,9 @@ export function resolveAgentCommand(input: {
   if (input.provider === "claude") {
     return {
       provider: "claude",
-      command: "claude --acp",
-      protocol: "acp",
-      framing: "content-length",
+      command: "claude --print --output-format stream-json --input-format stream-json --verbose --permission-mode bypassPermissions",
+      protocol: "claude-stream-json",
+      framing: "newline",
     };
   }
 
@@ -81,34 +81,9 @@ function resolveBinary(bin: string): string | null {
   return null;
 }
 
-function supportsAcpFlag(bin: string): boolean {
-  try {
-    const result = execSync(`${bin} --acp 2>&1 || true`, {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 5000,
-    });
-    // If stderr contains "unknown option", this version doesn't support --acp
-    return !result.includes("unknown option");
-  } catch {
-    // Timeout or other error — assume not supported
-    return false;
-  }
-}
-
 export function detectAvailableProviders(): AgentProvider[] {
   const available: AgentProvider[] = [];
-  const claudeBin = resolveBinary("claude");
-  if (claudeBin) {
-    if (supportsAcpFlag(claudeBin)) {
-      available.push("claude");
-    } else {
-      process.stderr.write(`[provider] Claude Code detected but --acp flag not supported (version too old?)\n`);
-    }
-  }
+  if (resolveBinary("claude")) available.push("claude");
   if (resolveBinary("codex")) available.push("codex");
-  if (available.length === 0) {
-    process.stderr.write(`[provider] no agent providers detected\n`);
-  }
   return available;
 }