@cli-remote/local 0.1.1 → 0.3.1

package/dist/index.cjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+'#!/usr/bin/env node'
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -2265,7 +2265,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes2, createHash } = require("crypto");
+    var { randomBytes: randomBytes3, createHash } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2803,7 +2803,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes2(16).toString("base64");
+      const key = randomBytes3(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -9981,6 +9981,7 @@ var ACCESS_TOKEN_TTL_MS = 60 * 6e4;
 var REFRESH_TOKEN_TTL_MS = 30 * 24 * 60 * 6e4;
 var REFRESH_MARGIN_MS = 5 * 6e4;
 var OUTPUT_BUFFER_SIZE = 500;
+var AUDIT_RETENTION_DAYS = 14;
 var FILE_CHUNK_SIZE = 64 * 1024;
 var MAX_TRANSFER_BYTES = 500 * 1024 * 1024;
 var UPLOAD_DIR = "uploads";
@@ -9991,59 +9992,6 @@ var CONFIG_FILE = "config.json";
 var LOG_DIR = "logs";
 
 // ../shared/src/whitelist.ts
-var DEFAULT_WHITELIST = [
-  "ls",
-  "cd",
-  "pwd",
-  "cat",
-  "less",
-  "head",
-  "tail",
-  "mkdir",
-  "rmdir",
-  "rm",
-  "cp",
-  "mv",
-  "touch",
-  "find",
-  "stat",
-  "tree",
-  "grep",
-  "awk",
-  "sed",
-  "sort",
-  "uniq",
-  "wc",
-  "cut",
-  "tr",
-  "xargs",
-  "git",
-  "ps",
-  "top",
-  "htop",
-  "kill",
-  "df",
-  "du",
-  "free",
-  "uname",
-  "whoami",
-  "env",
-  "echo",
-  "node",
-  "npm",
-  "pnpm",
-  "yarn",
-  "python",
-  "python3",
-  "pip",
-  "go",
-  "cargo",
-  "make",
-  "docker",
-  "claude",
-  "codex",
-  "kimi-cli"
-];
 var DANGEROUS_PATTERNS = [
   /\brm\s+-[rfRF]+\s+\/(\s|$)/,
   /\bsudo\b/,
@@ -10054,6 +10002,9 @@ var DANGEROUS_PATTERNS = [
   /\bshutdown\b/,
   /\breboot\b/
 ];
+function findDangerousPattern(line) {
+  return DANGEROUS_PATTERNS.find((p) => p.test(line));
+}
 
 // src/pty-manager.ts
 var import_node_pty = require("node-pty");
@@ -10186,20 +10137,55 @@ var PtyManager = class {
 var import_node_fs = require("node:fs");
 var import_node_os2 = require("node:os");
 var import_node_path2 = require("node:path");
+function logRoot() {
+  return (0, import_node_path2.join)((0, import_node_os2.homedir)(), DEFAULT_CONFIG_DIR, LOG_DIR);
+}
 function todayDir() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
+function pruneAuditLogs(retentionDays) {
+  if (retentionDays <= 0) return 0;
+  const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 6e4).toISOString().slice(0, 10);
+  let removed = 0;
+  let entries;
+  try {
+    entries = (0, import_node_fs.readdirSync)(logRoot());
+  } catch {
+    return 0;
+  }
+  for (const name of entries) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(name)) continue;
+    if (name >= cutoff) continue;
+    try {
+      (0, import_node_fs.rmSync)((0, import_node_path2.join)(logRoot(), name), { recursive: true, force: true });
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
 var SessionLogger = class {
-  path;
-  closed = false;
-  constructor(sessionId, cmd) {
-    const dir = (0, import_node_path2.join)((0, import_node_os2.homedir)(), DEFAULT_CONFIG_DIR, LOG_DIR, todayDir());
-    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  constructor(sessionId, cmd, mode = "full") {
+    this.mode = mode;
+    if (mode === "off") {
+      this.path = "";
+      return;
+    }
+    const dir = (0, import_node_path2.join)(logRoot(), todayDir());
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
+    try {
+      (0, import_node_fs.chmodSync)(dir, 448);
+    } catch {
+    }
     this.path = (0, import_node_path2.join)(dir, `${sessionId}.log`);
-    this.write({ ts: Date.now(), event: "spawn", cmd });
+    (0, import_node_fs.appendFileSync)(this.path, "", { mode: 384 });
+    (0, import_node_fs.chmodSync)(this.path, 384);
+    this.write({ ts: Date.now(), event: "spawn", cmd, mode });
   }
+  path;
+  closed = false;
   logInput(data) {
-    if (this.closed) return;
+    if (this.closed || this.mode === "off") return;
     this.write({
       ts: Date.now(),
       dir: "in",
@@ -10208,7 +10194,7 @@ var SessionLogger = class {
     });
   }
   logOutput(data) {
-    if (this.closed) return;
+    if (this.closed || this.mode !== "full") return;
     this.write({
       ts: Date.now(),
       dir: "out",
@@ -10217,119 +10203,40 @@ var SessionLogger = class {
     });
   }
   logRejected(cmd, reason, dangerous) {
-    if (this.closed) return;
+    if (this.closed || this.mode === "off") return;
     this.write({ ts: Date.now(), event: "rejected", cmd, reason, dangerous });
   }
   logForced(cmd) {
-    if (this.closed) return;
+    if (this.closed || this.mode === "off") return;
     this.write({ ts: Date.now(), event: "forced", cmd });
   }
   logExit(code) {
-    if (this.closed) return;
+    if (this.closed || this.mode === "off") return;
     this.write({ ts: Date.now(), event: "exit", code });
     this.closed = true;
   }
   write(record) {
+    if (!this.path) return;
     try {
-      (0, import_node_fs.appendFileSync)(this.path, JSON.stringify(record) + "\n", { encoding: "utf-8" });
+      (0, import_node_fs.appendFileSync)(this.path, JSON.stringify(record) + "\n", { encoding: "utf-8", mode: 384 });
     } catch {
     }
   }
 };
 
 // src/whitelist-checker.ts
-function splitCommands(line) {
-  const parts = [];
-  let current = "";
-  let inSingle = false;
-  let inDouble = false;
-  for (let i = 0; i < line.length; i++) {
-    const c = line[i];
-    if (c === "'" && !inDouble) {
-      inSingle = !inSingle;
-      current += c;
-      continue;
-    }
-    if (c === '"' && !inSingle) {
-      inDouble = !inDouble;
-      current += c;
-      continue;
-    }
-    if (!inSingle && !inDouble) {
-      const next = line[i + 1];
-      if (c === "&" && next === "&") {
-        parts.push(current);
-        current = "";
-        i++;
-        continue;
-      }
-      if (c === "|" && next === "|") {
-        parts.push(current);
-        current = "";
-        i++;
-        continue;
-      }
-      if (c === ";" || c === "|") {
-        parts.push(current);
-        current = "";
-        continue;
-      }
-    }
-    current += c;
-  }
-  if (current.trim()) parts.push(current);
-  return parts;
-}
-function firstToken(cmd) {
-  const trimmed = cmd.trim();
-  if (!trimmed) return null;
-  const tokens = trimmed.split(/\s+/);
-  for (const t of tokens) {
-    if (!t) continue;
-    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) continue;
-    return t;
-  }
-  return null;
-}
-function checkCommand(line, whitelist, dangerousPatterns = DANGEROUS_PATTERNS) {
+function checkCommand(line, dangerConfirm) {
   const trimmed = line.trim();
-  if (!trimmed) return { allowed: true };
-  if (line.includes("$(") || line.includes("`")) {
+  if (!trimmed || !dangerConfirm) return { allowed: true };
+  const pattern = findDangerousPattern(trimmed);
+  if (pattern) {
     return {
       allowed: false,
       rejectedCmd: trimmed,
-      reason: "\u5305\u542B\u547D\u4EE4\u66FF\u6362 ($() \u6216 `)\uFF0C\u5DF2\u88AB\u7981\u6B62"
+      reason: "\u5339\u914D\u5371\u9669\u547D\u4EE4\u6A21\u5F0F\uFF0C\u8BF7\u4E8C\u6B21\u786E\u8BA4",
+      dangerous: true
     };
   }
-  if (trimmed.startsWith("(")) {
-    return {
-      allowed: false,
-      rejectedCmd: trimmed,
-      reason: "\u5305\u542B\u5B50 shell ( )\uFF0C\u5DF2\u88AB\u7981\u6B62"
-    };
-  }
-  for (const p of dangerousPatterns) {
-    if (p.test(line)) {
-      return {
-        allowed: false,
-        rejectedCmd: trimmed,
-        reason: "\u5339\u914D\u5371\u9669\u547D\u4EE4\u6A21\u5F0F",
-        dangerous: true
-      };
-    }
-  }
-  const segments = splitCommands(line);
-  for (const seg of segments) {
-    const cmd = firstToken(seg);
-    if (!cmd) continue;
-    if (!whitelist.has(cmd)) {
-      return {
-        allowed: false,
-        rejectedCmd: cmd,
-        reason: `"${cmd}" \u4E0D\u5728\u767D\u540D\u5355`
-      };
-    }
-  }
   return { allowed: true };
 }
 
@@ -10595,9 +10502,108 @@ async function apiPost(port, path, timeoutMs = 800) {
   }
 }
 
+// src/setup-callback.ts
+var import_node_http2 = require("node:http");
+var import_node_crypto = require("node:crypto");
+var BODY_LIMIT = 64 * 1024;
+function startSetupCallback(timeoutMs = 3 * 6e4) {
+  return new Promise((resolveStart, rejectStart) => {
+    const chan = (0, import_node_crypto.randomBytes)(8).toString("hex");
+    let timer = null;
+    let settled = false;
+    let server = null;
+    const cors = {
+      "access-control-allow-origin": "*",
+      "access-control-allow-methods": "POST, OPTIONS",
+      "access-control-allow-headers": "content-type",
+      "access-control-allow-private-network": "true",
+      "access-control-max-age": "600"
+    };
+    const done = new Promise((resolve2, reject) => {
+      timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        stop();
+        reject(new Error("\u7B49\u5F85\u7F51\u9875\u56DE\u8C03\u8D85\u65F6"));
+      }, timeoutMs);
+      function stop() {
+        if (timer) clearTimeout(timer);
+        server?.close();
+      }
+      function finish(fn) {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        server?.close();
+        fn();
+      }
+      const tryPort = (port) => {
+        if (port > 18802) {
+          rejectStart(new Error("no free port for the setup callback"));
+          return;
+        }
+        const s = (0, import_node_http2.createServer)((req, res) => {
+          const reply = (code, body) => {
+            res.writeHead(code, { "content-type": "application/json", ...cors });
+            res.end(JSON.stringify(body));
+          };
+          if (req.method === "OPTIONS") {
+            reply(204, {});
+            return;
+          }
+          if (req.method !== "POST" || !req.url?.startsWith("/setup")) {
+            reply(404, { ok: false, error: "not found" });
+            return;
+          }
+          let size = 0;
+          const chunks = [];
+          req.on("data", (c) => {
+            size += c.length;
+            if (size > BODY_LIMIT) {
+              req.destroy();
+              return;
+            }
+            chunks.push(c);
+          });
+          req.on("end", () => {
+            try {
+              const body = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+              if (body.chan !== chan || !body.registrationKey) {
+                reply(400, { ok: false, error: "bad request" });
+                return;
+              }
+              reply(200, { ok: true });
+              const key = body.registrationKey;
+              finish(() => resolve2(key));
+            } catch {
+              reply(400, { ok: false, error: "bad request" });
+            }
+          });
+        });
+        s.once("error", () => {
+          s.close();
+          tryPort(port + 1);
+        });
+        s.listen(port, "127.0.0.1", () => {
+          server = s;
+          resolveStart({
+            port,
+            chan,
+            done,
+            stop: () => {
+              finish(() => reject(new Error("callback stopped")));
+            }
+          });
+        });
+      };
+      tryPort(18793);
+    });
+  });
+}
+
 // src/auth.ts
 var import_node_child_process = require("node:child_process");
-var import_node_crypto = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 var import_promises2 = require("node:fs/promises");
 var import_node_os5 = require("node:os");
 var import_node_path5 = require("node:path");
@@ -10785,7 +10791,7 @@ async function ensureMachineId() {
     if (typeof cfg.machineId === "string" && cfg.machineId) return cfg.machineId;
   } catch {
   }
-  const machineId = "m_" + (0, import_node_crypto.randomBytes)(16).toString("hex");
+  const machineId = "m_" + (0, import_node_crypto2.randomBytes)(16).toString("hex");
   await mergeLocalConfig({ machineId });
   return machineId;
 }
@@ -10816,11 +10822,16 @@ async function loadConfig() {
     return {};
   }
 }
-function buildWhitelist(cfg) {
-  const set = new Set(DEFAULT_WHITELIST);
-  cfg.whitelist?.add?.forEach((c) => set.add(c));
-  cfg.whitelist?.remove?.forEach((c) => set.delete(c));
-  return set;
+function applyConfigDeprecations(cfg) {
+  if (cfg.whitelist) {
+    console.log(
+      '[local] config "whitelist" \u5DF2\u5E9F\u5F03\uFF08v0.4\uFF09\uFF1Abash \u5168\u900F\u4F20\uFF0C\u4E0D\u518D\u6709\u767D\u540D\u5355\u3002\u5982\u9700\u5371\u9669\u547D\u4EE4\u4E8C\u6B21\u786E\u8BA4\uFF0C\u8BBE\u7F6E dangerConfirm: true'
+    );
+  }
+  if (cfg.auditMode && !["full", "commands", "off"].includes(cfg.auditMode)) {
+    console.log(`[local] \u65E0\u6548\u7684 auditMode "${cfg.auditMode}"\uFF0C\u56DE\u9000 full`);
+    cfg.auditMode = "full";
+  }
 }
 function isTTY() {
   return process.stdin.isTTY === true;
@@ -10890,19 +10901,18 @@ async function setupWizard(config, opts) {
       console.log("[local] \u5F53\u524D\u975E\u4EA4\u4E92\u7EC8\u7AEF\uFF1A\u62FF\u5230 key \u540E\u5199\u5165 ~/.cli-remote/config.json \u518D\u8FD0\u884C\u3002");
       return null;
     }
-    console.log("  1) \u767B\u5F55\u8D26\u53F7\u81EA\u52A8\u83B7\u53D6\uFF08\u63A8\u8350\uFF09");
-    console.log("  2) \u4ECE\u7F51\u9875\u300C\u63A7\u5236\u9762\u677F\u300D\u590D\u5236\u7C98\u8D34");
+    console.log("  1) \u901A\u8FC7\u7F51\u9875\u767B\u5F55\u83B7\u53D6\uFF08\u63A8\u8350\uFF0C\u81EA\u52A8\u5B8C\u6210\uFF0C\u65E0\u9700\u590D\u5236\u7C98\u8D34\uFF09");
+    console.log("  2) \u76F4\u63A5\u8F93\u5165 registrationKey");
+    console.log("  3) \u5728\u6B64\u8F93\u5165\u8D26\u53F7\u5BC6\u7801\u83B7\u53D6");
     const mode = (await readInput("\u9009\u62E9 [1]: ")).trim();
     if (mode === "2") {
-      openBrowser(base);
-      console.log(`[local] \u5DF2\u6253\u5F00\u6D4F\u89C8\u5668\uFF0C\u8BF7\u767B\u5F55 ${base} \u5E76\u5728\u300C\u63A7\u5236\u9762\u677F\u300D\u9875\u590D\u5236 registrationKey`);
       const ans = (await readInput("\u7C98\u8D34 registrationKey: ")).trim();
       if (!ans) {
         console.log("[local] \u672A\u63D0\u4F9B registrationKey\uFF0C\u9000\u51FA\u3002");
         return null;
       }
       registrationKey = ans;
-    } else {
+    } else if (mode === "3") {
       for (; ; ) {
         const email = (await readInput("\u90AE\u7BB1: ")).trim();
         const password = (await readInput("\u5BC6\u7801: ")).trim();
@@ -10920,6 +10930,26 @@ async function setupWizard(config, opts) {
           console.log("[local] \u91CD\u8BD5\uFF08\u6216 Ctrl+C \u9000\u51FA\uFF09\u3002");
         }
       }
+    } else {
+      const cb = await startSetupCallback();
+      const setupUrl = `${base}/local-setup?port=${cb.port}&chan=${cb.chan}`;
+      console.log(`[local] \u5DF2\u6253\u5F00\u6D4F\u89C8\u5668\uFF1A${setupUrl}`);
+      console.log("[local] \u672A\u767B\u5F55\u65F6\u4F1A\u5148\u8FDB\u5165\u767B\u5F55\u9875\uFF0C\u767B\u5F55\u540E\u81EA\u52A8\u7EE7\u7EED\uFF0C\u65E0\u9700\u56DE\u5230\u7EC8\u7AEF");
+      openBrowser(setupUrl);
+      try {
+        registrationKey = await cb.done;
+        console.log("[local] \u5DF2\u4ECE\u7F51\u9875\u83B7\u53D6 registrationKey");
+      } catch {
+        console.log("[local] \u672A\u6536\u5230\u7F51\u9875\u56DE\u8C03\uFF0C\u53EF\u624B\u52A8\u7C98\u8D34 registrationKey\uFF08\u56DE\u8F66\u8DF3\u8FC7\u9000\u51FA\uFF09\uFF1A");
+        const ans = (await readInput("registrationKey: ")).trim();
+        if (!ans) {
+          cb.stop();
+          console.log("[local] \u672A\u63D0\u4F9B registrationKey\uFF0C\u9000\u51FA\u3002");
+          return null;
+        }
+        registrationKey = ans;
+      }
+      cb.stop();
     }
     changed = true;
   }
@@ -10940,7 +10970,10 @@ async function startLocal(opts = {}) {
     registrationKey = setup.registrationKey;
   }
   const baseUrl = baseUrlFromWsUrl(url);
-  const whitelist = buildWhitelist(config);
+  applyConfigDeprecations(config);
+  const dangerConfirm = config.dangerConfirm === true;
+  const auditMode = config.auditMode ?? "full";
+  const retentionDays = config.auditRetentionDays ?? AUDIT_RETENTION_DAYS;
   const pty = new PtyManager();
   const loggers = /* @__PURE__ */ new Map();
   const lineBuffers = /* @__PURE__ */ new Map();
@@ -10984,8 +11017,15 @@ async function startLocal(opts = {}) {
   const commands = detectCommands();
   console.log(`[local] connecting to ${url}`);
   console.log(`[local] deviceId=${credentials.deviceId || "(\u672A\u6388\u6743)"}`);
-  console.log(`[local] whitelist: ${whitelist.size} commands`);
+  console.log(`[local] bash: passthrough (audit: ${auditMode}, retention: ${retentionDays === 0 ? "forever" : retentionDays + "d"}${dangerConfirm ? ", dangerConfirm: on" : ""})`);
   console.log(`[local] available CLIs: ${commands.join(", ")}`);
+  const pruned = pruneAuditLogs(retentionDays);
+  if (pruned > 0) console.log(`[local] pruned ${pruned} expired audit log dir(s)`);
+  const pruneTimer = setInterval(() => {
+    const n = pruneAuditLogs(retentionDays);
+    if (n > 0) console.log(`[local] pruned ${n} expired audit log dir(s)`);
+  }, 24 * 60 * 6e4);
+  pruneTimer.unref?.();
   let phase = "starting";
   let phaseReason = "";
   let reconnectAttempts = 0;
@@ -11236,7 +11276,7 @@ async function startLocal(opts = {}) {
   function handleSpawn(frame) {
     const sessionId = frame.sessionId;
     try {
-      const logger = new SessionLogger(sessionId, frame.cmd);
+      const logger = new SessionLogger(sessionId, frame.cmd, auditMode);
       pty.spawn(
         sessionId,
         { cmd: frame.cmd, cols: frame.cols, rows: frame.rows, cwd: frame.cwd },
@@ -11314,7 +11354,7 @@ async function startLocal(opts = {}) {
       if (char === "\r" || char === "\n") {
         const line = buf;
         buf = "";
-        const result = checkCommand(line, whitelist);
+        const result = checkCommand(line, dangerConfirm);
         if (result.allowed) {
           ptyWriteChar(sessionId, "\r");
           logger.logInput(new TextEncoder().encode(line + "\r"));
@@ -11518,11 +11558,28 @@ function resolveHere() {
 })();
 var argUrl = process.argv[2];
 var argMatch = argUrl && (argUrl.startsWith("ws://") || argUrl.startsWith("wss://"));
+function readVersion() {
+  if (true) return "0.3.1";
+  try {
+    const pkg = JSON.parse(
+      (0, import_node_fs5.readFileSync)(new URL("../package.json", import_meta.url), "utf-8")
+    );
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+if (argUrl === "-v" || argUrl === "--version" || argUrl === "version") {
+  console.log(`cli-local ${readVersion()}`);
+  console.log(`node ${process.version} (${process.platform} ${process.arch})`);
+  process.exit(0);
+}
 if (argUrl && !argMatch && (argUrl === "-h" || argUrl === "--help" || argUrl === "help")) {
   console.log(`cli-local \u2014 local PTY agent for cli-remote (gateway \u5E38\u9A7B\u670D\u52A1)
 
 usage:
   cli-local                      \u65E0 gateway \u4E14\u5DF2\u914D\u7F6E\u65F6\u524D\u53F0\u8FD0\u884C\uFF1B\u5426\u5219\u663E\u793A\u72B6\u6001
+  cli-local -v | --version       \u67E5\u770B\u7248\u672C
   cli-local pair                 \u91CD\u65B0\u6388\u6743\uFF08\u540A\u9500/\u8FC7\u671F\u540E\u91CD\u914D\u5BF9\uFF1Bgateway \u70ED\u52A0\u8F7D\uFF09
   cli-local gateway start        \u540E\u53F0\u542F\u52A8\u5E38\u9A7B gateway\uFF08\u63A8\u8350\uFF09
   cli-local gateway stop|restart|status|logs [-f] [-n N]
@@ -11841,7 +11898,7 @@ if (argUrl === "gateway") {
       const up = Math.floor(st.uptimeMs / 1e3);
       const upStr = up > 3600 ? `${Math.floor(up / 3600)}h${Math.floor(up % 3600 / 60)}m` : up > 60 ? `${Math.floor(up / 60)}m${up % 60}s` : `${up}s`;
       const exp = st.accessTokenExpiresAt ? new Date(st.accessTokenExpiresAt).toLocaleTimeString() : "\u2014";
-      console.log(`[gateway] running (pid ${gatewayPid() ?? "?"}, api :${port})`);
+      console.log(`[gateway] running (pid ${gatewayPid() ?? "?"}, api :${port}) \u2014 cli-local ${readVersion()}`);
       console.log(`[gateway] \u72B6\u6001: ${phaseLabel[st.phase] ?? st.phase}${st.reason ? ` (${st.reason})` : ""}`);
       console.log(`[gateway] hub: ${st.hubUrl}`);
       console.log(`[gateway] deviceId: ${st.deviceId ?? "\u2014"}`);
@@ -11863,7 +11920,7 @@ if (argUrl === "gateway") {
       hub = cfg.relayUrl ?? hub;
     } catch {
     }
-    console.log(`[gateway] running (pid ${pid}) \u2014 \u63A7\u5236API\u672A\u54CD\u5E94\uFF08\u65E7\u7248\u672C\uFF1F\uFF09`);
+    console.log(`[gateway] running (pid ${pid}) \u2014 cli-local ${readVersion()}\uFF08\u63A7\u5236API\u672A\u54CD\u5E94\uFF0C\u65E7\u7248\u672C\uFF1F\uFF09`);
     console.log(`[gateway] hub: ${hub}`);
     console.log(`[gateway] \u65E5\u5FD7: ${gatewayLogFile()}`);
     process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cli-remote/local",
-  "version": "0.1.1",
+  "version": "0.3.1",
   "description": "Local PTY agent for cli-remote — exposes your local CLI tools (claude/codex/kimi-cli/shell) to the mobile web client via a self-hosted hub.",
   "license": "MIT",
   "repository": {
@@ -26,7 +26,7 @@
   ],
   "scripts": {
     "dev": "tsx watch src/index.ts",
-    "build": "esbuild src/index.ts --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:node-pty --banner:js='#!/usr/bin/env node'",
+    "build": "node scripts/build.mjs",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "pnpm build"
   },