@oxygen-agent/cli 1.1014.1464 → 1.1014.1597

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

@@ -1114,7 +1114,11 @@ export function lintWorkflowCodeSourceSafety(source, path = "$.source") {
         issues.push({ path, code: "empty_function_source", message: "Typed code source cannot be empty." });
         return issues;
     }
-    const scannable = stripCommentsAndStrings(source);
+    const scan = stripCommentsAndStrings(source);
+    if (scan.ambiguousSlash) {
+        return [{ path, code: "unsafe_code_source", message: "Typed code source has an ambiguous slash after a brace. Parenthesize the expression or separate statements with a semicolon." }];
+    }
+    const scannable = scan.source;
     for (const entry of UNSAFE_WORKFLOW_CODE_SOURCE_PATTERNS) {
         if (!entry.pattern.test(scannable))
             continue;
@@ -1695,6 +1699,15 @@ export function validatePureFunctionSource(source, path, add) {
 function stripCommentsAndStrings(source) {
     const out = [];
     const stack = [{ mode: "code", braces: 0 }];
+    const expressionKeywords = new Set(["return", "throw", "case", "delete", "void", "typeof", "yield", "await", "in", "instanceof", "else", "do"]);
+    const controlKeywords = new Set(["if", "while", "for", "with", "switch", "catch"]);
+    const statementBlockKeywords = new Set(["else", "do", "try", "finally", "catch"]);
+    const braceKinds = [];
+    const controlParens = [];
+    let regexAllowed = true;
+    let ambiguousAfterBrace = false;
+    let previousToken = "";
+    let previousWordEnd = 0;
     let i = 0;
     const n = source.length;
     while (i < n) {
@@ -1708,11 +1721,15 @@ function stripCommentsAndStrings(source) {
             }
             if (ch === "`") {
                 stack.pop();
+                regexAllowed = false;
+                previousToken = "literal";
                 i += 1;
                 continue;
             }
             if (ch === "$" && next === "{") {
                 stack.push({ mode: "code", braces: 0 });
+                regexAllowed = true;
+                previousToken = "";
                 out.push(" ");
                 i += 2;
                 continue;
@@ -1733,6 +1750,39 @@ function stripCommentsAndStrings(source) {
             i = Math.min(i + 2, n);
             continue;
         }
+        if (ch === "/" && ambiguousAfterBrace)
+            return { source: out.join(""), ambiguousSlash: true };
+        if (!/\s/.test(ch))
+            ambiguousAfterBrace = false;
+        // Regex quotes must not make the string scanner swallow executable code.
+        if (ch === "/" && regexAllowed) {
+            let end = i + 1;
+            let characterClass = false;
+            while (end < n && source[end] !== "\n" && source[end] !== "\r") {
+                const current = source[end];
+                if (current === "\\") {
+                    end += 2;
+                    continue;
+                }
+                if (current === "[")
+                    characterClass = true;
+                else if (current === "]")
+                    characterClass = false;
+                else if (current === "/" && !characterClass)
+                    break;
+                end += 1;
+            }
+            if (end < n && source[end] === "/") {
+                end += 1;
+                while (end < n && /[a-z]/i.test(source[end]))
+                    end += 1;
+                out.push('""');
+                i = end;
+                regexAllowed = false;
+                previousToken = "literal";
+                continue;
+            }
+        }
         if (ch === '"' || ch === "'") {
             const quote = ch;
             i += 1;
@@ -1740,6 +1790,8 @@ function stripCommentsAndStrings(source) {
                 i += source[i] === "\\" ? 2 : 1;
             i += 1;
             out.push('""');
+            regexAllowed = false;
+            previousToken = "literal";
             continue;
         }
         if (ch === "`") {
@@ -1747,12 +1799,60 @@ function stripCommentsAndStrings(source) {
             i += 1;
             continue;
         }
+        if (/[a-z_$]/i.test(ch)) {
+            const start = i;
+            while (i < n && /[\w$]/.test(source[i]))
+                i += 1;
+            const word = source.slice(start, i);
+            out.push(word);
+            previousToken = previousToken === "." ? "identifier" : word;
+            previousWordEnd = i;
+            regexAllowed = expressionKeywords.has(previousToken);
+            continue;
+        }
         if (ch === "}" && top.braces === 0 && stack.length > 1) {
             stack.pop();
             out.push(" ");
             i += 1;
             continue;
         }
+        if (ch === "=" && next === ">") {
+            out.push("=>");
+            previousToken = "=>";
+            regexAllowed = true;
+            i += 2;
+            continue;
+        }
+        if (ch === "{") {
+            const enclosing = braceKinds[braceKinds.length - 1];
+            let kind = "unknown";
+            if ((previousToken === ")" && regexAllowed) || statementBlockKeywords.has(previousToken)
+                || previousToken === ";" || (previousToken === "{" && (enclosing === "statement" || enclosing === "function")))
+                kind = "statement";
+            else if (previousToken === "=>")
+                kind = "function";
+            else if (["=", "(", "[", ","].includes(previousToken) || (previousToken === ":" && enclosing === "object")
+                || (previousToken === "return" && !/[\r\n]/.test(source.slice(previousWordEnd, i))))
+                kind = "object";
+            braceKinds.push(kind);
+        }
+        if (ch === "(")
+            controlParens.push(controlKeywords.has(previousToken));
+        if (ch === ")")
+            regexAllowed = controlParens.pop() ?? false;
+        else if (ch === "}") {
+            const kind = braceKinds.pop();
+            regexAllowed = kind === "statement";
+            // Other brace forms need a parser to distinguish declarations from expressions.
+            ambiguousAfterBrace = kind === "unknown";
+        }
+        else if (!/\s/.test(ch)) {
+            if (!((ch === "+" || ch === "-") && (next === ch || previousToken === ch))) {
+                regexAllowed = /[([{,:;=!?&|+*%^~<>\/-]/.test(ch);
+            }
+        }
+        if (!/\s/.test(ch))
+            previousToken = ch;
         if (ch === "{")
             top.braces += 1;
         else if (ch === "}")
@@ -1760,7 +1860,7 @@ function stripCommentsAndStrings(source) {
         out.push(ch);
         i += 1;
     }
-    return out.join("");
+    return { source: out.join(""), ambiguousSlash: false };
 }
 function validateRecipeBundleSafety(source, path, add) {
     if (!source.trim()) {
@@ -1770,7 +1870,12 @@ function validateRecipeBundleSafety(source, path, add) {
     // Scan only real code: comments and string literals are blanked first so a
     // token that merely appears in prose or data (e.g. "eval" in a comment) does
     // not trip the lint, while genuine calls survive.
-    const scannable = stripCommentsAndStrings(source);
+    const scan = stripCommentsAndStrings(source);
+    if (scan.ambiguousSlash) {
+        add(path, "unsafe_recipe_bundle", "Durable recipe bundle has an ambiguous slash after a brace. Parenthesize the expression or separate statements with a semicolon.");
+        return;
+    }
+    const scannable = scan.source;
     for (const entry of UNSAFE_RECIPE_BUNDLE_PATTERNS) {
         if (entry.pattern.test(scannable)) {
             add(path, "unsafe_recipe_bundle", `Durable recipe bundle cannot reference '${entry.token}'. Use ctx.tools.run(), ctx.step(), ctx.now(), or ctx.uuid() instead.`);

package/package.json

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