@clawos-dev/clawd 0.2.2-beta.1.e86e2eb → 0.2.2-beta.2.b7ef550

package/dist/cli.cjs

@@ -1205,7 +1205,7 @@ var require_atomic_sleep = __commonJS({
 var require_sonic_boom = __commonJS({
   "../node_modules/.pnpm/sonic-boom@4.2.1/node_modules/sonic-boom/index.js"(exports2, module2) {
     "use strict";
-    var fs16 = require("fs");
+    var fs17 = require("fs");
     var EventEmitter = require("events");
     var inherits = require("util").inherits;
     var path16 = require("path");
@@ -1262,20 +1262,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs16.mkdirSync(path16.dirname(file), { recursive: true });
-          const fd = fs16.openSync(file, flags, mode);
+          if (sonic.mkdir) fs17.mkdirSync(path16.dirname(file), { recursive: true });
+          const fd = fs17.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs16.mkdir(path16.dirname(file), { recursive: true }, (err) => {
+        fs17.mkdir(path16.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs16.open(file, flags, mode, fileOpened);
+          fs17.open(file, flags, mode, fileOpened);
         });
       } else {
-        fs16.open(file, flags, mode, fileOpened);
+        fs17.open(file, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -1316,8 +1316,8 @@ var require_sonic_boom = __commonJS({
         this.flush = flushBuffer;
         this.flushSync = flushBufferSync;
         this._actualWrite = actualWriteBuffer;
-        fsWriteSync = () => fs16.writeSync(this.fd, this._writingBuf);
-        fsWrite = () => fs16.write(this.fd, this._writingBuf, this.release);
+        fsWriteSync = () => fs17.writeSync(this.fd, this._writingBuf);
+        fsWrite = () => fs17.write(this.fd, this._writingBuf, this.release);
       } else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
         this._writingBuf = "";
         this.write = write;
@@ -1326,15 +1326,15 @@ var require_sonic_boom = __commonJS({
         this._actualWrite = actualWrite;
         fsWriteSync = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs16.writeSync(this.fd, this._writingBuf);
+            return fs17.writeSync(this.fd, this._writingBuf);
           }
-          return fs16.writeSync(this.fd, this._writingBuf, "utf8");
+          return fs17.writeSync(this.fd, this._writingBuf, "utf8");
         };
         fsWrite = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs16.write(this.fd, this._writingBuf, this.release);
+            return fs17.write(this.fd, this._writingBuf, this.release);
           }
-          return fs16.write(this.fd, this._writingBuf, "utf8", this.release);
+          return fs17.write(this.fd, this._writingBuf, "utf8", this.release);
         };
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
@@ -1391,7 +1391,7 @@ var require_sonic_boom = __commonJS({
           }
         }
         if (this._fsync) {
-          fs16.fsyncSync(this.fd);
+          fs17.fsyncSync(this.fd);
         }
         const len = this._len;
         if (this._reopening) {
@@ -1505,7 +1505,7 @@ var require_sonic_boom = __commonJS({
       const onDrain = () => {
         if (!this._fsync) {
           try {
-            fs16.fsync(this.fd, (err) => {
+            fs17.fsync(this.fd, (err) => {
               this._flushPending = false;
               cb(err);
             });
@@ -1607,7 +1607,7 @@ var require_sonic_boom = __commonJS({
       const fd = this.fd;
       this.once("ready", () => {
         if (fd !== this.fd) {
-          fs16.close(fd, (err) => {
+          fs17.close(fd, (err) => {
             if (err) {
               return this.emit("error", err);
             }
@@ -1656,7 +1656,7 @@ var require_sonic_boom = __commonJS({
           buf = this._bufs[0];
         }
         try {
-          const n = Buffer.isBuffer(buf) ? fs16.writeSync(this.fd, buf) : fs16.writeSync(this.fd, buf, "utf8");
+          const n = Buffer.isBuffer(buf) ? fs17.writeSync(this.fd, buf) : fs17.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -1672,7 +1672,7 @@ var require_sonic_boom = __commonJS({
         }
       }
       try {
-        fs16.fsyncSync(this.fd);
+        fs17.fsyncSync(this.fd);
       } catch {
       }
     }
@@ -1693,7 +1693,7 @@ var require_sonic_boom = __commonJS({
           buf = mergeBuf(this._bufs[0], this._lens[0]);
         }
         try {
-          const n = fs16.writeSync(this.fd, buf);
+          const n = fs17.writeSync(this.fd, buf);
           buf = buf.subarray(n);
           this._len = Math.max(this._len - n, 0);
           if (buf.length <= 0) {
@@ -1721,13 +1721,13 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = Buffer.isBuffer(this._writingBuf) ? fs16.writeSync(this.fd, this._writingBuf) : fs16.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = Buffer.isBuffer(this._writingBuf) ? fs17.writeSync(this.fd, this._writingBuf) : fs17.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs16.write(this.fd, this._writingBuf, release);
+        fs17.write(this.fd, this._writingBuf, release);
       }
     }
     function actualWriteBuffer() {
@@ -1736,7 +1736,7 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
       if (this.sync) {
         try {
-          const written = fs16.writeSync(this.fd, this._writingBuf);
+          const written = fs17.writeSync(this.fd, this._writingBuf);
           release(null, written);
         } catch (err) {
           release(err);
@@ -1745,7 +1745,7 @@ var require_sonic_boom = __commonJS({
         if (kCopyBuffer) {
           this._writingBuf = Buffer.from(this._writingBuf);
         }
-        fs16.write(this.fd, this._writingBuf, release);
+        fs17.write(this.fd, this._writingBuf, release);
       }
     }
     function actualClose(sonic) {
@@ -1761,12 +1761,12 @@ var require_sonic_boom = __commonJS({
       sonic._lens = [];
       assert(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
       try {
-        fs16.fsync(sonic.fd, closeWrapped);
+        fs17.fsync(sonic.fd, closeWrapped);
       } catch {
       }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
-          fs16.close(sonic.fd, done);
+          fs17.close(sonic.fd, done);
         } else {
           done();
         }
@@ -8077,6 +8077,7 @@ Env (advanced):
 // src/index.ts
 var import_node_os10 = __toESM(require("os"), 1);
 var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs16 = __toESM(require("fs"), 1);
 
 // src/logger.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -16587,6 +16588,7 @@ var StateFileManager = class {
 // src/tunnel/tunnel-manager.ts
 var import_node_fs13 = __toESM(require("fs"), 1);
 var import_node_path12 = __toESM(require("path"), 1);
+var import_node_crypto3 = __toESM(require("crypto"), 1);
 var import_node_child_process4 = require("child_process");
 
 // src/tunnel/tunnel-store.ts
@@ -16961,11 +16963,12 @@ var TunnelManager = class {
         override: this.deps.frpcBinaryOverride ?? void 0
       });
       const tomlPath = import_node_path12.default.join(this.deps.dataDir, "frpc.toml");
+      const proxyName = `clawd-${t.subdomain}-${localPort}-${import_node_crypto3.default.randomBytes(3).toString("hex")}`;
       const toml = buildFrpcToml({
         serverAddr: t.frpsHost,
         serverPort: t.frpsPort,
         authToken: t.frpsToken,
-        proxyName: "clawd",
+        proxyName,
         subdomain: t.subdomain,
         localPort,
         logLevel: "info"
@@ -16992,7 +16995,10 @@ var TunnelManager = class {
           proc.kill("SIGTERM");
         } catch {
         }
-        return { ok: false, error: new Error(ready.error) };
+        const tail = formatFrpcTail(ready.output);
+        const msg = tail ? `${ready.error}
+${tail}` : ready.error;
+        return { ok: false, error: new Error(msg) };
       }
       this.deps.logger?.info("tunnel: frpc up", { subdomain: t.subdomain, url: t.url });
       return { ok: true, proc };
@@ -17002,6 +17008,13 @@ var TunnelManager = class {
     }
   }
 };
+function formatFrpcTail(raw, maxLines = 12) {
+  const stripped = raw.replace(/\[[0-9;]*[A-Za-z]/g, "");
+  const lines = stripped.split("\n").filter((l) => l.trim().length > 0);
+  if (lines.length === 0) return "";
+  const tail = lines.slice(-maxLines).join("\n");
+  return ["\u2500\u2500\u2500 frpc output (last lines) \u2500\u2500\u2500", tail, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"].join("\n");
+}
 async function waitForFrpcReady(proc, timeoutMs) {
   return new Promise((resolve) => {
     let settled = false;
@@ -17018,13 +17031,16 @@ async function waitForFrpcReady(proc, timeoutMs) {
         finish({ ok: true });
       }
       if (/login to server failed|authentication failed/i.test(buf)) {
-        finish({ ok: false, error: `frpc handshake failed: ${buf.trim().slice(-200)}` });
+        finish({ ok: false, error: "frpc handshake failed", output: buf });
+      }
+      if (/start error: proxy \[[^\]]+\] already exists/i.test(buf)) {
+        finish({ ok: false, error: "frpc proxy name conflict", output: buf });
       }
     };
     const onExit = (code) => {
-      finish({ ok: false, error: `frpc exited before ready (code=${code})` });
+      finish({ ok: false, error: `frpc exited before ready (code=${code})`, output: buf });
     };
-    const onErr = (err) => finish({ ok: false, error: `frpc spawn error: ${err.message}` });
+    const onErr = (err) => finish({ ok: false, error: `frpc spawn error: ${err.message}`, output: buf });
     const cleanup = () => {
       proc.stdout?.off("data", onData);
       proc.stderr?.off("data", onData);
@@ -17037,26 +17053,26 @@ async function waitForFrpcReady(proc, timeoutMs) {
     proc.on("exit", onExit);
     proc.on("error", onErr);
     const timer = setTimeout(() => {
-      finish({ ok: false, error: `frpc startup timeout after ${timeoutMs}ms` });
+      finish({ ok: false, error: `frpc startup timeout after ${timeoutMs}ms`, output: buf });
     }, timeoutMs);
   });
 }
 
 // src/tunnel/device-key.ts
 var import_node_os8 = __toESM(require("os"), 1);
-var import_node_crypto3 = __toESM(require("crypto"), 1);
+var import_node_crypto4 = __toESM(require("crypto"), 1);
 var DERIVE_SALT = "clawd-tunnel-device-v1";
 function deriveStableDeviceKey(opts = {}) {
   const hostname = opts.hostname ?? import_node_os8.default.hostname();
   const uid = opts.uid ?? (typeof import_node_os8.default.userInfo === "function" ? import_node_os8.default.userInfo().uid : 0);
   const input = `${hostname}::${uid}`;
-  return import_node_crypto3.default.createHmac("sha256", DERIVE_SALT).update(input).digest("hex").slice(0, 32);
+  return import_node_crypto4.default.createHmac("sha256", DERIVE_SALT).update(input).digest("hex").slice(0, 32);
 }
 
 // src/auth-store.ts
 var import_node_fs14 = __toESM(require("fs"), 1);
 var import_node_path13 = __toESM(require("path"), 1);
-var import_node_crypto4 = __toESM(require("crypto"), 1);
+var import_node_crypto5 = __toESM(require("crypto"), 1);
 var AUTH_FILE_NAME = "auth.json";
 function authFilePath(dataDir) {
   return import_node_path13.default.join(dataDir, AUTH_FILE_NAME);
@@ -17071,7 +17087,7 @@ function loadOrCreateAuthToken(opts) {
   return token;
 }
 function defaultGenerate() {
-  return import_node_crypto4.default.randomBytes(32).toString("base64url");
+  return import_node_crypto5.default.randomBytes(32).toString("base64url");
 }
 function readAuthFile(file) {
   try {
@@ -17488,11 +17504,27 @@ async function startDaemon(config) {
       const r = await tunnelMgr.start({ localPort: config.port });
       stateSnapshot = { ...stateSnapshot, tunnelUrl: r.url };
       stateMgr.write(stateSnapshot);
-      process.stdout.write(`Tunnel: ${r.url}
+      const connectUrl = resolvedAuthToken ? `${r.url}#token=${resolvedAuthToken}` : r.url;
+      const lines = [
+        `Tunnel:      ${r.url}`,
+        ...resolvedAuthToken ? [`Connect:     ${connectUrl}`] : [],
+        `Frpc config: ${import_node_path15.default.join(config.dataDir, "frpc.toml")}`,
+        `Frpc log:    ${import_node_path15.default.join(config.dataDir, "frpc.log")}`
+      ];
+      const width = Math.max(...lines.map((l) => l.length));
+      const bar = "\u2550".repeat(width + 4);
+      process.stdout.write(`
+${bar}
+`);
+      for (const l of lines) process.stdout.write(`  ${l}
 `);
-      if (resolvedAuthToken) {
-        process.stdout.write(`Connect: ${r.url}#token=${resolvedAuthToken}
+      process.stdout.write(`${bar}
+
 `);
+      try {
+        const connectPath = import_node_path15.default.join(config.dataDir, "connect.txt");
+        import_node_fs16.default.writeFileSync(connectPath, lines.join("\n") + "\n", { mode: 384 });
+      } catch {
       }
     } catch (err) {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.2-beta.1.e86e2eb",
+  "version": "0.2.2-beta.2.b7ef550",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",