linkshell-cli 0.10.42 → 0.10.44

package/src/commands/desktop-update.ts

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { ensureHostRunning, withRunningHost } from "./host.js";
+import { linkshellDir, readHostLaunch, readHostOwner, readPid, stopDaemonAndWait } from "../utils/daemon.js";
+import { standaloneBundle } from "../utils/standalone.js";
+
+type Marker = {
+  schema: 1;
+  app: string;
+  machineId: string;
+  gatewayKey?: string;
+  deviceIds: string[];
+  env: NodeJS.ProcessEnv;
+};
+const markerPath = () => join(linkshellDir(), "desktop-update.json");
+
+/** Called only after the desktop's explicit install confirmation. External hosts are left alone. */
+export async function prepareDesktopUpdate(): Promise<void> {
+  const app = standaloneBundle();
+  if (!app) throw new Error("只有独立 App 可以协调自身更新");
+  if (existsSync(markerPath())) throw new Error("上次更新尚未恢复，请先重新打开 LinkShell");
+  const pid = readPid("host");
+  if (!pid || readHostOwner(pid) !== app) return;
+  const before = await withRunningHost(async (client) => ({
+    machine: await client.call("machine.info", {}, 5000),
+    gateway: await client.call("gateway.status", {}, 5000),
+  }));
+  if (!before) throw new Error("无法确认正在运行的服务状态，更新已暂停");
+  const marker: Marker = { schema: 1, app, machineId: before.machine.machineId, gatewayKey: before.gateway.machine?.id, deviceIds: before.gateway.devices.map((d) => d.id), env: readHostLaunch(pid) };
+  mkdirSync(linkshellDir(), { recursive: true });
+  const temporary = `${markerPath()}.${process.pid}.tmp`;
+  writeFileSync(temporary, JSON.stringify(marker), { mode: 0o600, flag: "wx" });
+  renameSync(temporary, markerPath());
+  // Keep the recovery marker even on a failed stop; never allow bundle replacement after this fails.
+  await stopDaemonAndWait("host", 30_000, pid);
+}
+
+/** New app and canceled update both run this, using their own bundled runtime and preserved settings. */
+export async function recoverDesktopUpdate(version: string): Promise<void> {
+  if (!existsSync(markerPath())) return;
+  const marker = JSON.parse(readFileSync(markerPath(), "utf8")) as Marker;
+  const app = standaloneBundle();
+  if (!app || marker.schema !== 1 || marker.app !== app) return;
+  const pid = readPid("host");
+  if (pid && readHostOwner(pid) !== app) throw new Error("另一套安装正在运行，未自动替换该服务。请先停止它，再重试恢复。");
+  await ensureHostRunning({ ...process.env, ...marker.env, LINKSHELL_APP_BUNDLE: app });
+  const after = await withRunningHost(async (client) => ({
+    machine: await client.call("machine.info", {}, 5000),
+    gateway: await client.call("gateway.status", {}, 5000),
+  }));
+  if (!after || after.machine.hostVersion !== version) throw new Error("新版 Host 尚未就绪，请查看日志并重试恢复");
+  if (after.machine.machineId !== marker.machineId || (marker.gatewayKey && after.gateway.machine?.id !== marker.gatewayKey) || marker.deviceIds.some((id) => !after.gateway.devices.some((device) => device.id === id))) {
+    throw new Error("恢复后的身份或配对信息不一致；保留恢复记录，请查看日志");
+  }
+  unlinkSync(markerPath());
+}

package/src/commands/desktop.ts

@@ -0,0 +1,86 @@
+import { loadAuth } from "../auth.js";
+import { runLogin } from "./login.js";
+import { runLogout } from "./logout.js";
+import { joinGatewayAfterLogin, readHostConfig, writeHostConfig, refreshGateway } from "./host.js";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { realpathSync } from "node:fs";
+import { standaloneBundle } from "../utils/standalone.js";
+import { prepareDesktopUpdate, recoverDesktopUpdate } from "./desktop-update.js";
+import { sep } from "node:path";
+import { ensureHostRunning, silenceSqliteWarning, withRunningHost } from "./host.js";
+import { linkshellDir, readHostLaunch, readHostOwner, readPid, stopDaemonAndWait } from "../utils/daemon.js";
+
+export function installationSource(path: string): "homebrew" | "npm" {
+  return path.includes(`${sep}Cellar${sep}linkshell${sep}`) ? "homebrew" : "npm";
+}
+
+/** A versioned, read-only snapshot. Missing sections stay unknown, never healthy. */
+export async function desktopSnapshot(version: string) {
+  let executable = process.argv[1]!;
+  try { executable = realpathSync(executable); } catch { /* Retain the launch path for diagnosis. */ }
+  const auth = loadAuth();
+  const account = auth?.userId ? { state: "signed-in", email: auth.email, userId: auth.userId } : { state: "signed-out" };
+  const base = { account, schema: 1, cliVersion: version, home: linkshellDir(), source: standaloneBundle() ? "standalone" : installationSource(executable), executable, hostOwner: readPid("host") ? readHostOwner(readPid("host")!) ?? "external" : "none", appBundle: standaloneBundle() };
+  const result = await withRunningHost(async (client) => {
+    const machine = await client.call("machine.info", {}, 5000);
+    const [gateway, sessions] = await Promise.all([
+      client.call("gateway.status", {}, 5000),
+      client.call("sessions.list", { limit: 200 }, 5000),
+    ]);
+    return { machine, gateway, sessions: sessions.sessions, hasMoreSessions: Boolean(sessions.nextBefore) };
+  });
+  return result ? { ...base, status: "running", ...result } : { ...base, status: readPid("host") ? "unreachable" : "stopped" };
+}
+
+export async function runDesktop(version: string, action: string): Promise<void> {
+  silenceSqliteWarning();
+  try {
+    if (action.startsWith("usage-")) {
+      const match = /^usage-(1|7|30)-(all|codex|claude)$/.exec(action);
+      if (!match) throw new Error("无效的用量筛选条件");
+      const result = await withRunningHost(client => client.call("usage.summary", { days: Number(match[1]) as 1 | 7 | 30, agent: match[2] as "all" | "codex" | "claude" }, 120_000));
+      if (!result) throw new Error("请先启动本机服务");
+      process.stdout.write(`${JSON.stringify(result)}\n`);
+      return;
+    }
+    if (action === "login") {
+      const result = await runLogin();
+      if (!result) throw new Error("登录未完成或已超时，请重试。");
+      await joinGatewayAfterLogin(result.plan);
+    }
+    else if (action === "logout") await runLogout();
+    else if (action === "connect-gateway") {
+      if (!loadAuth()?.userId) throw new Error("请先登录账号。");
+      if (process.env.LINKSHELL_GATEWAY) throw new Error("网关由启动环境指定，请移除 LINKSHELL_GATEWAY 后重新打开 App。");
+      const config = readHostConfig(linkshellDir());
+      delete config.gateway;
+      writeHostConfig(linkshellDir(), config);
+      await ensureHostRunning();
+      await refreshGateway(15_000);
+    }
+    else if (action === "prepare-update") { await prepareDesktopUpdate(); }
+    else if (action === "recover-update") { await recoverDesktopUpdate(version); }
+    else if (action === "start") await ensureHostRunning();
+    else if (action === "stop" || action === "restart") {
+      const pid = readPid("host");
+      const env = { ...process.env, ...(pid ? readHostLaunch(pid) : {}) };
+      await stopDaemonAndWait("host", 30_000, pid ?? undefined);
+      if (action === "restart") await ensureHostRunning(env);
+    } else if (action !== "snapshot") throw new Error("Unknown desktop action");
+    process.stdout.write(`${JSON.stringify(await desktopSnapshot(version))}\n`);
+  } catch (error) {
+    process.stdout.write(`${JSON.stringify({ schema: 1, status: "unknown", error: error instanceof Error ? error.message : String(error) })}\n`);
+    process.exitCode = 1;
+  }
+}
+
+export async function openDesktop(): Promise<void> {
+  if (process.platform !== "darwin") throw new Error("LinkShell.app is available on macOS only");
+  silenceSqliteWarning();
+  const { shippedApp } = await import("@linkshell/host");
+  const app = shippedApp();
+  if (!app) throw new Error("LinkShell.app is missing; reinstall linkshell-cli with optional dependencies enabled");
+  // Pass the exact Node and CLI pair: Finder's PATH need not contain the user's package manager.
+  await promisify(execFile)("/usr/bin/open", ["-n", "-a", app, "--args", "--dashboard", "--cli-node", process.execPath, ...process.execArgv.flatMap((arg) => ["--cli-arg", arg]), "--cli-script", realpathSync(process.argv[1]!), "--cli-path", process.env.PATH ?? "", "--home", linkshellDir()]);
+}

package/src/commands/login.ts

@@ -42,14 +42,14 @@ export async function runLogin(): Promise<LoginResult | null> {
   const hash = window.location.hash.substring(1);
   if (hash) {
     fetch('/token?' + hash, { method: 'POST' })
-      .then(() => { document.body.innerHTML = '<h2>Login successful! You can close this tab.</h2>'; })
+      .then(response => { if (!response.ok) throw new Error('Login failed'); document.body.innerHTML = '<h2>Login successful! You can close this tab.</h2>'; })
       .catch(() => { document.body.innerHTML = '<h2>Login failed. Please try again.</h2>'; });
   } else {
     // Try query params (iTool may pass tokens as query params)
     const params = window.location.search.substring(1);
     if (params) {
       fetch('/token?' + params, { method: 'POST' })
-        .then(() => { document.body.innerHTML = '<h2>Login successful! You can close this tab.</h2>'; })
+        .then(response => { if (!response.ok) throw new Error('Login failed'); document.body.innerHTML = '<h2>Login successful! You can close this tab.</h2>'; })
         .catch(() => { document.body.innerHTML = '<h2>Login failed. Please try again.</h2>'; });
     } else {
       document.body.innerHTML = '<h2>No auth data received. Please try again.</h2>';
@@ -120,10 +120,16 @@ export async function runLogin(): Promise<LoginResult | null> {
           }
         } catch {}
 
+        if (!userId) {
+          res.writeHead(401);
+          res.end("无法验证账号，请重新登录。");
+          return;
+        }
+
         const tokens: AuthTokens = {
           accessToken,
           refreshToken,
-          expiresAt: Date.now() + expiresIn * 1000,
+          expiresAt: Date.now() + (Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn : 3600) * 1000,
           userId,
           email,
         };
@@ -156,6 +162,8 @@ export async function runLogin(): Promise<LoginResult | null> {
       res.end("Not found");
     });
 
+    server.on("error", () => { clearTimeout(timeout); resolve(null); });
+
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
       if (!addr || typeof addr === "string") {

package/src/commands/upgrade.ts

@@ -1,6 +1,8 @@
 import { execFileSync, type ExecFileSyncOptionsWithStringEncoding } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { join, sep } from "node:path";
+import { standaloneBundle } from "../utils/standalone.js";
+import { linkshellDir } from "../utils/daemon.js";
 import { runUpgradeWorker, type CliCommand } from "./upgrade-worker.js";
 
 function isBrewInstall(): boolean {
@@ -34,6 +36,13 @@ async function fetchLatestVersion(): Promise<string | null> {
 }
 
 export async function runUpgrade(current: string): Promise<void> {
+  const app = standaloneBundle();
+  if (app) {
+    execFileSync("/usr/bin/open", ["-n", "-a", app, "--args", "--dashboard", "--check-updates", "--home", linkshellDir()]);
+    process.stderr.write("  已打开 LinkShell 软件更新；App、内置 CLI 和 Host 将一起更新。\n");
+    return;
+  }
+
   process.stderr.write(`\n  Current version: ${current}\n  Checking for updates...\n\n`);
   const latest = await fetchLatestVersion();
   if (!latest) {

package/src/index.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { standaloneBundle } from "./utils/standalone.js";
 import { Command, Option } from "commander";
 import { runDoctor } from "./commands/doctor.js";
 import { runSetup } from "./commands/setup.js";
@@ -10,6 +11,10 @@ import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const pkg = require("../../../package.json") as { version: string };
 
+const bundledApp = standaloneBundle();
+if (bundledApp) process.env.LINKSHELL_APP_BUNDLE = bundledApp;
+else delete process.env.LINKSHELL_APP_BUNDLE;
+
 const program = new Command();
 
 program
@@ -19,6 +24,14 @@ program
   )
   .version(pkg.version);
 
+program.command("app")
+  .description("Open the native Mac status app (included with the CLI)")
+  .action(async () => { const { openDesktop } = await import("./commands/desktop.js"); await openDesktop(); });
+
+program.command("desktop", { hidden: true })
+  .option("--action <action>", "snapshot, start, stop or restart", "snapshot")
+  .action(async (options) => { const { runDesktop } = await import("./commands/desktop.js"); await runDesktop(pkg.version, options.action); });
+
 // ── host ────────────────────────────────────────────────────────────
 
 const hostCmd = program

package/src/utils/daemon.ts

@@ -12,7 +12,7 @@ const hostLaunchFile = join(LINKSHELL_DIR, "host-launch.json");
 export function saveHostLaunch(pid: number, tcpPort?: number): void {
   const env = Object.fromEntries(HOST_ENV.flatMap((key) => process.env[key] === undefined ? [] : [[key, process.env[key]]]));
   if (tcpPort !== undefined) env.LINKSHELL_DEV_PORT = String(tcpPort);
-  writeFileSync(hostLaunchFile, `${JSON.stringify({ pid, env })}\n`, { mode: 0o600 });
+  writeFileSync(hostLaunchFile, `${JSON.stringify({ pid, env, executable: process.execPath, entry: process.argv[1], appBundle: process.env.LINKSHELL_APP_BUNDLE })}\n`, { mode: 0o600 });
 }
 
 export function readHostLaunch(pid: number): NodeJS.ProcessEnv {
@@ -26,6 +26,14 @@ export function readHostLaunch(pid: number): NodeJS.ProcessEnv {
   }
 }
 
+/** Ownership is recorded by the host itself, and is valid only for that live PID. */
+export function readHostOwner(pid: number): string | undefined {
+  try {
+    const saved = JSON.parse(readFileSync(hostLaunchFile, "utf8")) as { pid?: number; appBundle?: string };
+    return saved.pid === pid && typeof saved.appBundle === "string" ? saved.appBundle : undefined;
+  } catch { return undefined; }
+}
+
 // "bridge" is the 1.x daemon: nothing starts one any more, but `linkshell stop` still ends one left running.
 type ServiceName = "gateway" | "bridge" | "host";
 
@@ -110,7 +118,7 @@ export function spawnDaemon(service: ServiceName, args: string[], env: NodeJS.Pr
       detached: true,
       stdio: ["ignore", out, err],
       // The launching terminal's environment is the most faithful one agents can get.
-      env: { ...env, LINKSHELL_ENV_FROM_TERMINAL: "1" },
+      env: { ...env, LINKSHELL_ENV_FROM_TERMINAL: env.LINKSHELL_APP_BUNDLE ? "0" : "1" },
     },
   );
 

package/src/utils/standalone.ts

@@ -0,0 +1,13 @@
+import { existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+
+/** Only an entry point physically inside a complete app may claim app-managed updates. */
+export function standaloneBundle(entry = process.argv[1] ?? ""): string | undefined {
+  let path: string;
+  try { path = realpathSync(entry); } catch { return undefined; }
+  const marker = ".app/Contents/Resources/runtime/cli/";
+  const index = path.lastIndexOf(marker);
+  if (index < 0) return undefined;
+  const app = path.slice(0, index + 4);
+  return existsSync(join(app, "Contents/Resources/standalone.json")) && existsSync(join(app, "Contents/MacOS/node")) ? app : undefined;
+}