@dadigua/web-terminal 0.0.0-stage → 0.1.3

package/dist-server/chunk-R33XRLBM.js

@@ -0,0 +1,88 @@
+// package.json
+var package_default = {
+  name: "@dadigua/web-terminal",
+  version: "0.1.3",
+  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",
+    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"
+  },
+  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.12.0",
+  bin: {
+    "web-terminal": "bin/web-terminal.mjs"
+  },
+  files: [
+    "bin/",
+    "dist-server/",
+    "dist/",
+    "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,353 @@
+import {
+  serviceName,
+  serviceProtocol,
+  serviceVersion
+} from "./chunk-R33XRLBM.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");
+  return {
+    host: String(process.env.HOST || input.host || "127.0.0.1"),
+    port,
+    dataDir,
+    token,
+    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" }
+  } });
+  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]\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;
+  }
+  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") });
+  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-TCUYGJ4K.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/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@dadigua/web-terminal",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.3",
+  "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",
+    "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"
+  },
+  "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.12.0",
+  "bin": {
+    "web-terminal": "bin/web-terminal.mjs"
+  },
+  "files": [
+    "bin/",
+    "dist-server/",
+    "dist/",
+    "config.example.yaml",
+    "README.md",
+    "API.md"
+  ],
+  "description": "Web Terminal：共享 PTY、图片与文本附件、文件预览及 VS Code 客户端",
+  "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"
+  }
+}