@workbench-ai/workbench-protocol 0.0.42 → 0.0.44

package/dist/task-source-result.js

@@ -0,0 +1,160 @@
+import path from "node:path";
+export function normalizeWorkbenchTaskSourceResult(value, label = "tasks.resolve result") {
+    const record = requiredRecord(value, label);
+    if (!Array.isArray(record.tasks)) {
+        throw new Error(`${label}.tasks must be an array.`);
+    }
+    const tasks = record.tasks.map((entry, index) => normalizeWorkbenchTaskBundle(entry, `${label}.tasks[${index}]`));
+    const duplicate = firstDuplicate(tasks.map((task) => task.id));
+    if (duplicate) {
+        throw new Error(`${label} contains duplicate task id: ${duplicate}`);
+    }
+    return {
+        tasks,
+        ...(record.environment !== undefined
+            ? { environment: normalizeTaskEnvironment(record.environment, `${label}.environment`) }
+            : {}),
+    };
+}
+export function normalizeWorkbenchTaskBundle(value, label) {
+    const record = requiredRecord(value, label);
+    if (typeof record.id !== "string" || record.id.trim().length === 0) {
+        throw new Error(`${label}.id must be a non-empty string.`);
+    }
+    return {
+        id: normalizeRelativePath(record.id, `${label}.id`),
+        task: normalizeWorkbenchTaskSpec(record.task, `${label}.task`),
+        publicFiles: normalizeTaskSourceFiles(record.publicFiles, `${label}.publicFiles`),
+        testFiles: normalizeTaskSourceFiles(record.testFiles, `${label}.testFiles`),
+        ...(record.solutionFiles !== undefined
+            ? { solutionFiles: normalizeTaskSourceFiles(record.solutionFiles, `${label}.solutionFiles`) }
+            : {}),
+        ...(record.sourceFiles !== undefined
+            ? { sourceFiles: normalizeTaskSourceFiles(record.sourceFiles, `${label}.sourceFiles`) }
+            : {}),
+    };
+}
+export function normalizeWorkbenchTaskSpec(value, label) {
+    const record = requiredRecord(value, label);
+    if (record.version !== 2) {
+        throw new Error(`${label}.version must be 2.`);
+    }
+    if (typeof record.task !== "string" || record.task.trim().length === 0) {
+        throw new Error(`${label}.task must be a non-empty string.`);
+    }
+    return {
+        version: 2,
+        task: record.task,
+        ...(record.environment !== undefined
+            ? { environment: normalizeTaskEnvironment(record.environment, `${label}.environment`) }
+            : {}),
+        ...(record.score !== undefined
+            ? { score: normalizeAdapterInvocation(record.score, `${label}.score`) }
+            : {}),
+    };
+}
+function normalizeTaskEnvironment(value, label) {
+    const record = requiredRecord(value, label);
+    const resources = record.resources === undefined
+        ? undefined
+        : normalizeTaskResources(record.resources, `${label}.resources`);
+    const network = record.network === undefined
+        ? undefined
+        : normalizeNetworkPolicy(record.network, `${label}.network`);
+    return {
+        ...(typeof record.dockerfile === "string" && record.dockerfile.trim()
+            ? { dockerfile: record.dockerfile }
+            : {}),
+        ...(typeof record.workdir === "string" && record.workdir.trim()
+            ? { workdir: record.workdir }
+            : {}),
+        ...(resources ? { resources } : {}),
+        ...(network ? { network } : {}),
+    };
+}
+function normalizeTaskResources(value, label) {
+    const record = requiredRecord(value, label);
+    return {
+        ...(typeof record.cpu === "number" ? { cpu: record.cpu } : {}),
+        ...(typeof record.memoryGb === "number" ? { memoryGb: record.memoryGb } : {}),
+        ...(typeof record.diskGb === "number" ? { diskGb: record.diskGb } : {}),
+        ...(typeof record.timeoutMinutes === "number" ? { timeoutMinutes: record.timeoutMinutes } : {}),
+    };
+}
+function normalizeNetworkPolicy(value, label) {
+    const record = requiredRecord(value, label);
+    if (record.egress !== "none" &&
+        record.egress !== "allowlist" &&
+        record.egress !== "open") {
+        throw new Error(`${label}.egress must be none, allowlist, or open.`);
+    }
+    return {
+        egress: record.egress,
+        ...(Array.isArray(record.allow)
+            ? { allow: record.allow.filter((entry) => typeof entry === "string") }
+            : {}),
+    };
+}
+function normalizeAdapterInvocation(value, label) {
+    const record = requiredRecord(value, label);
+    if (typeof record.use !== "string" || record.use.trim().length === 0) {
+        throw new Error(`${label}.use must be a non-empty string.`);
+    }
+    return {
+        use: record.use,
+        with: record.with === undefined ? {} : record.with,
+        ...(record.auth !== undefined ? { auth: record.auth } : {}),
+    };
+}
+function normalizeTaskSourceFiles(value, label) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${label} must be an array.`);
+    }
+    return value.map((entry, index) => {
+        const record = requiredRecord(entry, `${label}[${index}]`);
+        if (typeof record.path !== "string" || record.path.trim().length === 0) {
+            throw new Error(`${label}[${index}].path must be a non-empty string.`);
+        }
+        if (typeof record.content !== "string") {
+            throw new Error(`${label}[${index}].content must be a string.`);
+        }
+        const encoding = record.encoding === "base64" ? "base64" : "utf8";
+        const kind = record.kind === "binary" || encoding === "base64" ? "binary" : "text";
+        return {
+            path: normalizeRelativePath(record.path, `${label}[${index}].path`),
+            kind,
+            encoding,
+            content: record.content,
+            executable: record.executable === true,
+        };
+    }).sort((left, right) => left.path.localeCompare(right.path));
+}
+function normalizeRelativePath(filePath, label) {
+    const normalized = path.posix.normalize(filePath.replace(/\\/gu, "/").replace(/^\/+/u, ""));
+    if (!normalized || normalized === "." || normalized.includes("\0")) {
+        throw new Error(`${label} must be a non-empty relative path.`);
+    }
+    if (normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+        throw new Error(`${label} must not escape the task-source result.`);
+    }
+    return normalized;
+}
+function requiredRecord(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    return value;
+}
+function firstDuplicate(values) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            return value;
+        }
+        seen.add(value);
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench-protocol",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "type": "module",
   "repository": {
     "type": "git",
@@ -20,7 +20,7 @@
   ],
   "dependencies": {
     "yaml": "^2.8.2",
-    "@workbench-ai/workbench-contract": "0.0.42"
+    "@workbench-ai/workbench-contract": "0.0.44"
   },
   "devDependencies": {
     "@types/node": "^24.3.1",