agent-office-cli 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office-cli",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Run and manage AI agent sessions locally, with optional relay to agentoffice.top",
   "license": "MIT",
   "engines": {

package/src/index.js

@@ -202,6 +202,9 @@ async function main() {
       });
       console.log(`AgentOffice tunnel connecting to relay: ${hosted.relayUrl}`);
       console.log(`- hosted auth: key from ${hosted.keySource}, relay from ${hosted.relaySource}`);
+      if (tunnel.logPath) {
+        console.log(`- tunnel log: ${tunnel.logPath}`);
+      }
       tunnel.sendStatusSummary(store.listSessionSummaries());
 
       let statusDebounceTimer = null;

package/src/runtime/index.js

@@ -19,6 +19,7 @@ const {
 } = require("./session-registry");
 const { ensureNodePtySpawnHelper } = require("./ensure-node-pty");
 const { startSleepInhibitor } = require("./sleep-inhibitor");
+const { createTunnelLogger, TUNNEL_LOG_PATH, describeWebSocketClose } = require("./tunnel-log");
 const {
   applyClaudeHookConfig,
   claudeSettingsPath,
@@ -47,6 +48,9 @@ module.exports = {
   removeSessionRecord,
   ensureNodePtySpawnHelper,
   startSleepInhibitor,
+  createTunnelLogger,
+  TUNNEL_LOG_PATH,
+  describeWebSocketClose,
   applyClaudeHookConfig,
   claudeSettingsPath,
   commandExists,

package/src/runtime/tunnel-log.js

@@ -0,0 +1,56 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const TUNNEL_LOG_PATH = path.join(os.homedir(), ".agentoffice", "logs", "tunnel.log");
+
+function describeWebSocketClose({ code, reason }) {
+  const parts = [];
+
+  if (typeof code === "number") {
+    parts.push(`code=${code}`);
+  }
+
+  if (reason) {
+    parts.push(`reason=${reason}`);
+  }
+
+  return parts.length > 0 ? parts.join(" ") : "no close details";
+}
+
+function createTunnelLogger({
+  logPath = TUNNEL_LOG_PATH,
+  now = () => new Date().toISOString(),
+  mkdirSync = fs.mkdirSync,
+  appendFileSync = fs.appendFileSync,
+  consoleObj = console,
+} = {}) {
+  function write(level, message) {
+    const line = `[${now()}] [${level}] ${message}`;
+    const print = level === "error" ? consoleObj.error : consoleObj.log;
+    print.call(consoleObj, line);
+
+    try {
+      mkdirSync(path.dirname(logPath), { recursive: true });
+      appendFileSync(logPath, `${line}\n`, "utf8");
+    } catch {
+      // Logging should never crash the tunnel client.
+    }
+  }
+
+  return {
+    logPath,
+    info(message) {
+      write("info", message);
+    },
+    error(message) {
+      write("error", message);
+    },
+  };
+}
+
+module.exports = {
+  TUNNEL_LOG_PATH,
+  createTunnelLogger,
+  describeWebSocketClose,
+};

package/src/runtime/tunnel-log.test.js

@@ -0,0 +1,43 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { createTunnelLogger, describeWebSocketClose } = require("./tunnel-log");
+
+test("describeWebSocketClose includes code and reason when present", () => {
+  assert.equal(
+    describeWebSocketClose({ code: 1006, reason: "network_reset" }),
+    "code=1006 reason=network_reset"
+  );
+});
+
+test("describeWebSocketClose falls back when no details are available", () => {
+  assert.equal(describeWebSocketClose({}), "no close details");
+});
+
+test("createTunnelLogger mirrors lines to console and appends a local tunnel log", () => {
+  const writes = [];
+  const consoleLines = [];
+
+  const logger = createTunnelLogger({
+    logPath: "/tmp/agentoffice-tunnel.log",
+    now: () => "2026-03-20T08:12:00.000Z",
+    mkdirSync: () => {},
+    appendFileSync: (_path, content) => writes.push(content),
+    consoleObj: {
+      log: (line) => consoleLines.push(["log", line]),
+      error: (line) => consoleLines.push(["error", line]),
+    },
+  });
+
+  logger.info("connected to relay");
+  logger.error("ws error: socket hang up");
+
+  assert.deepEqual(consoleLines, [
+    ["log", "[2026-03-20T08:12:00.000Z] [info] connected to relay"],
+    ["error", "[2026-03-20T08:12:00.000Z] [error] ws error: socket hang up"],
+  ]);
+  assert.deepEqual(writes, [
+    "[2026-03-20T08:12:00.000Z] [info] connected to relay\n",
+    "[2026-03-20T08:12:00.000Z] [error] ws error: socket hang up\n",
+  ]);
+});

package/src/tunnel.js

@@ -1,5 +1,6 @@
 const { WebSocket } = require("ws");
 const { toSessionSummary } = require("./core");
+const { createTunnelLogger, describeWebSocketClose } = require("./runtime/tunnel-log");
 
 const RECONNECT_BASE_MS = 1000;
 const RECONNECT_MAX_MS = 30000;
@@ -40,7 +41,7 @@ function buildLocalRequestHeaders(headers, localServerUrl) {
   return nextHeaders;
 }
 
-function createTunnelClient({ key, relayUrl, localServerUrl }) {
+function createTunnelClient({ key, relayUrl, localServerUrl, logger = createTunnelLogger() }) {
   let ws = null;
   let reconnectDelay = RECONNECT_BASE_MS;
   let stopped = false;
@@ -68,7 +69,7 @@ function createTunnelClient({ key, relayUrl, localServerUrl }) {
 
     ws.on("open", () => {
       reconnectDelay = RECONNECT_BASE_MS;
-      console.log("[tunnel] connected to relay, authenticating...");
+      logger.info("[tunnel] connected to relay, authenticating...");
       ws.send(JSON.stringify({ type: "auth", key }));
     });
 
@@ -91,12 +92,12 @@ function createTunnelClient({ key, relayUrl, localServerUrl }) {
 
         if (msg.type === "auth:ok") {
           authenticated = true;
-          console.log(`[tunnel] authenticated with relay: ${relayUrl} (userId=${msg.userId})`);
+          logger.info(`[tunnel] authenticated with relay: ${relayUrl} (userId=${msg.userId})`);
           flushStatusSummary();
           return;
         }
         if (msg.type === "auth:error") {
-          console.error(`[tunnel] authentication failed: ${msg.error || "invalid key"}`);
+          logger.error(`[tunnel] authentication failed: ${msg.error || "invalid key"}`);
           stopped = true;
           ws.close();
           return;
@@ -108,20 +109,23 @@ function createTunnelClient({ key, relayUrl, localServerUrl }) {
 
         await handleRelayMessage(msg);
       } catch (err) {
-        console.error(`[tunnel] message error: ${err.message}`);
+        logger.error(`[tunnel] message error: ${err.message}`);
       }
     });
 
-    ws.on("close", (code) => {
+    ws.on("close", (code, reasonBuffer) => {
+      const reason = Buffer.isBuffer(reasonBuffer) ? reasonBuffer.toString("utf8") : String(reasonBuffer || "");
+      const closeDetails = describeWebSocketClose({ code, reason });
       if (stopped) {
+        logger.info(`[tunnel] stopped with close ${closeDetails}`);
         return;
       }
       if (code === 4401) {
-        console.error("[tunnel] authentication rejected by relay. Not reconnecting.");
+        logger.error(`[tunnel] authentication rejected by relay (${closeDetails}). Not reconnecting.`);
         stopped = true;
         return;
       }
-      console.log(`[tunnel] disconnected (${code}). Reconnecting in ${reconnectDelay}ms...`);
+      logger.info(`[tunnel] disconnected (${closeDetails}). Reconnecting in ${reconnectDelay}ms...`);
       setTimeout(() => {
         reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
         connect();
@@ -129,7 +133,7 @@ function createTunnelClient({ key, relayUrl, localServerUrl }) {
     });
 
     ws.on("error", (err) => {
-      console.error(`[tunnel] ws error: ${err.message}`);
+      logger.error(`[tunnel] ws error: ${err.message}`);
     });
   }
 
@@ -250,6 +254,7 @@ function createTunnelClient({ key, relayUrl, localServerUrl }) {
   connect();
 
   return {
+    logPath: logger.logPath,
     sendStatusSummary,
     stop
   };