agent-office-cli 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office-cli",
-  "version": "0.1.5",
+  "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

@@ -19,6 +19,7 @@ const {
   createPtyManager,
   defaultTransportForProvider,
   ensureNodePtySpawnHelper,
+  startSleepInhibitor,
   listSessionRecords,
   removeSessionRecord,
   applyClaudeHookConfig,
@@ -172,6 +173,13 @@ async function main() {
       throw new Error("tmux is required for AgentOffice local sessions. Install it first, for example with `brew install tmux`.");
     }
 
+    const sleepInhibitor = startSleepInhibitor({ commandExists });
+    if (sleepInhibitor.started) {
+      console.log("- sleep guard: caffeinate active");
+    } else if (process.platform === "darwin") {
+      console.log("- sleep guard: skipped (caffeinate unavailable)");
+    }
+
     const store = createSessionStore();
     const ptyManager = createPtyManager({ store });
     const restored = ptyManager.restoreManagedSessions();
@@ -194,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

@@ -18,6 +18,8 @@ const {
   removeSessionRecord
 } = 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,
@@ -45,6 +47,10 @@ module.exports = {
   persistSessionRecord,
   removeSessionRecord,
   ensureNodePtySpawnHelper,
+  startSleepInhibitor,
+  createTunnelLogger,
+  TUNNEL_LOG_PATH,
+  describeWebSocketClose,
   applyClaudeHookConfig,
   claudeSettingsPath,
   commandExists,

package/src/runtime/sleep-inhibitor.js

@@ -0,0 +1,31 @@
+const { spawn } = require("node:child_process");
+
+function startSleepInhibitor({
+  pid = process.pid,
+  platform = process.platform,
+  commandExists = () => true,
+  spawn: spawnProcess = spawn
+} = {}) {
+  if (platform !== "darwin") {
+    return { started: false, reason: "unsupported_platform" };
+  }
+
+  if (!commandExists("caffeinate")) {
+    return { started: false, reason: "missing_command" };
+  }
+
+  const child = spawnProcess("caffeinate", ["-dimsu", "-w", String(pid)], {
+    stdio: "ignore"
+  });
+  child.unref?.();
+
+  return {
+    started: true,
+    reason: "started",
+    child
+  };
+}
+
+module.exports = {
+  startSleepInhibitor
+};

package/src/runtime/sleep-inhibitor.test.js

@@ -0,0 +1,63 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { startSleepInhibitor } = require("./sleep-inhibitor");
+
+test("startSleepInhibitor starts caffeinate by default on macOS", () => {
+  const calls = [];
+  const child = {
+    unrefCalled: false,
+    unref() {
+      this.unrefCalled = true;
+    }
+  };
+
+  const result = startSleepInhibitor({
+    pid: 4321,
+    platform: "darwin",
+    commandExists: (command) => command === "caffeinate",
+    spawn: (command, args, options) => {
+      calls.push({ command, args, options });
+      return child;
+    }
+  });
+
+  assert.deepEqual(calls, [
+    {
+      command: "caffeinate",
+      args: ["-dimsu", "-w", "4321"],
+      options: { stdio: "ignore" }
+    }
+  ]);
+  assert.equal(child.unrefCalled, true);
+  assert.equal(result.started, true);
+  assert.equal(result.reason, "started");
+});
+
+test("startSleepInhibitor skips non-macOS platforms", () => {
+  const result = startSleepInhibitor({
+    pid: 4321,
+    platform: "linux",
+    commandExists: () => true,
+    spawn: () => {
+      throw new Error("spawn should not be called");
+    }
+  });
+
+  assert.equal(result.started, false);
+  assert.equal(result.reason, "unsupported_platform");
+});
+
+test("startSleepInhibitor skips when caffeinate is unavailable", () => {
+  const result = startSleepInhibitor({
+    pid: 4321,
+    platform: "darwin",
+    commandExists: () => false,
+    spawn: () => {
+      throw new Error("spawn should not be called");
+    }
+  });
+
+  assert.equal(result.started, false);
+  assert.equal(result.reason, "missing_command");
+});

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
   };