hotsheet 0.17.0-beta.22 → 0.17.0-beta.24

package/dist/channel.js

@@ -34145,9 +34145,9 @@ var StdioServerTransport = class {
 
 // src/channel.ts
 init_zod();
-import { readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { createServer } from "http";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/channel.tools.ts
 init_zod();
@@ -34685,9 +34685,113 @@ async function callTool(name, args2, dataDir2, fetchFn = globalThis.fetch) {
 }
 
 // src/channel-config.ts
-import { basename as basename2, dirname, join as join2, resolve } from "path";
+import { basename as basename2, dirname, join as join3, resolve } from "path";
 init_zod();
 
+// src/channelLog.ts
+import { appendFileSync, renameSync, statSync } from "fs";
+import { join as join2 } from "path";
+var CHANNEL_LOG_MAX_BYTES = 1048576;
+function createChannelLogger(logPath, options = {}) {
+  let injectedBlankLine = false;
+  const pidSuffix = options.pidLabel !== void 0 && options.pidLabel !== "" ? ` ${options.pidLabel}` : "";
+  return {
+    log(event, details) {
+      try {
+        const size = safeStatSize(logPath);
+        if (size >= CHANNEL_LOG_MAX_BYTES) {
+          try {
+            renameSync(logPath, `${logPath}.old`);
+          } catch {
+          }
+        }
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        const detailsText = details === void 0 || details === "" ? "" : ` ${details}`;
+        const prefix = !injectedBlankLine && size > 0 ? "\n" : "";
+        injectedBlankLine = true;
+        appendFileSync(logPath, `${prefix}[${ts}] [pid ${process.pid}${pidSuffix}] ${event}:${detailsText}
+`, "utf-8");
+      } catch {
+      }
+    }
+  };
+}
+function safeStatSize(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+
+// src/channelPortFile.ts
+import { closeSync, openSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
+function readChannelInfo(portFile2) {
+  let raw;
+  try {
+    raw = readFileSync2(portFile2, "utf-8").trim();
+  } catch {
+    return null;
+  }
+  if (raw === "") return null;
+  if (raw.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null) return null;
+      const obj = parsed;
+      if (typeof obj.port !== "number" || !Number.isInteger(obj.port)) return null;
+      return {
+        port: obj.port,
+        pid: typeof obj.pid === "number" && Number.isInteger(obj.pid) ? obj.pid : null,
+        slug: typeof obj.slug === "string" && obj.slug !== "" ? obj.slug : null,
+        startedAt: typeof obj.startedAt === "string" && obj.startedAt !== "" ? obj.startedAt : null
+      };
+    } catch {
+      return null;
+    }
+  }
+  const legacyPort = parseInt(raw, 10);
+  if (isNaN(legacyPort)) return null;
+  return { port: legacyPort, pid: null, slug: null, startedAt: null };
+}
+function writeChannelInfo(portFile2, info) {
+  const tmp = `${portFile2}.tmp.${process.pid.toString(36)}`;
+  const body = JSON.stringify({
+    port: info.port,
+    pid: info.pid,
+    slug: info.slug,
+    startedAt: info.startedAt
+  });
+  writeFileSync(tmp, body, "utf-8");
+  renameSync2(tmp, portFile2);
+  try {
+    const slash = portFile2.lastIndexOf("/");
+    if (slash > 0) {
+      const fd = openSync(portFile2.slice(0, slash), "r");
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function maybeUnlinkPortFile(portFile2, myPort2, myPid = process.pid) {
+  const info = readChannelInfo(portFile2);
+  if (info === null) return false;
+  if (info.pid !== null) {
+    if (info.pid !== myPid) return false;
+  } else {
+    if (info.port !== myPort2) return false;
+  }
+  try {
+    unlinkSync(portFile2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/claude-allow-rule.ts
 init_zod();
 init_file_settings();
@@ -34731,6 +34835,48 @@ function clearAllPermissions() {
   queue.length = 0;
 }
 
+// src/channelPortFileWatcher.ts
+var REWRITE_BURST_MAX = 5;
+var REWRITE_BURST_WINDOW_MS = 6e4;
+function installPortFileWatcher(opts) {
+  const intervalMs = opts.intervalMs ?? 5e3;
+  const setIntervalFn = opts.setIntervalFn ?? setInterval;
+  const clearIntervalFn = opts.clearIntervalFn ?? ((handle2) => {
+    clearInterval(handle2);
+  });
+  const rewriteTimestamps = [];
+  let livelocked = false;
+  const tick = () => {
+    if (livelocked) return;
+    const current = readChannelInfo(opts.portFile);
+    if (current !== null && current.pid === opts.info.pid && current.port === opts.info.port && current.slug === opts.info.slug) {
+      return;
+    }
+    const now = Date.now();
+    while (rewriteTimestamps.length > 0 && now - rewriteTimestamps[0] > REWRITE_BURST_WINDOW_MS) {
+      rewriteTimestamps.shift();
+    }
+    if (rewriteTimestamps.length >= REWRITE_BURST_MAX) {
+      livelocked = true;
+      opts.log?.("port-file-heal-livelock", `${String(REWRITE_BURST_MAX)} rewrites in ${String(REWRITE_BURST_WINDOW_MS)}ms \u2014 giving up to avoid hot-spin`);
+      return;
+    }
+    rewriteTimestamps.push(now);
+    const reason = current === null ? "vanished" : `pid-mismatch on-disk=${String(current.pid)} ours=${String(opts.info.pid)}`;
+    try {
+      writeChannelInfo(opts.portFile, opts.info);
+      opts.log?.("port-file-heal-rewrite", reason);
+      opts.notify?.();
+    } catch (err) {
+      opts.log?.("port-file-heal-error", String(err));
+    }
+  };
+  const handle = setIntervalFn(tick, intervalMs);
+  return () => {
+    clearIntervalFn(handle);
+  };
+}
+
 // src/channelStdioWatcher.ts
 function installStdioDisconnectHandler(opts) {
   const { stdin, stdout, onDisconnect, log } = opts;
@@ -34774,7 +34920,7 @@ function installStdioDisconnectHandler(opts) {
 }
 
 // src/channel.ts
-var CHANNEL_VERSION = 7;
+var CHANNEL_VERSION = 8;
 var dataDir = ".hotsheet";
 var args = process.argv.slice(2);
 for (let i = 0; i < args.length; i++) {
@@ -34783,9 +34929,12 @@ for (let i = 0; i < args.length; i++) {
     i++;
   }
 }
-var portFile = join3(dataDir, "channel-port");
+var portFile = join4(dataDir, "channel-port");
 var serverSlug = slugifyDataDir(dataDir);
 var serverName = `hotsheet-channel-${serverSlug}`;
+var processStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+var channelLog = createChannelLogger(join4(dataDir, "mcp.log"));
+channelLog.log("process-start", `argv=${process.argv.slice(2).join(" ")} dataDir=${dataDir} serverName=${serverName}`);
 var mcp = new Server(
   { name: serverName, version: "0.1.0" },
   {
@@ -34816,17 +34965,23 @@ mcp.setRequestHandler(ListToolsRequestSchema, () => {
 });
 mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args2 } = request.params;
+  channelLog.log("tools/call", `name=${name}`);
   const result = await callTool(name, args2 ?? {}, dataDir);
   return result;
 });
 await mcp.connect(new StdioServerTransport());
+channelLog.log("mcp-connect", "StdioServerTransport ready");
 installStdioDisconnectHandler({
   stdin: process.stdin,
   stdout: process.stdout,
-  log: (msg) => process.stderr.write(`${serverName}: ${msg}
-`),
-  onDisconnect: () => {
-    void cleanup();
+  log: (msg) => {
+    process.stderr.write(`${serverName}: ${msg}
+`);
+    channelLog.log("stdio-watcher", msg);
+  },
+  onDisconnect: (reason) => {
+    channelLog.log("disconnect", `reason=${reason} \u2014 invoking cleanup`);
+    void cleanup(`stdio-${reason}`);
   }
 });
 var PermissionRequestSchema = external_exports3.object({
@@ -34866,7 +35021,13 @@ var httpServer = createServer(async (req, res) => {
   }
   if (req.method === "GET" && req.url === "/health") {
     res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ ok: true, version: CHANNEL_VERSION }));
+    res.end(JSON.stringify({
+      ok: true,
+      version: CHANNEL_VERSION,
+      pid: process.pid,
+      slug: serverSlug,
+      startedAt: processStartedAt
+    }));
     return;
   }
   if (req.method === "GET" && req.url === "/permission") {
@@ -34972,6 +35133,7 @@ var httpServer = createServer(async (req, res) => {
       }
       body += String(chunk);
     }
+    channelLog.log("trigger", `bodyBytes=${body.length}`);
     try {
       await mcp.notification({
         method: "notifications/claude/channel",
@@ -34983,6 +35145,7 @@ var httpServer = createServer(async (req, res) => {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ ok: true }));
     } catch (err) {
+      channelLog.log("trigger-error", String(err));
       res.writeHead(500, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: String(err) }));
     }
@@ -34999,8 +35162,8 @@ var httpServer = createServer(async (req, res) => {
 });
 function notifyMainServer(abortSignal) {
   try {
-    const settingsPath = join3(dataDir, "settings.json");
-    const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+    const settingsPath = join4(dataDir, "settings.json");
+    const settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
     if (settings.port === void 0 || settings.port === 0) {
       process.stderr.write(`[notify] no port in settings.json
 `);
@@ -35024,40 +35187,78 @@ function notifyMainServer(abortSignal) {
     return Promise.resolve();
   }
 }
+var myPort = null;
+var disposePortFileWatcher = null;
 httpServer.listen(0, "127.0.0.1", () => {
   const addr = httpServer.address();
   if (addr !== null && typeof addr !== "string") {
     const port = addr.port;
+    myPort = port;
+    const myInfo = {
+      port,
+      pid: process.pid,
+      slug: serverSlug,
+      startedAt: processStartedAt
+    };
     try {
-      writeFileSync(portFile, String(port), "utf-8");
+      writeChannelInfo(portFile, myInfo);
     } catch {
     }
+    disposePortFileWatcher = installPortFileWatcher({
+      portFile,
+      info: myInfo,
+      intervalMs: 5e3,
+      log: (event, details) => channelLog.log(event, details),
+      notify: () => {
+        void notifyMainServer();
+      }
+    });
     process.stderr.write(`${serverName} listening on port ${port}
 `);
+    channelLog.log("http-listen", `port=${port}`);
     void notifyMainServer();
   }
 });
-async function cleanup() {
-  try {
-    unlinkSync(portFile);
-  } catch {
-  }
+var heartbeatInterval = setInterval(() => {
+  const mem = process.memoryUsage();
+  channelLog.log("heartbeat", `uptime=${process.uptime().toFixed(1)}s rss=${(mem.rss / 1024 / 1024).toFixed(1)}MiB`);
+}, 6e4);
+heartbeatInterval.unref();
+var cleanupInFlight = false;
+async function cleanup(reason = "unspecified") {
+  if (cleanupInFlight) return;
+  cleanupInFlight = true;
+  channelLog.log("cleanup-start", `reason=${reason}`);
+  clearInterval(heartbeatInterval);
+  if (disposePortFileWatcher !== null) {
+    disposePortFileWatcher();
+    disposePortFileWatcher = null;
+  }
+  if (myPort !== null) maybeUnlinkPortFile(portFile, myPort);
   try {
     const controller = new AbortController();
     setTimeout(() => controller.abort(), 1e3);
     await notifyMainServer(controller.signal);
   } catch {
   }
+  channelLog.log("cleanup-end", `reason=${reason} \u2014 exiting`);
   process.exit(0);
 }
-process.on("SIGTERM", () => void cleanup());
-process.on("SIGINT", () => void cleanup());
-process.on("SIGHUP", () => void cleanup());
-process.on("exit", () => {
-  try {
-    unlinkSync(portFile);
-  } catch {
-  }
+process.on("SIGTERM", () => {
+  channelLog.log("signal", "SIGTERM");
+  void cleanup("SIGTERM");
+});
+process.on("SIGINT", () => {
+  channelLog.log("signal", "SIGINT");
+  void cleanup("SIGINT");
+});
+process.on("SIGHUP", () => {
+  channelLog.log("signal", "SIGHUP");
+  void cleanup("SIGHUP");
+});
+process.on("exit", (code) => {
+  channelLog.log("exit", `code=${code}`);
+  if (myPort !== null) maybeUnlinkPortFile(portFile, myPort);
 });
 export {
   CHANNEL_VERSION