@atom-workflow-agent/atom-executor 0.1.0

package/dist/timeout/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.js","sourceRoot":"","sources":["../../src/timeout/timeout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAEnE,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,SAA8C,EAC9C,SAAwB,EACxB,YAA0B;IAE1B,IAAI,YAAY,EAAE,OAAO,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;QACnC,MAAM,MAAM,YAAY,iBAAiB;YACvC,CAAC,CAAC,MAAM;YACR,CAAC,CAAC,IAAI,iBAAiB,CAAC,WAAW,EAAE,qBAAqB,EAAE,KAAK,EAAE,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAChI,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,MAAM,aAAa,GAAG,GAAS,EAAE;QAC/B,MAAM,MAAM,GAAG,YAAY,EAAE,MAAM,CAAC;QACpC,UAAU,CAAC,KAAK,CAAC,MAAM,YAAY,iBAAiB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,iBAAiB,CAAC,WAAW,EAAE,qBAAqB,EAAE,KAAK,EAAE,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IAC7L,CAAC,CAAC;IACF,YAAY,EAAE,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IACvE,MAAM,KAAK,GAAG,SAAS,KAAK,IAAI;QAC9B,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,iBAAiB,CAAC,SAAS,EAAE,mBAAmB,SAAS,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;IAE5H,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;YAC/C,MAAM,eAAe,GAAG,GAAS,EAAE;gBACjC,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC;gBACxC,MAAM,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,iBAAiB,CAAC,WAAW,EAAE,qBAAqB,CAAC,CAAC,CAAC;YACvG,CAAC,CAAC;YACF,UAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YAC7E,IAAI,UAAU,CAAC,MAAM,CAAC,OAAO;gBAAE,eAAe,EAAE,CAAC;QACnD,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC;YACxB,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC;YAC5B,OAAO;SACR,CAAC,CAAC;IACL,CAAC;YAAS,CAAC;QACT,IAAI,KAAK;YAAE,YAAY,CAAC,KAAK,CAAC,CAAC;QAC/B,YAAY,EAAE,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC"}

package/dist/worker/atom-worker-entry.mjs

@@ -0,0 +1,200 @@
+import { isAtomTransition, createAtomLifecycleHelpers } from "@atom-workflow-agent/atom-sdk";
+import { randomUUID } from "node:crypto";
+
+const pending = new Map();
+const controller = new AbortController();
+let started = false;
+
+process.on("message", (message) => {
+  if (!message || typeof message !== "object") return;
+  if (message.type === "abort") {
+    controller.abort(new Error(message.reason || "Atom Attempt aborted"));
+    return;
+  }
+  if (message.type === "rpc.result") {
+    const request = pending.get(message.requestId);
+    if (!request) return;
+    pending.delete(message.requestId);
+    if (message.ok) request.resolve(message.value);
+    else request.reject(workerError(message.error));
+    return;
+  }
+  if (message.type !== "run" || started) return;
+  started = true;
+  void execute(message.request);
+});
+
+async function execute(request) {
+  const attemptId = request.context.runtime.attemptId;
+  emit(request, "process.started", { pid: process.pid });
+  const attemptResources = resources("attempt");
+  const instanceResources = resources("instance");
+  const logger = createLogger(request);
+  let definition;
+  let failure;
+  try {
+    definition = await loadDefinition(request);
+    emit(request, "atom.loaded", { sourceId: request.source.sourceId, atom: `${request.atom.id}@${request.atom.version}` });
+    if (definition.initialize) {
+      emit(request, "initialize.started");
+      await definition.initialize({ cwd: request.context.cwd, logger, resources: instanceResources, metadata: request.context.metadata });
+      emit(request, "initialize.completed");
+    }
+    const context = {
+      runtime: request.context.runtime,
+      cwd: request.context.cwd,
+      signal: controller.signal,
+      logger,
+      metadata: request.context.metadata,
+      ...(request.context.decision ? { decision: request.context.decision } : {}),
+      resources: attemptResources,
+      artifacts: {
+        put: input => rpc({ method: "artifacts.put", input }),
+        get: id => rpc({ method: "artifacts.get", id }),
+      },
+      ...createAtomLifecycleHelpers(),
+    };
+    const hook = request.phase;
+    emit(request, `${hook}.started`);
+    if (hook === "resume" && !definition.resume) throw coded("ATOM_RESUME_UNAVAILABLE", `Atom does not define resume(): ${request.atom.id}@${request.atom.version}`);
+    const raw = hook === "execute"
+      ? await definition.execute(request.input, context)
+      : await definition.resume(request.input, request.resumeInput, context);
+    emit(request, `${hook}.completed`);
+    const invocation = isAtomTransition(raw)
+      ? { kind: "transition", result: raw.result }
+      : { kind: "output", output: raw };
+    await attemptResources.disposeAll(isAtomTransition(raw) ? "interrupted" : "completed");
+    if (definition.dispose) {
+      emit(request, "dispose.started");
+      await definition.dispose({ cwd: request.context.cwd, logger, resources: instanceResources, metadata: request.context.metadata });
+      emit(request, "dispose.completed");
+    }
+    await instanceResources.disposeAll("shutdown");
+    emit(request, "process.completed");
+    await finish({ type: "completed", invocation });
+    return;
+  } catch (error) {
+    failure = error;
+  }
+  try { await attemptResources.disposeAll(controller.signal.aborted ? "cancelled" : "failed"); } catch (error) { failure = new AggregateError([failure, error], "Atom Attempt and cleanup failed"); }
+  try {
+    if (definition?.dispose) {
+      emit(request, "dispose.started");
+      await definition.dispose({ cwd: request.context.cwd, logger, resources: instanceResources, metadata: request.context.metadata });
+      emit(request, "dispose.completed");
+    }
+    await instanceResources.disposeAll("shutdown");
+  } catch (error) { failure = new AggregateError([failure, error], "Atom Attempt and dispose failed"); }
+  await finish({ type: "failed", error: serializeError(failure) });
+}
+
+async function loadDefinition(request) {
+  if (request.protocolVersion !== 1) throw coded("ATOM_WORKER_PROTOCOL_UNSUPPORTED", `Unsupported protocol version: ${request.protocolVersion}`);
+  const module = await import(request.source.moduleUrl);
+  const atomPackage = module.atomPackage ?? module.default;
+  if (!atomPackage || !Array.isArray(atomPackage.atoms)) throw coded("ATOM_PACKAGE_EXPORT_INVALID", `Atom module did not export atomPackage: ${request.source.sourceId}`);
+  const definition = atomPackage.atoms.find((candidate) => candidate?.manifest?.id === request.atom.id && candidate?.manifest?.version === request.atom.version);
+  if (!definition) throw coded("ATOM_NOT_FOUND", `Atom module does not export ${request.atom.id}@${request.atom.version}`);
+  if (typeof definition.execute !== "function") throw coded("INVALID_ATOM", `Atom execute() is missing: ${request.atom.id}@${request.atom.version}`);
+  return definition;
+}
+
+function resources(scope) {
+  const registered = new Map();
+  let disposed = false;
+  return {
+    scope,
+    register(resource) {
+      if (disposed) throw new Error("Atom resources are already disposed");
+      if (!resource || typeof resource.id !== "string" || typeof resource.dispose !== "function") throw new TypeError("Atom resource is invalid");
+      if (registered.has(resource.id)) throw new Error(`Duplicate Atom resource: ${resource.id}`);
+      registered.set(resource.id, resource);
+    },
+    async disposeAll(reason) {
+      if (disposed) return;
+      disposed = true;
+      const failures = [];
+      for (const resource of [...registered.values()].reverse()) {
+        try { await resource.dispose(reason); } catch (error) { failures.push(error); }
+      }
+      registered.clear();
+      if (failures.length) throw new AggregateError(failures, "Atom resource cleanup failed");
+    },
+  };
+}
+
+function createLogger(request) {
+  const write = (level, message, fields) => emit(request, "atom.log", { level, message, ...(fields ? { fields } : {}) });
+  return {
+    debug: (message, fields) => write("debug", message, fields),
+    info: (message, fields) => write("info", message, fields),
+    warn: (message, fields) => write("warn", message, fields),
+    error: (message, fields) => write("error", message, fields),
+  };
+}
+
+function rpc(request) {
+  if (controller.signal.aborted) return Promise.reject(controller.signal.reason ?? new Error("Atom Attempt aborted"));
+  const requestId = randomUUID();
+  return new Promise((resolve, reject) => {
+    pending.set(requestId, { resolve, reject });
+    send({ type: "rpc", requestId, request }).catch((error) => {
+      pending.delete(requestId);
+      reject(error);
+    });
+  });
+}
+
+function emit(request, type, data) {
+  void send({
+    type: "event",
+    event: {
+      schemaVersion: "1.0",
+      type,
+      timestamp: new Date().toISOString(),
+      attemptId: request.context.runtime.attemptId,
+      phase: request.phase,
+      ...(data === undefined ? {} : { data }),
+    },
+  });
+}
+
+function coded(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+
+function workerError(error) {
+  return Object.assign(new Error(error?.message ?? "Atom worker RPC failed"), {
+    name: error?.name ?? "Error",
+    code: error?.code ?? "ATOM_WORKER_RPC_FAILED",
+    retryable: error?.retryable === true,
+    ...(error?.details === undefined ? {} : { details: error.details }),
+  });
+}
+
+function serializeError(error) {
+  const candidate = error instanceof Error ? error : new Error(String(error));
+  return {
+    name: candidate.name,
+    code: typeof candidate.code === "string" ? candidate.code : "ATOM_EXECUTION_FAILED",
+    message: candidate.message,
+    retryable: candidate.retryable === true,
+    ...(candidate.details === undefined ? {} : { details: candidate.details }),
+    ...(candidate.stack ? { stack: candidate.stack } : {}),
+  };
+}
+
+async function finish(message) {
+  try { await send(message); } finally {
+    process.disconnect?.();
+    setImmediate(() => process.exit(0));
+  }
+}
+
+function send(message) {
+  return new Promise((resolve, reject) => {
+    if (!process.send) return reject(new Error("Atom worker IPC channel is unavailable"));
+    process.send(message, (error) => error ? reject(error) : resolve());
+  });
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@atom-workflow-agent/atom-executor",
+  "version": "0.1.0",
+  "description": "Isolated lifecycle execution for one atom attempt.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joekbits/atom-workflow-agent.git",
+    "directory": "packages/atom-executor"
+  },
+  "homepage": "https://github.com/joekbits/atom-workflow-agent/tree/main/packages/atom-executor#readme",
+  "bugs": {
+    "url": "https://github.com/joekbits/atom-workflow-agent/issues"
+  },
+  "keywords": [
+    "atom",
+    "workflow",
+    "executor",
+    "worker"
+  ],
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "README.zh-CN.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@atom-workflow-agent/contracts": "0.1.0",
+    "@atom-workflow-agent/atom-sdk": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && mkdir -p dist/worker && cp src/worker/atom-worker-entry.mjs dist/worker/atom-worker-entry.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}