@oxygen-agent/cli 1.922.14 → 1.948.1

package/node_modules/@oxygen/shared/dist/workspace-file-storage.js

@@ -0,0 +1,126 @@
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { OxygenError } from "./cli-result.js";
+import { resolveObjectStorageClient } from "./object-storage.js";
+export const WORKSPACE_VISUAL_SOURCE_MAX_BYTES = 1_500_000;
+export const WORKSPACE_VISUAL_BINARY_MAX_BYTES = 50 * 1024 * 1024;
+/** Platform abuse guard shared by every plan, not a storage entitlement. */
+export const WORKSPACE_RETAINED_FILES_MAX_BYTES = 1024 * 1024 * 1024;
+const STORAGE_TIMEOUT_MS = 60_000;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const ORGANIZATION = /^[A-Za-z0-9_-]{1,128}$/;
+const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+export function assertWorkspaceFileId(id) {
+    if (!UUID.test(id))
+        throw new OxygenError("invalid_request", "A valid workspace file ID is required.");
+}
+export function normalizeWorkspaceVisualFileName(name) {
+    const result = name.trim();
+    if (!result || Buffer.byteLength(result) > 255 || /[\x00-\x1f\x7f/\\]/.test(result) || result === "." || result === "..") {
+        throw new OxygenError("invalid_request", "File name must be a filename of at most 255 bytes, without paths or control characters.");
+    }
+    return result;
+}
+export function buildWorkspaceFileObjectKey(input) {
+    assertWorkspaceFileId(input.fileId);
+    if (!ORGANIZATION.test(input.organizationId))
+        throw new OxygenError("invalid_request", "Invalid workspace identity.");
+    const name = normalizeWorkspaceVisualFileName(input.fileName);
+    const safeName = name.replace(/[^A-Za-z0-9._-]/g, "_").replace(/^[^A-Za-z0-9]+/, "").slice(0, 200) || "file";
+    return `workspace-files/${input.organizationId}/${input.fileId}/${safeName}`;
+}
+export function isWorkspaceFileObjectKeyForOrganization(key, organizationId, fileId) {
+    const parts = key.split("/");
+    return ORGANIZATION.test(organizationId) && parts.length === 4
+        && parts[0] === "workspace-files" && parts[1] === organizationId
+        && UUID.test(parts[2] ?? "") && SAFE_NAME.test(parts[3] ?? "")
+        && (fileId === undefined || parts[2] === fileId);
+}
+export function assertWorkspaceFileObjectKey(input) {
+    if (!isWorkspaceFileObjectKeyForOrganization(input.storageKey, input.organizationId, input.fileId)) {
+        throw new OxygenError("forbidden_storage_key", "File storage does not belong to this workspace file.");
+    }
+}
+/** Framing check only. Full media validation belongs in the isolated renderer validator. */
+export function assertWorkspaceVisualBinary(bytes, mimeType) {
+    if (bytes.byteLength < 1 || bytes.byteLength > WORKSPACE_VISUAL_BINARY_MAX_BYTES) {
+        throw new OxygenError("workspace_file_too_large", "Visual output must contain between 1 byte and 50 MiB.");
+    }
+    const png = [137, 80, 78, 71, 13, 10, 26, 10];
+    const valid = mimeType === "image/png"
+        ? png.every((byte, index) => bytes[index] === byte)
+        : mimeType === "application/pdf" && Buffer.from(bytes.subarray(0, 5)).toString("ascii") === "%PDF-";
+    if (!valid)
+        throw new OxygenError("workspace_file_invalid_type", "Visual output bytes do not match the declared PNG or PDF format.");
+}
+export function workspaceFileSha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+export async function readWorkspaceFileObject(input) {
+    input.signal?.throwIfAborted();
+    assertWorkspaceFileObjectKey(input);
+    if (!Number.isSafeInteger(input.sizeBytes) || input.sizeBytes < 1 || input.sizeBytes > WORKSPACE_VISUAL_BINARY_MAX_BYTES || !/^[a-f0-9]{64}$/.test(input.sha256)) {
+        throw new OxygenError("workspace_file_integrity_failed", "File metadata failed integrity validation.");
+    }
+    const { client, bucket } = resolveObjectStorageClient();
+    const signal = input.signal ? AbortSignal.any([input.signal, AbortSignal.timeout(STORAGE_TIMEOUT_MS)]) : AbortSignal.timeout(STORAGE_TIMEOUT_MS);
+    const result = await client.send(new GetObjectCommand({
+        Bucket: bucket, Key: input.storageKey, Range: `bytes=0-${input.sizeBytes}`,
+    }), { abortSignal: signal });
+    const body = result.Body;
+    if (!body)
+        throw new OxygenError("workspace_file_storage_missing", "Stored file bytes are unavailable.");
+    const stream = body;
+    const abort = () => stream.destroy?.(new Error("Workspace file read timed out."));
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+        if (typeof stream[Symbol.asyncIterator] !== "function")
+            throw new OxygenError("workspace_file_storage_invalid", "Stored file transport is invalid.");
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of stream) {
+            signal.throwIfAborted();
+            if (!(chunk instanceof Uint8Array))
+                throw new OxygenError("workspace_file_storage_invalid", "Stored file transport is invalid.");
+            size += chunk.byteLength;
+            if (size > input.sizeBytes)
+                throw new OxygenError("workspace_file_integrity_failed", "Stored file exceeds its recorded size.");
+            chunks.push(Buffer.from(chunk));
+        }
+        const bytes = Buffer.concat(chunks, size);
+        signal.throwIfAborted();
+        if (size !== input.sizeBytes || workspaceFileSha256(bytes) !== input.sha256 || result.ContentType?.split(";", 1)[0]?.trim().toLowerCase() !== input.mimeType) {
+            throw new OxygenError("workspace_file_integrity_failed", "Stored file failed size, format or digest verification.");
+        }
+        assertWorkspaceVisualBinary(bytes, input.mimeType);
+        return bytes;
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+        stream.destroy?.();
+    }
+}
+/** Immutable PUT followed by bounded readback. A matching existing object is a safe retry. */
+export async function putWorkspaceFileObject(input) {
+    input.signal?.throwIfAborted();
+    assertWorkspaceVisualBinary(input.bytes, input.mimeType);
+    const storageKey = buildWorkspaceFileObjectKey(input);
+    const bytes = Buffer.from(input.bytes);
+    const sha256 = workspaceFileSha256(bytes);
+    const { client, bucket } = resolveObjectStorageClient();
+    try {
+        await client.send(new PutObjectCommand({
+            Bucket: bucket, Key: storageKey, Body: bytes, ContentLength: bytes.byteLength,
+            ContentType: input.mimeType, ContentDisposition: "attachment", IfNoneMatch: "*",
+        }), { abortSignal: input.signal ? AbortSignal.any([input.signal, AbortSignal.timeout(STORAGE_TIMEOUT_MS)]) : AbortSignal.timeout(STORAGE_TIMEOUT_MS) });
+    }
+    catch (error) {
+        // Never overwrite a prior attempt, even after upload-success/DB-failure.
+        const status = error?.$metadata?.httpStatusCode;
+        if (status !== 412)
+            throw error;
+    }
+    await readWorkspaceFileObject({ ...input, storageKey, sizeBytes: bytes.byteLength, sha256 });
+    return { storageKey, sizeBytes: bytes.byteLength, sha256 };
+}

package/node_modules/@oxygen/shared/package.json

@@ -6,6 +6,11 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
+    "./vercel-sandbox-fetch": {
+      "types": "./dist/vercel-sandbox-fetch.d.ts",
+      "import": "./dist/vercel-sandbox-fetch.js",
+      "default": "./dist/vercel-sandbox-fetch.js"
+    },
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
@@ -190,6 +195,11 @@
       "types": "./dist/publishing-limits.d.ts",
       "import": "./dist/publishing-limits.js",
       "default": "./dist/publishing-limits.js"
+    },
+    "./workspace-file-storage": {
+      "types": "./dist/workspace-file-storage.d.ts",
+      "import": "./dist/workspace-file-storage.js",
+      "default": "./dist/workspace-file-storage.js"
     }
   },
   "dependencies": {}

package/node_modules/@oxygen/workflows/dist/graph/lint.js

@@ -232,6 +232,15 @@ value, add, scope, options) {
     }
     return sound;
 }
+/**
+ * The character the graph host puts between a node id and its loop iteration
+ * path when it mints a node execution's persisted `step_id`
+ * (`${nodeId}#${iterationPath.join(".")}` — apps/worker
+ * workflow-graph-processor.ts `stepKey`). Declared here rather than imported so
+ * the linter stays a leaf of the worker, and pinned against the real producer
+ * by the `invalid_node_id_character` test.
+ */
+const ITERATION_STEP_ID_SEPARATOR = "#";
 function lintNodeIdentity(node, path, seenIds, add) {
     let sound = true;
     if (!isNonEmptyString(node.id)) {
@@ -246,6 +255,19 @@ function lintNodeIdentity(node, path, seenIds, add) {
         add(`${path}.id`, "reserved_node_id", `Node id '${node.id}' is reserved (it collides with a JavaScript object key and would be dropped from node outputs). Choose another id.`);
         sound = false;
     }
+    else if (node.id.includes(ITERATION_STEP_ID_SEPARATOR)) {
+        // `#` is not a style rule — it is the runtime's own separator. A node
+        // execution's persisted identity is `<node id>#<iteration path>`
+        // (apps/worker workflow-graph-processor.ts `stepKey`, kept byte-identical to
+        // tenant-db's `step_id` convention), so a node literally named `a#1` shares a
+        // step_id with the second iteration of a loop body named `a`. The collision
+        // is silent and destructive: whichever row exists first is replayed as the
+        // other's completed output, so one of the two never runs and the run still
+        // reports success. Rejecting the character at authoring time is the only
+        // place this can be caught cheaply.
+        add(`${path}.id`, "invalid_node_id_character", `Node id '${node.id}' must not contain '${ITERATION_STEP_ID_SEPARATOR}' (it is reserved for loop iteration step ids, so '${node.id}' would collide with an iteration of another node). Choose another id.`);
+        sound = false;
+    }
     else if (seenIds.has(node.id)) {
         add(`${path}.id`, "duplicate_node_id", `Node id '${node.id}' is duplicated.`);
     }

package/package.json

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