linkshell-cli 0.4.1 → 0.5.1

package/src/commands/setup.ts

@@ -16,23 +16,11 @@ function ask(
   });
 }
 
-function choose(
-  rl: readline.Interface,
-  question: string,
-  options: string[],
-  defaultIdx = 0,
-): Promise<string> {
-  return new Promise((resolve) => {
-    process.stdout.write(`  ${question}\n`);
-    for (let i = 0; i < options.length; i++) {
-      const marker = i === defaultIdx ? "\x1b[36m>\x1b[0m" : " ";
-      process.stdout.write(`  ${marker} ${i + 1}. ${options[i]}\n`);
-    }
-    rl.question(`  Choice (${defaultIdx + 1}): `, (answer) => {
-      const idx = Number(answer.trim()) - 1;
-      resolve(options[idx >= 0 && idx < options.length ? idx : defaultIdx]!);
-    });
-  });
+function defaultShell(): string {
+  if (process.platform === "win32") {
+    return process.env.COMSPEC ?? "cmd.exe";
+  }
+  return process.env.SHELL ?? "/bin/bash";
 }
 
 export async function runSetup(): Promise<void> {
@@ -49,17 +37,11 @@ export async function runSetup(): Promise<void> {
 
   const gateway = await ask(rl, "Gateway URL (leave empty for built-in)", "");
 
-  const provider = (await choose(
+  const command = await ask(
     rl,
-    "Default provider:",
-    ["claude", "codex", "gemini", "copilot", "custom"],
-    ["claude", "codex", "gemini", "copilot", "custom"].indexOf(existing.provider ?? "claude"),
-  )) as LinkShellConfig["provider"];
-
-  let command: string | undefined;
-  if (provider === "custom") {
-    command = await ask(rl, "Custom command", existing.command ?? "bash");
-  }
+    "Terminal command (the shell or CLI you want to bridge)",
+    existing.command ?? defaultShell(),
+  );
 
   const clientName = await ask(
     rl,
@@ -76,8 +58,8 @@ export async function runSetup(): Promise<void> {
 
   const config: LinkShellConfig = {
     gateway: gateway || undefined,
-    provider,
-    command,
+    provider: "custom",
+    command: command || undefined,
     clientName,
     hostname: hostnameName || undefined,
   };

package/src/index.ts

@@ -22,7 +22,7 @@ const program = new Command();
 program
   .name("linkshell")
   .description(
-    "Bridge a local Claude/Codex terminal session to a remote gateway",
+    "Bridge a local terminal session to a remote gateway. Launch any CLI (Claude/Codex/etc.) manually inside the shell.",
   )
   .version(pkg.version);
 
@@ -45,10 +45,14 @@ program
   .option("--session-id <id>", "Session identifier (auto-created if omitted)")
   .option(
     "--provider <provider>",
-    "claude | codex | gemini | copilot | custom",
-    config.provider ?? "claude",
+    "(deprecated — always custom; launch your CLI manually inside the shell)",
+    "custom",
+  )
+  .option(
+    "--command <command>",
+    "Shell or CLI to spawn in the PTY (default: $SHELL)",
+    config.command,
   )
-  .option("--command <command>", "Override provider executable", config.command)
   .option(
     "--client-name <name>",
     "Display name for this CLI",
@@ -485,12 +489,11 @@ program
       return;
     }
 
-    const provider = config.provider ?? "claude";
     const childArgs = [
       "start",
       "--_foreground-bridge",
       "--gateway", gwWsUrl,
-      "--provider", provider,
+      "--provider", "custom",
       "--client-name", config.clientName ?? "local-cli",
       "--cols", String(config.cols ?? 120),
       "--rows", String(config.rows ?? 36),
@@ -505,7 +508,7 @@ program
     daemon.saveMetadata("bridge", { keepAwake, startedAt: Date.now() });
     process.stderr.write(`\n  \x1b[32m✓\x1b[0m Bridge started in background (PID ${pid})\n`);
     process.stderr.write(`    Gateway: ${chosen.name}\n`);
-    process.stderr.write(`    Provider: ${provider}\n`);
+    process.stderr.write(`    Provider: custom (shell)\n`);
     process.stderr.write(`    Keep awake: ${keepAwake ? "enabled" : "disabled"}\n`);
     process.stderr.write(`    Desktop: enabled\n`);
     process.stderr.write(`    Agent GUI: enabled (Codex app-server)\n`);
@@ -607,7 +610,7 @@ program
     }
 
     process.stderr.write(
-      "  Connect: linkshell start --gateway <url> --provider claude\n\n",
+      "  Connect: linkshell start --gateway <url>\n\n",
     );
   });
 

package/src/providers.ts

@@ -11,6 +11,13 @@ export interface ProviderConfig {
   env: NodeJS.ProcessEnv;
 }
 
+function defaultShell(): string {
+  if (process.platform === "win32") {
+    return process.env.COMSPEC ?? "cmd.exe";
+  }
+  return process.env.SHELL ?? "/bin/bash";
+}
+
 function stripOuterQuotes(value: string): string {
   const trimmed = value.trim();
   if (
@@ -65,125 +72,26 @@ function which(bin: string): string | undefined {
   return undefined;
 }
 
-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 },
-  };
-}
-
-function resolveCodexProvider(input: {
-  command?: string;
-  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: "codex",
-    command: resolved,
-    args: input.args,
-    env: { ...process.env },
-  };
-}
-
-function resolveGeminiProvider(input: {
+export function resolveProviderConfig(input: {
+  provider?: ProviderName;
   command?: string;
   args: string[];
 }): ProviderConfig {
-  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) {
+  if (input.provider && input.provider !== "custom") {
     process.stderr.write(
-      "[warn] GOOGLE_API_KEY / GEMINI_API_KEY not set — Gemini may fail to authenticate\n",
+      `[warn] --provider=${input.provider} is no longer supported; falling back to a shell. ` +
+        `Launch your CLI manually inside the terminal (e.g. type "${input.provider}").\n`,
     );
   }
 
-  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}").`,
-    );
-  }
+  const requested = input.command?.trim();
+  const command = requested && requested.length > 0 ? requested : defaultShell();
+  const resolved = which(command) ?? command;
 
   return {
-    provider: "copilot",
+    provider: "custom",
     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/agent-workspace.ts

@@ -765,6 +765,13 @@ interface ProviderRuntimeCapabilities {
 
 const ALL_REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh"] as const;
 const ALL_PERMISSION_MODES = ["read_only", "workspace_write", "full_access"] as const;
+
+// Codex `model/list` is the source of truth — these are only used when the RPC
+// returns nothing so mobile still sees a usable picker.
+const CODEX_FALLBACK_MODELS: AgentModelOption[] = [
+  { id: "default", label: "默认模型" },
+];
+const CODEX_FALLBACK_DEFAULT_MODEL = "default";
 const CODEX_COMMAND_NAMES = ["plan", "exit-plan", "compact", "clear", "status", "review", "subagents"] as const;
 const CLAUDE_REMOTE_HIDDEN_COMMANDS = new Set([
   "add-dir",
@@ -1150,10 +1157,13 @@ function parseModelListCapabilities(value: unknown): ProviderRuntimeCapabilities
   const raw = asRecord(value);
   const modelsValue =
     Array.isArray(value) ? value :
+    Array.isArray(raw?.data) ? raw.data :
     Array.isArray(raw?.models) ? raw.models :
     Array.isArray(raw?.items) ? raw.items :
     Array.isArray(raw?.modelOptions) ? raw.modelOptions :
     [];
+  let inferredDefault: string | undefined;
+  const efforts = new Set<string>();
   const models = modelsValue
     .map((entry, index) => {
       const model = asRecord(entry);
@@ -1162,24 +1172,44 @@ function parseModelListCapabilities(value: unknown): ProviderRuntimeCapabilities
           ? { id: entry, label: entry }
           : undefined;
       }
+      if (model.hidden === true) return undefined;
       const modelId = firstString(model, ["id", "model", "name", "value"]) ?? `model-${index + 1}`;
-      const label = firstString(model, ["label", "title", "displayName", "name"]) ?? modelId;
+      const label = firstString(model, ["displayName", "label", "title", "name"]) ?? modelId;
+      if (model.isDefault === true && !inferredDefault) inferredDefault = modelId;
+      const supported = Array.isArray(model.supportedReasoningEfforts) ? model.supportedReasoningEfforts : [];
+      for (const item of supported) {
+        const effort = typeof item === "string"
+          ? item
+          : firstString(asRecord(item), ["reasoningEffort", "id", "value"]);
+        if (effort && ALL_REASONING_EFFORTS.includes(effort as typeof ALL_REASONING_EFFORTS[number])) {
+          efforts.add(effort);
+        }
+      }
       return { id: modelId, label };
     })
     .filter((entry): entry is AgentModelOption => Boolean(entry));
   const defaultModel =
     firstString(raw, ["defaultModel", "default_model", "currentModel"]) ??
-    firstString(asRecord(raw?.defaults), ["model"]);
-  const effortsValue =
+    firstString(asRecord(raw?.defaults), ["model"]) ??
+    inferredDefault;
+  const explicitEffortsValue =
     Array.isArray(raw?.reasoningEfforts) ? raw.reasoningEfforts :
     Array.isArray(raw?.reasoning_efforts) ? raw.reasoning_efforts :
     Array.isArray(raw?.efforts) ? raw.efforts :
     undefined;
-  const reasoningEfforts = effortsValue
-    ?.filter((entry): entry is string => typeof entry === "string" && ALL_REASONING_EFFORTS.includes(entry as typeof ALL_REASONING_EFFORTS[number]));
+  if (explicitEffortsValue) {
+    for (const item of explicitEffortsValue) {
+      if (typeof item === "string" && ALL_REASONING_EFFORTS.includes(item as typeof ALL_REASONING_EFFORTS[number])) {
+        efforts.add(item);
+      }
+    }
+  }
+  const reasoningEfforts = efforts.size
+    ? ALL_REASONING_EFFORTS.filter((effort) => efforts.has(effort))
+    : undefined;
   if (models.length === 0 && !defaultModel && !reasoningEfforts?.length) return undefined;
   return {
-    ...(models.length > 0 ? { models: [{ id: "default", label: "默认模型" }, ...models] } : {}),
+    ...(models.length > 0 ? { models } : {}),
     ...(defaultModel ? { defaultModel } : {}),
     ...(reasoningEfforts?.length ? { reasoningEfforts } : {}),
   };
@@ -1300,6 +1330,7 @@ export class AgentWorkspaceProxy {
       }
       case "agent.v2.snapshot.request": {
         const payload = parseTypedPayload("agent.v2.snapshot.request", envelope.payload);
+        await this.syncProviderSessions();
         this.sendSnapshot(payload.conversationId);
         break;
       }
@@ -1465,16 +1496,36 @@ export class AgentWorkspaceProxy {
   ): Promise<void> {
     if (client instanceof AcpClient && protocol !== "codex-app-server") return;
     const listModels = (client as { listModels?: () => Promise<unknown> }).listModels;
-    if (typeof listModels !== "function") return;
-    try {
-      const result = await listModels.call(client);
-      const runtimeCapabilities = parseModelListCapabilities(result);
-      if (runtimeCapabilities) this.providerCapabilities.set(provider, runtimeCapabilities);
-    } catch (error) {
-      if (this.input.verbose) {
-        process.stderr.write(`[agent:v2] model/list failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+    let runtimeCapabilities: ProviderRuntimeCapabilities | undefined;
+    if (typeof listModels === "function") {
+      try {
+        const result = await listModels.call(client);
+        runtimeCapabilities = parseModelListCapabilities(result);
+      } catch (error) {
+        if (this.input.verbose) {
+          process.stderr.write(`[agent:v2] model/list failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
       }
     }
+    if (provider === "codex") {
+      // Codex `model/list` is unreliable across versions — make sure mobile always
+      // sees a usable model picker by merging in a static fallback list.
+      const merged: ProviderRuntimeCapabilities = {
+        models: runtimeCapabilities?.models?.length
+          ? runtimeCapabilities.models
+          : [...CODEX_FALLBACK_MODELS],
+        defaultModel: runtimeCapabilities?.defaultModel ?? CODEX_FALLBACK_DEFAULT_MODEL,
+        reasoningEfforts: runtimeCapabilities?.reasoningEfforts?.length
+          ? runtimeCapabilities.reasoningEfforts
+          : [...ALL_REASONING_EFFORTS],
+        commands: runtimeCapabilities?.commands,
+        modes: runtimeCapabilities?.modes,
+        currentMode: runtimeCapabilities?.currentMode,
+      };
+      this.providerCapabilities.set(provider, merged);
+      return;
+    }
+    if (runtimeCapabilities) this.providerCapabilities.set(provider, runtimeCapabilities);
   }
 
   private async syncProviderSessions(): Promise<void> {