0sec-cli 0.22.1 → 0.23.0

package/chunks/{process-N245QIQG.js → process-MJYJ2K5E.js}

@@ -4,7 +4,8 @@ const require = __0CreateRequire(import.meta.url);
 import {
   ProcessRuntime,
   describeSpawnFailure
-} from "./chunk-W6UWZFKL.js";
+} from "./chunk-O6KPVYOI.js";
+import "./chunk-RS4MAN3Q.js";
 import "./chunk-VCSFCHAJ.js";
 export {
   ProcessRuntime,

package/chunks/remote-workflow-runtime-RGQ5ECMN.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+import {
+  BackendIdSchema,
+  requireBackendCapability
+} from "./chunk-LTEE2JWK.js";
+import {
+  external_exports
+} from "./chunk-VIT5ALXF.js";
+import "./chunk-VCSFCHAJ.js";
+
+// packages/cli/src/remote-workflow-runtime.ts
+var executionSchema = external_exports.object({ id: external_exports.string().min(1).max(160), status: external_exports.enum(["queued", "running", "completed", "failed", "cancelled", "interrupted"]) }).passthrough();
+async function readJson(response) {
+  const maximum = 16 * 1024 * 1024;
+  const chunks = [];
+  let bytes = 0;
+  if (response.body) {
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const next = await reader.read();
+        if (next.done) break;
+        bytes += next.value.byteLength;
+        if (bytes > maximum) throw new Error("Workflow backend response exceeds 16 MiB.");
+        chunks.push(next.value);
+      }
+    } finally {
+      await reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+  let value;
+  try {
+    value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new Error(`Workflow backend returned invalid JSON (HTTP ${response.status}).`);
+  }
+  if (!response.ok) {
+    const error = value && typeof value === "object" && "error" in value ? value.error : void 0;
+    throw new Error(typeof error === "string" ? error.slice(0, 4096) : `Workflow backend request failed (HTTP ${response.status}).`);
+  }
+  return value;
+}
+async function createRemoteWorkflowRuntime(options, suppliedRegistry) {
+  const backendId = BackendIdSchema.parse(options.backendId);
+  const registry = suppliedRegistry ?? new (await import("./backend-connections-H52NIVH2.js")).BackendConnectionRegistry({ configPath: options.configPath });
+  const connection = await registry.handshake(backendId);
+  if (connection.backend.transport !== "http") throw new Error("Select a registered remote HTTP backend; local execution cannot use this transport.");
+  requireBackendCapability(connection.backend, "workflow-engine");
+  let disposed = false;
+  const active = /* @__PURE__ */ new Set();
+  const invoke = async (name, args = {}) => {
+    if (disposed) throw new Error("Remote workflow client is closed.");
+    const abort = new AbortController();
+    active.add(abort);
+    const timeout = setTimeout(() => abort.abort(new Error("Workflow backend request timed out.")), 3e4);
+    try {
+      return await readJson(await registry.request(backendId, "/api/workflow-engine/call", { method: "POST", body: { name, args }, signal: abort.signal }));
+    } finally {
+      clearTimeout(timeout);
+      active.delete(abort);
+    }
+  };
+  return {
+    listTemplates: () => invoke("list_templates"),
+    getTemplate: (id) => invoke("get_template", { id }),
+    listWorkflows: () => invoke("list_workflows"),
+    listRuns: () => invoke("list_runs"),
+    getWorkflow: (id) => invoke("get_workflow", { id }),
+    saveWorkflow: (definition, expectedRevision) => invoke("save_workflow", { definition, ...expectedRevision !== void 0 ? { expectedRevision } : {} }),
+    startRun: async (request) => {
+      if (request.model !== void 0) throw new Error("The selected backend owns its configured model connection.");
+      const { model: _model, ...args } = request;
+      return executionSchema.parse(await invoke("start_run", args));
+    },
+    getRun: async (id) => {
+      const result = await invoke("get_run", { runId: id });
+      return result === null ? null : executionSchema.parse(result);
+    },
+    getRunResults: (id, page = {}) => invoke("get_run_results", { runId: id, ...page }),
+    cancelRun: (id) => invoke("cancel_run", { runId: id }),
+    dispose: async () => {
+      if (disposed) return;
+      disposed = true;
+      for (const abort of active) abort.abort();
+      active.clear();
+      if (!suppliedRegistry) registry.dispose?.();
+    }
+  };
+}
+export {
+  createRemoteWorkflowRuntime
+};