@drisp/cli 0.4.5 → 0.5.0

package/dist/chunk-ZVOGOZNT.js

@@ -0,0 +1,395 @@
+// src/app/dashboard/instanceSocketClient.ts
+import { WebSocket } from "ws";
+var DEFAULT_HEARTBEAT_MS = 3e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+function instanceSocketUrl(dashboardUrl, instanceId) {
+  const url = new URL(dashboardUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = `/api/instances/${encodeURIComponent(instanceId)}/socket`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function createInstanceSocketClient(opts) {
+  const heartbeatMs = opts.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
+  const connectTimeoutMs = opts.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const log = opts.log ?? (() => {
+  });
+  const now = opts.now ?? (() => Date.now());
+  const makeWebSocket = opts.makeWebSocket ?? ((url, accessToken) => new WebSocket(url, [accessToken]));
+  const frameHandlers = /* @__PURE__ */ new Set();
+  const closeHandlers = /* @__PURE__ */ new Set();
+  let ws = null;
+  let heartbeat = null;
+  let droppedSinceClose = 0;
+  function send(frame) {
+    if (!ws || ws.readyState !== ws.OPEN) {
+      droppedSinceClose += 1;
+      if (droppedSinceClose === 1) {
+        log(
+          "warn",
+          `instance socket dropped frame (socket not open): type=${frame.type}`
+        );
+      }
+      return;
+    }
+    droppedSinceClose = 0;
+    try {
+      ws.send(JSON.stringify(frame));
+    } catch (err) {
+      log(
+        "warn",
+        `instance socket send failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  function startHeartbeat() {
+    stopHeartbeat();
+    const interval = setInterval(() => {
+      send({ type: "ping", ts: now() });
+    }, heartbeatMs);
+    interval.unref();
+    heartbeat = interval;
+  }
+  function stopHeartbeat() {
+    if (heartbeat) {
+      clearInterval(heartbeat);
+      heartbeat = null;
+    }
+  }
+  function emitClose(reason) {
+    stopHeartbeat();
+    for (const handler of [...closeHandlers]) {
+      try {
+        handler(reason);
+      } catch {
+      }
+    }
+  }
+  function handleFrame(parsed) {
+    if (parsed.type === "job_assignment") {
+      send({ type: "assignment_accepted", runId: parsed.runId });
+      log("info", `instance socket: assignment accepted runId=${parsed.runId}`);
+    }
+    for (const handler of [...frameHandlers]) {
+      try {
+        handler(parsed);
+      } catch (err) {
+        log(
+          "warn",
+          `instance socket frame handler threw: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  async function connect() {
+    if (ws) throw new Error("instance socket already connected");
+    const url = instanceSocketUrl(opts.dashboardUrl, opts.instanceId);
+    const next = makeWebSocket(url, opts.accessToken);
+    try {
+      await new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+          next.off("open", onOpen);
+          next.off("error", onError);
+          clearTimeout(timer);
+        };
+        const onOpen = () => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve();
+        };
+        const onError = (err) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(new Error(`instance socket connect failed: ${err.message}`));
+        };
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(
+            new Error(
+              `instance socket connect failed: timed out after ${connectTimeoutMs}ms`
+            )
+          );
+        }, connectTimeoutMs);
+        next.once("open", onOpen);
+        next.once("error", onError);
+      });
+    } catch (err) {
+      next.on("error", () => {
+      });
+      try {
+        next.terminate();
+      } catch {
+      }
+      throw err;
+    }
+    ws = next;
+    startHeartbeat();
+    next.on("message", (data) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(String(data));
+      } catch (err) {
+        log(
+          "warn",
+          `instance socket frame parse failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        return;
+      }
+      handleFrame(parsed);
+    });
+    next.on("close", (_code, reasonBuf) => {
+      if (next !== ws) return;
+      ws = null;
+      const reason = reasonBuf.toString() || "closed";
+      emitClose(reason);
+    });
+    next.on("error", (err) => {
+      log("warn", `instance socket error: ${err.message}`);
+    });
+  }
+  function close(reason) {
+    stopHeartbeat();
+    if (ws) {
+      try {
+        ws.close(1e3, reason ?? "client closed");
+      } catch {
+        ws.terminate();
+      }
+    }
+    ws = null;
+  }
+  function onFrame(handler) {
+    frameHandlers.add(handler);
+  }
+  function onClose(handler) {
+    closeHandlers.add(handler);
+  }
+  function sendRunEvent(event) {
+    send({ type: "run_event", ...event });
+  }
+  function sendFeedEvent(event) {
+    send({ type: "feed_event", ...event });
+  }
+  return { connect, close, onFrame, onClose, sendRunEvent, sendFeedEvent };
+}
+
+// src/infra/daemon/pidLock.ts
+import fs from "fs";
+function acquirePidLock(pidPath) {
+  const ownPid = process.pid;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const fd = fs.openSync(pidPath, "wx", 384);
+      try {
+        fs.writeSync(fd, `${ownPid}
+`);
+        fs.fsyncSync(fd);
+      } finally {
+        fs.closeSync(fd);
+      }
+      return makeHandle(pidPath, ownPid);
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    const existing = readPidLock(pidPath);
+    if (existing.state === "held") {
+      throw new Error(
+        `dashboard daemon is already running as pid ${existing.pid} (lock at ${pidPath}). Use "drisp dashboard daemon stop" to terminate it.`
+      );
+    }
+    if (existing.state === "stale") {
+      try {
+        fs.unlinkSync(pidPath);
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+      continue;
+    }
+  }
+  throw new Error(
+    `dashboard daemon: failed to acquire pid lock at ${pidPath} after retry`
+  );
+}
+function readPidLock(pidPath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(pidPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { state: "absent" };
+    }
+    throw err;
+  }
+  const pid = Number.parseInt(raw.trim(), 10);
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return { state: "stale", pid: 0 };
+  }
+  if (!isProcessAlive(pid)) {
+    return { state: "stale", pid };
+  }
+  return { state: "held", pid };
+}
+function makeHandle(pidPath, pid) {
+  let released = false;
+  return {
+    pid,
+    release() {
+      if (released) return;
+      released = true;
+      try {
+        const raw = fs.readFileSync(pidPath, "utf-8").trim();
+        if (raw === String(pid)) {
+          fs.unlinkSync(pidPath);
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+        }
+      }
+    }
+  };
+}
+function isProcessAlive(pid) {
+  if (process.platform === "win32") {
+    return true;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+
+// src/infra/config/attachmentMirror.ts
+import crypto from "crypto";
+import fs2 from "fs";
+import os from "os";
+import path from "path";
+function attachmentMirrorPath(env = process.env) {
+  const home = env["HOME"] ?? os.homedir();
+  return path.join(home, ".config", "athena", "attachments.json");
+}
+function readAttachmentMirror(env = process.env) {
+  const file = attachmentMirrorPath(env);
+  let raw;
+  try {
+    raw = fs2.readFileSync(file, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `attachment mirror ${file} is invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    return parseAttachmentMirror(parsed);
+  } catch (err) {
+    throw new Error(
+      `attachment mirror ${file} is invalid: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function writeAttachmentMirror(mirror, env = process.env) {
+  const validated = parseAttachmentMirror(mirror);
+  const file = attachmentMirrorPath(env);
+  const dir = path.dirname(file);
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+  const fd = fs2.openSync(tmp, "w", 384);
+  try {
+    fs2.writeSync(fd, JSON.stringify(validated, null, 2) + "\n");
+    fs2.fsyncSync(fd);
+  } finally {
+    fs2.closeSync(fd);
+  }
+  try {
+    fs2.renameSync(tmp, file);
+  } catch (err) {
+    try {
+      fs2.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  if (process.platform !== "win32") {
+    try {
+      fs2.chmodSync(dir, 448);
+      fs2.chmodSync(file, 384);
+    } catch {
+    }
+  }
+}
+function removeAttachmentMirror(env = process.env) {
+  const file = attachmentMirrorPath(env);
+  try {
+    fs2.unlinkSync(file);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+function parseAttachmentMirror(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("root must be an object");
+  }
+  const obj = raw;
+  if (typeof obj["instanceId"] !== "string" || obj["instanceId"].length === 0) {
+    throw new Error("instanceId must be a non-empty string");
+  }
+  if (typeof obj["fetchedAt"] !== "number") {
+    throw new Error("fetchedAt must be a number");
+  }
+  if (!Array.isArray(obj["attachments"])) {
+    throw new Error("attachments must be an array");
+  }
+  const attachments = obj["attachments"].map((entry, idx) => {
+    if (typeof entry !== "object" || entry === null) {
+      throw new Error(`attachments[${idx}] must be an object`);
+    }
+    const e = entry;
+    if (typeof e["runnerId"] !== "string" || e["runnerId"].length === 0) {
+      throw new Error(
+        `attachments[${idx}].runnerId must be a non-empty string`
+      );
+    }
+    const out = { runnerId: e["runnerId"] };
+    if (typeof e["name"] === "string") out.name = e["name"];
+    if (typeof e["executionTarget"] === "string") {
+      out.executionTarget = e["executionTarget"];
+    }
+    if (typeof e["remoteInstanceId"] === "string") {
+      out.remoteInstanceId = e["remoteInstanceId"];
+    }
+    return out;
+  });
+  return {
+    instanceId: obj["instanceId"],
+    fetchedAt: obj["fetchedAt"],
+    attachments
+  };
+}
+
+export {
+  createInstanceSocketClient,
+  attachmentMirrorPath,
+  readAttachmentMirror,
+  writeAttachmentMirror,
+  removeAttachmentMirror,
+  acquirePidLock,
+  readPidLock
+};
+//# sourceMappingURL=chunk-ZVOGOZNT.js.map