@forgezero/runtime 0.1.0 → 0.1.1

package/dist/queue.js

@@ -7,240 +7,209 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/queue.ts
-var systemClock = { now: () => Date.now() };
-var UNITS = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
-function durationMs(value) {
-  if (typeof value === "number")
-    return value;
-  const match = /^(\d+)([smhd])$/.exec(value);
-  if (!match)
-    throw new Error(`"${value}" is not a duration like 30s, 5m, 1h, 1d.`);
-  return Number(match[1]) * UNITS[match[2]];
-}
-var MODES = ["standalone", "cluster"];
-function memoryStore(clock = systemClock) {
-  const messages = new Map;
-  const leases = new Map;
-  let fences = 0;
-  const all = (queue) => messages.get(queue) ?? [];
-  return {
-    mode: "standalone",
-    async append(queue, message) {
-      messages.set(queue, [...all(queue), message]);
-    },
-    async findByDedupe(queue, dedupeKey, sinceMs) {
-      return all(queue).find((message) => message.dedupeKey === dedupeKey && message.enqueuedAtMs >= sinceMs) ?? null;
-    },
-    async claimKey(queue, owner, ttlMs, nowMs) {
-      const ready = all(queue).filter((message) => message.status === "ready" && message.availableAtMs <= nowMs);
-      for (const message of ready.sort((a, b) => a.sequence - b.sequence)) {
-        const held = leases.get(`${queue}\x00${message.key}`);
-        if (held && held.untilMs > nowMs)
-          continue;
-        fences += 1;
-        const lease = { key: message.key, fence: fences, untilMs: nowMs + ttlMs, owner };
-        leases.set(`${queue}\x00${message.key}`, lease);
-        return lease;
-      }
-      return null;
-    },
-    async renewKey(queue, lease, ttlMs, nowMs) {
-      const held = leases.get(`${queue}\x00${lease.key}`);
-      if (!held || held.fence !== lease.fence)
-        return false;
-      held.untilMs = nowMs + ttlMs;
-      return true;
-    },
-    async releaseKey(queue, lease) {
-      const held = leases.get(`${queue}\x00${lease.key}`);
-      if (held?.fence === lease.fence)
-        leases.delete(`${queue}\x00${lease.key}`);
-    },
-    async readKey(queue, key, nowMs, limit) {
-      return all(queue).filter((message) => message.key === key && message.status === "ready" && message.availableAtMs <= nowMs).sort((a, b) => a.sequence - b.sequence).slice(0, limit);
-    },
-    async update(queue, id, patch) {
-      const message = all(queue).find((entry) => entry.id === id);
-      if (message)
-        Object.assign(message, patch);
-    },
-    async stats(queue) {
-      const list = all(queue);
-      return {
-        ready: list.filter((message) => message.status === "ready").length,
-        leased: list.filter((message) => message.status === "leased").length,
-        dead: list.filter((message) => message.status === "dead").length,
-        keys: new Set(list.filter((message) => message.status === "ready").map((m) => m.key)).size
-      };
-    },
-    async dead(queue, limit) {
-      return all(queue).filter((message) => message.status === "dead").sort((a, b) => b.sequence - a.sequence).slice(0, limit);
-    }
-  };
+class QueueStoppedError extends Error {
+  constructor() {
+    super("queue: stopped before this task could run");
+    this.name = "QueueStoppedError";
+  }
 }
-function createQueue(options) {
-  const {
-    name,
-    store,
-    handler,
-    concurrency = 4,
-    leaseMs = 30000,
-    maxAttempts = 5,
-    backoffMs = 1000,
-    maxBackoffMs = 60000,
-    dedupeWindowMs = 300000,
-    batch = 32,
-    clock = systemClock,
-    owner = `worker-${Math.trunc(clock.now())}`
-  } = options;
-  if (options.require && store.mode !== options.require) {
-    throw new Error(`Queue "${name}" requires a ${options.require} store but was given a ${store.mode} one. ` + "A memory store loses everything on restart.");
+
+class TaskCancelledError extends Error {
+  constructor() {
+    super("queue: task cancelled");
+    this.name = "TaskCancelledError";
   }
+}
+var DEFAULT_RETRY = {
+  attempts: 1,
+  backoffMs: (attempt) => Math.min(30000, 2 ** attempt * 100)
+};
+function createQueue(options = {}) {
+  const width = Math.max(1, options.width ?? 8);
+  const retry = { ...DEFAULT_RETRY, ...options.retry };
+  const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const lanes = new Map;
+  const running = new Set;
+  const paused = new Set;
   let sequence = 0;
-  let running = false;
-  let inFlight = 0;
-  const held = new Set;
-  const backoffFor = (attempt) => Math.min(maxBackoffMs, backoffMs * 2 ** Math.max(0, attempt - 1));
-  async function enqueue(args) {
-    if (!args.key)
-      throw new Error("Every message needs a key — it is what orders the work.");
-    const nowMs = clock.now();
-    if (args.dedupeKey) {
-      const existing = await store.findByDedupe(name, args.dedupeKey, nowMs - dedupeWindowMs);
-      if (existing)
-        return { id: existing.id, duplicate: true };
+  let globallyPaused = false;
+  let accepting = true;
+  let aborted = false;
+  let completed = 0;
+  let failed = 0;
+  const idle = [];
+  const announceIdle = () => {
+    if (running.size > 0)
+      return;
+    for (const lane of lanes.values())
+      if (lane.length > 0)
+        return;
+    while (idle.length > 0)
+      idle.shift()();
+  };
+  function pump() {
+    if (globallyPaused || aborted)
+      return;
+    for (const [key, lane] of lanes) {
+      if (running.size >= width)
+        break;
+      if (running.has(key) || paused.has(key) || lane.length === 0)
+        continue;
+      execute(key);
     }
-    sequence += 1;
-    const message = {
-      id: `${name}-${nowMs}-${sequence}`,
-      key: args.key,
-      body: args.body,
-      sequence,
-      status: "ready",
-      attempts: 0,
-      availableAtMs: nowMs + (args.delayMs ?? 0),
-      dedupeKey: args.dedupeKey,
-      enqueuedAtMs: nowMs
-    };
-    await store.append(name, message);
-    return { id: message.id, duplicate: false };
+    announceIdle();
   }
-  async function drainKey(lease) {
+  async function execute(key) {
+    running.add(key);
     try {
-      for (let taken = 0;taken < batch; taken += 1) {
-        const nowMs = clock.now();
-        if (!await store.renewKey(name, lease, leaseMs, nowMs))
-          return;
-        const [message] = await store.readKey(name, lease.key, nowMs, 1);
-        if (!message)
-          return;
-        await store.update(name, message.id, { status: "leased", attempts: message.attempts + 1 });
-        try {
-          await handler({ ...message, attempts: message.attempts + 1 }, {
-            holdsKey: () => store.renewKey(name, lease, leaseMs, clock.now()),
-            log: (line) => options.onError?.({ ...message }, line),
-            attempt: message.attempts + 1
-          });
-          await store.update(name, message.id, { status: "done", completedAtMs: clock.now() });
-        } catch (cause) {
-          const attempts = message.attempts + 1;
-          const reason = cause instanceof Error ? cause.message : String(cause);
-          options.onError?.(message, cause);
-          if (attempts >= maxAttempts) {
-            await store.update(name, message.id, { status: "dead", lastError: reason });
-            continue;
-          }
-          await store.update(name, message.id, {
-            status: "ready",
-            lastError: reason,
-            availableAtMs: clock.now() + backoffFor(attempts)
-          });
-          return;
-        }
+      for (;; ) {
+        const lane = lanes.get(key);
+        const entry = lane?.[0];
+        if (!entry || globallyPaused || paused.has(key) || aborted)
+          break;
+        lane.shift();
+        await attempt(entry);
       }
     } finally {
-      await store.releaseKey(name, lease);
-      held.delete(lease.key);
+      running.delete(key);
+      if (lanes.get(key)?.length === 0)
+        lanes.delete(key);
+      pump();
     }
   }
-  async function tick() {
-    const claimed = [];
-    while (inFlight + claimed.length < concurrency) {
-      const lease = await store.claimKey(name, owner, leaseMs, clock.now());
-      if (!lease)
-        break;
-      if (held.has(lease.key))
-        break;
-      held.add(lease.key);
-      claimed.push(lease);
+  async function attempt(entry) {
+    if (entry.cancelled) {
+      entry.reject(new TaskCancelledError);
+      return;
     }
-    if (claimed.length === 0)
-      return 0;
-    inFlight += claimed.length;
-    try {
-      await Promise.all(claimed.map((lease) => drainKey(lease)));
-    } finally {
-      inFlight -= claimed.length;
+    for (;; ) {
+      entry.attempt += 1;
+      try {
+        const value = await entry.run();
+        completed += 1;
+        entry.resolve(value);
+        return;
+      } catch (cause) {
+        if (entry.attempt >= retry.attempts || entry.cancelled || aborted) {
+          failed += 1;
+          entry.reject(cause);
+          return;
+        }
+        await sleep(retry.backoffMs(entry.attempt));
+      }
     }
-    return claimed.length;
   }
   return {
-    enqueue,
-    tick,
-    async drain(maxPasses = 100) {
-      for (let pass = 0;pass < maxPasses; pass += 1) {
-        if (await tick() === 0)
+    run(key, handler) {
+      const id = `q_${++sequence}`;
+      if (!accepting) {
+        const refused = Promise.reject(new QueueStoppedError);
+        refused.catch(() => {
           return;
+        });
+        return { id, key, result: refused };
       }
+      let resolve;
+      let reject;
+      const result = new Promise((ok, no) => {
+        resolve = ok;
+        reject = no;
+      });
+      const entry = {
+        id,
+        key,
+        run: async () => handler(),
+        resolve,
+        reject,
+        attempt: 0,
+        cancelled: false
+      };
+      const lane = lanes.get(key);
+      if (lane)
+        lane.push(entry);
+      else
+        lanes.set(key, [entry]);
+      pump();
+      return { id, key, result };
     },
-    start(intervalMs = 200) {
-      if (running)
-        return;
-      running = true;
-      const loop = async () => {
-        while (running) {
-          try {
-            if (await tick() === 0)
-              await new Promise((r) => setTimeout(r, intervalMs));
-          } catch {
-            await new Promise((r) => setTimeout(r, intervalMs));
-          }
-        }
+    cancel(id) {
+      for (const [key, lane] of lanes) {
+        const index = lane.findIndex((entry2) => entry2.id === id);
+        if (index === -1)
+          continue;
+        const [entry] = lane.splice(index, 1);
+        entry.cancelled = true;
+        entry.reject(new TaskCancelledError);
+        if (lane.length === 0 && !running.has(key))
+          lanes.delete(key);
+        return true;
+      }
+      return false;
+    },
+    pauseKey(key) {
+      paused.add(key);
+    },
+    resumeKey(key) {
+      paused.delete(key);
+      pump();
+    },
+    pause() {
+      globallyPaused = true;
+    },
+    resume() {
+      globallyPaused = false;
+      pump();
+    },
+    snapshot() {
+      let queued = 0;
+      for (const lane of lanes.values())
+        queued += lane.length;
+      return {
+        running: running.size,
+        queued,
+        keys: lanes.size,
+        paused: globallyPaused,
+        pausedKeys: [...paused],
+        completed,
+        failed
       };
-      loop();
     },
-    stop() {
-      running = false;
+    whenIdle() {
+      if (running.size === 0 && [...lanes.values()].every((lane) => lane.length === 0)) {
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => idle.push(resolve));
     },
-    mode: store.mode,
-    stats: () => store.stats(name),
-    dead: (limit = 50) => store.dead(name, limit),
-    async revive(id) {
-      await store.update(name, id, { status: "ready", attempts: 0, availableAtMs: clock.now() });
+    async stop(deadlineMs = 30000) {
+      accepting = false;
+      const before = { completed, failed };
+      let timedOut = false;
+      await Promise.race([
+        this.whenIdle(),
+        sleep(deadlineMs).then(() => {
+          timedOut = true;
+        })
+      ]);
+      if (timedOut)
+        aborted = true;
+      let abandoned = 0;
+      for (const lane of lanes.values()) {
+        abandoned += lane.length;
+        for (const entry of lane.splice(0))
+          entry.reject(new QueueStoppedError);
+      }
+      abandoned += running.size;
+      return {
+        completed: completed - before.completed,
+        failed: failed - before.failed,
+        abandoned,
+        timedOut
+      };
     }
   };
 }
-var VERSION = "0.1.0";
-function clusterStore(adapter) {
-  return {
-    mode: "cluster",
-    append: (queue, message) => adapter.insert(queue, message),
-    findByDedupe: (queue, dedupeKey, sinceMs) => adapter.findDuplicate(queue, dedupeKey, sinceMs),
-    claimKey: (queue, owner, ttlMs, nowMs) => adapter.takeKey({ queue, owner, untilMs: nowMs + ttlMs, nowMs }),
-    renewKey: (queue, lease, ttlMs, nowMs) => adapter.extendKey(queue, lease.key, lease.fence, nowMs + ttlMs),
-    releaseKey: (queue, lease) => adapter.dropKey(queue, lease.key, lease.fence),
-    readKey: (queue, key, nowMs, limit) => adapter.readReady(queue, key, nowMs, limit),
-    update: (queue, id, patch) => adapter.patch(queue, id, patch),
-    stats: (queue) => adapter.counts(queue),
-    dead: (queue, limit) => adapter.deadLetter(queue, limit)
-  };
-}
 export {
-  systemClock,
-  memoryStore,
-  durationMs,
   createQueue,
-  clusterStore,
-  VERSION,
-  MODES
+  TaskCancelledError,
+  QueueStoppedError
 };

package/dist/ssh-agent.d.ts

@@ -46,6 +46,19 @@ export declare const AGENT_TIMEOUT_MS = 3000;
 export declare function listIdentities(socketPath?: string): Promise<AgentIdentity[]>;
 /** Ed25519 only. See the module note — determinism is the whole mechanism. */
 export declare function listCustodyIdentities(socketPath?: string): Promise<AgentIdentity[]>;
+/**
+ * Sign arbitrary bytes with an identity the agent holds.
+ *
+ * Exported because a fresh proof from a terminal needs it: the server issues a
+ * nonce and this is what turns it into something the server can verify against
+ * a registered public key. `deriveCustodyKey` signs a FIXED challenge and hashes
+ * the result — that is a key-derivation, not a proof, and using it as one would
+ * replay.
+ *
+ * Returns the raw ed25519 signature, unwrapped from the agent's blob, because
+ * that is what a verifier takes.
+ */
+export declare function signWithIdentity(identity: AgentIdentity, data: Uint8Array, socketPath?: string): Promise<Uint8Array>;
 /**
  * Derive the 32-byte custody key for an identity.
  *

package/dist/ssh-agent.js

@@ -100,6 +100,11 @@ async function listIdentities(socketPath) {
 async function listCustodyIdentities(socketPath) {
   return (await listIdentities(socketPath)).filter((id) => id.type === "ssh-ed25519");
 }
+async function signWithIdentity(identity, data, socketPath) {
+  const wrapped = await sign(identity.blob, Buffer.from(data), socketPath);
+  const [raw] = readString(wrapped, readString(wrapped, 0)[1]);
+  return new Uint8Array(raw);
+}
 async function sign(blob, data, socketPath) {
   const payload = Buffer.concat([
     Buffer.from([SSH_AGENTC_SIGN_REQUEST]),
@@ -132,6 +137,7 @@ async function assertDeterministic(identity, socketPath) {
   return first;
 }
 export {
+  signWithIdentity,
   listIdentities,
   listCustodyIdentities,
   deriveCustodyKey,