linkshell-cli 0.5.7 → 0.5.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkshell-cli",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Remote terminal bridge for Claude Code / Codex / Gemini / Copilot — control from your phone",
   "type": "module",
   "main": "dist/index.js",
@@ -11,6 +11,7 @@
     "dist",
     "src",
     "scripts",
+    "web",
     "README.md",
     "LICENSE"
   ],
@@ -35,7 +36,7 @@
     "qrcode-terminal": "^0.12.0",
     "ws": "^8.18.1",
     "zod": "^3.24.3",
-    "@linkshell/gateway": "0.4.12",
+    "@linkshell/gateway": "0.4.27",
     "@linkshell/protocol": "0.4.4"
   },
   "optionalDependencies": {
@@ -48,7 +49,7 @@
     "vitest": "^3.2.1"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node scripts/copy-web.mjs",
     "postinstall": "node scripts/postinstall.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "dev": "tsx src/index.ts",

package/scripts/copy-web.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// Copy the built web-dashboard SPA into the CLI package (packages/cli/web) so
+// it ships in the npm tarball. The CLI's embedded gateway then serves it via
+// WEB_DIST, giving LAN / self-hosted users the same in-app web console that the
+// cloud gateway Docker image bundles separately.
+//
+// Non-fatal when the web build is absent: a CLI-only `tsc` build still
+// succeeds; the embedded gateway just logs "web UI not bundled". Release builds
+// must build apps/web-dashboard FIRST so this copy has something to pick up.
+import { cpSync, existsSync, rmSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url)); // packages/cli/scripts
+const src = resolve(here, "../../../apps/web-dashboard/dist");
+const dest = resolve(here, "../web"); // packages/cli/web
+
+if (!existsSync(resolve(src, "index.html"))) {
+  console.warn(
+    `[copy-web] web-dashboard build not found at ${src} — skipping. ` +
+      `The in-app agent console will be blank for embedded-gateway users. ` +
+      `Run \`pnpm --filter @linkshell/web-dashboard build\` first.`,
+  );
+  process.exit(0);
+}
+
+try {
+  rmSync(dest, { recursive: true, force: true });
+  cpSync(src, dest, { recursive: true });
+  console.log(`[copy-web] copied ${src} -> ${dest}`);
+} catch (err) {
+  console.error(`[copy-web] failed to copy web dist: ${err}`);
+  process.exit(1);
+}

package/src/index.ts

@@ -12,10 +12,39 @@ import { getLanIp } from "./utils/lan-ip.js";
 import { shouldKeepAwake } from "./utils/keep-awake.js";
 
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { existsSync, statSync } from "node:fs";
 
 const require = createRequire(import.meta.url);
 const pkg = require("../../../package.json") as { version: string };
 
+// Locate the bundled web-dashboard SPA and point the (embedded) gateway's
+// static server at it via WEB_DIST — BEFORE any gateway module is imported,
+// because static-web.ts freezes WEB_DIST at module-load time. This is what lets
+// the in-app WebView render for LAN / self-hosted users whose CLI runs its own
+// embedded gateway (the cloud image bundles web separately). A user-set
+// WEB_DIST always wins. Probed across published-package, monorepo-compiled, and
+// dev (tsx) layouts; the first candidate containing index.html is used.
+if (!process.env.WEB_DIST) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(here, "../../../web"), // published npm package root, and packages/cli/web (compiled)
+    resolve(here, "../../../apps/web-dashboard/dist"), // dev: tsx src/index.ts in the monorepo
+  ];
+  for (const dir of candidates) {
+    try {
+      if (existsSync(resolve(dir, "index.html")) && statSync(dir).isDirectory()) {
+        process.env.WEB_DIST = dir;
+        break;
+      }
+    } catch {
+      // ignore and try the next candidate
+    }
+  }
+}
+
+
 const config = loadConfig();
 const program = new Command();
 

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

@@ -434,8 +434,19 @@ export function claudePermissionModeFor(input: {
   return "default";
 }
 
+const FALLBACK_MODEL_LABELS: Record<string, string> = {
+  default: "默认模型",
+  sonnet: "Sonnet",
+  opus: "Opus",
+  opusplan: "Opus Plan",
+  haiku: "Haiku",
+  "sonnet[1m]": "Sonnet 1M",
+  "opus[1m]": "Opus 1M",
+};
+
 export class ClaudeSdkClient {
   private query: ClaudeQuery | undefined;
+  private startup: ((params?: { options?: Record<string, unknown>; initializeTimeoutMs?: number }) => Promise<{ query(prompt: string): AsyncGenerator<unknown> & { supportedModels(): Promise<{ value: string; displayName: string }[]>; interrupt(): Promise<void> }; close(): void }>) | undefined;
   private claudeSessionId: string | undefined;
   private abortController: AbortController | undefined;
   private permissionWaiters = new Map<string, (outcome: "allow" | "deny") => void>();
@@ -461,6 +472,12 @@ export class ClaudeSdkClient {
         throw new Error("Claude Agent SDK does not export query()");
       }
       this.query = query as ClaudeQuery;
+      // startup() pre-warms the CLI subprocess so we can discover available models
+      // without starting a full conversation (via supportedModels() on the Query).
+      const startup = (mod as { startup?: unknown }).startup;
+      if (typeof startup === "function") {
+        this.startup = startup as typeof this.startup;
+      }
       return { status: "ok", protocol: "claude-agent-sdk" };
     } catch (error) {
       throw new Error(
@@ -675,27 +692,63 @@ export class ClaudeSdkClient {
 
   async listModels(): Promise<unknown> {
     let defaultModel: string = "default";
+    // Read the user's configured default model from settings.json. This is always
+    // consulted (both for live discovery and for the fallback path).
+    let availableModels: string[] | undefined;
     try {
       const settingsPath = join(homedir(), ".claude", "settings.json");
       if (existsSync(settingsPath)) {
-        const raw = JSON.parse(readFileSync(settingsPath, "utf8")) as { model?: unknown };
+        const raw = JSON.parse(readFileSync(settingsPath, "utf8")) as { model?: unknown; availableModels?: unknown };
         if (typeof raw.model === "string" && raw.model.trim().length > 0) {
           defaultModel = raw.model.trim();
         }
+        if (Array.isArray(raw.availableModels)) {
+          availableModels = raw.availableModels.filter((m): m is string => typeof m === "string");
+        }
       }
     } catch {
       // Fallback to "default" if settings file is unreadable.
     }
+
+    // Dynamic model discovery: use the Claude Agent SDK's startup() to get the
+    // REAL model list for THIS API key (different keys/tiers see different models).
+    // Falls back to settings.json availableModels → hardcoded list on any failure.
+    if (this.startup) {
+      let warm: Awaited<ReturnType<NonNullable<typeof this.startup>>> | undefined;
+      try {
+        warm = await this.startup({ initializeTimeoutMs: 10_000 });
+        const q = warm.query("");
+        try {
+          const sdkModels: { value: string; displayName: string }[] = await (q as unknown as { supportedModels(): Promise<{ value: string; displayName: string }[]> }).supportedModels();
+          if (sdkModels.length > 0) {
+            // Filter to admin-configured allowlist if present, then map to our format.
+            const allow = availableModels;
+            const filtered = allow
+              ? sdkModels.filter((m) => allow.includes(m.value) || m.value === "default")
+              : sdkModels;
+            return {
+              defaultModel,
+              models: filtered.map((m) => ({ id: m.value, label: m.displayName || m.value })),
+            };
+          }
+        } catch {
+          // supportedModels() failed — the subprocess may be in a bad state. Close it.
+        } finally {
+          try { warm.close(); } catch { /* ignore */ }
+        }
+      } catch {
+        // startup() failed — clean up if it partially succeeded.
+        try { warm?.close(); } catch { /* ignore */ }
+      }
+    }
+
+    // Fallback: admin-configured allowlist, or the full Claude Code alias set.
+    const fallbackModels = availableModels ?? [
+      "default", "sonnet", "opus", "opusplan", "haiku", "sonnet[1m]", "opus[1m]",
+    ];
     return {
       defaultModel,
-      models: [
-        { id: "default", label: "默认模型" },
-        { id: "sonnet", label: "Sonnet" },
-        { id: "opus", label: "Opus" },
-        { id: "haiku", label: "Haiku" },
-        { id: "sonnet[1m]", label: "Sonnet 1M" },
-        { id: "opusplan", label: "Opus Plan" },
-      ],
+      models: fallbackModels.map((id) => ({ id, label: FALLBACK_MODEL_LABELS[id] ?? id })),
     };
   }
 

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

@@ -574,16 +574,30 @@ export class ClaudeStreamJsonClient {
   }
 
   async listModels(): Promise<unknown> {
+    let defaultModel: string = "default";
+    let availableModels: string[] | undefined;
+    try {
+      const settingsPath = join(homedir(), ".claude", "settings.json");
+      if (existsSync(settingsPath)) {
+        const raw = JSON.parse(readFileSync(settingsPath, "utf8")) as { model?: unknown; availableModels?: unknown };
+        if (typeof raw.model === "string" && raw.model.trim().length > 0) {
+          defaultModel = raw.model.trim();
+        }
+        if (Array.isArray(raw.availableModels)) {
+          availableModels = raw.availableModels.filter((m): m is string => typeof m === "string");
+        }
+      }
+    } catch {
+      // Fallback to defaults if settings file is unreadable.
+    }
+    const ids = availableModels ?? ["default", "sonnet", "opus", "opusplan", "haiku", "sonnet[1m]", "opus[1m]"];
+    const LABELS: Record<string, string> = {
+      default: "默认模型", sonnet: "Sonnet", opus: "Opus", opusplan: "Opus Plan",
+      haiku: "Haiku", "sonnet[1m]": "Sonnet 1M", "opus[1m]": "Opus 1M",
+    };
     return {
-      defaultModel: "default",
-      models: [
-        { id: "default", label: "默认模型" },
-        { id: "sonnet", label: "Sonnet" },
-        { id: "opus", label: "Opus" },
-        { id: "haiku", label: "Haiku" },
-        { id: "sonnet[1m]", label: "Sonnet 1M" },
-        { id: "opusplan", label: "Opus Plan" },
-      ],
+      defaultModel,
+      models: ids.map((id) => ({ id, label: LABELS[id] ?? id })),
     };
   }