@holin-work/holin-cli 1.2.0 → 1.3.0

package/bin/holin-cli.js

@@ -11,18 +11,21 @@
  *   holin-cli proxy status                         # check proxy status
  */
 
-import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync, openSync, appendFileSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync, openSync, appendFileSync, statSync, renameSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import http from "http";
 import https from "https";
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
 const UPSTREAM_URL = "https://api.holin.work/icbu/mcp";
 const PROXY_HOST = "127.0.0.1";
 const PROXY_PORT = 18787;
+const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes idle → auto-exit
+const HEALTH_CHECK_INTERVAL_MS = 60 * 1000; // check idle + credentials every 60s
+const LOG_MAX_BYTES = 5 * 1024 * 1024; // 5MB log rotation
 
 const CONFIG_DIR = join(
   process.env.XDG_CONFIG_HOME || join(homedir(), ".config"),
@@ -79,12 +82,47 @@ function log(msg) {
   const line = `[${new Date().toISOString()}] ${msg}\n`;
   try {
     ensureConfigDir();
+    // Rotate log if too large
+    if (existsSync(LOG_FILE)) {
+      const stat = statSync(LOG_FILE);
+      if (stat.size > LOG_MAX_BYTES) {
+        const rotated = LOG_FILE + ".1";
+        if (existsSync(rotated)) unlinkSync(rotated);
+        renameSync(LOG_FILE, rotated);
+      }
+    }
     appendFileSync(LOG_FILE, line);
   } catch {
     console.error(line.trim());
   }
 }
 
+/**
+ * Check if a port is in use, and if so, whether it's an old holin-cli proxy.
+ * Returns { inUse: boolean, isHolinProxy: boolean, pid: number|null }
+ */
+function checkPortInUse(port) {
+  try {
+    const output = execSync(`lsof -i :${port} -sTCP:LISTEN -P -n`, { encoding: "utf8" }).trim();
+    if (!output) return { inUse: false, isHolinProxy: false, pid: null };
+    // Parse PID from lsof output (second column, first data row)
+    const lines = output.split("\n").filter(l => l.includes("LISTEN"));
+    if (lines.length === 0) return { inUse: false, isHolinProxy: false, pid: null };
+    const parts = lines[0].split(/\s+/);
+    const pid = parseInt(parts[1], 10);
+    // Check if it's a holin-cli process
+    try {
+      const cmd = execSync(`ps -p ${pid} -o command=`, { encoding: "utf8" }).trim();
+      const isHolin = cmd.includes("holin-cli") && cmd.includes("proxy");
+      return { inUse: true, isHolinProxy: isHolin, pid };
+    } catch {
+      return { inUse: true, isHolinProxy: false, pid };
+    }
+  } catch {
+    return { inUse: false, isHolinProxy: false, pid: null };
+  }
+}
+
 /**
  * Verify API key by calling holin_ping via MCP.
  */
@@ -161,8 +199,12 @@ async function setCredentials(apiKey) {
 
 // ── Proxy Server ─────────────────────────────────────────────────────────────
 
+let lastRequestTime = Date.now();
+
 function createProxyServer() {
   const server = http.createServer((req, res) => {
+    lastRequestTime = Date.now();
+    const requestStart = Date.now();
     // Collect request body for logging
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
@@ -174,7 +216,7 @@ function createProxyServer() {
         bodyPreview = JSON.stringify({ method: parsed.method, id: parsed.id, params: parsed.params ? Object.keys(parsed.params) : undefined });
       } catch { /* not JSON */ }
 
-      log(`[proxy] ${req.method} ${req.url} body=${bodyPreview}`);
+      log(`[proxy] → ${req.method} ${req.url} body=${bodyPreview}`);
 
       // Block OAuth discovery probes — return 401 so platform knows auth is required
       if (req.url.startsWith("/.well-known/")) {
@@ -235,15 +277,64 @@ function createProxyServer() {
       headers: forwardHeaders,
     };
 
+    // Parse request body to determine MCP method
+    let mcpMethod = "";
+    try {
+      const parsed = JSON.parse(rawBody);
+      mcpMethod = parsed.method || "";
+    } catch { /* not JSON */ }
+
+    // Non-streaming methods should return JSON, not SSE
+    // Accio expects JSON for initialize and tools/list
+    const shouldConvertToJson = mcpMethod === "initialize" || mcpMethod === "tools/list";
+
     const proxyReq = https.request(options, (proxyRes) => {
-      log(`[proxy] ← ${proxyRes.statusCode} content-type=${proxyRes.headers["content-type"]}`);
-      // Forward response headers (strip content-length for chunked SSE)
-      const headers = { ...proxyRes.headers };
-      delete headers["content-length"];
-      delete headers["transfer-encoding"];
-
-      res.writeHead(proxyRes.statusCode || 502, headers);
-      proxyRes.pipe(res);
+      const elapsed = Date.now() - requestStart;
+      log(`[proxy] ← ${proxyRes.statusCode} ${elapsed}ms content-type=${proxyRes.headers["content-type"]} method=${mcpMethod}`);
+
+      if (shouldConvertToJson && proxyRes.headers["content-type"]?.includes("text/event-stream")) {
+        // Collect SSE response and convert to JSON
+        log(`[proxy] converting SSE→JSON for ${mcpMethod}`);
+        const sseChunks = [];
+        let ended = false;
+        const finish = () => {
+          if (ended) return;
+          ended = true;
+          const sseText = Buffer.concat(sseChunks).toString("utf8");
+          let jsonBody = sseText;
+          // Parse SSE: extract the last "data:" line
+          for (const line of sseText.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("data:")) {
+              jsonBody = trimmed.slice(5).trim();
+            }
+          }
+          const headers = { ...proxyRes.headers };
+          headers["content-type"] = "application/json";
+          headers["content-length"] = Buffer.byteLength(jsonBody);
+          delete headers["transfer-encoding"];
+          // Add mcp-session-id for stateful MCP clients (Accio expects this)
+          if (mcpMethod === "initialize") {
+            headers["mcp-session-id"] = `holin-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+          }
+          log(`[proxy] converted SSE→JSON, ${jsonBody.length} bytes, session=${headers["mcp-session-id"] || "n/a"}`);
+          if (!res.headersSent) {
+            res.writeHead(proxyRes.statusCode || 502, headers);
+            res.end(jsonBody);
+          }
+        };
+        proxyRes.on("data", (c) => sseChunks.push(c));
+        proxyRes.on("end", finish);
+        // Safety timeout: SSE may keep connection open; force finish after 3s
+        setTimeout(finish, 3000);
+      } else {
+        // Stream SSE directly for tools/call and other methods
+        const headers = { ...proxyRes.headers };
+        delete headers["content-length"];
+        delete headers["transfer-encoding"];
+        res.writeHead(proxyRes.statusCode || 502, headers);
+        proxyRes.pipe(res);
+      }
     });
 
     proxyReq.on("error", (err) => {
@@ -368,6 +459,29 @@ function cmdProxyStart() {
     return;
   }
 
+  // Check if port is occupied by an old/stale holin-cli proxy
+  const portCheck = checkPortInUse(PROXY_PORT);
+  if (portCheck.inUse) {
+    if (portCheck.isHolinProxy) {
+      console.log(`[holin-cli] Port ${PROXY_PORT} occupied by stale holin-cli proxy (pid ${portCheck.pid}), killing it...`);
+      try {
+        process.kill(portCheck.pid, "SIGTERM");
+        // Wait for it to exit
+        let waited = 0;
+        while (checkPortInUse(PROXY_PORT).inUse && waited < 3000) {
+          execSync("sleep 0.2");
+          waited += 200;
+        }
+      } catch (err) {
+        console.error(`[holin-cli] Failed to kill stale proxy: ${err.message}`);
+      }
+    } else {
+      console.error(`[holin-cli] Error: Port ${PROXY_PORT} already in use by another process (pid ${portCheck.pid}).`);
+      console.error("[holin-cli] Please free the port or stop the other process.");
+      process.exit(1);
+    }
+  }
+
   const server = createProxyServer();
 
   server.on("error", (err) => {
@@ -381,6 +495,7 @@ function cmdProxyStart() {
 
   server.listen(PROXY_PORT, PROXY_HOST, () => {
     writePidFile(process.pid);
+    lastRequestTime = Date.now();
     const msg = `[holin-cli] Proxy listening on http://${PROXY_HOST}:${PROXY_PORT}/mcp (pid ${process.pid})`;
     if (isDaemon) {
       // Daemon mode: write to log file, don't print to stdout
@@ -390,19 +505,47 @@ function cmdProxyStart() {
       console.log(msg);
       console.log(`[holin-cli] Upstream: ${UPSTREAM_URL}`);
       console.log(`[holin-cli] Health check: http://${PROXY_HOST}:${PROXY_PORT}/health`);
+      console.log(`[holin-cli] Idle timeout: ${IDLE_TIMEOUT_MS / 60000} minutes`);
       console.log("[holin-cli] Press Ctrl+C to stop.");
     }
   });
 
-  // Cleanup on exit
-  const cleanup = () => {
+  // Health check: idle timeout + credentials file monitoring
+  const healthCheck = setInterval(() => {
+    const idleMs = Date.now() - lastRequestTime;
+    if (idleMs > IDLE_TIMEOUT_MS) {
+      log(`[proxy] Idle for ${Math.round(idleMs / 60000)} minutes, auto-exiting.`);
+      cleanupAndExit();
+      return;
+    }
+    // Check if credentials file still exists (user may have logged out / uninstalled)
+    if (!existsSync(CREDENTIALS_FILE)) {
+      log("[proxy] Credentials file removed, auto-exiting.");
+      cleanupAndExit();
+      return;
+    }
+    const creds = readCredentials();
+    if (!creds?.api_key) {
+      log("[proxy] Credentials cleared, auto-exiting.");
+      cleanupAndExit();
+      return;
+    }
+  }, HEALTH_CHECK_INTERVAL_MS);
+
+  function cleanupAndExit() {
+    clearInterval(healthCheck);
+    try {
+      server.close();
+    } catch {}
     try {
       if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
     } catch {}
     process.exit(0);
-  };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
+  }
+
+  // Cleanup on exit
+  process.on("SIGINT", cleanupAndExit);
+  process.on("SIGTERM", cleanupAndExit);
 }
 
 function startProxyDaemon() {
@@ -474,6 +617,115 @@ function cmdProxyStatus() {
   console.log(`[holin-cli] Log file: ${LOG_FILE}`);
 }
 
+async function cmdDoctor() {
+  const results = [];
+  const pass = (msg) => results.push({ ok: true, msg });
+  const fail = (msg, fix) => results.push({ ok: false, msg, fix });
+  const warn = (msg, fix) => results.push({ ok: null, msg, fix });
+
+  // 1. Credentials file
+  const creds = readCredentials();
+  if (!creds?.api_key) {
+    fail("Credentials file missing or empty", "Run: holin-cli auth login");
+  } else if (!creds.api_key.startsWith("holin_")) {
+    fail("API Key format invalid (must start with 'holin_')", "Re-run: holin-cli auth login");
+  } else {
+    pass(`Credentials file OK (${creds.customer_name || creds.customer_id || "unknown"} / ${creds.plan || "unknown plan"})`);
+  }
+
+  // 2. Proxy process
+  const running = isProxyRunning();
+  const pid = readPidFile();
+  if (running && pid) {
+    pass(`Proxy running (pid ${pid})`);
+  } else if (pid && !running) {
+    warn("Stale pid file found (process not running)", "Run: holin-cli proxy stop (cleans pid file)");
+  } else {
+    warn("Proxy not running", "Run: holin-cli auth login (auto-starts proxy)");
+  }
+
+  // 3. Port
+  const portCheck = checkPortInUse(PROXY_PORT);
+  if (portCheck.inUse) {
+    if (portCheck.isHolinProxy) {
+      pass(`Port ${PROXY_PORT} in use by holin-cli proxy (pid ${portCheck.pid})`);
+    } else {
+      fail(`Port ${PROXY_PORT} occupied by another process (pid ${portCheck.pid})`, "Stop the other process or free the port");
+    }
+  } else if (running) {
+    warn(`Proxy running but port ${PROXY_PORT} not listening`, "Proxy may be in a bad state. Run: holin-cli proxy stop && holin-cli proxy start");
+  } else {
+    pass(`Port ${PROXY_PORT} is free`);
+  }
+
+  // 4. Upstream connectivity
+  if (creds?.api_key) {
+    try {
+      const result = await pingVerify(creds.api_key);
+      if (result?.authorized) {
+        pass(`Upstream API OK (authorized as ${result.customer_name || "unknown"})`);
+      } else {
+        fail("Upstream API reachable but API Key not authorized", "Check your API Key in the Holin merchant portal");
+      }
+    } catch (err) {
+      fail(`Upstream API unreachable: ${err.message}`, "Check network connection and https://api.holin.work status");
+    }
+  }
+
+  // 5. MCP tools (via proxy if running)
+  if (running) {
+    try {
+      const res = await fetch(`http://${PROXY_HOST}:${PROXY_PORT}/mcp`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" }),
+        signal: AbortSignal.timeout(5000),
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const tools = data?.result?.tools || [];
+        pass(`MCP tools OK (${tools.length} tools: ${tools.map(t => t.name).join(", ")})`);
+      } else {
+        fail(`MCP tools/list returned ${res.status}`, "Check proxy log: " + LOG_FILE);
+      }
+    } catch (err) {
+      fail(`MCP tools/list failed: ${err.message}`, "Proxy may be unhealthy. Run: holin-cli proxy restart");
+    }
+  }
+
+  // 6. Log file
+  try {
+    const stat = statSync(LOG_FILE);
+    const sizeKB = Math.round(stat.size / 1024);
+    if (stat.size > LOG_MAX_BYTES) {
+      warn(`Log file is ${sizeKB}KB (auto-rotates at ${LOG_MAX_BYTES / 1024 / 1024}MB)`, "Will be rotated on next write");
+    } else {
+      pass(`Log file OK (${sizeKB}KB)`);
+    }
+  } catch {
+    pass("Log file not created yet (no proxy activity)");
+  }
+
+  // Print report
+  console.log("");
+  console.log("=== Holin CLI Doctor ===");
+  console.log("");
+  let hasFail = false;
+  for (const r of results) {
+    const icon = r.ok === true ? "✓" : r.ok === false ? "✗" : "⚠";
+    console.log(`  ${icon} ${r.msg}`);
+    if (!r.ok && r.fix) console.log(`    → ${r.fix}`);
+    if (r.ok === false) hasFail = true;
+  }
+  console.log("");
+  if (hasFail) {
+    console.log("Result: Issues found. Follow the fix suggestions above.");
+    process.exit(1);
+  } else {
+    console.log("Result: All checks passed.");
+  }
+}
+
 // ── Entrypoint ───────────────────────────────────────────────────────────────
 
 const [, , cmd, sub] = process.argv;
@@ -493,6 +745,11 @@ if (cmd === "auth" && sub === "login") {
   cmdProxyStop();
 } else if (cmd === "proxy" && sub === "status") {
   cmdProxyStatus();
+} else if (cmd === "doctor") {
+  cmdDoctor().catch((err) => {
+    console.error(`[holin-cli] Doctor failed: ${err.message}`);
+    process.exit(1);
+  });
 } else {
   console.log("Usage:");
   console.log("  holin-cli auth login     — authorize with HOLIN_API_KEY env var + auto-start proxy");
@@ -501,5 +758,6 @@ if (cmd === "auth" && sub === "login") {
   console.log("  holin-cli proxy start    — start proxy in foreground");
   console.log("  holin-cli proxy stop     — stop background proxy");
   console.log("  holin-cli proxy status   — check proxy status");
+  console.log("  holin-cli doctor         — diagnose all components");
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holin-work/holin-cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Holin CLI — Accio plugin authorization tool for ICBU batch listing",
   "type": "module",
   "bin": {