akm-cli 0.9.1 → 0.9.2-alpha.1

package/dist/tasks/scheduler-invocation.js

@@ -4,9 +4,11 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { bundleRefToString, parseBundleRef } from "../core/asset/asset-ref.js";
 import { resolveStashDir } from "../core/common.js";
 import { ConfigError } from "../core/errors.js";
 import { getCacheDir, getConfigDir, getDataDir, getTaskContextDir } from "../core/paths.js";
+import { normaliseTaskConceptId } from "./task-id.js";
 export const SCHEDULED_TASK_CONTEXT_KEYS = [
     "AKM_BUNDLE_DIR",
     "AKM_CONFIG_DIR",
@@ -15,14 +17,9 @@ export const SCHEDULED_TASK_CONTEXT_KEYS = [
     "AKM_STATE_DIR",
 ];
 /**
- * The AKM_* directory context currently in effect, as a plain env fragment.
- *
- * A scheduled run restores these into `process.env` from its
- * `--scheduler-context` descriptor precisely because such installs have
- * non-default directories. Paths that build a child environment from an
- * allowlist rather than inheriting (the agent spawn) must forward this
- * explicitly, or the child's `akm` sub-commands silently target the default
- * stash and DB.
+ * The AKM directory context currently restored from a scheduler descriptor.
+ * Child environments that are built from an allowlist must forward this
+ * closed set explicitly so nested AKM commands stay in the same installation.
  */
 export function scheduledTaskContextEnv(env = process.env) {
     const out = {};
@@ -45,28 +42,13 @@ export function resolveScheduledTaskContext(env = process.env, platform = proces
         AKM_STATE_DIR: path.resolve(resolveStateDir(env, platform)),
     });
 }
-/**
- * Build the one scheduler-generated argv shape consumed by all backends.
- *
- * `target` records the bundle a non-primary task lives in as a `--bundle
- * <bundle>` token so the scheduled `akm task run` resolves the task (and its
- * relative asset refs) from that bundle. It is emitted ONLY when supplied and
- * non-empty — callers pass it exclusively for a non-default bundle, so a
- * primary-bundle (or default) task omits the target pair.
- */
-export function buildScheduledTaskInvocation(akmArgv, id, contextPath, target) {
-    const targetArgs = target !== undefined && target !== "" ? ["--bundle", target] : [];
+/** Build an installed argv from one already-validated public scheduler tail. */
+export function buildScheduledBindingInvocation(akmArgv, contextPath, invocation) {
+    const parsed = parsePublicSchedulerInvocation(invocation);
+    if (!parsed)
+        throw invalidSchedulerInvocation();
     return {
-        argv: [
-            ...akmArgv,
-            SCHEDULER_CONTEXT_ARG,
-            assertAbsolutePath(contextPath),
-            "task",
-            "run",
-            id,
-            ...targetArgs,
-            "--scheduled",
-        ],
+        argv: [...akmArgv, SCHEDULER_CONTEXT_ARG, assertAbsolutePath(contextPath), ...parsed.invocation],
     };
 }
 export function schedulerContextDescriptor(context = resolveScheduledTaskContext(), envPath = process.env.PATH ?? "") {
@@ -188,31 +170,60 @@ export function consumeSchedulerContextArg(argv, env = process.env) {
     loadSchedulerContextDescriptor(file, env);
     return [...argv.slice(0, index), ...argv.slice(index + 2)];
 }
-export function parseScheduledTaskArgv(argv) {
+/** Parse either the public scheduled task or qualified workflow invocation. */
+export function parseScheduledBindingArgv(argv) {
     const contextIndex = argv.indexOf(SCHEDULER_CONTEXT_ARG);
     if (contextIndex < 1 || argv.indexOf(SCHEDULER_CONTEXT_ARG, contextIndex + 1) !== -1)
         return undefined;
     const contextPath = argv[contextIndex + 1];
-    const tasksIndex = contextIndex + 2;
-    if (!contextPath || argv[tasksIndex] !== "task" || argv[tasksIndex + 1] !== "run" || !argv[tasksIndex + 2]) {
+    if (!contextPath)
         return undefined;
-    }
-    let index = tasksIndex + 3;
-    let target;
-    if (argv[index] === "--bundle") {
-        target = argv[index + 1];
-        if (!target)
-            return undefined;
-        index += 2;
-    }
-    if (argv[index] !== "--scheduled" || index !== argv.length - 1)
+    const publicInvocation = parsePublicSchedulerInvocation(argv.slice(contextIndex + 2));
+    if (!publicInvocation)
         return undefined;
     return {
         binding: [...argv.slice(0, contextIndex)],
         contextPath: assertAbsolutePath(contextPath),
-        ...(target !== undefined ? { target } : {}),
+        invocation: publicInvocation.invocation,
+        ...(publicInvocation.target !== undefined ? { target: publicInvocation.target } : {}),
     };
 }
+function parsePublicSchedulerInvocation(invocation) {
+    if (invocation[0] === "task" && invocation[1] === "run" && invocation[2]) {
+        try {
+            if (normaliseTaskConceptId(invocation[2]) !== invocation[2])
+                return undefined;
+        }
+        catch {
+            return undefined;
+        }
+        let index = 3;
+        let target;
+        if (invocation[index] === "--bundle") {
+            target = invocation[index + 1];
+            if (!target)
+                return undefined;
+            index += 2;
+        }
+        if (invocation[index] !== "--scheduled" || index !== invocation.length - 1)
+            return undefined;
+        return { invocation: [...invocation], ...(target !== undefined ? { target } : {}) };
+    }
+    if (invocation[0] !== "workflow" || invocation[1] !== "run" || invocation.length !== 3)
+        return undefined;
+    const ref = invocation[2];
+    if (!ref)
+        return undefined;
+    try {
+        const parsed = parseBundleRef(ref);
+        if (!parsed.bundle || parsed.fragment !== undefined || bundleRefToString(parsed) !== ref)
+            return undefined;
+        return { invocation: [...invocation], target: parsed.bundle };
+    }
+    catch {
+        return undefined;
+    }
+}
 function canonicalContext(input) {
     const inputKeys = Object.keys(input);
     if (inputKeys.length !== SCHEDULED_TASK_CONTEXT_KEYS.length ||
@@ -313,3 +324,6 @@ function resolveStateDir(env, platform) {
 function invalidSchedulerContext() {
     return new ConfigError(`Invalid scheduler context; expected exactly ${SCHEDULED_TASK_CONTEXT_KEYS.join(", ")} as absolute paths.`, "INVALID_CONFIG_FILE");
 }
+function invalidSchedulerInvocation() {
+    return new ConfigError("Invalid scheduler invocation; expected public `task run <id> [--bundle <bundle>] --scheduled` or `workflow run <qualified-ref>` argv.", "INVALID_CONFIG_FILE");
+}