linkshell-cli 0.2.100 → 0.2.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkshell-cli",
-  "version": "0.2.100",
+  "version": "0.2.102",
   "description": "Remote terminal bridge for Claude Code / Codex / Gemini / Copilot — control from your phone",
   "type": "module",
   "main": "dist/index.js",
@@ -29,9 +29,16 @@
     "type": "git",
     "url": "git+https://github.com/LiuTianjie/LinkShell.git"
   },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "postinstall": "node scripts/postinstall.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run"
+  },
   "dependencies": {
-    "@linkshell/gateway": "^0.2.33",
-    "@linkshell/protocol": "^0.2.28",
+    "@linkshell/gateway": "workspace:^0.2.33",
+    "@linkshell/protocol": "workspace:^0.2.28",
     "commander": "^13.1.0",
     "node-pty": "^1.0.0",
     "qrcode-terminal": "^0.12.0",
@@ -46,12 +53,5 @@
     "@types/ws": "^8.5.14",
     "tsx": "^4.19.3",
     "vitest": "^3.2.1"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "postinstall": "node scripts/postinstall.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "dev": "tsx src/index.ts",
-    "test": "vitest run"
   }
-}
+}

package/src/index.ts

@@ -81,6 +81,7 @@ program
   .option("--verbose", "Enable verbose logging")
   .option("--_foreground-bridge", undefined) // internal
   .allowUnknownOption(true)
+  .allowExcessArguments(true)
   .action(async (options, command) => {
     const daemon = await import("./utils/daemon.js");
     const keepAwake = shouldKeepAwake(options.keepAwake);

package/src/providers.ts

@@ -1,4 +1,5 @@
-import { execSync } from "node:child_process";
+import { accessSync, constants, existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
 
 export type ProviderName = "claude" | "codex" | "gemini" | "copilot" | "custom";
 
@@ -9,12 +10,58 @@ export interface ProviderConfig {
   env: NodeJS.ProcessEnv;
 }
 
-function which(bin: string): string | undefined {
+function stripOuterQuotes(value: string): string {
+  const trimmed = value.trim();
+  if (
+    (trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function canExecute(path: string): boolean {
   try {
-    return execSync(`which ${bin}`, { encoding: "utf8" }).trim() || undefined;
+    accessSync(path, constants.X_OK);
+    return true;
   } catch {
+    return process.platform === "win32" && existsSync(path);
+  }
+}
+
+function executableExtensions(bin: string): string[] {
+  if (process.platform !== "win32") return [""];
+  if (/\.[^\\/]+$/.test(bin)) return [""];
+  const pathext = process.env.PATHEXT?.split(";").filter(Boolean) ?? [];
+  return ["", ...pathext.map((ext) => ext.toLowerCase()), ...pathext.map((ext) => ext.toUpperCase())];
+}
+
+function commandHasPathSeparator(command: string): boolean {
+  return command.includes("/") || command.includes("\\");
+}
+
+function which(bin: string): string | undefined {
+  const command = stripOuterQuotes(bin);
+  if (!command) return undefined;
+  const extensions = executableExtensions(command);
+  if (commandHasPathSeparator(command)) {
+    for (const extension of extensions) {
+      const candidate = `${command}${extension}`;
+      if (canExecute(candidate)) return candidate;
+    }
     return undefined;
   }
+  const pathEntries = (process.env.PATH ?? "")
+    .split(delimiter)
+    .filter(Boolean);
+  for (const dir of pathEntries) {
+    for (const extension of extensions) {
+      const candidate = join(dir, `${command}${extension}`);
+      if (canExecute(candidate)) return candidate;
+    }
+  }
+  return undefined;
 }
 
 function resolveClaudeProvider(input: {

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

@@ -997,9 +997,11 @@ export class AgentWorkspaceProxy {
     client: AcpClient | ClaudeSdkClient | ClaudeStreamJsonClient,
     protocol: AgentProtocol,
   ): Promise<void> {
-    if (!(client instanceof AcpClient) || protocol !== "codex-app-server") return;
+    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 client.listModels();
+      const result = await listModels.call(client);
       const runtimeCapabilities = parseModelListCapabilities(result);
       if (runtimeCapabilities) this.providerCapabilities.set(provider, runtimeCapabilities);
     } catch (error) {
@@ -1781,10 +1783,11 @@ export class AgentWorkspaceProxy {
     if (normalized === "reasoning" || normalized === "thinking") {
       const text = firstString(item, ["text", "content", "summary", "message"]) ??
         stringifyDefined(item.contentItems ?? item.summary);
+      if (!text?.trim()) return true;
       this.upsertItem(conversationId, {
         ...base,
         kind: "thinking",
-        text: text ?? (streaming ? "正在思考" : "完成思考"),
+        text,
       });
       return true;
     }

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

@@ -1,6 +1,6 @@
 import { homedir } from "node:os";
 import { readdirSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import type { AgentFraming, AgentProtocol } from "./provider-resolver.js";
 
 type AgentPermissionMode = "read_only" | "workspace_write" | "full_access";
@@ -68,6 +68,29 @@ function isRealClaudeSessionId(value: string | undefined): value is string {
   return Boolean(value && !value.startsWith("agent-session-"));
 }
 
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function stringField(value: unknown, keys: string[]): string | undefined {
+  const record = asRecord(value);
+  if (!record) return undefined;
+  for (const key of keys) {
+    const candidate = record[key];
+    if (typeof candidate === "string" && candidate.trim()) return candidate;
+  }
+  return undefined;
+}
+
+function isInsideCwd(cwd: string, candidate: string): boolean {
+  const root = resolve(cwd);
+  const target = resolve(root, candidate);
+  const rel = relative(root, target);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
 function outcomeFromPermissionResponse(value: unknown): "allow" | "deny" {
   const raw = value && typeof value === "object" ? value as Record<string, unknown> : {};
   if (raw.behavior === "allow") return "allow";
@@ -158,9 +181,18 @@ export class ClaudeSdkClient {
       abortController,
       canUseTool: async (toolName: string, toolInput: unknown) => {
         if (input.permissionMode === "full_access") return { behavior: "allow" };
+        if (["Read", "Glob", "Grep", "LS", "NotebookRead", "TodoRead"].includes(toolName)) {
+          return { behavior: "allow" };
+        }
         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" && ["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" };
+          }
+        }
         const requestId = id("claude-perm");
         const response = await this.input.onRequest("claude/requestApproval", {
           requestId,
@@ -248,6 +280,19 @@ export class ClaudeSdkClient {
     return { sessions };
   }
 
+  async listModels(): Promise<unknown> {
+    return {
+      defaultModel: "default",
+      models: [
+        { id: "sonnet", label: "Sonnet" },
+        { id: "opus", label: "Opus" },
+        { id: "haiku", label: "Haiku" },
+        { id: "sonnet[1m]", label: "Sonnet 1M" },
+        { id: "opusplan", label: "Opus Plan" },
+      ],
+    };
+  }
+
   stop(): void {
     this.cancel({});
   }

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

@@ -443,6 +443,19 @@ export class ClaudeStreamJsonClient {
     return { sessions };
   }
 
+  async listModels(): Promise<unknown> {
+    return {
+      defaultModel: "default",
+      models: [
+        { id: "sonnet", label: "Sonnet" },
+        { id: "opus", label: "Opus" },
+        { id: "haiku", label: "Haiku" },
+        { id: "sonnet[1m]", label: "Sonnet 1M" },
+        { id: "opusplan", label: "Opus Plan" },
+      ],
+    };
+  }
+
   stop(): void {
     if (this.child && !this.child.killed) {
       this.child.kill("SIGTERM");