linkshell-cli 0.3.28 → 0.3.29

package/src/runtime/acp/claude-sdk-client.ts

@@ -1,9 +1,9 @@
-import { isAbsolute, relative, resolve } from "node:path";
-import { listClaudeStoredSessions } from "./claude-sessions.js";
+import { homedir } from "node:os";
+import { readdirSync, existsSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import type { AgentFraming, AgentProtocol } from "./provider-resolver.js";
 
 type AgentPermissionMode = "read_only" | "workspace_write" | "full_access";
-type AgentCollaborationMode = "default" | "plan";
 
 interface ClaudeContentBlock {
   type?: string;
@@ -37,13 +37,21 @@ type AgentInputContentBlock = {
   text?: string;
   data?: string;
   mimeType?: string;
-  path?: string;
 };
 
 function id(prefix: string): string {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
+function projectHash(cwd: string): string {
+  return (
+    "-" +
+    resolve(cwd)
+      .replace(/\/$/, "")
+      .replace(/\//g, "-")
+  );
+}
+
 function extractToolResultText(content: unknown): string {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -86,9 +94,6 @@ function toClaudeMessageContent(blocks: AgentInputContentBlock[]): Record<string
           },
         };
       }
-      if (block.type === "file" && block.path) {
-        return { type: "text", text: block.text ?? `@${block.path}` };
-      }
       return { type: "text", text: block.text ?? "" };
     })
     .filter((block) =>
@@ -135,42 +140,6 @@ function isInsideCwd(cwd: string, candidate: string): boolean {
   return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
 }
 
-function samePath(left: string, right: string): boolean {
-  return resolve(left) === resolve(right);
-}
-
-function isClaudeFileTool(toolName: string): boolean {
-  return toolName === "Write" ||
-    toolName === "Edit" ||
-    toolName === "MultiEdit" ||
-    toolName === "NotebookEdit";
-}
-
-function filePathFromToolInput(toolInput: unknown): string | undefined {
-  return stringField(toolInput, ["file_path", "path", "notebook_path"]);
-}
-
-function fileChangeKind(toolName: string): string {
-  return toolName === "Write" ? "create" : "update";
-}
-
-function claudeEffort(value: string | undefined): "low" | "medium" | "high" | "xhigh" | undefined {
-  if (value === "low" || value === "medium" || value === "high" || value === "xhigh") return value;
-  if (value === "minimal") return "low";
-  return undefined;
-}
-
-function claudePermissionMode(
-  permissionMode: AgentPermissionMode | undefined,
-  collaborationMode: AgentCollaborationMode | undefined,
-): "default" | "acceptEdits" | "bypassPermissions" | "plan" | "dontAsk" | undefined {
-  if (collaborationMode === "plan") return "plan";
-  if (permissionMode === "full_access") return "bypassPermissions";
-  if (permissionMode === "workspace_write") return "acceptEdits";
-  if (permissionMode === "read_only") return "dontAsk";
-  return undefined;
-}
-
 function outcomeFromPermissionResponse(value: unknown): "allow" | "deny" {
   const raw = value && typeof value === "object" ? value as Record<string, unknown> : {};
   if (raw.behavior === "allow") return "allow";
@@ -228,11 +197,6 @@ export class ClaudeSdkClient {
   }
 
   async loadSession(input: { sessionId: string; cwd: string; mcpServers?: unknown }): Promise<unknown> {
-    if (!isRealClaudeSessionId(input.sessionId)) {
-      this.claudeSessionId = undefined;
-      return { sessionId: undefined, status: "ready", cwd: input.cwd };
-    }
-    this.assertResumeCwd(input.sessionId, input.cwd);
     this.claudeSessionId = input.sessionId;
     return { sessionId: input.sessionId, status: "loaded", cwd: input.cwd };
   }
@@ -244,15 +208,11 @@ export class ClaudeSdkClient {
     model?: string;
     reasoningEffort?: string;
     permissionMode?: AgentPermissionMode;
-    collaborationMode?: AgentCollaborationMode;
+    collaborationMode?: "default" | "plan";
     cwd: string;
   }): Promise<unknown> {
     if (!this.query) await this.initialize();
     if (!this.query) throw new Error("Claude Agent SDK is not initialized");
-    const resumeSessionId = isRealClaudeSessionId(input.sessionId ?? this.claudeSessionId)
-      ? input.sessionId ?? this.claudeSessionId
-      : undefined;
-    if (resumeSessionId) this.assertResumeCwd(resumeSessionId, input.cwd ?? this.input.cwd);
 
     this.abortController?.abort();
     const abortController = new AbortController();
@@ -263,7 +223,6 @@ export class ClaudeSdkClient {
     const prompt = inputBlocks
       .map((block) => {
         if (block.type === "image") return `[${block.mimeType ?? "image"} attachment]`;
-        if (block.type === "file" && block.path) return block.text ?? `@${block.path}`;
         return block.text ?? "";
       })
       .filter(Boolean)
@@ -277,11 +236,11 @@ export class ClaudeSdkClient {
         if (["Read", "Glob", "Grep", "LS", "NotebookRead", "TodoRead"].includes(toolName)) {
           return { behavior: "allow" };
         }
-        if (input.permissionMode === "read_only" && ["Write", "Edit", "MultiEdit", "NotebookEdit", "Bash"].includes(toolName)) {
+        if (input.permissionMode === "read_only" && ["Write", "Edit", "MultiEdit", "Bash"].includes(toolName)) {
           return { behavior: "deny", message: "Read-only mode is active." };
         }
-        if (input.permissionMode === "workspace_write" && isClaudeFileTool(toolName)) {
-          const filePath = filePathFromToolInput(toolInput);
+        if (input.permissionMode === "workspace_write" && ["Write", "Edit", "MultiEdit"].includes(toolName)) {
+          const filePath = stringField(toolInput, ["file_path", "path", "notebook_path"]);
           if (filePath && isInsideCwd(input.cwd ?? this.input.cwd, filePath)) {
             return { behavior: "allow" };
           }
@@ -304,15 +263,8 @@ export class ClaudeSdkClient {
       },
     };
     if (input.model) sdkOptions.model = input.model;
-    const effort = claudeEffort(input.reasoningEffort);
-    if (effort) sdkOptions.effort = effort;
-    const permissionMode = claudePermissionMode(input.permissionMode, input.collaborationMode);
-    if (permissionMode) {
-      sdkOptions.permissionMode = permissionMode;
-      if (permissionMode === "bypassPermissions") sdkOptions.allowDangerouslySkipPermissions = true;
-    }
-    if (resumeSessionId) {
-      sdkOptions.resume = resumeSessionId;
+    if (isRealClaudeSessionId(input.sessionId ?? this.claudeSessionId)) {
+      sdkOptions.resume = input.sessionId ?? this.claudeSessionId;
     }
 
     const toolNames = new Map<string, string>();
@@ -381,13 +333,28 @@ export class ClaudeSdkClient {
   }
 
   async listSessions(): Promise<unknown> {
-    return listClaudeStoredSessions(this.input.cwd);
+    const projectDir = join(homedir(), ".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")) {
+          sessions.push({
+            id: entry.replace(".jsonl", ""),
+            cwd: this.input.cwd,
+            lastModified: 0,
+          });
+        }
+      }
+    } catch {
+      // Ignore unreadable Claude project storage.
+    }
+    return { sessions };
   }
 
   async listModels(): Promise<unknown> {
     return {
       defaultModel: "default",
-      reasoningEfforts: ["low", "medium", "high", "xhigh"],
       models: [
         { id: "sonnet", label: "Sonnet" },
         { id: "opus", label: "Opus" },
@@ -462,17 +429,10 @@ export class ClaudeSdkClient {
               sessionId: this.claudeSessionId,
               item: {
                 id: toolId,
-                type: toolName === "Bash" ? "commandExecution" : isClaudeFileTool(toolName) ? "fileChange" : "toolCall",
+                type: toolName === "Bash" ? "commandExecution" : toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit" ? "fileChange" : "toolCall",
                 toolName,
                 tool: toolName,
                 input: block.input,
-                path: isClaudeFileTool(toolName) ? filePathFromToolInput(block.input) : undefined,
-                changes: isClaudeFileTool(toolName)
-                  ? [{
-                      path: filePathFromToolInput(block.input),
-                      kind: fileChangeKind(toolName),
-                    }].filter((entry) => Boolean(entry.path))
-                  : undefined,
                 command: block.input?.command as string | undefined,
                 cwd: block.input?.cwd as string | undefined ?? state.cwd,
                 status: "running",
@@ -501,7 +461,7 @@ export class ClaudeSdkClient {
             sessionId: this.claudeSessionId,
             item: {
               id: toolId ?? id("tool"),
-              type: toolName === "Bash" ? "commandExecution" : toolName && isClaudeFileTool(toolName) ? "fileChange" : "toolCall",
+              type: "toolCall",
               toolName,
               tool: toolName,
               status: block.is_error ? "failed" : "completed",
@@ -526,12 +486,4 @@ export class ClaudeSdkClient {
       }
     }
   }
-
-  private assertResumeCwd(sessionId: string, cwd: string): void {
-    const stored = listClaudeStoredSessions(cwd).sessions.find((session) => session.id === sessionId);
-    if (!stored || samePath(stored.cwd, cwd)) return;
-    throw new Error(
-      `Claude session ${sessionId} belongs to ${stored.cwd}. Reopen that workspace or start a new Claude session from ${cwd}.`,
-    );
-  }
 }

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

@@ -1,17 +1,17 @@
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { createInterface } from "node:readline";
-import { listClaudeStoredSessions } from "./claude-sessions.js";
+import { homedir } from "node:os";
+import { readdirSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
 import type { AgentFraming, AgentProtocol } from "./provider-resolver.js";
 
 type AgentPermissionMode = "read_only" | "workspace_write" | "full_access";
-type AgentCollaborationMode = "default" | "plan";
 
 type AgentInputContentBlock = {
   type?: string;
   text?: string;
   data?: string;
   mimeType?: string;
-  path?: string;
 };
 
 interface ClaudeStreamEvent {
@@ -37,6 +37,16 @@ interface ClaudeContentBlock {
   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)}`;
 }
@@ -71,39 +81,6 @@ function splitImageDataUrl(value: string, fallbackMimeType = "image/png"): { dat
   };
 }
 
-function claudeEffort(value: string | undefined): "low" | "medium" | "high" | "xhigh" | undefined {
-  if (value === "low" || value === "medium" || value === "high" || value === "xhigh") return value;
-  if (value === "minimal") return "low";
-  return undefined;
-}
-
-function claudePermissionMode(
-  permissionMode: AgentPermissionMode | undefined,
-  collaborationMode: AgentCollaborationMode | undefined,
-): "default" | "acceptEdits" | "bypassPermissions" | "plan" | "dontAsk" {
-  if (collaborationMode === "plan") return "plan";
-  if (permissionMode === "full_access") return "bypassPermissions";
-  if (permissionMode === "workspace_write") return "acceptEdits";
-  if (permissionMode === "read_only") return "dontAsk";
-  return "default";
-}
-
-function isClaudeFileTool(toolName: string): boolean {
-  return toolName === "Write" ||
-    toolName === "Edit" ||
-    toolName === "MultiEdit" ||
-    toolName === "NotebookEdit";
-}
-
-function filePathFromToolInput(toolInput: Record<string, unknown> | undefined): string | undefined {
-  const filePath = toolInput?.file_path ?? toolInput?.path ?? toolInput?.notebook_path;
-  return typeof filePath === "string" && filePath.trim() ? filePath : undefined;
-}
-
-function fileChangeKind(toolName: string): string {
-  return toolName === "Write" ? "create" : "update";
-}
-
 export class ClaudeStreamJsonClient {
   private child: ChildProcessWithoutNullStreams | undefined;
   private claudeSessionId: string | undefined;
@@ -153,7 +130,7 @@ export class ClaudeStreamJsonClient {
     model?: string;
     reasoningEffort?: string;
     permissionMode?: AgentPermissionMode;
-    collaborationMode?: AgentCollaborationMode;
+    collaborationMode?: "default" | "plan";
     cwd: string;
   }): Promise<unknown> {
     if (this.child) {
@@ -168,11 +145,8 @@ export class ClaudeStreamJsonClient {
       "--output-format", "stream-json",
       "--input-format", "stream-json",
       "--verbose",
-      "--permission-mode", claudePermissionMode(input.permissionMode, input.collaborationMode),
+      "--permission-mode", "bypassPermissions",
     ];
-    if (input.permissionMode === "read_only") {
-      args.push("--disallowedTools", "Bash,Write,Edit,MultiEdit,NotebookEdit");
-    }
 
     // Use stored session for --resume (only when we have a real session ID from system.init)
     if (this.claudeSessionId) {
@@ -186,10 +160,6 @@ export class ClaudeStreamJsonClient {
     if (input.model) {
       args.push("--model", input.model);
     }
-    const effort = claudeEffort(input.reasoningEffort);
-    if (effort) {
-      args.push("--effort", effort);
-    }
 
     // Build the user message
     const contentBlocks = (input.content as AgentInputContentBlock[]).map(
@@ -198,9 +168,6 @@ export class ClaudeStreamJsonClient {
           const image = splitImageDataUrl(block.data, block.mimeType);
           return { type: "image", source: { type: "base64", media_type: image.mimeType, data: image.data } };
         }
-        if (block.type === "file" && block.path) {
-          return { type: "text", text: block.text ?? `@${block.path}` };
-        }
         return { type: "text", text: block.text ?? "" };
       },
     );
@@ -352,17 +319,10 @@ export class ClaudeStreamJsonClient {
                     sessionId: this.claudeSessionId,
                     item: {
                       id: block.id ?? id("tool"),
-                      type: toolName === "Bash" ? "commandExecution" : isClaudeFileTool(toolName) ? "fileChange" : "toolCall",
+                      type: toolName === "Bash" ? "commandExecution" : toolName === "Write" || toolName === "Edit" ? "fileChange" : "toolCall",
                       toolName: block.name,
                       tool: block.name,
                       input: block.input,
-                      path: isClaudeFileTool(toolName) ? filePathFromToolInput(block.input) : undefined,
-                      changes: isClaudeFileTool(toolName)
-                        ? [{
-                            path: filePathFromToolInput(block.input),
-                            kind: fileChangeKind(toolName),
-                          }].filter((entry) => Boolean(entry.path))
-                        : undefined,
                       command: block.input?.command as string | undefined,
                       cwd: block.input?.cwd as string | undefined ?? cwd,
                       status: "running",
@@ -411,7 +371,7 @@ export class ClaudeStreamJsonClient {
                   sessionId: this.claudeSessionId,
                   item: {
                     id: toolId ?? id("tool"),
-                    type: toolName === "Bash" ? "commandExecution" : toolName && isClaudeFileTool(toolName) ? "fileChange" : "toolCall",
+                    type: "toolCall",
                     toolName,
                     tool: toolName,
                     status: isError ? "failed" : "completed",
@@ -514,13 +474,35 @@ export class ClaudeStreamJsonClient {
   }
 
   async listSessions(): Promise<unknown> {
-    return listClaudeStoredSessions(this.input.cwd);
+    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 };
   }
 
   async listModels(): Promise<unknown> {
     return {
       defaultModel: "default",
-      reasoningEfforts: ["low", "medium", "high", "xhigh"],
       models: [
         { id: "sonnet", label: "Sonnet" },
         { id: "opus", label: "Opus" },

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

@@ -1,33 +1,27 @@
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { AgentFraming } from "./provider-resolver.js";
 
-export interface JsonRpcRequest {
-  jsonrpc?: "2.0";
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
   id: number | string;
   method: string;
   params?: unknown;
 }
 
-export interface JsonRpcResponse {
-  jsonrpc?: "2.0";
+interface JsonRpcResponse {
+  jsonrpc: "2.0";
   id: number | string;
   result?: unknown;
   error?: { code: number; message: string; data?: unknown };
 }
 
-export interface JsonRpcNotification {
-  jsonrpc?: "2.0";
+interface JsonRpcNotification {
+  jsonrpc: "2.0";
   method: string;
   params?: unknown;
 }
 
-export type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
-
-interface JsonRpcTransportOptions {
-  includeJsonrpc?: boolean;
-  verbose?: boolean;
-  onStderrData?: (message: string) => void;
-}
+type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
 
 export class JsonRpcStdioTransport {
   private child: ChildProcessWithoutNullStreams | undefined;
@@ -48,8 +42,6 @@ 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,
-    private readonly options: JsonRpcTransportOptions = {},
   ) {}
 
   start(cwd: string): void {
@@ -65,10 +57,7 @@ export class JsonRpcStdioTransport {
     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.options.onStderrData?.(trimmed);
-      }
+      if (trimmed) process.stderr.write(`[agent:stderr] ${trimmed}\n`);
     });
     this.child.on("error", (error) => this.failAll(error.message));
     this.child.on("exit", (code, signal) => {
@@ -81,7 +70,7 @@ export class JsonRpcStdioTransport {
       return Promise.reject(new Error("ACP agent is not running"));
     }
     const id = this.nextId++;
-    const message: JsonRpcRequest = this.withJsonrpc({ id, method, params });
+    const message: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
     return new Promise((resolve, reject) => {
       const timer = timeoutMs && timeoutMs > 0
         ? setTimeout(() => {
@@ -95,11 +84,7 @@ export class JsonRpcStdioTransport {
   }
 
   notify(method: string, params?: unknown): void {
-    this.write(this.withJsonrpc({ method, params }));
-  }
-
-  send(message: JsonRpcMessage): void {
-    this.write(this.normalizeOutgoing(message));
+    this.write({ jsonrpc: "2.0", method, params });
   }
 
   stop(): void {
@@ -109,17 +94,6 @@ export class JsonRpcStdioTransport {
     this.failAll("ACP transport stopped");
   }
 
-  private normalizeOutgoing<T extends JsonRpcMessage>(message: T): T {
-    const includeJsonrpc = this.options.includeJsonrpc ?? true;
-    if (includeJsonrpc) return { jsonrpc: "2.0", ...message } as T;
-    const { jsonrpc: _jsonrpc, ...rest } = message;
-    return rest as T;
-  }
-
-  private withJsonrpc<T extends JsonRpcMessage>(message: T): T {
-    return this.normalizeOutgoing(message);
-  }
-
   private write(message: JsonRpcMessage): void {
     const raw = JSON.stringify(message);
     if (this.framing === "newline") {
@@ -159,13 +133,6 @@ export class JsonRpcStdioTransport {
     try {
       message = JSON.parse(raw) as JsonRpcMessage;
     } catch {
-      if (this.options.verbose) {
-        process.stderr.write(`[agent:rpc] ignored invalid JSON: ${raw.slice(0, 200)}\n`);
-      }
-      return;
-    }
-
-    if (this.onMessage?.(message)) {
       return;
     }
 
@@ -182,15 +149,16 @@ export class JsonRpcStdioTransport {
 
     if ("method" in message && "id" in message) {
       Promise.resolve(this.onRequest(message.method, message.params))
-        .then((result) => this.write(this.withJsonrpc({ id: message.id, result })))
+        .then((result) => this.write({ jsonrpc: "2.0", id: message.id, result }))
         .catch((error) => {
-          this.write(this.withJsonrpc({
+          this.write({
+            jsonrpc: "2.0",
             id: message.id,
             error: {
               code: -32000,
               message: error instanceof Error ? error.message : String(error),
             },
-          }));
+          });
         });
       return;
     }

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

@@ -16,34 +16,6 @@ export interface AgentCommandConfig {
   framing: AgentFraming;
 }
 
-export function resolveCodexAppServerCommands(input: {
-  command?: string;
-}): AgentCommandConfig[] {
-  const explicit = input.command?.trim();
-  if (explicit) {
-    return [{
-      provider: "codex",
-      command: explicit,
-      protocol: "codex-app-server",
-      framing: "newline",
-    }];
-  }
-  return [
-    {
-      provider: "codex",
-      command: "codex app-server --listen stdio://",
-      protocol: "codex-app-server",
-      framing: "newline",
-    },
-    {
-      provider: "codex",
-      command: "codex app-server proxy",
-      protocol: "codex-app-server",
-      framing: "newline",
-    },
-  ];
-}
-
 export function resolveAgentCommand(input: {
   provider: AgentProvider;
   command?: string;
@@ -61,7 +33,12 @@ export function resolveAgentCommand(input: {
   }
 
   if (input.provider === "codex") {
-    return resolveCodexAppServerCommands({ command: input.command })[0] ?? null;
+    return {
+      provider: "codex",
+      command: "codex app-server --listen stdio://",
+      protocol: "codex-app-server",
+      framing: "newline",
+    };
   }
 
   if (input.provider === "claude") {