@dadigua/web-terminal 0.0.0-stage → 0.1.4

package/dist-server/chunk-TD3NJESY.js

@@ -0,0 +1,90 @@
+// package.json
+var package_default = {
+  name: "@dadigua/web-terminal",
+  version: "0.1.4",
+  type: "module",
+  scripts: {
+    dev: "tsx src/server/index.ts --dev",
+    build: "tsc --noEmit && vite build && tsx scripts/build-server.ts",
+    start: "tsx src/server/index.ts",
+    test: "tsx --test tests/*.test.ts",
+    check: "tsc --noEmit",
+    "build:clients": "tsx scripts/build-clients.ts",
+    "package:vscode": "pnpm build:clients && tsx scripts/package-vscode.ts",
+    "install:vscode": "pnpm package:vscode && tsx src/cli.ts install-vscode",
+    electron: "pnpm build:clients && electron dist-clients/electron",
+    "package:electron:win": "pnpm build:clients && tsx scripts/package-electron.ts --win",
+    "package:electron:linux": "pnpm build:clients && tsx scripts/package-electron.ts --linux",
+    prepack: "pnpm build && pnpm package:vscode"
+  },
+  dependencies: {
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-serialize": "0.14.0",
+    "@xterm/headless": "6.0.0",
+    "@xterm/xterm": "^6.0.0",
+    express: "^5.1.0",
+    multer: "^2.0.2",
+    "node-pty": "^1.1.0",
+    react: "^19.2.0",
+    "react-dom": "^19.2.0",
+    sharp: "^0.34.5",
+    ws: "^8.18.3",
+    yaml: "^2.8.2"
+  },
+  devDependencies: {
+    "@types/vscode": "^1.96.0",
+    "@vscode/vsce": "^3.9.2",
+    electron: "^42.3.3",
+    "electron-builder": "^26.15.3",
+    esbuild: "^0.28.0",
+    "@types/express": "^5.0.0",
+    "@types/multer": "^2.0.0",
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^5.1.0",
+    tsx: "^4.20.6",
+    typescript: "^5.9.3",
+    vite: "^7.2.0"
+  },
+  engines: {
+    node: ">=22"
+  },
+  packageManager: "pnpm@11.28.2",
+  bin: {
+    "web-terminal": "bin/web-terminal.mjs"
+  },
+  files: [
+    "bin/",
+    "dist-server/",
+    "dist/",
+    "release/web-terminal.vsix",
+    "config.example.yaml",
+    "README.md",
+    "API.md"
+  ],
+  description: "Web Terminal\uFF1A\u5171\u4EAB PTY\u3001\u56FE\u7247\u4E0E\u6587\u672C\u9644\u4EF6\u3001\u6587\u4EF6\u9884\u89C8\u53CA VS Code \u5BA2\u6237\u7AEF",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/laopo001/web-terminal.git"
+  },
+  homepage: "https://github.com/laopo001/web-terminal#readme",
+  bugs: {
+    url: "https://github.com/laopo001/web-terminal/issues"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/shared/service.ts
+var serviceName = "@dadigua/web-terminal";
+var serviceProtocol = 1;
+var serviceVersion = package_default.version;
+
+export {
+  serviceName,
+  serviceProtocol,
+  serviceVersion
+};

package/dist-server/cli.js

@@ -0,0 +1,363 @@
+import {
+  serviceName,
+  serviceProtocol,
+  serviceVersion
+} from "./chunk-TD3NJESY.js";
+
+// src/cli.ts
+import { fileURLToPath } from "node:url";
+import { resolve as resolve3, join as join2, dirname } from "node:path";
+import { mkdir as mkdir2, rm as rm2 } from "node:fs/promises";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { parseArgs } from "node:util";
+
+// src/server/config.ts
+import { mkdirSync, readFileSync, existsSync, realpathSync, writeFileSync, chmodSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { resolve } from "node:path";
+import { randomBytes, createHash } from "node:crypto";
+import { parse } from "yaml";
+function loadConfig(defaults = {}) {
+  const configFile = resolve(process.env.WEB_TERMINAL_CONFIG || defaults.configFile || "config.yaml");
+  const raw = existsSync(configFile) ? parse(readFileSync(configFile, "utf8")) : {};
+  if (raw !== null && (typeof raw !== "object" || Array.isArray(raw))) throw new Error("config.yaml \u5FC5\u987B\u662F\u914D\u7F6E\u5BF9\u8C61");
+  const input = raw || {};
+  const dataDir = resolve(process.env.WEB_TERMINAL_DATA_DIR || input.dataDir || defaults.dataDir || ".data");
+  mkdirSync(dataDir, { recursive: true, mode: 448 });
+  const tokenFile = resolve(dataDir, "token");
+  let token = process.env.WEB_TERMINAL_TOKEN?.trim();
+  if (!token) {
+    if (!existsSync(tokenFile)) writeFileSync(tokenFile, randomBytes(32).toString("base64url") + "\n", { mode: 384, flag: "wx" });
+    chmodSync(tokenFile, 384);
+    token = readFileSync(tokenFile, "utf8").trim();
+  }
+  if (!token || token.length > 1024) throw new Error("token \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u4E14\u6700\u591A 1024 \u4E2A\u5B57\u7B26");
+  const port = Number(process.env.PORT || input.port || 3840);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("port \u65E0\u6548");
+  const uploadHome = resolve(process.env.WEB_TERMINAL_HOME || resolve(homedir(), ".web-terminal"));
+  return {
+    host: String(process.env.HOST || input.host || "127.0.0.1"),
+    port,
+    dataDir,
+    token,
+    uploadDir: resolve(input.uploadDir || defaults.uploadDir || resolve(uploadHome, "uploads")),
+    defaultCwd: realpathSync(resolve(input.defaultCwd || homedir())),
+    shell: String(input.shell || process.env.SHELL || (process.platform === "win32" ? "powershell.exe" : "/bin/bash")),
+    machineId: `${hostname()}-${createHash("sha256").update(dataDir).digest("hex").slice(0, 8)}`,
+    maxUploadBytes: 20 * 1024 * 1024
+  };
+}
+
+// src/shared/clientUrl.ts
+var defaultServerUrl = "http://localhost:3840";
+function normalizeServerUrl(input) {
+  let url;
+  try {
+    url = new URL(input.trim());
+  } catch {
+    throw new Error("\u8BF7\u8F93\u5165\u5B8C\u6574\u7684 http:// \u6216 https:// \u670D\u52A1\u5668\u5730\u5740");
+  }
+  if (!["http:", "https:"].includes(url.protocol) || !url.hostname) throw new Error("\u670D\u52A1\u5668\u5730\u5740\u53EA\u652F\u6301 HTTP \u6216 HTTPS");
+  if (url.username || url.password || url.search || url.hash) throw new Error("\u670D\u52A1\u5668\u5730\u5740\u4E0D\u80FD\u5305\u542B\u8D26\u53F7\u3001\u5BC6\u7801\u3001\u67E5\u8BE2\u53C2\u6570\u6216\u951A\u70B9\uFF1Btoken \u8BF7\u5728 Web \u767B\u5F55\u9875\u8F93\u5165");
+  if (url.pathname !== "/") throw new Error("\u8BF7\u586B\u5199\u670D\u52A1\u5668\u6839\u5730\u5740\uFF0C\u4F8B\u5982 http://localhost:3840");
+  return url.origin;
+}
+
+// src/service/manager.ts
+import { mkdir, readFile as readFile2, writeFile, rename, rm, open } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join, resolve as resolve2 } from "node:path";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { parse as parse2, stringify } from "yaml";
+
+// src/service/probe.ts
+import { connect } from "node:net";
+function isLocalServer(input) {
+  const url = new URL(normalizeServerUrl(input));
+  return url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+}
+async function portState(url, timeout) {
+  return new Promise((resolve4) => {
+    const socket = connect({ host: url.hostname.replace(/^\[|\]$/g, ""), port: Number(url.port || (url.protocol === "https:" ? 443 : 80)) });
+    const finish = (state) => {
+      socket.destroy();
+      resolve4(state);
+    };
+    socket.setTimeout(timeout, () => finish("unknown"));
+    socket.once("connect", () => finish("open"));
+    socket.once("error", (error) => finish(error.code === "ECONNREFUSED" ? "closed" : "unknown"));
+  });
+}
+async function probeService(input, timeout = 1500) {
+  const root = normalizeServerUrl(input);
+  const url = new URL(root);
+  try {
+    const response = await fetch(`${root}/health`, { signal: AbortSignal.timeout(timeout), redirect: "manual" });
+    if (!response.ok || !response.headers.get("content-type")?.includes("application/json")) {
+      await response.body?.cancel();
+      return { kind: "conflict", message: `${root} \u7AEF\u53E3\u5DF2\u6709\u670D\u52A1\uFF0C\u4F46\u6CA1\u6709\u8FD4\u56DE Web Terminal \u8EAB\u4EFD\uFF08HTTP ${response.status}\uFF09\u3002\u8BF7\u68C0\u67E5\u7AEF\u53E3\u5360\u7528\u6216\u5347\u7EA7\u65E7\u670D\u52A1\u3002` };
+    }
+    const reader = response.body.getReader();
+    let body = "";
+    try {
+      const decoder = new TextDecoder();
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        body += decoder.decode(value, { stream: true });
+        if (body.length > 8192) throw new Error("\u8EAB\u4EFD\u54CD\u5E94\u8FC7\u5927");
+      }
+      body += decoder.decode();
+    } finally {
+      await reader.cancel();
+    }
+    let identity;
+    try {
+      identity = JSON.parse(body);
+    } catch {
+      return { kind: "conflict", message: `${root} \u8FD4\u56DE\u7684\u670D\u52A1\u8EAB\u4EFD\u65E0\u6548\u3002` };
+    }
+    if (identity?.service !== serviceName || typeof identity.version !== "string" || typeof identity.instanceId !== "string" || !Number.isInteger(identity.pid) || typeof identity.managed !== "boolean") {
+      return { kind: "conflict", message: `${root} \u7AEF\u53E3\u88AB\u5176\u4ED6\u670D\u52A1\u5360\u7528\uFF0C\u672A\u542F\u52A8\u6216\u505C\u6B62\u4EFB\u4F55\u8FDB\u7A0B\u3002` };
+    }
+    if (identity.protocol !== serviceProtocol) return { kind: "incompatible", message: `Web Terminal ${identity.version} \u7684\u670D\u52A1\u534F\u8BAE\u4E0D\u517C\u5BB9\uFF0C\u8BF7\u5347\u7EA7\u670D\u52A1\u6216\u5BA2\u6237\u7AEF\u3002` };
+    return { kind: "ready", identity };
+  } catch {
+    const state = await portState(url, timeout);
+    if (state === "closed") return { kind: "stopped" };
+    if (state === "open") return { kind: "unreachable", message: `${root} \u7AEF\u53E3\u5DF2\u5360\u7528\u4F46\u8EAB\u4EFD\u68C0\u67E5\u65E0\u54CD\u5E94\uFF1B\u670D\u52A1\u53EF\u80FD\u6302\u8D77\u3002\u672A\u542F\u52A8\u5176\u4ED6\u670D\u52A1\u3002` };
+    return { kind: "unreachable", message: `\u65E0\u6CD5\u8BBF\u95EE ${root}\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u3001\u5730\u5740\u6216\u8F6C\u53D1\u914D\u7F6E\u3002` };
+  }
+}
+
+// src/service/process.ts
+import { readFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+async function processStamp(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return void 0;
+  try {
+    if (process.platform === "linux") {
+      const stat = await readFile(`/proc/${pid}/stat`, "utf8");
+      const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+      if (fields[0] === "Z") return void 0;
+      return `${(await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim()}:${fields[19]}`;
+    }
+    if (process.platform === "win32") {
+      const { stdout: stdout2 } = await execute("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}').CreationDate.ToUniversalTime().Ticks`], { timeout: 5e3, windowsHide: true });
+      return stdout2.trim() || void 0;
+    }
+    const { stdout } = await execute("ps", ["-p", String(pid), "-o", "lstart="], { timeout: 5e3 });
+    return stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+var delay = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+async function stopProcess(pid, stamp) {
+  if (await processStamp(pid) !== stamp) return;
+  process.kill(pid, "SIGTERM");
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    if (await processStamp(pid) !== stamp) return;
+    await delay(100);
+  }
+  if (await processStamp(pid) === stamp) process.kill(pid, "SIGKILL");
+  const forcedDeadline = Date.now() + 3e3;
+  while (Date.now() < forcedDeadline) {
+    if (await processStamp(pid) !== stamp) return;
+    await delay(100);
+  }
+  throw new Error("\u540E\u53F0\u8FDB\u7A0B\u672A\u80FD\u9000\u51FA\uFF0C\u8BF7\u67E5\u770B\u670D\u52A1\u65E5\u5FD7");
+}
+
+// src/service/manager.ts
+function servicePaths(url, home = process.env.WEB_TERMINAL_HOME || join(homedir2(), ".web-terminal")) {
+  if (!isLocalServer(url)) throw new Error("\u53EA\u80FD\u7BA1\u7406\u672C\u673A HTTP \u670D\u52A1\uFF1B\u8FDC\u7A0B\u5730\u5740\u8BF7\u5728\u670D\u52A1\u5668\u6240\u5728\u673A\u5668\u8FD0\u884C web-terminal");
+  const base = resolve2(home);
+  const directory = join(base, "servers", new URL(url).port || "80");
+  return { base, directory, state: join(directory, "server.yaml"), log: join(directory, "server.log"), config: join(base, "config.yaml"), lock: join(directory, "manager.lock") };
+}
+async function readState(file) {
+  try {
+    const state = parse2(await readFile2(file, "utf8"));
+    if (Number.isSafeInteger(state?.pid) && state.pid > 0 && typeof state.stamp === "string" && typeof state.instanceId === "string" && typeof state.url === "string") return state;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return void 0;
+}
+async function writeState(file, state) {
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  await writeFile(temporary, stringify(state), { mode: 384, flag: "wx" });
+  await rename(temporary, file);
+}
+async function manageService(action, options) {
+  const paths = servicePaths(options.url, options.home);
+  await mkdir(paths.directory, { recursive: true, mode: 448 });
+  const owner = { pid: process.pid, stamp: await processStamp(process.pid) };
+  if (!owner.stamp) throw new Error("\u65E0\u6CD5\u6821\u9A8C\u5F53\u524D\u8FDB\u7A0B\uFF0C\u4E0D\u80FD\u5B89\u5168\u7BA1\u7406\u540E\u53F0\u670D\u52A1");
+  const deadline = Date.now() + 2e4;
+  for (; ; ) {
+    try {
+      await writeFile(paths.lock, stringify(owner), { flag: "wx", mode: 384 });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const previous = parse2(await readFile2(paths.lock, "utf8"));
+        if (previous?.stamp && await processStamp(previous.pid) !== previous.stamp) {
+          await rm(paths.lock, { force: true });
+          continue;
+        }
+      } catch (error2) {
+        if (error2.code === "ENOENT") continue;
+      }
+      if (Date.now() >= deadline) throw new Error("\u53E6\u4E00\u4E2A\u5BA2\u6237\u7AEF\u6B63\u5728\u7BA1\u7406\u670D\u52A1\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+      await delay(150);
+    }
+  }
+  try {
+    let status = await probeService(options.url);
+    const state = await readState(paths.state);
+    const owned = state && await processStamp(state.pid) === state.stamp;
+    if (status.kind === "conflict" || status.kind === "incompatible") throw new Error(status.message);
+    if (action === "start" && status.kind === "ready") return status.identity;
+    if (status.kind === "ready" && (!owned || status.identity.instanceId !== state.instanceId || status.identity.pid !== state.pid)) {
+      throw new Error("\u8BE5 Web Terminal \u7531\u5176\u4ED6\u65B9\u5F0F\u542F\u52A8\uFF0C\u672A\u505C\u6B62\u5B83\u3002\u8BF7\u7528\u539F\u6765\u7684\u670D\u52A1\u7BA1\u7406\u5668\u91CD\u542F\uFF08\u4F8B\u5982 systemctl --user restart web-terminal.service\uFF09\u3002");
+    }
+    if (owned) await stopProcess(state.pid, state.stamp);
+    else if (status.kind === "unreachable") throw new Error(status.message);
+    await rm(paths.state, { force: true });
+    if (action === "stop") return void 0;
+    status = await probeService(options.url);
+    if (status.kind === "ready") return status.identity;
+    if (status.kind !== "stopped") throw new Error(status.message);
+    const log = await open(paths.log, "a", 384);
+    let child;
+    let failure;
+    let exited = false;
+    try {
+      const config = options.config ? resolve2(options.config) : state?.config;
+      child = spawn(process.execPath, [options.entry, "serve", "--url", options.url, "--home", paths.base, ...config ? ["--config", config] : []], {
+        detached: true,
+        stdio: ["ignore", log.fd, log.fd],
+        windowsHide: true,
+        env: { ...process.env, ELECTRON_RUN_AS_NODE: void 0 }
+      });
+      child.once("error", (error) => {
+        failure = error;
+      });
+      child.once("exit", () => {
+        exited = true;
+      });
+    } finally {
+      await log.close();
+    }
+    child.unref();
+    const started = Date.now();
+    while (Date.now() - started < 15e3) {
+      if (failure || exited) break;
+      const current = await probeService(options.url, 500);
+      const launched = await readState(paths.state);
+      if (current.kind === "ready" && launched && launched.pid === child.pid && current.identity.instanceId === launched.instanceId) return current.identity;
+      if (current.kind === "conflict" || current.kind === "incompatible") break;
+      await delay(100);
+    }
+    if (child.pid && !exited) {
+      const stamp = await processStamp(child.pid);
+      if (stamp) await stopProcess(child.pid, stamp);
+    }
+    const logReader = await open(paths.log, "r");
+    let output;
+    try {
+      const size = (await logReader.stat()).size;
+      const tail = Buffer.alloc(Math.min(size, 4e3));
+      const { bytesRead } = await logReader.read(tail, 0, tail.length, Math.max(0, size - tail.length));
+      output = tail.subarray(0, bytesRead).toString("utf8");
+    } finally {
+      await logReader.close();
+    }
+    throw new Error(`\u540E\u53F0\u542F\u52A8\u5931\u8D25\uFF1A${failure?.message || output || "\u7B49\u5F85\u670D\u52A1\u5C31\u7EEA\u8D85\u65F6"}
+\u65E5\u5FD7\uFF1A${paths.log}`);
+  } finally {
+    await rm(paths.lock, { force: true });
+  }
+}
+
+// src/cli.ts
+async function main() {
+  const { values, positionals } = parseArgs({ allowPositionals: true, options: {
+    url: { type: "string", default: defaultServerUrl },
+    home: { type: "string" },
+    config: { type: "string" },
+    version: { type: "boolean" },
+    help: { type: "boolean" },
+    vsix: { type: "string" }
+  } });
+  if (values.version) {
+    console.log(JSON.stringify({ service: serviceName, version: serviceVersion }));
+    return;
+  }
+  const action = positionals[0] || "start";
+  if (values.help) {
+    console.log("web-terminal [start|restart|stop|status] [--url http://localhost:3840] [--config /path/config.yaml] [--home /path/state]\nweb-terminal install-vscode [--vsix /path/web-terminal.vsix]\n\u5B89\u88C5\u81EA\u5E26\u63D2\u4EF6\u5230\u5DF2\u68C0\u6D4B\u5230\u7684 VS Code Stable/Insiders\uFF1BWSL \u4E0B\u540C\u65F6\u5B89\u88C5 Windows \u5BBF\u4E3B\u3002\n\u914D\u7F6E\u3001token\u3001\u8FDB\u7A0B\u72B6\u6001\u548C\u65E5\u5FD7\u9ED8\u8BA4\u4F4D\u4E8E ~/.web-terminal/\u3002\u91CD\u542F\u4F1A\u7ED3\u675F\u666E\u901A Shell \u4F1A\u8BDD\u3002");
+    return;
+  }
+  if (action === "install-vscode") {
+    const { installVSCodeExtension } = await import("./vscodeInstaller-WIM5VHDI.js");
+    await installVSCodeExtension({ vsixPath: values.vsix, onInstalled: (result) => console.log(`${result.target} \u5DF2\u5B89\u88C5 ${result.extension}`) });
+    console.log("\u8BF7\u5728\u5DF2\u6253\u5F00\u7684 VS Code \u7A97\u53E3\u8FD0\u884C Developer: Reload Window \u4EE5\u52A0\u8F7D\u63D2\u4EF6\u3002");
+    return;
+  }
+  if (values.vsix) throw new Error("--vsix \u4EC5\u7528\u4E8E install-vscode");
+  const url = normalizeServerUrl(values.url);
+  if (action === "status") {
+    console.log(JSON.stringify(await probeService(url)));
+    return;
+  }
+  if (action !== "serve") {
+    if (!["start", "restart", "stop"].includes(action)) throw new Error(`\u672A\u77E5\u547D\u4EE4\uFF1A${action}`);
+    const identity = await manageService(action, { url, entry: fileURLToPath(import.meta.url), home: values.home, config: values.config });
+    console.log(JSON.stringify({ ok: true, url, identity }));
+    return;
+  }
+  const paths = servicePaths(url, values.home);
+  await mkdir2(paths.directory, { recursive: true, mode: 448 });
+  const configFile = resolve3(values.config || process.env.WEB_TERMINAL_CONFIG || paths.config);
+  process.env.WEB_TERMINAL_CONFIG = configFile;
+  process.chdir(dirname(configFile));
+  const config = loadConfig({ dataDir: join2(paths.directory, "data"), uploadDir: join2(paths.base, "uploads") });
+  config.host = new URL(url).hostname === "localhost" ? "127.0.0.1" : new URL(url).hostname.replace(/^\[|\]$/g, "");
+  config.port = Number(new URL(url).port || 80);
+  const instanceId = randomUUID2();
+  const { createApp } = await import("./app-3OE4ER7S.js");
+  const runtime = await createApp(config, { managed: true, instanceId, staticDir: fileURLToPath(new URL("../dist/", import.meta.url)) });
+  const stamp = await processStamp(process.pid);
+  if (!stamp) throw new Error("\u65E0\u6CD5\u53D6\u5F97\u8FDB\u7A0B\u542F\u52A8\u6807\u8BC6\uFF0C\u62D2\u7EDD\u542F\u52A8\u4E0D\u53EF\u5B89\u5168\u7BA1\u7406\u7684\u540E\u53F0");
+  await new Promise((done, reject) => {
+    runtime.server.once("error", reject);
+    runtime.server.listen(config.port, config.host, done);
+  });
+  await writeState(paths.state, { pid: process.pid, stamp, instanceId, url, config: configFile });
+  console.log(`Web Terminal ${serviceVersion}: ${url}
+token \u6587\u4EF6\uFF1A${join2(config.dataDir, "token")}`);
+  let closing = false;
+  for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
+    if (closing) return;
+    closing = true;
+    void (async () => {
+      await runtime.close();
+      if ((await readState(paths.state))?.instanceId === instanceId) await rm2(paths.state, { force: true });
+    })().then(() => process.exit(0), (error) => {
+      console.error(error);
+      process.exit(1);
+    });
+  });
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/dist-server/vscodeInstaller-WIM5VHDI.js

@@ -0,0 +1,210 @@
+import {
+  serviceVersion
+} from "./chunk-TD3NJESY.js";
+
+// src/vscodeInstaller.ts
+import { execFile } from "node:child_process";
+import { access, readFile, readdir, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+var extensionId = "dadigua.web-terminal";
+var psQuote = (value) => `'${value.replaceAll("'", "''")}'`;
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findServerLauncher(root) {
+  const cliRoot = join(root, "cli/servers");
+  let recent = [];
+  try {
+    const value = JSON.parse(await readFile(join(cliRoot, "lru.json"), "utf8"));
+    if (Array.isArray(value)) recent = value.filter((item) => typeof item === "string" && !item.includes("/") && !item.includes("\\"));
+  } catch {
+  }
+  const candidates = [
+    ...(await readdir(cliRoot).catch(() => [])).map((name) => ({ name, path: join(cliRoot, name, "server") })),
+    ...(await readdir(join(root, "bin")).catch(() => [])).map((name) => ({ name, path: join(root, "bin", name) }))
+  ];
+  const available = [];
+  for (const candidate of candidates) {
+    const entry = join(candidate.path, "out/server-main.js");
+    if (!await exists(entry)) continue;
+    available.push({ ...candidate, entry, mtime: (await stat(candidate.path)).mtimeMs });
+  }
+  available.sort((a, b) => {
+    const rank = (name) => recent.includes(name) ? recent.indexOf(name) : Infinity;
+    return rank(a.name) - rank(b.name) || b.mtime - a.mtime;
+  });
+  const server = available[0];
+  if (!server) return void 0;
+  const node = join(server.path, "node");
+  return { file: await exists(node) ? node : process.execPath, args: [server.entry, "--extensions-dir", join(root, "extensions")] };
+}
+async function findCommand(command) {
+  for (const directory of (process.env.PATH || "").split(delimiter)) {
+    const candidate = resolve(directory, command);
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function isWsl() {
+  if (process.platform !== "linux") return false;
+  if (process.env.WSL_DISTRO_NAME) return true;
+  return (await readFile("/proc/version", "utf8").catch(() => "")).toLowerCase().includes("microsoft");
+}
+async function localLaunchers(options, wsl) {
+  const launchers = [];
+  for (const [channel, command, override, folder] of [
+    ["Stable", "code", options.codeCommand, ".vscode-server"],
+    ["Insiders", "code-insiders", options.codeInsidersCommand, ".vscode-server-insiders"]
+  ]) {
+    if (override) {
+      launchers.push({ label: `\u672C\u673A ${channel}`, file: override, args: [] });
+      continue;
+    }
+    if (process.platform === "linux") {
+      const defaultRoot = join(homedir(), folder);
+      const agentRoot = process.env.VSCODE_AGENT_FOLDER;
+      const root = agentRoot && agentRoot.includes("insiders") === (channel === "Insiders") ? agentRoot : defaultRoot;
+      const server = await findServerLauncher(root);
+      if (server) {
+        launchers.push({ label: `${wsl ? "WSL" : "Remote"} ${channel}`, ...server });
+        continue;
+      }
+    }
+    const file = await findCommand(command);
+    if (file && !(wsl && (file.startsWith("/mnt/") || file.includes("/remote-cli/")))) {
+      launchers.push({ label: `\u672C\u673A ${channel}`, file, args: [] });
+    }
+  }
+  return launchers;
+}
+async function invoke(launcher, args) {
+  const { stdout } = await execute(launcher.file, [...launcher.args, ...args], {
+    timeout: 6e4,
+    windowsHide: true,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  if (stdout.includes("Command is only available in WSL or inside a Visual Studio Code terminal")) {
+    throw new Error(stdout.trim());
+  }
+  return stdout;
+}
+function verifyExtension(output, version) {
+  const extension = output.split(/\r?\n/).map((line) => line.trim()).find((line) => line.toLowerCase().startsWith(`${extensionId}@`));
+  if (!extension || version && extension !== `${extensionId}@${version}`) {
+    throw new Error(`\u5B89\u88C5\u540E\u672A\u627E\u5230 ${extensionId}${version ? `@${version}` : ""}\uFF0C\u6269\u5C55\u5217\u8868\uFF1A
+${output.trim()}`);
+  }
+  return extension;
+}
+async function installWindows(vsix, wsl, version) {
+  const source = wsl ? (await execute("wslpath", ["-w", vsix])).stdout.trim() : vsix;
+  const script = `
+$ErrorActionPreference = 'Stop'
+$temporary = $null
+try {
+  Set-Location $env:SystemDrive\\
+  $vsix = ${psQuote(source)}
+  if (${wsl ? "$true" : "$false"}) {
+    $temporary = Join-Path $env:TEMP ('web-terminal-' + [guid]::NewGuid() + '.vsix')
+    Copy-Item -LiteralPath $vsix -Destination $temporary
+    $vsix = $temporary
+  }
+  $results = @()
+  $failures = @()
+  foreach ($channel in @(
+    @{ Name = 'Stable'; Command = 'code.cmd'; Folder = 'Microsoft VS Code' },
+    @{ Name = 'Insiders'; Command = 'code-insiders.cmd'; Folder = 'Microsoft VS Code Insiders' }
+  )) {
+    $command = (Get-Command $channel.Command -ErrorAction SilentlyContinue | Select-Object -First 1).Source
+    if (-not $command) {
+      foreach ($base in @((Join-Path $env:LOCALAPPDATA 'Programs'), $env:ProgramFiles, [Environment]::GetEnvironmentVariable('ProgramFiles(x86)'))) {
+        if (-not $base) { continue }
+        $candidate = Join-Path $base ($channel.Folder + '\\bin\\' + $channel.Command)
+        if (Test-Path -LiteralPath $candidate) { $command = $candidate; break }
+      }
+    }
+    if (-not $command) { continue }
+    try {
+      & $command --install-extension $vsix --force | Out-Host
+      if ($LASTEXITCODE -ne 0) { throw ('\u5B89\u88C5\u547D\u4EE4\u9000\u51FA\u7801\uFF1A' + $LASTEXITCODE) }
+      $extensions = & $command --list-extensions --show-versions
+      if ($LASTEXITCODE -ne 0) { throw ('\u6269\u5C55\u5217\u8868\u547D\u4EE4\u9000\u51FA\u7801\uFF1A' + $LASTEXITCODE) }
+      $match = $extensions | Where-Object { $_ -like '${extensionId}@*' } | Select-Object -First 1
+      if (-not $match${version ? ` -or $match -ne ${psQuote(`${extensionId}@${version}`)}` : ""}) { throw '\u5B89\u88C5\u540E\u672A\u627E\u5230\u6307\u5B9A\u7248\u672C\u7684 Web Terminal \u6269\u5C55' }
+      $results += @{ target = ('Windows ' + $channel.Name); extension = $match }
+    } catch { $failures += ('Windows ' + $channel.Name + ': ' + $_.Exception.Message) }
+  }
+  Write-Output ('WEB_TERMINAL_INSTALL::' + (ConvertTo-Json -Compress -Depth 4 -InputObject @{ installed = @($results); failures = @($failures) }))
+} catch { Write-Error $_ -ErrorAction Continue; exit 1 }
+finally { if ($temporary) { Remove-Item -LiteralPath $temporary -Force -ErrorAction SilentlyContinue } }
+`;
+  const powershell = wsl ? "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe" : "powershell.exe";
+  const { stdout } = await execute(powershell, ["-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64")], {
+    timeout: 18e4,
+    windowsHide: true,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  const marker = stdout.split(/\r?\n/).find((line) => line.startsWith("WEB_TERMINAL_INSTALL::"));
+  if (!marker) throw new Error(`Windows \u5B89\u88C5\u6CA1\u6709\u8FD4\u56DE\u9A8C\u8BC1\u7ED3\u679C\uFF1A
+${stdout.trim()}`);
+  const result = JSON.parse(marker.slice("WEB_TERMINAL_INSTALL::".length));
+  for (const installed of result.installed) verifyExtension(installed.extension, version);
+  if (result.failures.length) throw new Error([...result.installed.map((item) => `${item.target} \u5DF2\u5B89\u88C5 ${item.extension}`), ...result.failures].join("\n"));
+  return result.installed;
+}
+async function installVSCodeExtension(options = {}) {
+  const path = options.vsixPath ? resolve(options.vsixPath) : fileURLToPath(new URL("../release/web-terminal.vsix", import.meta.url));
+  if (!await exists(path)) throw new Error(`\u672A\u627E\u5230 VSIX\uFF1A${path}\u3002\u672C\u5730\u5F00\u53D1\u8BF7\u8FD0\u884C pnpm package:vscode\uFF0C\u6216\u7528 --vsix \u6307\u5B9A\u6587\u4EF6\u3002`);
+  const version = options.vsixPath ? void 0 : serviceVersion;
+  const wsl = await isWsl();
+  const installed = [];
+  const failures = [];
+  const record = (result) => {
+    installed.push(result);
+    options.onInstalled?.(result);
+  };
+  if (process.platform !== "win32") {
+    for (const launcher of await localLaunchers(options, wsl)) {
+      try {
+        await invoke(launcher, ["--install-extension", path, "--force"]);
+        const extension = verifyExtension(await invoke(launcher, ["--list-extensions", "--show-versions"]), version);
+        record({ target: launcher.label, extension });
+      } catch (error) {
+        failures.push(`${launcher.label}\uFF1A${errorDetail(error)}`);
+      }
+    }
+  }
+  if (process.platform === "win32" || (options.installWindowsHost ?? wsl)) {
+    try {
+      for (const result of await installWindows(path, wsl, version)) record(result);
+    } catch (error) {
+      failures.push(errorDetail(error));
+    }
+  }
+  if (failures.length) throw new Error(`\u63D2\u4EF6\u5B89\u88C5\u672A\u5168\u90E8\u5B8C\u6210\uFF1A
+${failures.join("\n")}`);
+  if (!installed.length) throw new Error("\u672A\u627E\u5230\u53EF\u7528\u7684 VS Code\u3002\u8BF7\u5B89\u88C5 VS Code \u5E76\u5C06 code \u52A0\u5165 PATH\uFF1BWSL \u6269\u5C55\u5BBF\u4E3B\u9700\u5148\u7528 Remote WSL \u8FDE\u63A5\u4E00\u6B21\u3002");
+  return installed;
+}
+function errorDetail(error) {
+  const failure = error;
+  return [error instanceof Error ? error.message : String(error), failure.stderr?.trim(), failure.stdout?.trim()].filter(Boolean).join("\n");
+}
+export {
+  findServerLauncher,
+  installVSCodeExtension
+};