@workbench-ai/workbench-core 0.0.46

package/dist/sandbox-plane.js

@@ -0,0 +1,327 @@
+import { assertWorkbenchExecutionIsolation, validateWorkbenchExecutionOutputPayloads, } from "./execution-outputs.js";
+export async function executeValidatedSandboxExecution(plane, execution, options) {
+    assertWorkbenchExecutionIsolation(execution);
+    const inputs = await options.fileStore.materializeInputs(execution);
+    const now = options.now ?? new Date().toISOString();
+    const timing = {};
+    timing.prepareStartedAt = new Date().toISOString();
+    const environment = plane.prepareEnvironment
+        ? await plane.prepareEnvironment(execution, options)
+        : {
+            backend: plane.backend.name,
+            kind: execution.sandbox.kind,
+            ref: execution.sandbox.ref,
+        };
+    timing.prepareFinishedAt = new Date().toISOString();
+    const allocation = createWorkbenchSandboxAllocation(execution, {
+        backend: plane.backend.name,
+        runnerId: options.runnerId,
+        now,
+    });
+    const capability = createWorkbenchExecutionCapability(execution, { now });
+    assertScopeIssues("Sandbox allocation", collectSandboxAllocationScopeIssues(allocation, execution, { now }));
+    assertScopeIssues("Execution capability", collectExecutionCapabilityScopeIssues(capability, execution, { now }));
+    timing.createStartedAt = new Date().toISOString();
+    const sandbox = await plane.createSandbox({
+        execution,
+        environment,
+        allocation,
+        capability,
+        inputs,
+    }, options);
+    timing.createFinishedAt = new Date().toISOString();
+    assertScopeIssues("Sandbox handle", collectSandboxHandleScopeIssues(sandbox, allocation, execution));
+    let result;
+    try {
+        timing.execStartedAt = new Date().toISOString();
+        result = await plane.exec({
+            execution,
+            environment,
+            sandbox,
+            allocation,
+            capability,
+            inputs,
+        }, options);
+        timing.execFinishedAt = new Date().toISOString();
+    }
+    catch (error) {
+        const finishedAt = new Date().toISOString();
+        timing.execFinishedAt = finishedAt;
+        result = {
+            executionId: execution.id,
+            status: "failed",
+            startedAt: now,
+            finishedAt,
+            outputs: {},
+            error: error instanceof Error ? error.message : String(error),
+            metadata: {
+                sandbox: createWorkbenchSandboxExecutionMetadata({
+                    backend: plane.backend.name,
+                    allocation,
+                    capability,
+                    handle: sandbox,
+                }),
+            },
+        };
+    }
+    finally {
+        timing.destroyStartedAt = new Date().toISOString();
+        await plane.destroySandbox(sandbox, options);
+        timing.destroyFinishedAt = new Date().toISOString();
+    }
+    result = attachSandboxLifecycleTiming(result, timing);
+    if (result.executionId !== execution.id) {
+        throw new Error(`Sandbox returned execution id ${result.executionId}, expected ${execution.id}.`);
+    }
+    if (result.status !== "succeeded") {
+        return { result, payloads: {} };
+    }
+    const outputPayloads = {};
+    for (const contract of execution.outputs) {
+        const ref = result.outputs[contract.name];
+        if (!ref) {
+            if (contract.required) {
+                throw new Error(`Sandbox result for ${execution.id} omitted required output ref ${contract.name}.`);
+            }
+            continue;
+        }
+        outputPayloads[contract.name] = await options.fileStore.readJson(ref);
+    }
+    return {
+        result,
+        payloads: validateWorkbenchExecutionOutputPayloads(execution, outputPayloads),
+    };
+}
+function attachSandboxLifecycleTiming(result, timing) {
+    const metadata = isJsonRecord(result.metadata) ? result.metadata : {};
+    const completedJob = isJsonRecord(metadata.completedJob) ? metadata.completedJob : null;
+    return {
+        ...result,
+        metadata: {
+            ...metadata,
+            sandboxTiming: timing,
+            ...(completedJob ? { completedJob: attachTimingToCompletedJob(completedJob, timing) } : {}),
+            ...(isJsonRecord(metadata.sandbox)
+                ? { sandbox: attachTimingToSandboxMetadata(metadata.sandbox, timing) }
+                : {}),
+        },
+    };
+}
+function attachTimingToCompletedJob(job, timing) {
+    if (!isJsonRecord(job.output)) {
+        return job;
+    }
+    const sandbox = isJsonRecord(job.output.sandbox)
+        ? attachTimingToSandboxMetadata(job.output.sandbox, timing)
+        : undefined;
+    return {
+        ...job,
+        output: {
+            ...job.output,
+            ...(sandbox ? { sandbox } : {}),
+        },
+    };
+}
+function attachTimingToSandboxMetadata(sandbox, timing) {
+    return {
+        ...sandbox,
+        timing,
+    };
+}
+export function createWorkbenchSandboxExecutionMetadata(args) {
+    return {
+        backend: args.backend,
+        allocation: {
+            ...args.allocation,
+            template: { ...args.allocation.template },
+            network: {
+                ...args.allocation.network,
+                ...(args.allocation.network.allow ? { allow: [...args.allocation.network.allow] } : {}),
+            },
+        },
+        capability: {
+            ...args.capability,
+            subject: { ...args.capability.subject },
+            inputs: args.capability.inputs.map((input) => ({ ...input })),
+            network: {
+                ...args.capability.network,
+                ...(args.capability.network.allow ? { allow: [...args.capability.network.allow] } : {}),
+            },
+        },
+        handle: {
+            ...args.handle,
+            template: { ...args.handle.template },
+            ...(args.handle.metadata ? { metadata: { ...args.handle.metadata } } : {}),
+        },
+    };
+}
+export function collectSandboxHandleScopeIssues(sandbox, allocation, execution) {
+    const issues = [];
+    if (sandbox.executionId !== execution.id) {
+        issues.push(`Sandbox handle execution id ${sandbox.executionId} does not match ${execution.id}.`);
+    }
+    if (sandbox.sandboxId !== allocation.sandboxId) {
+        issues.push(`Sandbox handle id ${sandbox.sandboxId} does not match allocation ${allocation.sandboxId}.`);
+    }
+    if (sandbox.lifecycleId !== allocation.lifecycleId) {
+        issues.push(`Sandbox handle lifecycle id does not match allocation ${allocation.lifecycleId}.`);
+    }
+    if (sandbox.backend !== allocation.backend) {
+        issues.push(`Sandbox handle backend ${sandbox.backend} does not match allocation ${allocation.backend}.`);
+    }
+    if (sandbox.template.kind !== allocation.template.kind || sandbox.template.ref !== allocation.template.ref) {
+        issues.push(`Sandbox handle template does not match allocation for execution ${execution.id}.`);
+    }
+    return issues;
+}
+export function createWorkbenchSandboxAllocation(execution, options) {
+    const nowMs = options.now ? Date.parse(options.now) : Date.now();
+    const ttlMs = options.ttlMs ?? Math.max(60_000, execution.policy.resources.timeoutMinutes * 60_000 + 60_000);
+    const safeExecutionId = execution.id.replace(/[^a-z0-9_]+/giu, "_");
+    const nonce = allocationNonce();
+    return {
+        sandboxId: options.sandboxId ?? `sbx_${safeExecutionId}_${nonce}`,
+        executionId: execution.id,
+        lifecycleId: options.lifecycleId ?? `lc_${safeExecutionId}_${nowMs}_${nonce}`,
+        backend: options.backend,
+        runnerId: options.runnerId ?? "local-runner",
+        template: { ...execution.sandbox },
+        network: {
+            ...execution.policy.network,
+            ...(execution.policy.network.allow ? { allow: [...execution.policy.network.allow] } : {}),
+        },
+        status: "allocated",
+        createdAt: new Date(nowMs).toISOString(),
+        expiresAt: new Date(nowMs + ttlMs).toISOString(),
+    };
+}
+function allocationNonce() {
+    const bytes = new Uint8Array(6);
+    if (globalThis.crypto?.getRandomValues) {
+        globalThis.crypto.getRandomValues(bytes);
+    }
+    else {
+        for (let index = 0; index < bytes.length; index += 1) {
+            bytes[index] = Math.floor(Math.random() * 256);
+        }
+    }
+    return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export function createWorkbenchExecutionCapability(execution, options = {}) {
+    const nowMs = options.now ? Date.parse(options.now) : Date.now();
+    const ttlMs = options.ttlMs ?? Math.max(60_000, execution.policy.resources.timeoutMinutes * 60_000 + 60_000);
+    return {
+        executionId: execution.id,
+        subject: {
+            tenantId: execution.policy.tenantId,
+            projectId: execution.projectId,
+            runId: execution.runId,
+            ...(execution.subjectId ? { subjectId: execution.subjectId } : {}),
+        },
+        inputs: execution.inputs.map((input) => ({ ...input })),
+        outputPrefix: options.outputPrefix ?? `executions/${execution.id}/outputs/`,
+        network: {
+            ...execution.policy.network,
+            ...(execution.policy.network.allow ? { allow: [...execution.policy.network.allow] } : {}),
+        },
+        expiresAt: new Date(nowMs + ttlMs).toISOString(),
+    };
+}
+export function collectExecutionCapabilityScopeIssues(capability, execution, options = {}) {
+    const issues = [];
+    if (capability.executionId !== execution.id) {
+        issues.push(`Capability execution id ${capability.executionId} does not match ${execution.id}.`);
+    }
+    if (capability.subject.tenantId !== execution.policy.tenantId) {
+        issues.push(`Capability tenant id does not match execution ${execution.id}.`);
+    }
+    if (capability.subject.projectId !== execution.projectId || capability.subject.runId !== execution.runId) {
+        issues.push(`Capability project/run scope does not match execution ${execution.id}.`);
+    }
+    if ((capability.subject.subjectId ?? null) !== (execution.subjectId ?? null)) {
+        issues.push(`Capability subject scope does not match execution ${execution.id}.`);
+    }
+    if (!capability.outputPrefix.startsWith(`executions/${execution.id}/`)) {
+        issues.push(`Capability output prefix must be scoped under executions/${execution.id}/.`);
+    }
+    if (networkPolicyKey(capability.network) !== networkPolicyKey(execution.policy.network)) {
+        issues.push(`Capability network policy does not match execution ${execution.id}.`);
+    }
+    const allowedInputs = new Set(execution.inputs.map((input) => `${input.name}\0${input.ref}\0${input.mountPath}\0${input.writable}`));
+    for (const input of capability.inputs) {
+        const key = `${input.name}\0${input.ref}\0${input.mountPath}\0${input.writable}`;
+        if (!allowedInputs.has(key)) {
+            issues.push(`Capability includes input ${input.name} outside execution ${execution.id}.`);
+        }
+    }
+    if (capability.inputs.length !== execution.inputs.length) {
+        issues.push(`Capability input count does not match execution ${execution.id}.`);
+    }
+    const nowMs = options.now ? Date.parse(options.now) : Date.now();
+    const expiresAtMs = Date.parse(capability.expiresAt);
+    if (!Number.isFinite(expiresAtMs)) {
+        issues.push(`Capability expiresAt must be an ISO timestamp for execution ${execution.id}.`);
+    }
+    else if (expiresAtMs <= nowMs) {
+        issues.push(`Capability is expired for execution ${execution.id}.`);
+    }
+    return issues;
+}
+function networkPolicyKey(policy) {
+    if (!policy || typeof policy !== "object") {
+        return "<invalid>";
+    }
+    return JSON.stringify({
+        egress: policy.egress,
+        ...(Array.isArray(policy.allow) ? { allow: [...policy.allow] } : {}),
+    });
+}
+export function collectSandboxAllocationScopeIssues(allocation, execution, options = {}) {
+    const issues = [];
+    if (allocation.executionId !== execution.id) {
+        issues.push(`Sandbox allocation execution id ${allocation.executionId} does not match ${execution.id}.`);
+    }
+    if (!allocation.sandboxId.trim()) {
+        issues.push(`Sandbox allocation for ${execution.id} must include a sandbox id.`);
+    }
+    if (!allocation.lifecycleId.trim()) {
+        issues.push(`Sandbox allocation for ${execution.id} must include a lifecycle id.`);
+    }
+    if (!allocation.backend.trim()) {
+        issues.push(`Sandbox allocation for ${execution.id} must include a backend.`);
+    }
+    if (!allocation.runnerId.trim()) {
+        issues.push(`Sandbox allocation for ${execution.id} must include a runner id.`);
+    }
+    if (allocation.template.kind !== execution.sandbox.kind || allocation.template.ref !== execution.sandbox.ref) {
+        issues.push(`Sandbox allocation template does not match execution ${execution.id}.`);
+    }
+    if (allocation.network.egress !== execution.policy.network.egress) {
+        issues.push(`Sandbox allocation network policy does not match execution ${execution.id}.`);
+    }
+    const expectedAllow = execution.policy.network.allow ?? [];
+    const actualAllow = allocation.network.allow ?? [];
+    if (JSON.stringify(actualAllow) !== JSON.stringify(expectedAllow)) {
+        issues.push(`Sandbox allocation network allowlist does not match execution ${execution.id}.`);
+    }
+    if (!["allocated", "running", "stopping", "stopped"].includes(allocation.status)) {
+        issues.push(`Sandbox allocation status ${allocation.status} is not supported for execution ${execution.id}.`);
+    }
+    const nowMs = options.now ? Date.parse(options.now) : Date.now();
+    const expiresAtMs = Date.parse(allocation.expiresAt);
+    if (!Number.isFinite(expiresAtMs)) {
+        issues.push(`Sandbox allocation expiresAt must be an ISO timestamp for execution ${execution.id}.`);
+    }
+    else if (expiresAtMs <= nowMs) {
+        issues.push(`Sandbox allocation is expired for execution ${execution.id}.`);
+    }
+    return issues;
+}
+function assertScopeIssues(label, issues) {
+    if (issues.length > 0) {
+        throw new Error(`${label} failed validation:\n${issues.join("\n")}`);
+    }
+}
+function isJsonRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}

package/dist/subject-patch.d.ts

@@ -0,0 +1,8 @@
+import type { SurfaceSnapshotFile, WorkbenchSubjectPatch } from "@workbench-ai/workbench-contract";
+export interface ApplyWorkbenchSubjectPatchInput {
+    baseFiles: readonly SurfaceSnapshotFile[];
+    patch: WorkbenchSubjectPatch;
+    edits: readonly string[];
+}
+export declare function applyWorkbenchSubjectPatch(input: ApplyWorkbenchSubjectPatchInput): SurfaceSnapshotFile[];
+//# sourceMappingURL=subject-patch.d.ts.map

package/dist/subject-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject-patch.d.ts","sourceRoot":"","sources":["../src/subject-patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,kCAAkC,CAAC;AAE1C,MAAM,WAAW,+BAA+B;IAC9C,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC1C,KAAK,EAAE,qBAAqB,CAAC;IAC7B,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,+BAA+B,GAAG,mBAAmB,EAAE,CAgDxG"}

package/dist/subject-patch.js

@@ -0,0 +1,63 @@
+export function applyWorkbenchSubjectPatch(input) {
+    const issues = [];
+    const edits = input.edits.map(normalizeRelativePath).filter(Boolean);
+    const patchPaths = new Set();
+    for (const file of input.patch.files) {
+        const filePath = normalizeRelativePath(file.path);
+        if (!isSafeRelativePath(filePath)) {
+            issues.push(`Subject patch contains unsafe path ${file.path}.`);
+        }
+        if (!isAllowedEditPath(filePath, edits)) {
+            issues.push(`Subject patch contains path outside optimizer edits: ${file.path}.`);
+        }
+        patchPaths.add(filePath);
+    }
+    for (const fileChange of input.patch.fileChanges) {
+        const filePath = normalizeRelativePath(fileChange);
+        if (!isSafeRelativePath(filePath)) {
+            issues.push(`Subject patch fileChanges contains unsafe path ${fileChange}.`);
+        }
+        if (!isAllowedEditPath(filePath, edits)) {
+            issues.push(`Subject patch fileChanges contains path outside optimizer edits: ${fileChange}.`);
+        }
+    }
+    if (issues.length > 0) {
+        throw new Error(issues.join("\n"));
+    }
+    const patched = new Map();
+    for (const file of input.baseFiles) {
+        patched.set(normalizeRelativePath(file.path), {
+            ...file,
+            path: normalizeRelativePath(file.path),
+        });
+    }
+    for (const file of input.patch.files) {
+        patched.set(normalizeRelativePath(file.path), {
+            ...file,
+            path: normalizeRelativePath(file.path),
+        });
+    }
+    const baseOrder = input.baseFiles.map((file) => normalizeRelativePath(file.path));
+    const addedPaths = [...patchPaths].filter((filePath) => !baseOrder.includes(filePath)).sort();
+    return [...baseOrder, ...addedPaths]
+        .flatMap((filePath) => {
+        const file = patched.get(filePath);
+        return file ? [file] : [];
+    });
+}
+function isAllowedEditPath(filePath, edits) {
+    const normalizedPath = normalizeRelativePath(filePath);
+    return edits.some((entry) => {
+        const normalizedEditPath = normalizeRelativePath(entry).replace(/\/+$/u, "");
+        return normalizedPath === normalizedEditPath || normalizedPath.startsWith(`${normalizedEditPath}/`);
+    });
+}
+function isSafeRelativePath(filePath) {
+    const normalized = normalizeRelativePath(filePath);
+    return normalized.length > 0
+        && !normalized.startsWith("/")
+        && !normalized.split("/").includes("..");
+}
+function normalizeRelativePath(filePath) {
+    return filePath.replace(/\\/gu, "/").replace(/^\.\/+/u, "").replace(/\/+/gu, "/");
+}

package/dist/trace-files.d.ts

@@ -0,0 +1,18 @@
+import type { SurfaceSnapshotFile, WorkbenchExecutionPurpose } from "@workbench-ai/workbench-contract";
+export declare const WORKBENCH_TRACE_ROOT = ".workbench/traces";
+export declare function readOutputTraceFiles(outputRoot: string, traceRoot: string): Promise<SurfaceSnapshotFile[]>;
+export declare function traceFilePaths(files: readonly SurfaceSnapshotFile[]): string[];
+export declare function workbenchTraceRunDirectory(args: {
+    sequence: number;
+    runId: string;
+}): string;
+export declare function workbenchTracePhaseDirectory(args: {
+    sequence: number;
+    runId: string;
+    phase: WorkbenchExecutionPurpose;
+}): string;
+export declare function workbenchTraceRunDirectoryName(args: {
+    sequence: number;
+    runId: string;
+}): string;
+//# sourceMappingURL=trace-files.d.ts.map

package/dist/trace-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-files.d.ts","sourceRoot":"","sources":["../src/trace-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,kCAAkC,CAAC;AAO1C,eAAO,MAAM,oBAAoB,sBAAsB,CAAC;AAExD,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAiChH;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAK9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAET;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,yBAAyB,CAAC;CAClC,GAAG,MAAM,CAET;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAKT"}

package/dist/trace-files.js

@@ -0,0 +1,94 @@
+import { importNodeModule, nodeBuiltin, } from "./runtime-utils.js";
+export const WORKBENCH_TRACE_ROOT = ".workbench/traces";
+export async function readOutputTraceFiles(outputRoot, traceRoot) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    const path = await importNodeModule(nodeBuiltin("path"));
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    const files = [];
+    async function walk(directory) {
+        const entries = await fs.readdir(directory, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const absolutePath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                const relativeDirectory = normalizeRelativePath(path.relative(outputRoot, absolutePath).replace(/\\/gu, "/"));
+                if (shouldSkipTraceDirectory(relativeDirectory)) {
+                    continue;
+                }
+                await walk(absolutePath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            const body = await fs.readFile(absolutePath);
+            const content = encodeTraceFileContent(body, decoder);
+            files.push({
+                path: normalizeRelativePath(`${traceRoot}/${path.relative(outputRoot, absolutePath).replace(/\\/gu, "/")}`),
+                kind: content.encoding === "base64" ? "binary" : "text",
+                encoding: content.encoding,
+                content: content.content,
+                executable: false,
+            });
+        }
+    }
+    await walk(outputRoot);
+    return files;
+}
+export function traceFilePaths(files) {
+    return files
+        .map((file) => file.path)
+        .filter((filePath) => filePath.startsWith(`${WORKBENCH_TRACE_ROOT}/`))
+        .sort();
+}
+export function workbenchTraceRunDirectory(args) {
+    return `${WORKBENCH_TRACE_ROOT}/${workbenchTraceRunDirectoryName(args)}`;
+}
+export function workbenchTracePhaseDirectory(args) {
+    return `${workbenchTraceRunDirectory(args)}/${String(tracePhaseSequence(args.phase)).padStart(6, "0")}-${args.phase}`;
+}
+export function workbenchTraceRunDirectoryName(args) {
+    const sequence = Number.isSafeInteger(args.sequence) && args.sequence >= 0
+        ? args.sequence
+        : 0;
+    return `${String(sequence).padStart(6, "0")}-${sanitizeTracePathSegment(args.runId)}`;
+}
+function shouldSkipTraceDirectory(relativeDirectory) {
+    return relativeDirectory === "session/home"
+        || relativeDirectory.startsWith("session/home/")
+        || relativeDirectory === "session/workspace"
+        || relativeDirectory.startsWith("session/workspace/")
+        || relativeDirectory.endsWith("/session/home")
+        || relativeDirectory.includes("/session/home/")
+        || relativeDirectory.endsWith("/session/workspace")
+        || relativeDirectory.includes("/session/workspace/");
+}
+function encodeTraceFileContent(body, utf8Decoder) {
+    try {
+        return {
+            encoding: "utf8",
+            content: utf8Decoder.decode(body),
+        };
+    }
+    catch {
+        return {
+            encoding: "base64",
+            content: body.toString("base64"),
+        };
+    }
+}
+function sanitizeTracePathSegment(value) {
+    const sanitized = value
+        .trim()
+        .replace(/[^a-z0-9_.-]+/giu, "_")
+        .replace(/^_+|_+$/gu, "");
+    return sanitized || "run";
+}
+function tracePhaseSequence(phase) {
+    if (phase === "improve") {
+        return 1;
+    }
+    return 2;
+}
+function normalizeRelativePath(filePath) {
+    return filePath.replace(/\\/gu, "/").replace(/^\/+/u, "").replace(/\/+/gu, "/");
+}

package/environments/libreoffice-agent/Dockerfile

@@ -0,0 +1,13 @@
+FROM node:22-bookworm-slim AS node
+
+FROM python:3.12-bookworm
+
+COPY --from=node /usr/local/bin/node /usr/local/bin/node
+COPY --from=node /usr/local/lib/node_modules /usr/local/lib/node_modules
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends ca-certificates fonts-dejavu git libreoffice \
+  && rm -rf /var/lib/apt/lists/* \
+  && ln -sf ../lib/node_modules/npm/bin/npm-cli.js /usr/local/bin/npm \
+  && ln -sf ../lib/node_modules/npm/bin/npx-cli.js /usr/local/bin/npx \
+  && pip install --no-cache-dir openpyxl pandas

package/environments/libreoffice-python/Dockerfile

@@ -0,0 +1,11 @@
+FROM node:22-bookworm-slim AS node
+
+FROM python:3.12-bookworm
+
+COPY --from=node /usr/local/bin/node /usr/local/bin/node
+COPY --from=node /usr/local/lib/node_modules /usr/local/lib/node_modules
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends ca-certificates fonts-dejavu libreoffice \
+  && rm -rf /var/lib/apt/lists/* \
+  && pip install --no-cache-dir openpyxl pandas

package/environments/node-22/Dockerfile

@@ -0,0 +1,3 @@
+FROM node:22-bookworm-slim
+
+RUN npm install --global vitest@3.2.4

package/environments/python-3.12/Dockerfile

@@ -0,0 +1,8 @@
+FROM node:22-bookworm-slim AS node
+
+FROM python:3.12-bookworm
+
+COPY --from=node /usr/local/bin/node /usr/local/bin/node
+COPY --from=node /usr/local/lib/node_modules /usr/local/lib/node_modules
+
+RUN pip install --no-cache-dir pytest

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@workbench-ai/workbench-core",
+  "version": "0.0.46",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/workbench-ai/workbench.git",
+    "directory": "packages/core"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "environments",
+    "worker"
+  ],
+  "dependencies": {
+    "yaml": "^2.8.2",
+    "@workbench-ai/workbench-protocol": "0.0.46",
+    "@workbench-ai/workbench-contract": "0.0.46"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.1",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist environments && tsc -p tsconfig.json && cp -R ../../environments ./environments",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --config vitest.config.ts"
+  }
+}