@drisp/cli 0.4.4 → 0.4.5

package/dist/{chunk-JAPBSL7D.js → chunk-PJUDHH4R.js}

@@ -11664,7 +11664,6 @@ var DEFAULT_RECONNECT_DELAYS_MS = [250, 1e3, 2e3, 5e3, 15e3];
 var DEFAULT_HEARTBEAT_MS2 = 3e4;
 var DEFAULT_WATCHDOG_MS = 9e4;
 var DEFAULT_MAX_QUEUE_SIZE = 5e3;
-var TERMINAL_KINDS = /* @__PURE__ */ new Set(["completion", "error"]);
 function createRunStreamClient(opts) {
   const log = opts.log ?? (() => {
   });
@@ -11889,9 +11888,8 @@ function createRunStreamClient(opts) {
       });
     },
     sendEvent(input) {
-      const seq = nextSeq++;
       const frame = {
-        seq,
+        seq: nextSeq++,
         ts: input.ts,
         kind: input.kind,
         payload: input.payload ?? null
@@ -11914,9 +11912,6 @@ function createRunStreamClient(opts) {
           );
         }
       }
-      if (TERMINAL_KINDS.has(frame.kind)) {
-      }
-      return seq;
     },
     whenTerminated() {
       if (serverTerminated) return Promise.resolve();
@@ -12078,104 +12073,106 @@ async function executeRemoteAssignment({
     });
   };
   send("progress", { message: "assignment received" });
-  const closeRunStream = async (reason) => {
-    if (!runStream) return;
-    const drainTimeout = new Promise((resolve) => {
-      const t = setTimeout(() => resolve(), 1e4);
-      t.unref?.();
-    });
-    await Promise.race([runStream.whenTerminated(), drainTimeout]);
-    await runStream.close(reason);
-    runStream = null;
-  };
-  if (!spec) {
-    send("error", {
-      message: "remote assignment missing prompt"
-    });
-    await closeRunStream("done");
-    return;
-  }
-  const projectDir = spec.projectDir ?? fallbackProjectDir;
-  let runtimeConfig;
   try {
-    runtimeConfig = bootstrapRuntimeConfigFn({
-      projectDir,
-      showSetup: false,
-      isolationPreset: "minimal",
-      workflowOverride: workflowNameFromRef(spec.workflow?.ref)
-    });
-  } catch (err) {
-    send("error", {
-      message: err instanceof Error ? err.message : String(err)
-    });
-    await closeRunStream("done");
-    return;
-  }
-  for (const warning of runtimeConfig.warnings) {
-    send("warning", { message: warning });
-  }
-  let buffered = "";
-  const stdout = {
-    write(chunk) {
-      buffered += chunk;
-      let newline = buffered.indexOf("\n");
-      while (newline >= 0) {
-        const line = buffered.slice(0, newline).trim();
-        buffered = buffered.slice(newline + 1);
-        if (line.length > 0) {
-          try {
-            const event = JSON.parse(line);
-            const data = event.data;
-            if (event.type === "exec.completed" && data?.success === false) {
-              deferredFailedCompletion = event;
-              continue;
+    if (!spec) {
+      send("error", { message: "remote assignment missing prompt" });
+      return;
+    }
+    const projectDir = spec.projectDir ?? fallbackProjectDir;
+    let runtimeConfig;
+    try {
+      runtimeConfig = bootstrapRuntimeConfigFn({
+        projectDir,
+        showSetup: false,
+        isolationPreset: "minimal",
+        workflowOverride: workflowNameFromRef(spec.workflow?.ref)
+      });
+    } catch (err) {
+      send("error", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+      return;
+    }
+    for (const warning of runtimeConfig.warnings) {
+      send("warning", { message: warning });
+    }
+    let buffered = "";
+    const stdout = {
+      write(chunk) {
+        buffered += chunk;
+        let newline = buffered.indexOf("\n");
+        while (newline >= 0) {
+          const line = buffered.slice(0, newline).trim();
+          buffered = buffered.slice(newline + 1);
+          if (line.length > 0) {
+            try {
+              const event = JSON.parse(line);
+              const data = event.data;
+              if (event.type === "exec.completed" && data?.success === false) {
+                deferredFailedCompletion = event;
+                continue;
+              }
+              send(eventKind(event), eventPayload(event), now());
+            } catch (err) {
+              send("progress", { line });
+              log(
+                "warn",
+                `remote run emitted malformed JSONL: ${err instanceof Error ? err.message : String(err)}`
+              );
             }
-            send(eventKind(event), eventPayload(event), now());
-          } catch (err) {
-            send("progress", { line });
-            log(
-              "warn",
-              `remote run emitted malformed JSONL: ${err instanceof Error ? err.message : String(err)}`
-            );
           }
+          newline = buffered.indexOf("\n");
         }
-        newline = buffered.indexOf("\n");
+        return true;
       }
-      return true;
-    }
-  };
-  const stderr = {
-    write(chunk) {
-      const text = chunk.trim();
-      if (text.length > 0) send("stderr", { text });
-      return true;
-    }
-  };
-  try {
-    await withEnv(spec.env, async () => {
-      const result = await runExecFn({
-        prompt: spec.prompt,
-        projectDir,
-        harness: runtimeConfig.harness,
-        athenaSessionId: spec.sessionId ?? `athena-${frame.runId}`,
-        isolationConfig: runtimeConfig.isolationConfig,
-        pluginMcpConfig: runtimeConfig.pluginMcpConfig,
-        workflow: runtimeConfig.workflow,
-        workflowPlan: runtimeConfig.workflowPlan,
-        json: true,
-        verbose: false,
-        ephemeral: false,
-        timeoutMs: spec.timeoutSec ? spec.timeoutSec * 1e3 : void 0,
-        signal: abortSignal,
-        stdout,
-        stderr
-      });
-      if (deferredFailedCompletion) {
-        const data = typeof deferredFailedCompletion.data === "object" && deferredFailedCompletion.data !== null ? deferredFailedCompletion.data : {};
-        send(
-          "error",
-          {
-            ...data,
+    };
+    const stderr = {
+      write(chunk) {
+        const text = chunk.trim();
+        if (text.length > 0) send("stderr", { text });
+        return true;
+      }
+    };
+    try {
+      await withEnv(spec.env, async () => {
+        const result = await runExecFn({
+          prompt: spec.prompt,
+          projectDir,
+          harness: runtimeConfig.harness,
+          athenaSessionId: spec.sessionId ?? `athena-${frame.runId}`,
+          isolationConfig: runtimeConfig.isolationConfig,
+          pluginMcpConfig: runtimeConfig.pluginMcpConfig,
+          workflow: runtimeConfig.workflow,
+          workflowPlan: runtimeConfig.workflowPlan,
+          json: true,
+          verbose: false,
+          ephemeral: false,
+          timeoutMs: spec.timeoutSec ? spec.timeoutSec * 1e3 : void 0,
+          signal: abortSignal,
+          stdout,
+          stderr
+        });
+        if (deferredFailedCompletion) {
+          const data = typeof deferredFailedCompletion.data === "object" && deferredFailedCompletion.data !== null ? deferredFailedCompletion.data : {};
+          send(
+            "error",
+            {
+              ...data,
+              success: result.success,
+              exitCode: result.exitCode,
+              athenaSessionId: result.athenaSessionId,
+              adapterSessionId: result.adapterSessionId,
+              finalMessage: result.finalMessage,
+              tokens: result.tokens,
+              durationMs: result.durationMs,
+              message: result.failure?.message ?? eventPayload(deferredFailedCompletion).message ?? "remote execution failed"
+            },
+            typeof deferredFailedCompletion.ts === "number" ? deferredFailedCompletion.ts : now()
+          );
+          return;
+        }
+        if (result.failure && result.failure.message !== lastTerminalFailureMessage) {
+          send("error", {
             success: result.success,
             exitCode: result.exitCode,
             athenaSessionId: result.athenaSessionId,
@@ -12183,33 +12180,139 @@ async function executeRemoteAssignment({
             finalMessage: result.finalMessage,
             tokens: result.tokens,
             durationMs: result.durationMs,
-            message: result.failure?.message ?? eventPayload(deferredFailedCompletion).message ?? "remote execution failed"
-          },
-          typeof deferredFailedCompletion.ts === "number" ? deferredFailedCompletion.ts : now()
-        );
-        return;
-      }
-      if (result.failure && result.failure.message !== lastTerminalFailureMessage) {
-        send("error", {
-          success: result.success,
-          exitCode: result.exitCode,
-          athenaSessionId: result.athenaSessionId,
-          adapterSessionId: result.adapterSessionId,
-          finalMessage: result.finalMessage,
-          tokens: result.tokens,
-          durationMs: result.durationMs,
-          message: result.failure.message
-        });
-      }
-    });
+            message: result.failure.message
+          });
+        }
+      });
+    } catch (err) {
+      send("error", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  } finally {
+    if (runStream) {
+      const drainTimeout = new Promise((resolve) => {
+        const t = setTimeout(() => resolve(), 1e4);
+        t.unref?.();
+      });
+      await Promise.race([runStream.whenTerminated(), drainTimeout]);
+      await runStream.close("done");
+    }
+  }
+}
+
+// src/infra/config/attachmentMirror.ts
+import crypto3 from "crypto";
+import fs20 from "fs";
+import os11 from "os";
+import path18 from "path";
+function attachmentMirrorPath(env = process.env) {
+  const home = env["HOME"] ?? os11.homedir();
+  return path18.join(home, ".config", "athena", "attachments.json");
+}
+function readAttachmentMirror(env = process.env) {
+  const file = attachmentMirrorPath(env);
+  let raw;
+  try {
+    raw = fs20.readFileSync(file, "utf-8");
   } catch (err) {
-    send("error", {
-      message: err instanceof Error ? err.message : String(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 = path18.dirname(file);
+  fs20.mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.${crypto3.randomBytes(4).toString("hex")}.tmp`;
+  const fd = fs20.openSync(tmp, "w", 384);
+  try {
+    fs20.writeSync(fd, JSON.stringify(validated, null, 2) + "\n");
+    fs20.fsyncSync(fd);
   } finally {
-    await closeRunStream("done");
+    fs20.closeSync(fd);
+  }
+  try {
+    fs20.renameSync(tmp, file);
+  } catch (err) {
+    try {
+      fs20.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  if (process.platform !== "win32") {
+    try {
+      fs20.chmodSync(dir, 448);
+      fs20.chmodSync(file, 384);
+    } catch {
+    }
   }
 }
+function removeAttachmentMirror(env = process.env) {
+  const file = attachmentMirrorPath(env);
+  try {
+    fs20.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
+  };
+}
 
 // src/app/dashboard/runtimeDaemon.ts
 var DEFAULT_RECONNECT_DELAYS_MS2 = [1e3, 2e3, 5e3, 1e4, 3e4];
@@ -12246,6 +12349,7 @@ async function runDashboardRuntimeDaemon(options = {}) {
   const refreshCooldownMs = options.refreshCooldownMs ?? DEFAULT_REFRESH_COOLDOWN_MS;
   const runHistoryLimit = options.runHistoryLimit ?? DEFAULT_RUN_HISTORY_LIMIT;
   const now = options.now ?? (() => Date.now());
+  const writeMirror = options.writeMirror ?? writeAttachmentMirror;
   const startedAt = now();
   let stopped = false;
   let reconnectAttempt = 0;
@@ -12379,6 +12483,26 @@ async function runDashboardRuntimeDaemon(options = {}) {
     });
     next.onFrame((frame) => {
       lastFrameAt = now();
+      if (frame.type === "attachments.changed") {
+        try {
+          writeMirror({
+            instanceId: token.instanceId,
+            fetchedAt: now(),
+            attachments: frame.attachments.map((a) => ({
+              runnerId: a.runnerId,
+              ...a.name !== void 0 ? { name: a.name } : {},
+              ...a.executionTarget !== void 0 ? { executionTarget: a.executionTarget } : {},
+              ...a.remoteInstanceId !== void 0 ? { remoteInstanceId: a.remoteInstanceId } : {}
+            }))
+          });
+        } catch (err) {
+          log(
+            "warn",
+            `runtime daemon: failed to write attachment mirror: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        return;
+      }
       if (frame.type === "cancel") {
         const entry = active.get(frame.runId);
         if (entry) {
@@ -12503,27 +12627,27 @@ async function runDashboardRuntimeDaemon(options = {}) {
 }
 
 // src/infra/daemon/stateDir.ts
-import fs20 from "fs";
-import os11 from "os";
-import path18 from "path";
+import fs21 from "fs";
+import os12 from "os";
+import path19 from "path";
 function daemonStatePaths(env = process.env) {
   const xdg = env["XDG_STATE_HOME"];
-  const home = env["HOME"] ?? os11.homedir();
-  const base = xdg && xdg.length > 0 ? xdg : path18.join(home, ".local", "state");
-  const dir = path18.join(base, "drisp");
+  const home = env["HOME"] ?? os12.homedir();
+  const base = xdg && xdg.length > 0 ? xdg : path19.join(home, ".local", "state");
+  const dir = path19.join(base, "drisp");
   return {
     dir,
-    pidPath: path18.join(dir, "dashboard-daemon.pid"),
-    logPath: path18.join(dir, "dashboard-daemon.log"),
-    socketPath: path18.join(dir, "dashboard-daemon.sock")
+    pidPath: path19.join(dir, "dashboard-daemon.pid"),
+    logPath: path19.join(dir, "dashboard-daemon.log"),
+    socketPath: path19.join(dir, "dashboard-daemon.sock")
   };
 }
 function ensureDaemonStateDir(env = process.env) {
   const paths = daemonStatePaths(env);
-  fs20.mkdirSync(paths.dir, { recursive: true, mode: 448 });
+  fs21.mkdirSync(paths.dir, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
     try {
-      fs20.chmodSync(paths.dir, 448);
+      fs21.chmodSync(paths.dir, 448);
     } catch {
     }
   }
@@ -12531,18 +12655,18 @@ function ensureDaemonStateDir(env = process.env) {
 }
 
 // src/infra/daemon/pidLock.ts
-import fs21 from "fs";
+import fs22 from "fs";
 function acquirePidLock(pidPath) {
   const ownPid = process.pid;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const fd = fs21.openSync(pidPath, "wx", 384);
+      const fd = fs22.openSync(pidPath, "wx", 384);
       try {
-        fs21.writeSync(fd, `${ownPid}
+        fs22.writeSync(fd, `${ownPid}
 `);
-        fs21.fsyncSync(fd);
+        fs22.fsyncSync(fd);
       } finally {
-        fs21.closeSync(fd);
+        fs22.closeSync(fd);
       }
       return makeHandle(pidPath, ownPid);
     } catch (err) {
@@ -12556,7 +12680,7 @@ function acquirePidLock(pidPath) {
     }
     if (existing.state === "stale") {
       try {
-        fs21.unlinkSync(pidPath);
+        fs22.unlinkSync(pidPath);
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
       }
@@ -12570,7 +12694,7 @@ function acquirePidLock(pidPath) {
 function readPidLock(pidPath) {
   let raw;
   try {
-    raw = fs21.readFileSync(pidPath, "utf-8");
+    raw = fs22.readFileSync(pidPath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { state: "absent" };
@@ -12594,9 +12718,9 @@ function makeHandle(pidPath, pid) {
       if (released) return;
       released = true;
       try {
-        const raw = fs21.readFileSync(pidPath, "utf-8").trim();
+        const raw = fs22.readFileSync(pidPath, "utf-8").trim();
         if (raw === String(pid)) {
-          fs21.unlinkSync(pidPath);
+          fs22.unlinkSync(pidPath);
         }
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -12622,7 +12746,7 @@ function isProcessAlive(pid) {
 }
 
 // src/infra/daemon/udsIpc.ts
-import fs22 from "fs";
+import fs23 from "fs";
 import net2 from "net";
 
 // src/infra/daemon/udsFrameCodec.ts
@@ -12667,7 +12791,7 @@ async function startUdsServer(socketPath, handler, log) {
   });
   if (process.platform !== "win32") {
     try {
-      fs22.chmodSync(socketPath, 384);
+      fs23.chmodSync(socketPath, 384);
     } catch {
     }
   }
@@ -12677,7 +12801,7 @@ async function startUdsServer(socketPath, handler, log) {
         server.close(() => resolve());
       });
       try {
-        fs22.unlinkSync(socketPath);
+        fs23.unlinkSync(socketPath);
       } catch (err) {
         if (err.code !== "ENOENT") {
         }
@@ -12795,7 +12919,7 @@ async function sendUdsRequest(socketPath, request, options = {}) {
 async function unlinkStaleSocket(socketPath) {
   let stat;
   try {
-    stat = fs22.statSync(socketPath);
+    stat = fs23.statSync(socketPath);
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -12822,7 +12946,7 @@ async function unlinkStaleSocket(socketPath) {
       `uds path ${socketPath} is in use by another process; aborting`
     );
   }
-  fs22.unlinkSync(socketPath);
+  fs23.unlinkSync(socketPath);
 }
 
 export {
@@ -12887,6 +13011,9 @@ export {
   bootstrapRuntimeConfig,
   EXEC_EXIT_CODE,
   runExec,
+  readAttachmentMirror,
+  writeAttachmentMirror,
+  removeAttachmentMirror,
   runDashboardRuntimeDaemon,
   daemonStatePaths,
   ensureDaemonStateDir,
@@ -12895,4 +13022,4 @@ export {
   startUdsServer,
   sendUdsRequest
 };
-//# sourceMappingURL=chunk-JAPBSL7D.js.map
+//# sourceMappingURL=chunk-PJUDHH4R.js.map