@oxygen-agent/cli 1.717.11 → 1.739.0

package/node_modules/@oxygen/workflows/dist/index.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import * as vm from "node:vm"; // skipcq: JS-C1003
-import { isWorkflowGraphManifest } from "./graph/types.js";
+import { isWorkflowGraphManifest, WORKFLOW_CODE_V1_DEFAULT_OUTPUT_BYTES, WORKFLOW_CODE_V1_DEFAULT_TIMEOUT_MS, WORKFLOW_CODE_V1_MAX_OUTPUT_BYTES, WORKFLOW_CODE_V1_MAX_TIMEOUT_MS, WORKFLOW_CODE_V1_MIN_OUTPUT_BYTES, WORKFLOW_CODE_V1_MIN_TIMEOUT_MS, } from "./graph/types.js";
 import { lintWorkflowGraphManifest } from "./graph/lint.js";
 export * from "./usage-estimate.js";
 // Pure event-dispatch semantics, shared by the apps/web and apps/worker event
@@ -51,6 +51,18 @@ const UNSAFE_RECIPE_BUNDLE_PATTERNS = [
     { token: "setTimeout", pattern: /\bsetTimeout\b/ },
     { token: "setInterval", pattern: /\bsetInterval\b/ }, // skipcq: SCT-A000
 ];
+// Code v1 has no ctx.now()/ctx.uuid() capability and runs as a pure transform,
+// so its determinism/capability denylist is intentionally stricter than the
+// durable-recipe compatibility scan above. Keep this separate: old immutable
+// recipe revisions must not acquire new lint failures merely because Code v1 is
+// introduced.
+const UNSAFE_WORKFLOW_CODE_SOURCE_PATTERNS = [
+    ...UNSAFE_RECIPE_BUNDLE_PATTERNS,
+    { token: "Date", pattern: /\bDate\b/ },
+    { token: "WebAssembly", pattern: /\bWebAssembly\b/ },
+    { token: "setImmediate", pattern: /\bsetImmediate\b/ },
+    { token: "queueMicrotask", pattern: /\bqueueMicrotask\b/ },
+];
 /** A valid workflow / recipe / trigger status. Optional everywhere it appears. */
 function isValidWorkflowStatus(value) {
     return value === "active" || value === "disabled";
@@ -910,13 +922,34 @@ export function buildBlueprint(input) {
         ?? hashWorkflowSource(JSON.stringify(draft, workflowJsonReplacer));
     return { ...draft, source_hash: sourceHash };
 }
-export function validateJsonSchemaValue(value, schema, path = "$") {
+export function validateJsonSchemaValue(value, schema, path = "$", maxIssues = Number.POSITIVE_INFINITY, maxVisits = Number.POSITIVE_INFINITY) {
     if (!schema || typeof schema !== "object" || Array.isArray(schema))
         return [];
     const issues = [];
-    validateJsonSchemaValueInto(value, schema, path, issues);
+    const budget = {
+        visits: 0,
+        maximum: Math.max(1, Math.floor(maxVisits)),
+        exhausted: false,
+    };
+    validateJsonSchemaValueInto(value, schema, path, issues, Math.max(1, Math.floor(maxIssues)), budget);
+    if (budget.exhausted) {
+        return [{
+                path,
+                code: "schema_validation_too_complex",
+                message: `${path} exceeded the JSON Schema validation work limit.`,
+            }];
+    }
     return issues;
 }
+function consumeJsonSchemaValidationBudget(budget, amount = 1) {
+    if (budget.exhausted)
+        return false;
+    budget.visits += amount;
+    if (budget.visits <= budget.maximum)
+        return true;
+    budget.exhausted = true;
+    return false;
+}
 export function assertRecipeBundleSafe(bundle) {
     const issues = lintRecipeBundleSafety(bundle, "$.bundle");
     const first = issues[0];
@@ -930,9 +963,29 @@ export function lintRecipeBundleSafety(bundle, path = "$.bundle") {
     });
     return issues;
 }
+/** Comment/string-aware author feedback for the stricter oxygen-js-v1 runtime. */
+export function lintWorkflowCodeSourceSafety(source, path = "$.source") {
+    const issues = [];
+    if (!source.trim()) {
+        issues.push({ path, code: "empty_function_source", message: "Typed code source cannot be empty." });
+        return issues;
+    }
+    const scannable = stripCommentsAndStrings(source);
+    for (const entry of UNSAFE_WORKFLOW_CODE_SOURCE_PATTERNS) {
+        if (!entry.pattern.test(scannable))
+            continue;
+        issues.push({
+            path,
+            code: "unsafe_code_source",
+            message: `Typed code source cannot reference '${entry.token}'. Bind deterministic JSON inputs and use explicit Tool nodes for capabilities.`,
+        });
+        break;
+    }
+    return issues;
+}
 export async function runPureWorkflowFunction(input) {
-    const timeoutMs = Math.max(10, Math.min(input.timeoutMs ?? 1_000, 10_000));
-    const maxOutputBytes = Math.max(1_000, Math.min(input.maxOutputBytes ?? 250_000, 2_000_000));
+    const timeoutMs = Math.max(WORKFLOW_CODE_V1_MIN_TIMEOUT_MS, Math.min(input.timeoutMs ?? WORKFLOW_CODE_V1_DEFAULT_TIMEOUT_MS, WORKFLOW_CODE_V1_MAX_TIMEOUT_MS));
+    const maxOutputBytes = Math.max(WORKFLOW_CODE_V1_MIN_OUTPUT_BYTES, Math.min(input.maxOutputBytes ?? WORKFLOW_CODE_V1_DEFAULT_OUTPUT_BYTES, WORKFLOW_CODE_V1_MAX_OUTPUT_BYTES));
     const issues = [];
     validatePureFunctionSource(input.source, "$.source", (path, code, message) => {
         issues.push({ path, code, message });
@@ -1027,6 +1080,10 @@ export const workflowApplySchema = {
             exclusiveMinimum: 0,
             description: "Hard credit ceiling for each autonomous delivery.",
         },
+        publish: {
+            type: "boolean",
+            description: "False saves an editable draft revision without publishing it. Defaults to true.",
+        },
     },
     required: ["manifest"],
     $defs: {
@@ -1039,11 +1096,26 @@ export const workflowCallSchema = {
     type: "object",
     additionalProperties: false,
     properties: {
+        workflow: { type: "string" },
         workflow_id: { type: "string" },
         workflow_name: { type: "string" },
         input: { type: "object", additionalProperties: true },
         mode: { enum: ["dry_run", "live", "smoke_test"] },
         idempotency_key: { type: "string" },
+        revision_version: {
+            type: "integer",
+            minimum: 1,
+            description: "Exact saved revision to run. Historical revisions are non-live only.",
+        },
+        approved: {
+            type: "boolean",
+            description: "Explicit approval required for live calls.",
+        },
+        max_credits: {
+            type: "number",
+            exclusiveMinimum: 0,
+            description: "Positive credit ceiling required for live calls.",
+        },
     },
     required: ["mode"],
 };
@@ -1061,6 +1133,15 @@ export const workflowEventEmitSchema = {
         external_event_id: { type: "string" },
         idempotency_key: { type: "string" },
         mode: { enum: ["dry_run", "live", "smoke_test"] },
+        approved: {
+            type: "boolean",
+            description: "Explicit approval required when event deliveries run live.",
+        },
+        max_credits: {
+            type: "number",
+            exclusiveMinimum: 0,
+            description: "Positive per-delivery credit ceiling required for live event emission.",
+        },
     },
     required: ["source", "event", "payload", "mode"],
 };
@@ -1116,18 +1197,24 @@ export function getWorkflowSchema(subject = "apply") {
     return schemas[subject];
 }
 function validateJsonSchemaValueInto(// skipcq: JS-R1005
-value, schema, path, issues) {
+value, schema, path, issues, maxIssues, budget) {
+    if (issues.length >= maxIssues || budget.exhausted)
+        return;
+    if (!consumeJsonSchemaValidationBudget(budget))
+        return;
     const startCount = issues.length;
-    if (schema.const !== undefined && !jsonEqual(value, schema.const)) {
-        issues.push({
+    if (schema.const !== undefined && !jsonEqual(value, schema.const, budget)) {
+        addJsonSchemaValidationIssue(issues, maxIssues, {
             path,
             code: "schema_const_mismatch",
             message: `${path} must equal the schema const value.`,
         });
         return;
     }
-    if (Array.isArray(schema.enum) && schema.enum.length > 0 && !schema.enum.some((entry) => jsonEqual(value, entry))) {
-        issues.push({
+    if (Array.isArray(schema.enum)
+        && schema.enum.length > 0
+        && !schema.enum.some((entry) => budget.exhausted || jsonEqual(value, entry, budget))) {
+        addJsonSchemaValidationIssue(issues, maxIssues, {
             path,
             code: "schema_enum_mismatch",
             message: `${path} must be one of the allowed values.`,
@@ -1136,22 +1223,26 @@ value, schema, path, issues) {
     }
     if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
         const matched = schema.anyOf.some((candidate) => {
+            if (budget.exhausted)
+                return true;
             const candidateIssues = [];
-            validateJsonSchemaValueInto(value, candidate, path, candidateIssues);
+            validateJsonSchemaValueInto(value, candidate, path, candidateIssues, 1, budget);
             return candidateIssues.length === 0;
         });
         if (!matched) {
-            issues.push({
+            addJsonSchemaValidationIssue(issues, maxIssues, {
                 path,
                 code: "schema_any_of_mismatch",
                 message: `${path} must match at least one allowed schema.`,
             });
+            return;
         }
-        return;
+        // A matching anyOf does not erase sibling constraints. JSON Schema applies
+        // them together; returning here silently skipped object/array rules.
     }
     const expectedTypes = normalizeSchemaTypes(schema);
     if (expectedTypes.length > 0 && !expectedTypes.some((type) => matchesJsonSchemaType(value, type))) {
-        issues.push({
+        addJsonSchemaValidationIssue(issues, maxIssues, {
             path,
             code: "schema_type_mismatch",
             message: `${path} must be ${formatSchemaTypes(expectedTypes)}.`,
@@ -1165,40 +1256,57 @@ value, schema, path, issues) {
     if (shouldValidateObject && isRecord(value)) {
         const properties = schema.properties ?? {};
         for (const requiredKey of schema.required ?? []) {
+            if (issues.length >= maxIssues || budget.exhausted)
+                break;
+            if (!consumeJsonSchemaValidationBudget(budget))
+                break;
             if (!Object.hasOwn(value, requiredKey) || value[requiredKey] === undefined) {
-                issues.push({
+                addJsonSchemaValidationIssue(issues, maxIssues, {
                     path: `${path}.${requiredKey}`,
                     code: "schema_required",
                     message: `${path}.${requiredKey} is required.`,
                 });
             }
         }
-        for (const [key, propertyValue] of Object.entries(value)) {
-            const propertySchema = properties[key];
-            if (propertySchema) {
-                validateJsonSchemaValueInto(propertyValue, propertySchema, `${path}.${key}`, issues);
+        // Object enumeration is real host work. Charge every key before iterating so
+        // a large output tested against many `anyOf` object candidates cannot rescan
+        // the same object hundreds of times outside the sandbox timeout.
+        const valueKeys = Object.keys(value);
+        if (!consumeJsonSchemaValidationBudget(budget, valueKeys.length))
+            return;
+        for (const key of valueKeys) {
+            if (issues.length >= maxIssues || budget.exhausted)
+                break;
+            const propertyValue = value[key];
+            const propertySchema = Object.hasOwn(properties, key) ? properties[key] : undefined;
+            if (isRecord(propertySchema)) {
+                validateJsonSchemaValueInto(propertyValue, propertySchema, `${path}.${key}`, issues, maxIssues, budget);
             }
             else if (schema.additionalProperties === false) {
-                issues.push({
+                addJsonSchemaValidationIssue(issues, maxIssues, {
                     path: `${path}.${key}`,
                     code: "schema_additional_property",
                     message: `${path}.${key} is not allowed.`,
                 });
             }
             else if (isRecord(schema.additionalProperties)) {
-                validateJsonSchemaValueInto(propertyValue, schema.additionalProperties, `${path}.${key}`, issues);
+                validateJsonSchemaValueInto(propertyValue, schema.additionalProperties, `${path}.${key}`, issues, maxIssues, budget);
             }
         }
     }
     const shouldValidateArray = expectedTypes.includes("array") || Boolean(schema.items);
     if (shouldValidateArray && Array.isArray(value) && schema.items) {
-        value.forEach((entry, index) => {
-            validateJsonSchemaValueInto(entry, schema.items, `${path}.${index}`, issues);
-        });
+        for (let index = 0; index < value.length && issues.length < maxIssues && !budget.exhausted; index += 1) {
+            validateJsonSchemaValueInto(value[index], schema.items, `${path}.${index}`, issues, maxIssues, budget);
+        }
     }
     if (issues.length > startCount)
         return;
 }
+function addJsonSchemaValidationIssue(issues, maxIssues, issue) {
+    if (issues.length < maxIssues)
+        issues.push(issue);
+}
 function normalizeSchemaTypes(schema) {
     if (Array.isArray(schema.type))
         return schema.type.filter((entry) => typeof entry === "string");
@@ -1235,8 +1343,43 @@ function formatSchemaTypes(types) {
         return `a ${types[0]}`;
     return types.map((type) => type === "null" ? "null" : `a ${type}`).join(" or ");
 }
-function jsonEqual(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
+function jsonEqual(left, right, budget) {
+    return jsonEqualInto(left, right, new WeakMap(), budget);
+}
+function jsonEqualInto(left, right, seen, budget) {
+    if (!consumeJsonSchemaValidationBudget(budget))
+        return false;
+    if (left === right)
+        return true;
+    if (left === null || right === null || typeof left !== typeof right)
+        return false;
+    if (typeof left !== "object" || typeof right !== "object")
+        return false;
+    const leftArray = Array.isArray(left);
+    if (leftArray !== Array.isArray(right))
+        return false;
+    const compared = seen.get(left);
+    if (compared?.has(right))
+        return true;
+    if (compared)
+        compared.add(right);
+    else
+        seen.set(left, new WeakSet([right]));
+    if (leftArray) {
+        const rightArray = right;
+        return left.length === rightArray.length
+            && left.every((entry, index) => !budget.exhausted && jsonEqualInto(entry, rightArray[index], seen, budget));
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord);
+    const rightKeys = Object.keys(rightRecord);
+    if (!consumeJsonSchemaValidationBudget(budget, leftKeys.length + rightKeys.length))
+        return false;
+    return leftKeys.length === rightKeys.length
+        && leftKeys.every((key) => Object.hasOwn(rightRecord, key)
+            && !budget.exhausted
+            && jsonEqualInto(leftRecord[key], rightRecord[key], seen, budget));
 }
 // Optional idempotency_key_path (webhook + event triggers): when present it must
 // be a non-empty string. `label` distinguishes the trigger type in the message.

package/node_modules/@oxygen/workflows/dist/portable.js

@@ -111,7 +111,9 @@ function nodeUsesWorkspaceAsset(node) {
             return (node.reason !== undefined && valueRefUsesWorkspaceAsset(node.reason))
                 || Object.values(node.request ?? {}).some(valueRefUsesWorkspaceAsset);
         case "code":
-            return Object.values(node.configuration ?? {}).some(valueRefUsesWorkspaceAsset);
+            return node.code !== undefined
+                ? Object.values(node.code.inputs).some(valueRefUsesWorkspaceAsset)
+                : Object.values(node.configuration ?? {}).some(valueRefUsesWorkspaceAsset);
         case "workflow":
             return Object.values(node.input).some(valueRefUsesWorkspaceAsset);
         case "trigger":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.717.11",
+  "version": "1.739.0",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",