@cli-remote/local 0.0.3 → 0.0.6

package/dist/index.cjs

@@ -3214,7 +3214,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
+          ws.once("open", function open2() {
             duplex._final(callback);
           });
           return;
@@ -3235,7 +3235,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
+          ws.once("open", function open2() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -6683,11 +6683,11 @@ var require_dijkstra = __commonJS({
         var predecessors = {};
         var costs = {};
         costs[s] = 0;
-        var open = dijkstra.PriorityQueue.make();
-        open.push(s, 0);
+        var open2 = dijkstra.PriorityQueue.make();
+        open2.push(s, 0);
         var closest, u, v, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit;
-        while (!open.empty()) {
-          closest = open.pop();
+        while (!open2.empty()) {
+          closest = open2.pop();
           u = closest.value;
           cost_of_s_to_u = closest.cost;
           adjacent_nodes = graph[u] || {};
@@ -6699,7 +6699,7 @@ var require_dijkstra = __commonJS({
               first_visit = typeof costs[v] === "undefined";
               if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
                 costs[v] = cost_of_s_to_u_plus_cost_of_e;
-                open.push(v, cost_of_s_to_u_plus_cost_of_e);
+                open2.push(v, cost_of_s_to_u_plus_cost_of_e);
                 predecessors[v] = u;
               }
             }
@@ -9786,10 +9786,10 @@ var require_browser = __commonJS({
           text = canvas;
           canvas = void 0;
         }
-        return new Promise(function(resolve, reject) {
+        return new Promise(function(resolve2, reject) {
           try {
             const data = QRCode2.create(text, opts);
-            resolve(renderFunc(data, canvas, opts));
+            resolve2(renderFunc(data, canvas, opts));
           } catch (e) {
             reject(e);
           }
@@ -9870,11 +9870,11 @@ var require_server = __commonJS({
     }
     function render(renderFunc, text, params) {
       if (!params.cb) {
-        return new Promise(function(resolve, reject) {
+        return new Promise(function(resolve2, reject) {
           try {
             const data = QRCode2.create(text, params.opts);
             return renderFunc(data, params.opts, function(err, data2) {
-              return err ? reject(err) : resolve(data2);
+              return err ? reject(err) : resolve2(data2);
             });
           } catch (e) {
             reject(e);
@@ -9939,10 +9939,10 @@ var require_lib = __commonJS({
 });
 
 // src/index.ts
-var import_node_fs2 = require("node:fs");
-var import_node_child_process2 = require("node:child_process");
-var import_node_os5 = require("node:os");
-var import_node_path5 = require("node:path");
+var import_node_fs4 = require("node:fs");
+var import_node_child_process3 = require("node:child_process");
+var import_node_os6 = require("node:os");
+var import_node_path6 = require("node:path");
 var import_node_url = require("node:url");
 
 // ../../node_modules/.pnpm/ws@8.21.3/node_modules/ws/wrapper.mjs
@@ -9957,10 +9957,11 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
 // src/client.ts
+var import_node_child_process2 = require("node:child_process");
 var import_node_readline = require("node:readline");
-var import_promises2 = require("node:fs/promises");
-var import_node_os4 = require("node:os");
-var import_node_path4 = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_node_os5 = require("node:os");
+var import_node_path5 = require("node:path");
 
 // ../shared/src/codec.ts
 var import_msgpack = __toESM(require_dist(), 1);
@@ -9980,6 +9981,9 @@ 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 FILE_CHUNK_SIZE = 64 * 1024;
+var MAX_TRANSFER_BYTES = 500 * 1024 * 1024;
+var UPLOAD_DIR = "uploads";
 var RECONNECT_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
 var DEFAULT_CONFIG_DIR = ".cli-remote";
 var CREDENTIALS_FILE = "credentials.json";
@@ -10074,6 +10078,8 @@ function resolveCommand(cmd) {
       return { file: "codex", args: [] };
     case "kimi-cli":
       return { file: "kimi", args: [] };
+    case "pi":
+      return { file: "pi", args: [] };
     default:
       return { file: cmd, args: [] };
   }
@@ -10327,19 +10333,196 @@ function checkCommand(line, whitelist, dangerousPatterns = DANGEROUS_PATTERNS) {
   return { allowed: true };
 }
 
-// src/auth.ts
-var import_node_child_process = require("node:child_process");
-var import_node_crypto = require("node:crypto");
+// src/file-transfer.ts
+var import_node_fs2 = require("node:fs");
 var import_promises = require("node:fs/promises");
 var import_node_os3 = require("node:os");
 var import_node_path3 = require("node:path");
+var FileTransferManager = class _FileTransferManager {
+  constructor(send, log) {
+    this.send = send;
+    this.log = log;
+  }
+  uploads = /* @__PURE__ */ new Map();
+  uploadDir() {
+    return (0, import_node_path3.join)((0, import_node_os3.homedir)(), DEFAULT_CONFIG_DIR, UPLOAD_DIR);
+  }
+  expandPath(p) {
+    const home = process.env.PTY_HOME ?? (0, import_node_os3.homedir)();
+    if (p === "~") return home;
+    if (p.startsWith("~/")) return (0, import_node_path3.join)(home, p.slice(2));
+    return (0, import_node_path3.resolve)(p);
+  }
+  /** Strip any directory components and control chars from a client filename. */
+  static sanitizeFilename(name) {
+    const base = (0, import_node_path3.basename)(name).replace(/[\u0000-\u001f\u007f]/g, "");
+    return base && base !== "." && base !== ".." ? base : "upload.bin";
+  }
+  async handleUploadStart(frame) {
+    const { sessionId, uploadId, filename, size } = frame;
+    if (this.uploads.has(uploadId)) return;
+    if (size > MAX_TRANSFER_BYTES) {
+      this.emit({
+        t: "upload-err",
+        sessionId,
+        uploadId,
+        reason: `\u6587\u4EF6\u8FC7\u5927\uFF08>${Math.floor(MAX_TRANSFER_BYTES / 1024 / 1024)}MB\uFF09`
+      });
+      return;
+    }
+    try {
+      const dir = this.uploadDir();
+      await (0, import_promises.mkdir)(dir, { recursive: true });
+      const target = await this.uniqPath(dir, _FileTransferManager.sanitizeFilename(filename));
+      const stream = (0, import_node_fs2.createWriteStream)(target, { mode: 384 });
+      this.uploads.set(uploadId, {
+        uploadId,
+        sessionId,
+        path: target,
+        size,
+        received: 0,
+        lastSeq: 0,
+        stream
+      });
+      this.emit({ t: "upload-ok", sessionId, uploadId, path: target });
+      this.log(`upload start ${uploadId} \u2192 ${target} (${size}B)`);
+    } catch (e) {
+      this.emit({ t: "upload-err", sessionId, uploadId, reason: e.message });
+    }
+  }
+  async uniqPath(dir, name) {
+    let candidate = (0, import_node_path3.join)(dir, name);
+    let i = 1;
+    while (await exists(candidate)) {
+      const dot = name.lastIndexOf(".");
+      const stem = dot > 0 ? name.slice(0, dot) : name;
+      const ext = dot > 0 ? name.slice(dot) : "";
+      candidate = (0, import_node_path3.join)(dir, `${stem} (${i++})${ext}`);
+    }
+    return candidate;
+  }
+  handleUploadChunk(frame) {
+    const up = this.uploads.get(frame.uploadId);
+    if (!up) return;
+    if (frame.seq <= up.lastSeq) return;
+    up.lastSeq = frame.seq;
+    up.received += frame.data.byteLength;
+    up.stream.write(Buffer.from(frame.data.buffer, frame.data.byteOffset, frame.data.byteLength));
+  }
+  async handleUploadEnd(frame) {
+    const up = this.uploads.get(frame.uploadId);
+    if (!up) return;
+    this.uploads.delete(frame.uploadId);
+    await new Promise((res) => up.stream.end(res));
+    const sizeOk = up.received === up.size;
+    this.log(`upload done ${frame.uploadId}: ${up.received}B \u2192 ${up.path}`);
+    if (!sizeOk) {
+      this.emit({
+        t: "upload-err",
+        sessionId: up.sessionId,
+        uploadId: frame.uploadId,
+        reason: `\u5927\u5C0F\u4E0D\u5339\u914D\uFF08\u58F0\u660E ${up.size}B\uFF0C\u5B9E\u6536 ${up.received}B\uFF09`
+      });
+    }
+  }
+  abortUpload(uploadId) {
+    const up = this.uploads.get(uploadId);
+    if (!up) return;
+    this.uploads.delete(uploadId);
+    up.stream.destroy();
+    this.log(`upload aborted ${uploadId}`);
+  }
+  /** Stream a file back to the web client with mild backpressure via `send`. */
+  async handleDownloadReq(frame, isBusy) {
+    const sessionId = frame.sessionId;
+    const downloadId = "dl_" + Math.random().toString(36).slice(2, 10);
+    let abs;
+    try {
+      abs = this.expandPath(frame.path);
+      const st = await (0, import_promises.stat)(abs);
+      if (!st.isFile()) throw new Error("\u4E0D\u662F\u666E\u901A\u6587\u4EF6");
+      if (st.size > MAX_TRANSFER_BYTES) {
+        throw new Error(`\u6587\u4EF6\u8FC7\u5927\uFF08>${Math.floor(MAX_TRANSFER_BYTES / 1024 / 1024)}MB\uFF09`);
+      }
+      this.emit({
+        t: "download-start",
+        sessionId,
+        downloadId,
+        filename: (0, import_node_path3.basename)(abs),
+        size: st.size
+      });
+      this.log(`download start ${downloadId} \u2190 ${abs} (${st.size}B)`);
+      await this.streamFile(sessionId, downloadId, abs, isBusy);
+      this.emit({ t: "download-end", sessionId, downloadId });
+      this.log(`download done ${downloadId}: ${abs}`);
+    } catch (e) {
+      this.emit({
+        t: "download-err",
+        sessionId,
+        downloadId,
+        reason: e.message
+      });
+    }
+  }
+  async streamFile(sessionId, downloadId, abs, isBusy) {
+    const handle = await (0, import_promises.open)(abs, "r");
+    try {
+      let seq = 0;
+      let pos = 0;
+      for (; ; ) {
+        const buf = Buffer.alloc(FILE_CHUNK_SIZE);
+        const { bytesRead } = await handle.read(buf, 0, FILE_CHUNK_SIZE, pos);
+        if (bytesRead === 0) break;
+        pos += bytesRead;
+        seq++;
+        this.emit({
+          t: "download-chunk",
+          sessionId,
+          downloadId,
+          data: new Uint8Array(buf.buffer, buf.byteOffset, bytesRead),
+          seq
+        });
+        if (isBusy()) {
+          await new Promise((res) => setImmediate(res));
+          let spins = 0;
+          while (isBusy() && spins++ < 2e3) {
+            await new Promise((res) => setTimeout(res, 20));
+          }
+        }
+      }
+    } finally {
+      await handle.close();
+    }
+  }
+  abortAll() {
+    for (const id of [...this.uploads.keys()]) this.abortUpload(id);
+  }
+  emit(frame) {
+    this.send(encodeFrame(frame));
+  }
+};
+async function exists(p) {
+  try {
+    await (0, import_promises.stat)(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/auth.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var import_promises2 = require("node:fs/promises");
+var import_node_os4 = require("node:os");
+var import_node_path4 = require("node:path");
 var import_qrcode = __toESM(require_lib(), 1);
 function credentialsPath() {
-  return (0, import_node_path3.join)((0, import_node_os3.homedir)(), DEFAULT_CONFIG_DIR, CREDENTIALS_FILE);
+  return (0, import_node_path4.join)((0, import_node_os4.homedir)(), DEFAULT_CONFIG_DIR, CREDENTIALS_FILE);
 }
 async function loadCredentials() {
   try {
-    const raw = JSON.parse(await (0, import_promises.readFile)(credentialsPath(), "utf-8"));
+    const raw = JSON.parse(await (0, import_promises2.readFile)(credentialsPath(), "utf-8"));
     if (!raw.deviceId || !raw.accessToken || !raw.refreshToken) return null;
     return raw;
   } catch {
@@ -10348,16 +10531,16 @@ async function loadCredentials() {
 }
 async function saveCredentials(creds) {
   const path = credentialsPath();
-  await (0, import_promises.mkdir)((0, import_node_path3.join)(path, ".."), { recursive: true });
-  await (0, import_promises.writeFile)(path, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+  await (0, import_promises2.mkdir)((0, import_node_path4.join)(path, ".."), { recursive: true });
+  await (0, import_promises2.writeFile)(path, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
   try {
-    await (0, import_promises.chmod)(path, 384);
+    await (0, import_promises2.chmod)(path, 384);
   } catch {
   }
 }
 async function clearCredentials() {
   try {
-    await (0, import_promises.writeFile)(credentialsPath(), "");
+    await (0, import_promises2.writeFile)(credentialsPath(), "");
   } catch {
   }
 }
@@ -10388,18 +10571,34 @@ function openBrowser(url) {
   } catch {
   }
 }
+async function loginAndFetchRegistrationKey(baseUrl, email, password) {
+  const login = await postJson(`${baseUrl}/api/login`, { email, password });
+  if (login.status !== 200) {
+    const reason = login.data?.reason;
+    throw new AuthError(`\u767B\u5F55\u5931\u8D25: ${reason ?? login.status}`);
+  }
+  const token = login.data.token;
+  if (!token) throw new AuthError("\u670D\u52A1\u7AEF\u672A\u8FD4\u56DE\u4F1A\u8BDD token");
+  const me = await fetch(`${baseUrl}/api/me`, {
+    headers: { authorization: `Bearer ${token}` }
+  });
+  if (!me.ok) throw new AuthError(`\u83B7\u53D6\u8D26\u53F7\u4FE1\u606F\u5931\u8D25 (${me.status})`);
+  const data = await me.json();
+  if (!data.registrationKey) throw new AuthError("\u8D26\u53F7\u4FE1\u606F\u91CC\u6CA1\u6709 registrationKey");
+  return { registrationKey: data.registrationKey, user: data.user?.email ?? email };
+}
 async function mergeLocalConfig(patch) {
-  const dir = (0, import_node_path3.join)((0, import_node_os3.homedir)(), DEFAULT_CONFIG_DIR);
-  const path = (0, import_node_path3.join)(dir, CONFIG_FILE);
+  const dir = (0, import_node_path4.join)((0, import_node_os4.homedir)(), DEFAULT_CONFIG_DIR);
+  const path = (0, import_node_path4.join)(dir, CONFIG_FILE);
   let existing = {};
   try {
-    existing = JSON.parse(await (0, import_promises.readFile)(path, "utf-8"));
+    existing = JSON.parse(await (0, import_promises2.readFile)(path, "utf-8"));
   } catch {
   }
-  await (0, import_promises.mkdir)(dir, { recursive: true });
-  await (0, import_promises.writeFile)(path, JSON.stringify({ ...existing, ...patch }, null, 2) + "\n");
+  await (0, import_promises2.mkdir)(dir, { recursive: true });
+  await (0, import_promises2.writeFile)(path, JSON.stringify({ ...existing, ...patch }, null, 2) + "\n");
 }
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 var AuthError = class extends Error {
 };
 async function deviceFlowAuthorize(baseUrl, registrationKey, deviceId) {
@@ -10411,7 +10610,7 @@ async function deviceFlowAuthorize(baseUrl, registrationKey, deviceId) {
   const res = await postJson(`${baseUrl}/oauth/device_authorization`, {
     registrationKey,
     device_id: deviceId,
-    device_name: (0, import_node_os3.hostname)(),
+    device_name: (0, import_node_os4.hostname)(),
     platform: process.platform
   });
   if (res.status !== 200) {
@@ -10514,9 +10713,9 @@ async function ensureCredentials(baseUrl, registrationKey) {
 
 // src/client.ts
 async function loadConfig() {
-  const path = (0, import_node_path4.join)((0, import_node_os4.homedir)(), DEFAULT_CONFIG_DIR, CONFIG_FILE);
+  const path = (0, import_node_path5.join)((0, import_node_os5.homedir)(), DEFAULT_CONFIG_DIR, CONFIG_FILE);
   try {
-    return JSON.parse(await (0, import_promises2.readFile)(path, "utf-8"));
+    return JSON.parse((0, import_node_fs3.readFileSync)(path, "utf-8"));
   } catch {
     return {};
   }
@@ -10530,10 +10729,32 @@ function buildWhitelist(cfg) {
 function isTTY() {
   return process.stdin.isTTY === true;
 }
+function detectCommands() {
+  const bins = [
+    ["claude", "claude"],
+    ["codex", "codex"],
+    ["kimi-cli", "kimi"],
+    ["pi", "pi"]
+  ];
+  const found = ["shell"];
+  for (const [cmd, bin] of bins) {
+    let ok = false;
+    if (process.platform === "win32") {
+      ok = (0, import_node_child_process2.spawnSync)("where", [bin], { timeout: 5e3 }).status === 0;
+    } else {
+      const shell = process.env.SHELL ?? "/bin/bash";
+      ok = (0, import_node_child_process2.spawnSync)(shell, ["-l", "-c", `command -v ${bin}`], {
+        timeout: 5e3
+      }).status === 0;
+    }
+    if (ok) found.push(cmd);
+  }
+  return found;
+}
 async function readInput(prompt) {
   const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
   try {
-    return await new Promise((resolve) => rl.question(prompt, (answer) => resolve(answer)));
+    return await new Promise((resolve2) => rl.question(prompt, (answer) => resolve2(answer)));
   } finally {
     rl.close();
   }
@@ -10568,18 +10789,42 @@ async function setupWizard(config, opts) {
     const base = baseUrlFromWsUrl(url);
     console.log("");
     console.log("[local] \u7F3A\u5C11 registrationKey\u3002");
-    console.log(`[local] \u5DF2\u6253\u5F00\u6D4F\u89C8\u5668\uFF0C\u8BF7\u767B\u5F55 ${base} \u5E76\u5728\u300C\u6211\u7684\u8BBE\u5907\u300D\u9875\u590D\u5236 registrationKey`);
-    openBrowser(base);
     if (!isTTY()) {
+      openBrowser(base);
       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;
     }
-    const ans = (await readInput("\u7C98\u8D34 registrationKey: ")).trim();
-    if (!ans) {
-      console.log("[local] \u672A\u63D0\u4F9B registrationKey\uFF0C\u9000\u51FA\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");
+    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 {
+      for (; ; ) {
+        const email = (await readInput("\u90AE\u7BB1: ")).trim();
+        const password = (await readInput("\u5BC6\u7801: ")).trim();
+        if (!email || !password) {
+          console.log("[local] \u90AE\u7BB1\u6216\u5BC6\u7801\u4E3A\u7A7A\uFF0C\u91CD\u8BD5\uFF08\u6216 Ctrl+C \u9000\u51FA\uFF09\u3002");
+          continue;
+        }
+        try {
+          const res = await loginAndFetchRegistrationKey(base, email, password);
+          registrationKey = res.registrationKey;
+          console.log(`[local] \u5DF2\u767B\u5F55 ${res.user}\uFF0C\u83B7\u53D6 registrationKey \u6210\u529F`);
+          break;
+        } catch (e) {
+          console.error(`[local] ${e.message}`);
+          console.log("[local] \u91CD\u8BD5\uFF08\u6216 Ctrl+C \u9000\u51FA\uFF09\u3002");
+        }
+      }
     }
-    registrationKey = ans;
     changed = true;
   }
   if (changed) {
@@ -10603,10 +10848,17 @@ async function startLocal(opts = {}) {
   const pty = new PtyManager();
   const loggers = /* @__PURE__ */ new Map();
   const lineBuffers = /* @__PURE__ */ new Map();
+  const transfers = new FileTransferManager(
+    (data) => safeSend(data),
+    (msg) => console.log(`[local] ${msg}`)
+  );
   let credentials = await ensureCredentials(baseUrl, registrationKey);
+  const commands = detectCommands();
+  if (opts.daemon) writeGatewayPid();
   console.log(`[local] connecting to ${url}`);
   console.log(`[local] deviceId=${credentials.deviceId}`);
   console.log(`[local] whitelist: ${whitelist.size} commands`);
+  console.log(`[local] available CLIs: ${commands.join(", ")}`);
   let ws = null;
   let heartbeatTimer = null;
   let reconnectTimer = null;
@@ -10622,7 +10874,8 @@ async function startLocal(opts = {}) {
         t: "auth",
         role: "bridge",
         deviceId: credentials.deviceId,
-        token: credentials.accessToken
+        token: credentials.accessToken,
+        commands
       })
     );
   }
@@ -10677,6 +10930,8 @@ async function startLocal(opts = {}) {
     userExitCode = code;
     if (reconnectTimer) clearTimeout(reconnectTimer);
     reconnectTimer = null;
+    if (opts.daemon) removeGatewayPid();
+    transfers.abortAll();
     pty.killAll();
     for (const [, logger] of loggers) logger.logExit(-1);
     loggers.clear();
@@ -10726,6 +10981,21 @@ async function startLocal(opts = {}) {
       case "replay-req":
         handleReplay(frame);
         break;
+      case "upload-start":
+        void transfers.handleUploadStart(frame);
+        break;
+      case "upload-chunk":
+        transfers.handleUploadChunk(frame);
+        break;
+      case "upload-end":
+        void transfers.handleUploadEnd(frame);
+        break;
+      case "download-req":
+        void transfers.handleDownloadReq(
+          frame,
+          () => ws ? ws.bufferedAmount > 4 * 1024 * 1024 : false
+        );
+        break;
       default:
         console.log("[local] unhandled frame:", frame.t);
     }
@@ -10878,7 +11148,8 @@ async function startLocal(opts = {}) {
       encodeFrame({
         t: "replay-res",
         sessionId: frame.sessionId,
-        frames
+        frames,
+        exists: pty.has(frame.sessionId)
       })
     );
   }
@@ -10899,6 +11170,37 @@ function toUint8(raw) {
   }
   throw new Error("unexpected raw type");
 }
+function gatewayPidFile() {
+  return (0, import_node_path5.join)((0, import_node_os5.homedir)(), DEFAULT_CONFIG_DIR, "gateway.pid");
+}
+function writeGatewayPid() {
+  (0, import_node_fs3.mkdirSync)((0, import_node_path5.join)((0, import_node_os5.homedir)(), DEFAULT_CONFIG_DIR), { recursive: true });
+  (0, import_node_fs3.writeFileSync)(gatewayPidFile(), String(process.pid));
+}
+function removeGatewayPid() {
+  try {
+    (0, import_node_fs3.rmSync)(gatewayPidFile());
+  } catch {
+  }
+}
+function gatewayPid() {
+  try {
+    const pid = Number((0, import_node_fs3.readFileSync)(gatewayPidFile(), "utf-8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function gatewayAlive() {
+  const pid = gatewayPid();
+  if (pid === null) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/index.ts
 var import_meta = {};
@@ -10917,15 +11219,15 @@ function resolveHere() {
     if (DEBUG) console.error("[debug] cannot resolve script path");
     return;
   }
-  const hereDir = (0, import_node_path5.dirname)(here);
+  const hereDir = (0, import_node_path6.dirname)(here);
   const candidates = [
-    (0, import_node_path5.join)(hereDir, "..", "node_modules", "node-pty", "prebuilds"),
-    (0, import_node_path5.join)(hereDir, "..", "..", "node-pty", "prebuilds"),
-    (0, import_node_path5.join)(hereDir, "..", "..", "..", "node_modules", "node-pty", "prebuilds")
+    (0, import_node_path6.join)(hereDir, "..", "node_modules", "node-pty", "prebuilds"),
+    (0, import_node_path6.join)(hereDir, "..", "..", "node-pty", "prebuilds"),
+    (0, import_node_path6.join)(hereDir, "..", "..", "..", "node_modules", "node-pty", "prebuilds")
   ];
   let prebuildsDir = null;
   for (const c of candidates) {
-    if ((0, import_node_fs2.existsSync)(c)) {
+    if ((0, import_node_fs4.existsSync)(c)) {
       prebuildsDir = c;
       break;
     }
@@ -10935,11 +11237,11 @@ function resolveHere() {
     return;
   }
   let n = 0;
-  for (const sub of (0, import_node_fs2.readdirSync)(prebuildsDir)) {
-    const helper = (0, import_node_path5.join)(prebuildsDir, sub, "spawn-helper");
-    if ((0, import_node_fs2.existsSync)(helper)) {
+  for (const sub of (0, import_node_fs4.readdirSync)(prebuildsDir)) {
+    const helper = (0, import_node_path6.join)(prebuildsDir, sub, "spawn-helper");
+    if ((0, import_node_fs4.existsSync)(helper)) {
       try {
-        (0, import_node_fs2.chmodSync)(helper, 493);
+        (0, import_node_fs4.chmodSync)(helper, 493);
         n++;
       } catch {
       }
@@ -10986,20 +11288,20 @@ example:
 }
 var LAUNCHD_LABEL = "net.cli-remote.local";
 function launchdPlistPath() {
-  return (0, import_node_path5.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+  return (0, import_node_path6.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
 }
 function entryScript() {
   const a1 = process.argv[1];
   if (!a1 || a1.endsWith(".ts")) return null;
   try {
-    return (0, import_node_fs2.realpathSync)(a1);
+    return (0, import_node_fs4.realpathSync)(a1);
   } catch {
     return a1;
   }
 }
 function run(cmd, args, okToFail = false) {
   try {
-    return (0, import_node_child_process2.execFileSync)(cmd, args, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+    return (0, import_node_child_process3.execFileSync)(cmd, args, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
   } catch (e) {
     if (okToFail) return null;
     throw e;
@@ -11010,7 +11312,7 @@ function launchdInstall(urlArg) {
     console.error(`[local] launchd \u5E38\u9A7B\u4EC5\u652F\u6301 macOS\uFF08\u5F53\u524D ${process.platform}\uFF09\uFF1BLinux \u8BF7\u7528 systemd --user \u81EA\u884C\u6258\u7BA1`);
     process.exit(1);
   }
-  const home = (0, import_node_os5.homedir)();
+  const home = (0, import_node_os6.homedir)();
   const entry = entryScript();
   if (!entry) {
     console.error("[local] \u5F53\u524D\u4EE5\u6E90\u7801\uFF08tsx\uFF09\u6A21\u5F0F\u8FD0\u884C\uFF0C\u65E0\u6CD5\u5B89\u88C5\u5E38\u9A7B\u670D\u52A1\u3002");
@@ -11018,28 +11320,28 @@ function launchdInstall(urlArg) {
     process.exit(1);
   }
   if (urlArg) {
-    const cfgDir = (0, import_node_path5.join)(home, DEFAULT_CONFIG_DIR);
-    (0, import_node_fs2.mkdirSync)(cfgDir, { recursive: true });
-    const cfgPath = (0, import_node_path5.join)(cfgDir, "config.json");
+    const cfgDir = (0, import_node_path6.join)(home, DEFAULT_CONFIG_DIR);
+    (0, import_node_fs4.mkdirSync)(cfgDir, { recursive: true });
+    const cfgPath = (0, import_node_path6.join)(cfgDir, "config.json");
     let cfg = {};
     try {
-      cfg = JSON.parse((0, import_node_fs2.readFileSync)(cfgPath, "utf-8"));
+      cfg = JSON.parse((0, import_node_fs4.readFileSync)(cfgPath, "utf-8"));
     } catch {
     }
     cfg.relayUrl = urlArg;
-    (0, import_node_fs2.writeFileSync)(cfgPath, JSON.stringify(cfg, null, 2) + "\n");
+    (0, import_node_fs4.writeFileSync)(cfgPath, JSON.stringify(cfg, null, 2) + "\n");
     console.log(`[local] relayUrl \u5DF2\u5199\u5165 ${cfgPath}`);
   }
-  const credPath = (0, import_node_path5.join)(home, DEFAULT_CONFIG_DIR, CREDENTIALS_FILE);
-  if (!(0, import_node_fs2.existsSync)(credPath)) {
+  const credPath = (0, import_node_path6.join)(home, DEFAULT_CONFIG_DIR, CREDENTIALS_FILE);
+  if (!(0, import_node_fs4.existsSync)(credPath)) {
     console.error("[local] \u5C1A\u672A\u6388\u6743\uFF08\u627E\u4E0D\u5230 credentials.json\uFF09\u3002");
     console.error("[local] \u8BF7\u5148\u4EA4\u4E92\u5F0F\u8FD0\u884C\u4E00\u6B21 cli-local \u5B8C\u6210\u914D\u7F6E\u4E0E\u6388\u6743\uFF0C\u518D\u5B89\u88C5\u5E38\u9A7B\u670D\u52A1\u3002");
     process.exit(1);
   }
   const plist = launchdPlistPath();
-  const logDir = (0, import_node_path5.join)(home, DEFAULT_CONFIG_DIR, "logs");
-  (0, import_node_fs2.mkdirSync)((0, import_node_path5.dirname)(plist), { recursive: true });
-  (0, import_node_fs2.mkdirSync)(logDir, { recursive: true });
+  const logDir = (0, import_node_path6.join)(home, DEFAULT_CONFIG_DIR, "logs");
+  (0, import_node_fs4.mkdirSync)((0, import_node_path6.dirname)(plist), { recursive: true });
+  (0, import_node_fs4.mkdirSync)(logDir, { recursive: true });
   const xml = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -11053,12 +11355,12 @@ function launchdInstall(urlArg) {
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
   <key>ThrottleInterval</key><integer>30</integer>
-  <key>StandardOutPath</key><string>${(0, import_node_path5.join)(logDir, "daemon.out.log")}</string>
-  <key>StandardErrorPath</key><string>${(0, import_node_path5.join)(logDir, "daemon.err.log")}</string>
+  <key>StandardOutPath</key><string>${(0, import_node_path6.join)(logDir, "daemon.out.log")}</string>
+  <key>StandardErrorPath</key><string>${(0, import_node_path6.join)(logDir, "daemon.err.log")}</string>
 </dict>
 </plist>
 `;
-  (0, import_node_fs2.writeFileSync)(plist, xml);
+  (0, import_node_fs4.writeFileSync)(plist, xml);
   const uid = process.getuid?.();
   if (uid === void 0) {
     console.error("[local] \u65E0\u6CD5\u786E\u5B9A uid\uFF0Claunchd \u5B89\u88C5\u5931\u8D25");
@@ -11076,7 +11378,7 @@ function launchdInstall(urlArg) {
 }
 function launchdUninstall() {
   const plist = launchdPlistPath();
-  if (!(0, import_node_fs2.existsSync)(plist)) {
+  if (!(0, import_node_fs4.existsSync)(plist)) {
     console.log("[local] \u672A\u627E\u5230\u5DF2\u5B89\u88C5\u7684\u5E38\u9A7B\u670D\u52A1\uFF08nothing to uninstall\uFF09");
     process.exit(0);
   }
@@ -11084,7 +11386,7 @@ function launchdUninstall() {
   const guiDomain = `gui/${uid ?? 0}`;
   run("launchctl", ["bootout", guiDomain, plist], true);
   run("launchctl", ["unload", "-w", plist], true);
-  (0, import_node_fs2.rmSync)(plist);
+  (0, import_node_fs4.rmSync)(plist);
   console.log(`[local] launchd \u670D\u52A1\u5DF2\u505C\u6B62\u5E76\u5378\u8F7D\uFF1A${LAUNCHD_LABEL}`);
 }
 if (argUrl && !argMatch && argUrl === "install") {
@@ -11095,6 +11397,173 @@ if (argUrl && !argMatch && argUrl === "uninstall") {
   launchdUninstall();
   process.exit(0);
 }
+if (argUrl === "gateway") {
+  let gatewayLogFile = function() {
+    return (0, import_node_path6.join)((0, import_node_os6.homedir)(), DEFAULT_CONFIG_DIR, "logs", "gateway.log");
+  }, stopWorker = function() {
+    const pid = gatewayPid();
+    if (pid === null || !gatewayAlive()) {
+      (0, import_node_fs4.rmSync)((0, import_node_path6.join)((0, import_node_os6.homedir)(), DEFAULT_CONFIG_DIR, "gateway.pid"), { force: true });
+      return;
+    }
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+    const t0 = Date.now();
+    while (Date.now() - t0 < 5e3 && gatewayAlive()) {
+      const end = Date.now() + 150;
+      while (Date.now() < end) {
+      }
+    }
+    (0, import_node_fs4.rmSync)((0, import_node_path6.join)((0, import_node_os6.homedir)(), DEFAULT_CONFIG_DIR, "gateway.pid"), { force: true });
+  }, gatewayStop = function() {
+    const pid = gatewayPid();
+    const wasRunning = gatewayAlive();
+    stopWorker();
+    console.log(wasRunning ? `[gateway] stopped (pid ${pid ?? "?"})` : "[gateway] not running");
+    process.exit(0);
+  }, gatewayStatus = function() {
+    if (!gatewayAlive()) {
+      console.log("[gateway] stopped");
+      process.exit(1);
+    }
+    const pid = gatewayPid();
+    let hub = "(\u672A\u914D\u7F6E)";
+    try {
+      const cfg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path6.join)((0, import_node_os6.homedir)(), DEFAULT_CONFIG_DIR, "config.json"), "utf-8"));
+      hub = cfg.relayUrl ?? hub;
+    } catch {
+    }
+    console.log(`[gateway] running (pid ${pid})`);
+    console.log(`[gateway] hub: ${hub}`);
+    console.log(`[gateway] \u65E5\u5FD7: ${gatewayLogFile()}`);
+    process.exit(0);
+  }, gatewayLogs = function() {
+    const follow = rest.includes("-f") || rest.includes("--follow");
+    const li = rest.findIndex((a) => a === "-n" || a === "--lines");
+    const lines = li >= 0 ? Number(rest[li + 1]) || 50 : 50;
+    const file = gatewayLogFile();
+    if (!(0, import_node_fs4.existsSync)(file)) {
+      console.log(`[gateway] \u6682\u65E0\u65E5\u5FD7\uFF08${file} \u4E0D\u5B58\u5728\uFF09`);
+      process.exit(0);
+    }
+    const tail = (0, import_node_fs4.readFileSync)(file, "utf-8").trimEnd().split("\n").slice(-lines);
+    console.log(tail.join("\n"));
+    if (!follow) process.exit(0);
+    let size = (0, import_node_fs4.statSync)(file).size;
+    console.log("--- following (Ctrl+C \u9000\u51FA) ---");
+    setInterval(() => {
+      try {
+        const st = (0, import_node_fs4.statSync)(file);
+        if (st.size > size) {
+          const fd = (0, import_node_fs4.openSync)(file, "r");
+          const buf = Buffer.alloc(st.size - size);
+          (0, import_node_fs4.readSync)(fd, buf, 0, buf.length, size);
+          (0, import_node_fs4.closeSync)(fd);
+          size = st.size;
+          process.stdout.write(buf.toString("utf-8"));
+        } else if (st.size < size) {
+          size = 0;
+        }
+      } catch {
+      }
+    }, 1e3);
+  };
+  gatewayLogFile2 = gatewayLogFile, stopWorker2 = stopWorker, gatewayStop2 = gatewayStop, gatewayStatus2 = gatewayStatus, gatewayLogs2 = gatewayLogs;
+  const action = process.argv[3] ?? "";
+  const rest = process.argv.slice(4);
+  const hubArg = (() => {
+    const i = rest.indexOf("--hub");
+    return i >= 0 ? rest[i + 1] : void 0;
+  })();
+  async function gatewayStart() {
+    if (gatewayAlive()) {
+      console.log(`[gateway] already running (pid ${gatewayPid()})`);
+      process.exit(0);
+    }
+    const home = (0, import_node_os6.homedir)();
+    const entry = entryScript();
+    const cfgDir = (0, import_node_path6.join)(home, DEFAULT_CONFIG_DIR);
+    const credPath = (0, import_node_path6.join)(cfgDir, CREDENTIALS_FILE);
+    const cfgPath = (0, import_node_path6.join)(cfgDir, "config.json");
+    const hasCfg = (0, import_node_fs4.existsSync)(cfgPath);
+    if (!entry) {
+      console.error("[gateway] \u6E90\u7801\uFF08tsx\uFF09\u6A21\u5F0F\u4E0D\u652F\u6301\u540E\u53F0\u8FD0\u884C\uFF1B\u8BF7\u7528 npm \u5B89\u88C5\u7248\uFF1Anpm i -g @cli-remote/local");
+      process.exit(1);
+    }
+    if (!hasCfg || !(0, import_node_fs4.existsSync)(credPath)) {
+      console.error("[gateway] \u5C1A\u672A\u914D\u7F6E/\u6388\u6743\u3002\u8BF7\u5148\u4EA4\u4E92\u5F0F\u8FD0\u884C\u4E00\u6B21 cli-local \u5B8C\u6210\u767B\u5F55\u4E0E\u8BBE\u5907\u6388\u6743\u3002");
+      process.exit(1);
+    }
+    (0, import_node_fs4.mkdirSync)((0, import_node_path6.dirname)(gatewayLogFile()), { recursive: true });
+    const out = (0, import_node_fs4.openSync)(gatewayLogFile(), "a");
+    const env = {};
+    for (const [k, v] of Object.entries(process.env)) if (v !== void 0) env[k] = v;
+    const args = [entry, "gateway", "run"];
+    if (hubArg) args.push("--hub", hubArg);
+    const child = (0, import_node_child_process3.spawn)(process.execPath, args, {
+      detached: true,
+      stdio: ["ignore", out, out],
+      env
+    });
+    child.unref();
+    console.log(`[gateway] started (pid ${child.pid})`);
+    console.log(`[gateway] \u65E5\u5FD7: ${gatewayLogFile()}`);
+    console.log("[gateway] \u72B6\u6001: cli-local gateway status");
+  }
+  switch (action) {
+    case "start":
+      gatewayStart().then(() => process.exit(0)).catch((e) => {
+        console.error(`[gateway] ${e.message}`);
+        process.exit(1);
+      });
+      break;
+    case "stop":
+      gatewayStop();
+      break;
+    case "restart":
+      stopWorker();
+      gatewayStart().then(() => process.exit(0)).catch((e) => {
+        console.error(`[gateway] ${e.message}`);
+        process.exit(1);
+      });
+      break;
+    case "status":
+      gatewayStatus();
+      break;
+    case "logs":
+      gatewayLogs();
+      break;
+    case "run":
+      startLocal({ url: hubArg, daemon: true }).catch((err) => {
+        if (err instanceof AuthError) console.error(`[local] ${err.message}`);
+        else console.error("[local] fatal:", err);
+        process.exit(1);
+      });
+      break;
+    default:
+      console.log(`cli-local gateway \u2014 \u540E\u53F0\u8FD0\u884C\u7BA1\u7406
+
+usage:
+  cli-local gateway start [--hub URL]   \u540E\u53F0\u542F\u52A8\uFF08\u81EA\u52A8\u91CD\u8FDE\uFF09
+  cli-local gateway stop                \u505C\u6B62
+  cli-local gateway restart             \u91CD\u542F
+  cli-local gateway status              \u8FD0\u884C\u72B6\u6001
+  cli-local gateway logs [-f] [-n N]    \u67E5\u770B\u65E5\u5FD7\uFF08-f \u8DDF\u968F\uFF09
+  cli-local gateway run [--hub URL]     \u524D\u53F0\u8FD0\u884C\uFF08\u4F9B start \u62C9\u8D77\uFF09
+
+\u8BF4\u660E\uFF1A\u540E\u53F0\u8FDB\u7A0B\u7531 pid \u6587\u4EF6\u7BA1\u7406\uFF08~/.cli-remote/gateway.pid\uFF09\uFF0C\u65E5\u5FD7\u5728
+~/.cli-remote/logs/gateway.log\u3002\u9996\u6B21\u4F7F\u7528\u8BF7\u5148\u4EA4\u4E92\u5F0F\u8FD0\u884C cli-local
+\u5B8C\u6210\u767B\u5F55\u4E0E\u8BBE\u5907\u6388\u6743\u3002macOS \u60F3\u5F00\u673A\u81EA\u542F\u7528 launchd\uFF1Acli-local install\u3002`);
+      process.exit(action ? 1 : 0);
+  }
+}
+var gatewayLogFile2;
+var stopWorker2;
+var gatewayStop2;
+var gatewayStatus2;
+var gatewayLogs2;
 startLocal(argMatch ? { url: argUrl } : {}).catch((err) => {
   if (err instanceof AuthError) {
     console.error(`[local] ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cli-remote/local",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "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": {