linkshell-cli 0.3.28 → 0.3.29

package/src/providers.ts

@@ -1,7 +1,8 @@
 import { accessSync, constants, existsSync } from "node:fs";
-import { basename, delimiter, join } from "node:path";
+import { delimiter, join } from "node:path";
+import type { TerminalProvider } from "@linkshell/protocol";
 
-export type ProviderName = "shell";
+export type ProviderName = TerminalProvider;
 
 export interface ProviderConfig {
   provider: ProviderName;
@@ -10,8 +11,6 @@ export interface ProviderConfig {
   env: NodeJS.ProcessEnv;
 }
 
-export type ShellConfig = ProviderConfig;
-
 function stripOuterQuotes(value: string): string {
   const trimmed = value.trim();
   if (
@@ -66,42 +65,125 @@ function which(bin: string): string | undefined {
   return undefined;
 }
 
-function shellSupportsLoginArg(command: string): boolean {
-  const name = basename(command).toLowerCase();
-  return ["bash", "zsh", "sh", "fish"].includes(name);
+function resolveClaudeProvider(input: {
+  command?: string;
+  args: string[];
+}): ProviderConfig {
+  const command = input.command ?? "claude";
+  const resolved = which(command);
+  if (!resolved) {
+    throw new Error(
+      `Claude CLI not found ("${command}"). Install it with: npm install -g @anthropic-ai/claude-code`,
+    );
+  }
+
+  // Claude starts an interactive REPL by default — that's exactly what we want in the PTY.
+  // Pass through any extra args the user provided.
+  return {
+    provider: "claude",
+    command: resolved,
+    args: input.args,
+    env: { ...process.env },
+  };
 }
 
-export function resolveShellConfig(input: {
+function resolveCodexProvider(input: {
   command?: string;
-  args?: string[];
-} = {}): ShellConfig {
-  const configuredShell = input.command ?? process.env.SHELL ?? (process.platform === "darwin" ? "/bin/zsh" : undefined);
-  const command = configuredShell ?? (process.platform === "win32" ? "cmd.exe" : "sh");
-  const resolved = which(command) ?? command;
-  const passthrough = input.args ?? [];
-  const args = passthrough.length > 0
-    ? passthrough
-    : shellSupportsLoginArg(resolved)
-      ? ["-l"]
-      : [];
+  args: string[];
+}): ProviderConfig {
+  const command = input.command ?? "codex";
+  const resolved = which(command);
+  if (!resolved) {
+    throw new Error(
+      `Codex CLI not found ("${command}"). Install it with: npm install -g @openai/codex`,
+    );
+  }
+
+  if (!process.env.OPENAI_API_KEY) {
+    process.stderr.write(
+      "[warn] OPENAI_API_KEY not set — Codex may fail to authenticate\n",
+    );
+  }
 
   return {
-    provider: "shell",
+    provider: "codex",
     command: resolved,
-    args,
+    args: input.args,
     env: { ...process.env },
   };
 }
 
-export function resolveProviderConfig(input: {
-  provider?: string;
+function resolveGeminiProvider(input: {
   command?: string;
   args: string[];
 }): ProviderConfig {
-  if (input.provider && input.provider !== "shell") {
+  const command = input.command ?? "gemini";
+  const resolved = which(command);
+  if (!resolved) {
+    throw new Error(
+      `Gemini CLI not found ("${command}"). Install it with: npm install -g @anthropic-ai/gemini-cli or check https://github.com/anthropics/gemini-cli`,
+    );
+  }
+
+  if (!process.env.GOOGLE_API_KEY && !process.env.GEMINI_API_KEY) {
     process.stderr.write(
-      `[warn] terminal provider "${input.provider}" is ignored in protocol v2; starting the system shell instead\n`,
+      "[warn] GOOGLE_API_KEY / GEMINI_API_KEY not set — Gemini may fail to authenticate\n",
     );
   }
-  return resolveShellConfig({ command: input.command, args: input.args });
+
+  return {
+    provider: "gemini",
+    command: resolved,
+    args: input.args,
+    env: { ...process.env },
+  };
+}
+
+function resolveCopilotProvider(input: {
+  command?: string;
+  args: string[];
+}): ProviderConfig {
+  const command = input.command ?? "github-copilot";
+  const resolved = which(command);
+  if (!resolved) {
+    throw new Error(
+      `GitHub Copilot CLI not found ("${command}").`,
+    );
+  }
+
+  return {
+    provider: "copilot",
+    command: resolved,
+    args: input.args,
+    env: { ...process.env },
+  };
+}
+
+export function resolveProviderConfig(input: {
+  provider: ProviderName;
+  command?: string;
+  args: string[];
+}): ProviderConfig {
+  switch (input.provider) {
+    case "claude":
+      return resolveClaudeProvider(input);
+    case "codex":
+      return resolveCodexProvider(input);
+    case "gemini":
+      return resolveGeminiProvider(input);
+    case "copilot":
+      return resolveCopilotProvider(input);
+    case "custom": {
+      if (!input.command) {
+        throw new Error("custom provider requires --command");
+      }
+      const resolved = which(input.command);
+      return {
+        provider: "custom",
+        command: resolved ?? input.command,
+        args: input.args,
+        env: { ...process.env },
+      };
+    }
+  }
 }

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

@@ -1,5 +1,4 @@
 import { JsonRpcStdioTransport } from "./json-rpc.js";
-import { listCodexStoredSessions, type CodexStoredSession } from "./codex-sessions.js";
 import type { AgentFraming, AgentProtocol } from "./provider-resolver.js";
 
 type AgentPermissionMode = "read_only" | "workspace_write" | "full_access";
@@ -16,83 +15,6 @@ function normalizeMcpServers(value: unknown): unknown[] {
   });
 }
 
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? value as Record<string, unknown>
-    : undefined;
-}
-
-function parseTimestamp(value: unknown): number | undefined {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value > 10_000_000_000 ? value : value * 1000;
-  }
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Date.parse(value);
-    return Number.isNaN(parsed) ? undefined : parsed;
-  }
-  return undefined;
-}
-
-function firstString(record: Record<string, unknown>, keys: string[]): string | undefined {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim()) return value;
-  }
-  return undefined;
-}
-
-function remoteSessionEntries(value: unknown): unknown[] {
-  const raw = asRecord(value);
-  return Array.isArray(value) ? value :
-    Array.isArray(raw?.data) ? raw.data :
-    Array.isArray(raw?.threads) ? raw.threads :
-    Array.isArray(raw?.sessions) ? raw.sessions :
-    Array.isArray(raw?.items) ? raw.items :
-    [];
-}
-
-function normalizeRemoteSession(entry: unknown, fallback?: CodexStoredSession): CodexStoredSession | undefined {
-  if (typeof entry === "string" && entry.trim()) {
-    return fallback ?? { id: entry, cwd: "", lastModified: Date.now() };
-  }
-  const session = asRecord(entry);
-  if (!session) return fallback;
-  const nestedThread = asRecord(session.thread);
-  const source = nestedThread ?? session;
-  const id = firstString(source, ["id", "threadId", "sessionId", "agentSessionId"]) ?? fallback?.id;
-  if (!id) return undefined;
-  return {
-    id,
-    cwd: firstString(source, ["cwd", "workingDirectory", "workspacePath"]) ?? fallback?.cwd ?? "",
-    title: firstString(source, ["title", "name", "summary", "thread_name"]) ?? fallback?.title,
-    createdAt: parseTimestamp(source.createdAt ?? source.created_at) ?? fallback?.createdAt,
-    lastModified: parseTimestamp(source.lastActivityAt ?? source.updatedAt ?? source.modifiedAt ?? source.lastModified ?? source.updated_at) ??
-      fallback?.lastModified ??
-      Date.now(),
-    archived: typeof source.archived === "boolean" ? source.archived : fallback?.archived,
-    status: firstString(source, ["status", "state", "phase"]) ?? fallback?.status,
-    runningTurnId: firstString(source, ["runningTurnId", "running_turn_id", "turnId", "activeTurnId"]) ?? fallback?.runningTurnId,
-  };
-}
-
-function mergeCodexSessionLists(remote: unknown, local: { sessions: CodexStoredSession[] }): { sessions: CodexStoredSession[] } {
-  const byId = new Map(local.sessions.map((session) => [session.id, session]));
-  for (const entry of remoteSessionEntries(remote)) {
-    const id = typeof entry === "string"
-      ? entry
-      : (() => {
-          const session = asRecord(entry);
-          const source = asRecord(session?.thread) ?? session;
-          return source ? firstString(source, ["id", "threadId", "sessionId", "agentSessionId"]) : undefined;
-        })();
-    const merged = normalizeRemoteSession(entry, id ? byId.get(id) : undefined);
-    if (merged?.id) byId.set(merged.id, merged);
-  }
-  return {
-    sessions: [...byId.values()].sort((a, b) => b.lastModified - a.lastModified),
-  };
-}
-
 function permissionsForMode(
   mode: AgentPermissionMode | undefined,
   cwd: string,
@@ -115,47 +37,9 @@ function permissionsForMode(
   };
 }
 
-function sandboxPolicyForMode(
-  mode: AgentPermissionMode | undefined,
-  cwd: string,
-): unknown | undefined {
-  if (mode === "full_access") return { type: "dangerFullAccess" };
-  if (mode === "read_only") return { type: "readOnly", networkAccess: false };
-  if (mode === "workspace_write") {
-    return {
-      type: "workspaceWrite",
-      writableRoots: [cwd],
-      networkAccess: false,
-      excludeTmpdirEnvVar: false,
-      excludeSlashTmp: false,
-    };
-  }
-  return undefined;
-}
-
-function approvalPolicyForMode(mode: AgentPermissionMode | undefined): unknown | undefined {
-  if (mode === "full_access") return "never";
-  if (mode === "read_only" || mode === "workspace_write") return "on-request";
-  return undefined;
-}
-
-function codexThreadConfig(input: {
-  cwd: string;
-  model?: string;
-  permissionMode?: AgentPermissionMode;
-}): Record<string, unknown> {
-  return {
-    cwd: input.cwd,
-    ...(input.model ? { model: input.model } : {}),
-    ...(approvalPolicyForMode(input.permissionMode) ? { approvalPolicy: approvalPolicyForMode(input.permissionMode) } : {}),
-    ...(sandboxPolicyForMode(input.permissionMode, input.cwd) ? { sandboxPolicy: sandboxPolicyForMode(input.permissionMode, input.cwd) } : {}),
-  };
-}
-
 export class AcpClient {
   private readonly transport: JsonRpcStdioTransport;
   private readonly protocol: AgentProtocol;
-  private readonly cwd: string;
 
   constructor(input: {
     command: string;
@@ -167,15 +51,12 @@ export class AcpClient {
     onExit: (message: string) => void;
   }) {
     this.protocol = input.protocol;
-    this.cwd = input.cwd;
     this.transport = new JsonRpcStdioTransport(
       input.command,
       input.framing,
       input.onNotification,
       input.onRequest,
       input.onExit,
-      undefined,
-      { includeJsonrpc: input.protocol !== "codex-app-server" },
     );
     this.transport.start(input.cwd);
   }
@@ -184,8 +65,9 @@ export class AcpClient {
     if (this.protocol === "codex-app-server") {
       const result = await this.transport.request("initialize", {
         clientInfo: { name: "LinkShell", version: "0.1" },
-        capabilities: { experimentalApi: true, optOutNotificationMethods: [] },
+        capabilities: { experimentalApi: true },
       });
+      this.transport.notify("initialized", {});
       return result;
     }
     return this.transport.request("initialize", {
@@ -198,9 +80,12 @@ export class AcpClient {
     });
   }
 
-  newSession(input: { cwd: string; mcpServers?: unknown; model?: string; permissionMode?: AgentPermissionMode }): Promise<unknown> {
+  newSession(input: { cwd: string; mcpServers?: unknown }): Promise<unknown> {
     if (this.protocol === "codex-app-server") {
-      return this.transport.request("thread/start", codexThreadConfig(input));
+      return this.transport.request("thread/start", {
+        cwd: input.cwd,
+        sessionStartSource: "startup",
+      });
     }
     return this.transport.request("session/new", {
       cwd: input.cwd,
@@ -208,11 +93,12 @@ export class AcpClient {
     });
   }
 
-  loadSession(input: { sessionId: string; cwd: string; mcpServers?: unknown; model?: string; permissionMode?: AgentPermissionMode }): Promise<unknown> {
+  loadSession(input: { sessionId: string; cwd: string; mcpServers?: unknown }): Promise<unknown> {
     if (this.protocol === "codex-app-server") {
       return this.transport.request("thread/resume", {
         threadId: input.sessionId,
-        ...codexThreadConfig(input),
+        cwd: input.cwd,
+        excludeTurns: false,
       });
     }
     return this.transport.request("session/load", {
@@ -222,15 +108,9 @@ export class AcpClient {
     });
   }
 
-  async listSessions(): Promise<unknown> {
+  listSessions(): Promise<unknown> {
     if (this.protocol === "codex-app-server") {
-      const localSessions = listCodexStoredSessions(this.cwd);
-      try {
-        const remoteSessions = await this.transport.request("thread/list", { limit: 200 });
-        return mergeCodexSessionLists(remoteSessions, localSessions);
-      } catch {
-        return localSessions;
-      }
+      return this.transport.request("thread/list", { limit: 20 });
     }
     return this.transport.request("session/list", {});
   }
@@ -242,56 +122,39 @@ export class AcpClient {
     return Promise.resolve(undefined);
   }
 
-  listTurns(input: { sessionId: string; limit?: number }): Promise<unknown> {
-    if (this.protocol === "codex-app-server") {
-      return this.transport.request("thread/turns/list", {
-        threadId: input.sessionId,
-        limit: input.limit ?? 200,
-      });
-    }
-    return Promise.resolve(undefined);
-  }
-
   prompt(input: {
     sessionId: string;
     content: unknown[];
     clientMessageId: string;
     model?: string;
     reasoningEffort?: string;
-    serviceTier?: string;
     permissionMode?: AgentPermissionMode;
     collaborationMode?: AgentCollaborationMode;
     cwd: string;
   }): Promise<unknown> {
     if (this.protocol === "codex-app-server") {
-      const collaborationMode = input.collaborationMode && input.model
+      const collaborationSettings = {
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.reasoningEffort ? { reasoning_effort: input.reasoningEffort } : {}),
+      };
+      const collaborationMode = input.collaborationMode && input.collaborationMode !== "default"
         ? {
             mode: input.collaborationMode,
-            settings: {
-              model: input.model,
-              reasoning_effort: input.reasoningEffort ?? null,
-              developer_instructions: null,
-            },
+            settings: collaborationSettings,
           }
         : undefined;
       return this.transport.request("turn/start", {
         threadId: input.sessionId,
-        cwd: input.cwd,
         model: input.model,
         effort: input.reasoningEffort,
-        ...(input.serviceTier === "fast" ? { serviceTier: input.serviceTier } : {}),
-        ...(approvalPolicyForMode(input.permissionMode) ? { approvalPolicy: approvalPolicyForMode(input.permissionMode) } : {}),
-        ...(sandboxPolicyForMode(input.permissionMode, input.cwd) ? { sandboxPolicy: sandboxPolicyForMode(input.permissionMode, input.cwd) } : {}),
-        ...(collaborationMode ? { collaborationMode } : {}),
+        permissions: permissionsForMode(input.permissionMode, input.cwd),
+        collaborationMode,
         input: input.content.map((block) => {
-          const raw = block as { type?: string; text?: string; data?: string; path?: string; name?: string };
+          const raw = block as { type?: string; text?: string; data?: string };
           if (raw.type === "image" && raw.data) {
             return { type: "image", url: raw.data };
           }
-          if (raw.type === "file" && raw.path) {
-            return { type: "mention", path: raw.path, name: raw.name };
-          }
-          return { type: "text", text: raw.text ?? "", text_elements: [] };
+          return { type: "text", text: raw.text ?? "" };
         }),
       }, null);
     }