@drisp/cli 0.4.4 → 0.4.7

package/dist/supervisor.js

@@ -0,0 +1,692 @@
+#!/usr/bin/env node
+import {
+  startDaemon
+} from "./chunk-SKWAGQXF.js";
+import "./chunk-D4W7RB25.js";
+import {
+  openDaemonLog
+} from "./chunk-2OJ3GGIP.js";
+import {
+  acquirePidLock,
+  attachmentMirrorPath,
+  createInstanceSocketClient,
+  readAttachmentMirror
+} from "./chunk-ZVOGOZNT.js";
+import {
+  readDashboardClientConfig,
+  refreshDashboardAccessToken,
+  resolveGatewayPaths,
+  resolveListenSpec
+} from "./chunk-WRHKXH5M.js";
+
+// src/app/entry/supervisor.tsx
+import { spawn } from "child_process";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/gateway/adapters/runner/adapter.ts
+var CAPABILITIES = {
+  chat: true,
+  threads: false,
+  relayPermission: false,
+  relayQuestion: false
+};
+function createRunnerAdapter(opts) {
+  const { runnerId, transport } = opts;
+  let unsubscribe = null;
+  let ctx = null;
+  function inboundFromAssignment(frame) {
+    return {
+      location: {
+        channelId: `runner:${runnerId}`,
+        accountId: `runner:${runnerId}`
+      },
+      sender: { id: `runner:${runnerId}` },
+      text: JSON.stringify({
+        kind: "job_assignment",
+        runId: frame.runId,
+        ...frame.runSpec !== void 0 ? { runSpec: frame.runSpec } : {}
+      }),
+      receivedAt: Date.now(),
+      idempotencyKey: frame.runId,
+      providerMessageId: frame.runId
+    };
+  }
+  function inboundFromCancel(frame) {
+    return {
+      location: {
+        channelId: `runner:${runnerId}`,
+        accountId: `runner:${runnerId}`
+      },
+      sender: { id: `runner:${runnerId}` },
+      text: JSON.stringify({ kind: "cancel", runId: frame.runId }),
+      receivedAt: Date.now(),
+      idempotencyKey: `cancel:${frame.runId}`,
+      providerMessageId: `cancel:${frame.runId}`
+    };
+  }
+  function parseOutbound(text) {
+    let env;
+    try {
+      env = JSON.parse(text);
+    } catch (err) {
+      throw new Error(
+        `runner adapter: malformed outbound envelope: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (typeof env !== "object" || env === null) {
+      throw new Error("runner adapter: outbound envelope must be an object");
+    }
+    const obj = env;
+    const kind = obj["kind"];
+    const runId = obj["runId"];
+    if (typeof runId !== "string" || runId.length === 0) {
+      throw new Error("runner adapter: outbound envelope missing runId");
+    }
+    if (kind !== "run_event") {
+      throw new Error(`runner adapter: unknown envelope kind: ${String(kind)}`);
+    }
+    const seq = obj["seq"];
+    const eventKind = obj["eventKind"];
+    const ts = obj["ts"];
+    if (typeof seq !== "number") {
+      throw new Error("runner adapter: run_event envelope missing seq");
+    }
+    if (typeof eventKind !== "string") {
+      throw new Error("runner adapter: run_event envelope missing eventKind");
+    }
+    return {
+      type: "run_event",
+      runId,
+      seq,
+      ts: typeof ts === "number" ? ts : Date.now(),
+      kind: eventKind,
+      ...obj["payload"] !== void 0 ? { payload: obj["payload"] } : {}
+    };
+  }
+  return {
+    id: `runner:${runnerId}`,
+    capabilities: CAPABILITIES,
+    async start(c) {
+      ctx = c;
+      unsubscribe = transport.subscribe(runnerId, (frame) => {
+        const emit = ctx?.emitInbound;
+        if (!emit) return;
+        if (frame.type === "job_assignment") {
+          emit(inboundFromAssignment(frame));
+        } else {
+          emit(inboundFromCancel(frame));
+        }
+      });
+      ctx.emitHealth({ at: Date.now(), transportOk: transport.isReady() });
+    },
+    async stop(_reason) {
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = null;
+      }
+      ctx = null;
+    },
+    async send(msg) {
+      if (!transport.isReady()) {
+        throw new Error("runner adapter: transport not ready");
+      }
+      const frame = parseOutbound(msg.text);
+      transport.send(frame);
+      return {
+        providerMessageId: msg.idempotencyKey,
+        deliveredAt: Date.now()
+      };
+    },
+    async probe() {
+      const ok = transport.isReady();
+      return {
+        ok,
+        detail: ok ? "transport ready" : "transport not ready",
+        checkedAt: Date.now()
+      };
+    }
+  };
+}
+
+// src/gateway/adapters/runner/instanceSocketTransport.ts
+function createInstanceSocketRunnerTransport(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const subscribers = /* @__PURE__ */ new Map();
+  let connected = true;
+  function deliver(runnerId, frame) {
+    const set = subscribers.get(runnerId);
+    if (!set) return;
+    for (const handler of [...set]) {
+      try {
+        handler(frame);
+      } catch (err) {
+        log(
+          "warn",
+          `runner transport handler threw: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  opts.source.onFrame((frame) => {
+    if (frame.type === "job_assignment") {
+      const f = frame;
+      if (!f.runnerId) return;
+      deliver(f.runnerId, {
+        type: "job_assignment",
+        runId: f.runId,
+        runSpec: f.runSpec
+      });
+      return;
+    }
+    if (frame.type === "cancel") {
+      const f = frame;
+      if (!f.runnerId) return;
+      deliver(f.runnerId, { type: "cancel", runId: f.runId });
+    }
+  });
+  opts.source.onClose(() => {
+    connected = false;
+  });
+  return {
+    subscribe(runnerId, handler) {
+      let set = subscribers.get(runnerId);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        subscribers.set(runnerId, set);
+      }
+      set.add(handler);
+      return () => {
+        const cur = subscribers.get(runnerId);
+        if (!cur) return;
+        cur.delete(handler);
+        if (cur.size === 0) subscribers.delete(runnerId);
+      };
+    },
+    send(frame) {
+      opts.source.sendRunEvent({
+        runId: frame.runId,
+        seq: frame.seq,
+        ts: frame.ts,
+        kind: frame.kind,
+        ...frame.payload !== void 0 ? { payload: frame.payload } : {}
+      });
+    },
+    isReady() {
+      return connected;
+    }
+  };
+}
+
+// src/app/dashboard/runnerTransport.ts
+function runnerTransportFromInstanceSocket(opts) {
+  const source = {
+    onFrame(handler) {
+      opts.client.onFrame((frame) => handler(frame));
+    },
+    onClose(handler) {
+      opts.client.onClose(handler);
+    },
+    sendRunEvent(event) {
+      opts.client.sendRunEvent(event);
+    }
+  };
+  return createInstanceSocketRunnerTransport({
+    source,
+    ...opts.log ? { log: opts.log } : {}
+  });
+}
+
+// src/app/supervisor/attachmentRunner.ts
+function createAttachmentRunner(opts) {
+  const exitHandlers = /* @__PURE__ */ new Set();
+  let child = null;
+  let exited = null;
+  function spawn2() {
+    const args = [
+      "--attachment-id",
+      opts.attachmentId,
+      "--runner",
+      opts.runnerId,
+      ...opts.extraArgs ?? []
+    ];
+    const next = opts.spawnChild(args);
+    exited = new Promise((resolve) => {
+      next.once(
+        "exit",
+        (code, signal) => {
+          const event = { code: code ?? 0, signal };
+          if (child === next) {
+            child = null;
+            exited = null;
+          }
+          for (const handler of exitHandlers) handler(event);
+          resolve(event);
+        }
+      );
+    });
+    child = next;
+  }
+  return {
+    attachmentId: opts.attachmentId,
+    runnerId: opts.runnerId,
+    async start() {
+      if (child) return;
+      spawn2();
+    },
+    async stop(_reason) {
+      const current = child;
+      const wait = exited;
+      if (!current) return;
+      current.kill("SIGTERM");
+      await wait;
+    },
+    onChildExit(handler) {
+      exitHandlers.add(handler);
+    }
+  };
+}
+
+// src/app/supervisor/attachmentSet.ts
+function createAttachmentSet(opts) {
+  const runners = /* @__PURE__ */ new Map();
+  async function stopRunner(runner, reason) {
+    try {
+      await runner.stop(reason);
+    } catch {
+    }
+  }
+  return {
+    async reconcile(desired) {
+      const desiredById = new Map(desired.map((d) => [d.attachmentId, d]));
+      const stops = [];
+      for (const [id, runner] of runners) {
+        const want = desiredById.get(id);
+        if (!want || want.runnerId !== runner.runnerId) {
+          runners.delete(id);
+          stops.push(stopRunner(runner, "detach"));
+        }
+      }
+      await Promise.all(stops);
+      for (const want of desired) {
+        if (runners.has(want.attachmentId)) continue;
+        const runner = opts.createRunner({
+          attachmentId: want.attachmentId,
+          runnerId: want.runnerId
+        });
+        runners.set(want.attachmentId, runner);
+        await runner.start();
+      }
+    },
+    list() {
+      return [...runners.values()].map((r) => ({
+        attachmentId: r.attachmentId,
+        runnerId: r.runnerId
+      }));
+    },
+    async shutdown() {
+      const stops = [];
+      for (const runner of runners.values()) {
+        stops.push(stopRunner(runner, "shutdown"));
+      }
+      runners.clear();
+      await Promise.all(stops);
+    }
+  };
+}
+
+// src/app/supervisor/mirrorAttachmentSource.ts
+import fs from "fs";
+import path from "path";
+function createMirrorAttachmentSource(opts = {}) {
+  const env = opts.env ?? process.env;
+  const log = opts.log ?? (() => {
+  });
+  const file = attachmentMirrorPath(env);
+  const dir = path.dirname(file);
+  const basename = path.basename(file);
+  const handlers = /* @__PURE__ */ new Set();
+  let watcher = null;
+  let closed = false;
+  function project() {
+    const mirror = readAttachmentMirror(env);
+    if (!mirror) return [];
+    return mirror.attachments.map((a) => ({
+      attachmentId: a.runnerId,
+      runnerId: a.runnerId
+    }));
+  }
+  function emit() {
+    if (closed) return;
+    let next;
+    try {
+      next = project();
+    } catch (err) {
+      log(
+        "warn",
+        `supervisor: failed to read attachment mirror: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return;
+    }
+    for (const handler of handlers) handler(next);
+  }
+  function ensureWatcher() {
+    if (watcher || closed) return;
+    try {
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+    } catch {
+    }
+    try {
+      watcher = fs.watch(dir, (_evt, filename) => {
+        if (filename && filename !== basename) return;
+        emit();
+      });
+      watcher.on("error", (err) => {
+        log(
+          "warn",
+          `supervisor: mirror watcher error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
+    } catch (err) {
+      log(
+        "warn",
+        `supervisor: failed to watch mirror dir ${dir}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return {
+    initial() {
+      return project();
+    },
+    subscribe(handler) {
+      handlers.add(handler);
+      ensureWatcher();
+      return () => {
+        handlers.delete(handler);
+      };
+    },
+    close() {
+      closed = true;
+      handlers.clear();
+      if (watcher) {
+        try {
+          watcher.close();
+        } catch {
+        }
+        watcher = null;
+      }
+    }
+  };
+}
+
+// src/app/supervisor/runSupervisor.ts
+async function runSupervisor(opts) {
+  const log = opts.log ?? (() => {
+  });
+  let stopped = false;
+  async function safeReconcile(desired) {
+    if (stopped) return;
+    try {
+      await opts.set.reconcile(desired);
+    } catch (err) {
+      log(
+        "warn",
+        `supervisor: reconcile failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const unsubscribe = opts.source.subscribe((next) => {
+    void safeReconcile(next);
+  });
+  await safeReconcile(opts.source.initial());
+  return {
+    async shutdown() {
+      stopped = true;
+      unsubscribe();
+      await opts.set.shutdown();
+    }
+  };
+}
+
+// src/app/entry/supervisor.tsx
+function supervisorPaths(env = process.env) {
+  const xdg = env["XDG_STATE_HOME"];
+  const home = env["HOME"] ?? os.homedir();
+  const base = xdg && xdg.length > 0 ? xdg : path2.join(home, ".local", "state");
+  const dir = path2.join(base, "drisp");
+  return {
+    dir,
+    pidPath: path2.join(dir, "supervisor.pid"),
+    logPath: path2.join(dir, "supervisor.log")
+  };
+}
+function ensureSupervisorDir(paths) {
+  fs2.mkdirSync(paths.dir, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") {
+    try {
+      fs2.chmodSync(paths.dir, 448);
+    } catch {
+    }
+  }
+}
+function resolveCliEntry() {
+  const here = fileURLToPath(import.meta.url);
+  return path2.join(path2.dirname(here), "cli.js");
+}
+async function runSupervisorEntry() {
+  const sup = supervisorPaths();
+  ensureSupervisorDir(sup);
+  const writer = openDaemonLog(sup.logPath);
+  const log = (level, message) => writer.write(level, message);
+  let pidLock;
+  try {
+    pidLock = acquirePidLock(sup.pidPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log("error", `supervisor startup: ${message}`);
+    writer.close();
+    process.stderr.write(`drisp supervisor: ${message}
+`);
+    return 1;
+  }
+  const cliEntry = resolveCliEntry();
+  const gatewayPaths = resolveGatewayPaths();
+  const listenSpec = resolveListenSpec({ paths: gatewayPaths });
+  let gateway;
+  try {
+    gateway = await startDaemon({
+      foreground: true,
+      paths: gatewayPaths,
+      listenSpec,
+      skipSignalHandlers: true
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log("error", `gateway startup failed: ${message}`);
+    pidLock.release();
+    writer.close();
+    process.stderr.write(
+      `drisp supervisor: gateway startup failed: ${message}
+`
+    );
+    return 1;
+  }
+  log(
+    "info",
+    `supervisor: embedded gateway listening on ${describeListener(gateway)}`
+  );
+  const dashboardConfig = readDashboardClientConfig();
+  let instanceSocket = null;
+  let runnerTransport = null;
+  if (dashboardConfig) {
+    try {
+      const token = await refreshDashboardAccessToken({});
+      instanceSocket = createInstanceSocketClient({
+        dashboardUrl: dashboardConfig.dashboardUrl,
+        instanceId: token.instanceId,
+        accessToken: token.accessToken,
+        log
+      });
+      await instanceSocket.connect();
+      runnerTransport = runnerTransportFromInstanceSocket({
+        client: instanceSocket,
+        log
+      });
+      log(
+        "info",
+        `supervisor: instance socket connected as ${token.instanceId}`
+      );
+    } catch (err) {
+      log(
+        "warn",
+        `supervisor: instance socket unavailable (runs will not flow): ${err instanceof Error ? err.message : String(err)}`
+      );
+      instanceSocket = null;
+      runnerTransport = null;
+    }
+  } else {
+    log("info", "supervisor: no dashboard config; skipping runner transport");
+  }
+  const source = createMirrorAttachmentSource({ log });
+  const set = createAttachmentSet({
+    createRunner: (input) => {
+      const child = createAttachmentRunner({
+        attachmentId: input.attachmentId,
+        runnerId: input.runnerId,
+        spawnChild: (args) => {
+          const proc = spawn(process.execPath, [cliEntry, ...args], {
+            stdio: "inherit"
+          });
+          return proc;
+        }
+      });
+      if (!runnerTransport) return child;
+      return wrapWithRunnerAdapter({
+        child,
+        attachmentId: input.attachmentId,
+        runnerId: input.runnerId,
+        transport: runnerTransport,
+        gateway,
+        log
+      });
+    }
+  });
+  const handle = await runSupervisor({ source, set, log });
+  log("info", "supervisor: ready");
+  const stopSignal = createDeferred();
+  let stopReason = "sigterm";
+  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", `supervisor stopping: ${reason}`);
+  try {
+    await handle.shutdown();
+  } catch (err) {
+    log(
+      "warn",
+      `supervisor shutdown failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  source.close();
+  if (instanceSocket) {
+    try {
+      instanceSocket.close("supervisor stopping");
+    } catch (err) {
+      log(
+        "warn",
+        `instance socket close failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  try {
+    await gateway.stop();
+  } catch (err) {
+    log(
+      "warn",
+      `gateway stop failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  pidLock.release();
+  log("info", `supervisor stopped: ${stopReason}`);
+  writer.close();
+  return 0;
+}
+function wrapWithRunnerAdapter(opts) {
+  const adapter = createRunnerAdapter({
+    runnerId: opts.runnerId,
+    transport: opts.transport
+  });
+  let registered = false;
+  return {
+    attachmentId: opts.child.attachmentId,
+    runnerId: opts.child.runnerId,
+    async start() {
+      if (!registered) {
+        try {
+          await opts.gateway.channelManager.register(adapter, {
+            attachmentId: opts.attachmentId
+          });
+          registered = true;
+        } catch (err) {
+          opts.log(
+            "warn",
+            `supervisor: failed to register runner adapter for ${opts.attachmentId}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      await opts.child.start();
+    },
+    async stop(reason) {
+      await opts.child.stop(reason);
+      if (registered) {
+        try {
+          await opts.gateway.channelManager.unregister(adapter.id, "shutdown");
+        } catch (err) {
+          opts.log(
+            "warn",
+            `supervisor: failed to unregister runner adapter for ${opts.attachmentId}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        registered = false;
+      }
+    },
+    onChildExit: opts.child.onChildExit
+  };
+}
+function describeListener(gateway) {
+  const l = gateway.listener;
+  if (l.kind === "uds") return l.socketPath ?? "<uds>";
+  return l.url ?? `${l.host ?? "?"}:${l.port ?? "?"}`;
+}
+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 runSupervisorEntry().then((code) => {
+  process.exit(code);
+});
+export {
+  runSupervisorEntry
+};
+//# sourceMappingURL=supervisor.js.map

package/package.json

@@ -17,7 +17,7 @@
 		"hooks",
 		"dashboard"
 	],
-	"version": "0.4.4",
+	"version": "0.4.7",
 	"license": "MIT",
 	"bin": {
 		"athena": "dist/cli.js",