@drisp/cli 0.4.0 → 0.4.2

package/dist/dashboard-daemon.js

@@ -0,0 +1,255 @@
+import {
+  acquirePidLock,
+  ensureDaemonStateDir,
+  runDashboardRuntimeDaemon,
+  startUdsServer
+} from "./chunk-WHELLVBL.js";
+import "./chunk-BTKQ67RE.js";
+import {
+  readDashboardClientConfig,
+  refreshDashboardAccessToken
+} from "./chunk-4CRZXLIP.js";
+import "./chunk-GE6PPB6Z.js";
+
+// src/infra/daemon/logFile.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_FILES = 5;
+function openDaemonLog(logPath, options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  fs.mkdirSync(path.dirname(logPath), { recursive: true, mode: 448 });
+  let fd = fs.openSync(logPath, "a", 384);
+  if (process.platform !== "win32") {
+    try {
+      fs.chmodSync(logPath, 384);
+    } catch {
+    }
+  }
+  function rotate() {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+    for (let i = maxFiles - 1; i >= 1; i -= 1) {
+      const src = `${logPath}.${i}`;
+      const dst = `${logPath}.${i + 1}`;
+      try {
+        fs.renameSync(src, dst);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+        }
+      }
+    }
+    try {
+      fs.renameSync(logPath, `${logPath}.1`);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+      }
+    }
+    fd = fs.openSync(logPath, "a", 384);
+    if (process.platform !== "win32") {
+      try {
+        fs.chmodSync(logPath, 384);
+      } catch {
+      }
+    }
+  }
+  function write(level, message) {
+    const line = `${now().toISOString()} ${level.toUpperCase()} ${redactSecrets(message)}
+`;
+    const buf = Buffer.from(line, "utf-8");
+    let stat = null;
+    try {
+      stat = fs.fstatSync(fd);
+    } catch {
+    }
+    if (stat && stat.size + buf.length > maxBytes) {
+      rotate();
+    }
+    try {
+      fs.writeSync(fd, buf);
+    } catch {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+      try {
+        fd = fs.openSync(logPath, "a", 384);
+        fs.writeSync(fd, buf);
+      } catch {
+      }
+    }
+  }
+  function close() {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+  }
+  return { write, close, path: logPath };
+}
+var SECRET_PATTERNS = [
+  [/Bearer\s+[A-Za-z0-9._\-+/=]+/g, "Bearer ***"],
+  [
+    /(["']?(?:access|refresh)_?token["']?\s*[:=]\s*)["']?[A-Za-z0-9._\-+/=]+/gi,
+    '$1"***"'
+  ],
+  [/(Sec-WebSocket-Protocol:\s*)\S+/gi, "$1***"],
+  [
+    /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}/g,
+    "***.***.***"
+  ]
+];
+function redactSecrets(message) {
+  let out = message;
+  for (const [pattern, replacement] of SECRET_PATTERNS) {
+    out = out.replace(pattern, replacement);
+  }
+  return out;
+}
+
+// src/app/entry/dashboardDaemon.ts
+async function runDashboardDaemonEntry() {
+  const stateDir = ensureDaemonStateDir();
+  const writer = openDaemonLog(stateDir.logPath);
+  const log = (level, message) => writer.write(level, message);
+  let pidLock;
+  try {
+    pidLock = acquirePidLock(stateDir.pidPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log("error", `daemon startup: ${message}`);
+    writer.close();
+    process.stderr.write(`drisp dashboard daemon: ${message}
+`);
+    return 1;
+  }
+  const config = readDashboardClientConfig();
+  if (!config) {
+    log("error", "daemon startup: not paired");
+    pidLock.release();
+    writer.close();
+    process.stderr.write(
+      'drisp dashboard daemon: not paired. Run "drisp dashboard pair" first.\n'
+    );
+    return 1;
+  }
+  let stopReason = "sigterm";
+  const stopSignal = createDeferred();
+  let daemonHandle = null;
+  try {
+    daemonHandle = await runDashboardRuntimeDaemon({
+      log,
+      refreshAccessToken: async () => refreshDashboardAccessToken({})
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log("error", `runtime startup failed: ${message}`);
+    pidLock.release();
+    writer.close();
+    process.stderr.write(`drisp dashboard daemon: ${message}
+`);
+    return 1;
+  }
+  const handler = (req) => {
+    if (!daemonHandle) {
+      return { ok: false, error: "daemon shutting down" };
+    }
+    switch (req.cmd) {
+      case "status": {
+        const snap = daemonHandle.snapshot();
+        return {
+          ok: true,
+          cmd: "status",
+          pid: pidLock.pid,
+          ...snap
+        };
+      }
+      case "runs": {
+        const runs = daemonHandle.listRuns({
+          ...req.active === true ? { active: true } : {},
+          ...typeof req.limit === "number" ? { limit: req.limit } : {}
+        });
+        return { ok: true, cmd: "runs", runs };
+      }
+      case "reload": {
+        return { ok: true, cmd: "reload" };
+      }
+      case "restart": {
+        stopReason = req.cmd;
+        stopSignal.resolve("restart");
+        return { ok: true, cmd: "restart" };
+      }
+      case "stop": {
+        stopReason = req.reason ?? "stop";
+        stopSignal.resolve("stop");
+        return { ok: true, cmd: "stop" };
+      }
+      default: {
+        const _exhaustive = req;
+        return {
+          ok: false,
+          error: `unknown command: ${JSON.stringify(_exhaustive)}`
+        };
+      }
+    }
+  };
+  const udsServer = await startUdsServer(stateDir.socketPath, handler, log);
+  log("info", `dashboard daemon listening on ${stateDir.socketPath}`);
+  const onSignal = (signal) => {
+    log("info", `received ${signal}`);
+    stopReason = signal;
+    stopSignal.resolve(signal);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  const reason = await stopSignal.promise;
+  process.off("SIGINT", onSignal);
+  process.off("SIGTERM", onSignal);
+  log("info", `daemon stopping: ${reason}`);
+  try {
+    await daemonHandle.stop(reason);
+  } catch (err) {
+    log(
+      "warn",
+      `runtime stop failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    await udsServer.close();
+  } catch (err) {
+    log(
+      "warn",
+      `uds close failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  pidLock.release();
+  log("info", `daemon stopped: ${stopReason}`);
+  writer.close();
+  return 0;
+}
+function createDeferred() {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  let settled = false;
+  return {
+    promise,
+    resolve(value) {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    }
+  };
+}
+void runDashboardDaemonEntry().then((code) => {
+  process.exit(code);
+});
+export {
+  runDashboardDaemonEntry
+};
+//# sourceMappingURL=dashboard-daemon.js.map

package/dist/hook-forwarder.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
+import "./chunk-HXBCZAP7.js";
 import {
   ATHENA_HOOK_SOCKET_ENV,
   generateId
-} from "./chunk-PSD3WBN4.js";
+} from "./chunk-BTKQ67RE.js";
 
 // src/harnesses/claude/hook-forwarder.ts
 import * as net from "net";

package/package.json

@@ -17,11 +17,12 @@
 		"hooks",
 		"dashboard"
 	],
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"license": "MIT",
 	"bin": {
 		"drisp": "dist/cli.js",
-		"drisp-hook-forwarder": "dist/hook-forwarder.js"
+		"drisp-hook-forwarder": "dist/hook-forwarder.js",
+		"drisp-dashboard-daemon": "dist/dashboard-daemon.js"
 	},
 	"type": "module",
 	"engines": {