@dobby.ai/dobby 0.1.0

package/dist/src/cron/store.js

@@ -0,0 +1,142 @@
+import { access, appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { z } from "zod";
+const jobScheduleSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("at"),
+        at: z.string().min(1),
+    }),
+    z.object({
+        kind: z.literal("every"),
+        everyMs: z.number().int().positive(),
+    }),
+    z.object({
+        kind: z.literal("cron"),
+        expr: z.string().min(1),
+        tz: z.string().min(1).optional(),
+    }),
+]);
+const scheduledJobSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    enabled: z.boolean(),
+    schedule: jobScheduleSchema,
+    sessionPolicy: z.enum(["stateless", "shared-session"]).optional(),
+    prompt: z.string(),
+    delivery: z.object({
+        connectorId: z.string().min(1),
+        routeId: z.string().min(1),
+        channelId: z.string().min(1),
+        threadId: z.string().min(1).optional(),
+    }),
+    createdAtMs: z.number().int().nonnegative(),
+    updatedAtMs: z.number().int().nonnegative(),
+    state: z.object({
+        nextRunAtMs: z.number().int().nonnegative().optional(),
+        runningAtMs: z.number().int().nonnegative().optional(),
+        lastRunAtMs: z.number().int().nonnegative().optional(),
+        lastStatus: z.enum(["ok", "error", "skipped"]).optional(),
+        lastError: z.string().optional(),
+        consecutiveErrors: z.number().int().nonnegative().optional(),
+    }),
+});
+const snapshotSchema = z.object({
+    version: z.literal(1),
+    jobs: z.array(scheduledJobSchema),
+});
+function cloneJob(job) {
+    return structuredClone(job);
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeAtomic(filePath, payload) {
+    await mkdir(dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    await writeFile(tempPath, payload, "utf-8");
+    await rename(tempPath, filePath);
+}
+export class CronStore {
+    jobsFilePath;
+    runLogFilePath;
+    logger;
+    jobs = new Map();
+    constructor(jobsFilePath, runLogFilePath, logger) {
+        this.jobsFilePath = jobsFilePath;
+        this.runLogFilePath = runLogFilePath;
+        this.logger = logger;
+    }
+    async load() {
+        this.jobs.clear();
+        const absolutePath = resolve(this.jobsFilePath);
+        if (await fileExists(absolutePath)) {
+            try {
+                const raw = await readFile(absolutePath, "utf-8");
+                const parsed = snapshotSchema.parse(JSON.parse(raw));
+                for (const job of parsed.jobs) {
+                    this.jobs.set(job.id, job);
+                }
+            }
+            catch (error) {
+                this.logger.warn({ err: error, filePath: absolutePath }, "Failed to load cron jobs store; starting empty");
+            }
+        }
+    }
+    listJobs() {
+        return [...this.jobs.values()]
+            .map((job) => cloneJob(job))
+            .sort((a, b) => a.createdAtMs - b.createdAtMs || a.id.localeCompare(b.id));
+    }
+    getJob(jobId) {
+        const found = this.jobs.get(jobId);
+        return found ? cloneJob(found) : null;
+    }
+    async upsertJob(job) {
+        const normalized = scheduledJobSchema.parse(job);
+        this.jobs.set(normalized.id, cloneJob(normalized));
+        await this.flush();
+    }
+    async updateJob(jobId, updater) {
+        const current = this.jobs.get(jobId);
+        if (!current) {
+            throw new Error(`Cron job '${jobId}' does not exist`);
+        }
+        const next = scheduledJobSchema.parse(updater(cloneJob(current)));
+        this.jobs.set(jobId, cloneJob(next));
+        await this.flush();
+        return cloneJob(next);
+    }
+    async removeJob(jobId) {
+        const deleted = this.jobs.delete(jobId);
+        if (!deleted) {
+            return false;
+        }
+        await this.flush();
+        return true;
+    }
+    async appendRunLog(record) {
+        const line = `${JSON.stringify(record)}\n`;
+        try {
+            await mkdir(dirname(this.runLogFilePath), { recursive: true });
+            await appendFile(this.runLogFilePath, line, "utf-8");
+        }
+        catch (error) {
+            this.logger.warn({ err: error, runLogFilePath: this.runLogFilePath }, "Failed to append cron run log");
+        }
+    }
+    async flush() {
+        const snapshot = {
+            version: 1,
+            jobs: [...this.jobs.values()]
+                .map((job) => cloneJob(job))
+                .sort((a, b) => a.createdAtMs - b.createdAtMs || a.id.localeCompare(b.id)),
+        };
+        await writeAtomic(this.jobsFilePath, `${JSON.stringify(snapshot, null, 2)}\n`);
+    }
+}

package/dist/src/cron/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/extension/loader.js

@@ -0,0 +1,97 @@
+import { access } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { readExtensionManifest } from "./manifest.js";
+function isJavaScriptEntry(entry) {
+    return entry.endsWith(".js") || entry.endsWith(".mjs") || entry.endsWith(".cjs");
+}
+function assertWithinRoot(pathToCheck, rootDir) {
+    const normalizedRoot = resolve(rootDir);
+    const normalizedPath = resolve(pathToCheck);
+    if (normalizedPath === normalizedRoot) {
+        return;
+    }
+    const rootPrefix = normalizedRoot.endsWith("/") || normalizedRoot.endsWith("\\")
+        ? normalizedRoot
+        : `${normalizedRoot}${process.platform === "win32" ? "\\" : "/"}`;
+    if (!normalizedPath.startsWith(rootPrefix)) {
+        throw new Error(`Path '${normalizedPath}' escapes package root '${normalizedRoot}'`);
+    }
+}
+function pickContributionModule(loadedModule) {
+    if ("default" in loadedModule) {
+        return loadedModule.default;
+    }
+    if ("contribution" in loadedModule) {
+        return loadedModule.contribution;
+    }
+    return undefined;
+}
+export class ExtensionLoader {
+    logger;
+    options;
+    extensionRequire;
+    constructor(logger, options) {
+        this.logger = logger;
+        this.options = options;
+        this.extensionRequire = createRequire(join(this.options.extensionsDir, "package.json"));
+    }
+    async loadAllowList(allowList) {
+        const loaded = [];
+        for (const packageConfig of allowList) {
+            if (packageConfig.enabled === false) {
+                this.logger.info({ package: packageConfig.package }, "Skipping disabled extension package");
+                continue;
+            }
+            loaded.push(await this.loadExternalPackage(packageConfig.package));
+        }
+        return loaded;
+    }
+    async loadExternalPackage(packageName) {
+        let packageJsonPath;
+        try {
+            packageJsonPath = this.extensionRequire.resolve(`${packageName}/package.json`);
+        }
+        catch (error) {
+            throw new Error(`Extension package '${packageName}' is not installed in '${this.options.extensionsDir}'. ` +
+                `Install it with: dobby extension install ${packageName}. ` +
+                `Resolver error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const packageRoot = dirname(packageJsonPath);
+        const manifestPath = resolve(join(packageRoot, "dobby.manifest.json"));
+        const manifest = await readExtensionManifest(manifestPath);
+        const contributions = [];
+        for (const contributionManifest of manifest.contributions) {
+            if (!isJavaScriptEntry(contributionManifest.entry)) {
+                throw new Error(`Contribution '${contributionManifest.id}' in package '${packageName}' must use a built JavaScript entry, got '${contributionManifest.entry}'`);
+            }
+            const entryPath = resolve(packageRoot, contributionManifest.entry);
+            assertWithinRoot(entryPath, packageRoot);
+            try {
+                await access(entryPath);
+            }
+            catch {
+                throw new Error(`Contribution '${contributionManifest.id}' in package '${packageName}' points to missing entry '${contributionManifest.entry}'`);
+            }
+            const loadedModule = (await import(pathToFileURL(entryPath).href));
+            const contributionModule = pickContributionModule(loadedModule);
+            if (!contributionModule || typeof contributionModule !== "object") {
+                throw new Error(`Extension contribution '${contributionManifest.id}' from package '${packageName}' does not export a valid module`);
+            }
+            const kind = contributionModule.kind;
+            if (kind !== contributionManifest.kind) {
+                throw new Error(`Contribution kind mismatch for '${contributionManifest.id}' in package '${packageName}': manifest=${contributionManifest.kind}, module=${kind ?? "unknown"}`);
+            }
+            contributions.push({
+                manifest: contributionManifest,
+                module: contributionModule,
+            });
+        }
+        return {
+            packageName,
+            manifest,
+            contributions,
+        };
+    }
+}

package/dist/src/extension/manager.js

@@ -0,0 +1,269 @@
+import { spawn } from "node:child_process";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { readExtensionManifest } from "./manifest.js";
+const STORE_PACKAGE_NAME = "dobby-extension-store";
+function isJavaScriptEntry(entry) {
+    return entry.endsWith(".js") || entry.endsWith(".mjs") || entry.endsWith(".cjs");
+}
+function assertWithinRoot(pathToCheck, rootDir) {
+    const normalizedRoot = resolve(rootDir);
+    const normalizedPath = resolve(pathToCheck);
+    if (normalizedPath === normalizedRoot) {
+        return;
+    }
+    const rootPrefix = normalizedRoot.endsWith("/") || normalizedRoot.endsWith("\\")
+        ? normalizedRoot
+        : `${normalizedRoot}${process.platform === "win32" ? "\\" : "/"}`;
+    if (!normalizedPath.startsWith(rootPrefix)) {
+        throw new Error(`Path '${normalizedPath}' escapes package root '${normalizedRoot}'`);
+    }
+}
+function parsePackageNameFromSpec(packageSpec) {
+    const trimmed = packageSpec.trim();
+    if (!trimmed)
+        return null;
+    const scopedMatch = /^(@[^/]+\/[^@]+)(?:@.+)?$/.exec(trimmed);
+    if (scopedMatch?.[1]) {
+        return scopedMatch[1];
+    }
+    if (trimmed.startsWith("file:")
+        || trimmed.startsWith("git+")
+        || trimmed.startsWith("http://")
+        || trimmed.startsWith("https://")
+        || trimmed.startsWith("./")
+        || trimmed.startsWith("../")
+        || trimmed.startsWith("/")
+        || trimmed.includes("/")) {
+        return null;
+    }
+    const unscopedMatch = /^([^@]+)(?:@.+)?$/.exec(trimmed);
+    return unscopedMatch?.[1] ?? null;
+}
+async function parsePackageNameFromLocalSpec(packageSpec) {
+    const trimmed = packageSpec.trim();
+    if (!trimmed)
+        return null;
+    let localPath = null;
+    if (trimmed.startsWith("file:")) {
+        localPath = trimmed.slice("file:".length);
+    }
+    else if (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("/")) {
+        localPath = trimmed;
+    }
+    if (!localPath) {
+        return null;
+    }
+    const packageJsonPath = resolve(process.cwd(), localPath, "package.json");
+    try {
+        const raw = await readFile(packageJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === "string" && parsed.name.length > 0 ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function pickInstalledPackageName(packageSpec, beforeDeps, afterDeps) {
+    const changedPackages = Object.entries(afterDeps)
+        .filter(([name, version]) => beforeDeps[name] !== version)
+        .map(([name]) => name);
+    if (changedPackages.length === 1) {
+        return changedPackages[0];
+    }
+    const inferred = parsePackageNameFromSpec(packageSpec);
+    if (inferred && afterDeps[inferred]) {
+        return inferred;
+    }
+    const localInferred = await parsePackageNameFromLocalSpec(packageSpec);
+    if (localInferred && afterDeps[localInferred]) {
+        return localInferred;
+    }
+    if (changedPackages.length > 0) {
+        return changedPackages[0];
+    }
+    throw new Error(`Could not determine installed package from spec '${packageSpec}'. Run 'extension list' to inspect extension store state.`);
+}
+export class ExtensionStoreManager {
+    logger;
+    extensionsDir;
+    constructor(logger, extensionsDir) {
+        this.logger = logger;
+        this.extensionsDir = extensionsDir;
+    }
+    async ensureStoreInitialized() {
+        await mkdir(this.extensionsDir, { recursive: true });
+        const storePackageJsonPath = this.storePackageJsonPath();
+        try {
+            await access(storePackageJsonPath);
+            return;
+        }
+        catch {
+            const payload = {
+                name: STORE_PACKAGE_NAME,
+                private: true,
+                description: "Managed extension store for dobby",
+            };
+            await writeFile(storePackageJsonPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+        }
+    }
+    async install(packageSpec) {
+        const installed = await this.installMany([packageSpec]);
+        if (installed.length === 0) {
+            throw new Error(`Failed to install package from spec '${packageSpec}'`);
+        }
+        return installed[0];
+    }
+    async installMany(packageSpecs) {
+        const normalizedSpecs = packageSpecs
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+        if (normalizedSpecs.length === 0) {
+            return [];
+        }
+        await this.ensureStoreInitialized();
+        const beforeDeps = await this.readDependencies();
+        await this.runNpm(["install", "--prefix", this.extensionsDir, "--save-exact", ...normalizedSpecs]);
+        const afterDeps = await this.readDependencies();
+        const seenPackages = new Set();
+        const installedPackages = [];
+        for (const spec of normalizedSpecs) {
+            const packageName = await this.resolveInstalledPackageName(spec, beforeDeps, afterDeps, normalizedSpecs.length > 1);
+            if (seenPackages.has(packageName)) {
+                continue;
+            }
+            seenPackages.add(packageName);
+            const version = afterDeps[packageName];
+            if (!version) {
+                throw new Error(`Package '${packageName}' is not present in extension store after installation`);
+            }
+            const installed = await this.readInstalledExtension(packageName, version);
+            this.logger.info({
+                package: installed.packageName,
+                version: installed.version,
+                contributions: installed.manifest.contributions.map((item) => `${item.kind}:${item.id}`),
+            }, "Extension installed");
+            installedPackages.push(installed);
+        }
+        return installedPackages;
+    }
+    async uninstall(packageName) {
+        await this.ensureStoreInitialized();
+        await this.runNpm(["uninstall", "--prefix", this.extensionsDir, packageName]);
+        this.logger.info({ package: packageName }, "Extension uninstalled");
+    }
+    async listInstalled() {
+        await this.ensureStoreInitialized();
+        const dependencies = await this.readDependencies();
+        const listed = [];
+        const names = Object.keys(dependencies).sort((a, b) => a.localeCompare(b));
+        for (const packageName of names) {
+            const version = dependencies[packageName];
+            try {
+                const installed = await this.readInstalledExtension(packageName, version);
+                listed.push({
+                    packageName,
+                    version,
+                    manifest: installed.manifest,
+                });
+            }
+            catch (error) {
+                listed.push({
+                    packageName,
+                    version,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return listed;
+    }
+    storePackageJsonPath() {
+        return join(this.extensionsDir, "package.json");
+    }
+    createStoreRequire() {
+        return createRequire(this.storePackageJsonPath());
+    }
+    async readDependencies() {
+        const path = this.storePackageJsonPath();
+        try {
+            const raw = await readFile(path, "utf-8");
+            const parsed = JSON.parse(raw);
+            return parsed.dependencies ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async readInstalledExtension(packageName, version) {
+        const storeRequire = this.createStoreRequire();
+        let packageJsonPath;
+        try {
+            packageJsonPath = storeRequire.resolve(`${packageName}/package.json`);
+        }
+        catch (error) {
+            throw new Error(`Package '${packageName}' is declared in extension store but cannot be resolved: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const packageRoot = dirname(packageJsonPath);
+        const manifestPath = resolve(packageRoot, "dobby.manifest.json");
+        const manifest = await readExtensionManifest(manifestPath);
+        for (const contribution of manifest.contributions) {
+            if (!isJavaScriptEntry(contribution.entry)) {
+                throw new Error(`Contribution '${contribution.id}' in package '${packageName}' must use a built JavaScript entry, got '${contribution.entry}'`);
+            }
+            const entryPath = resolve(packageRoot, contribution.entry);
+            assertWithinRoot(entryPath, packageRoot);
+            try {
+                await access(entryPath);
+            }
+            catch {
+                throw new Error(`Contribution '${contribution.id}' in package '${packageName}' points to missing entry '${contribution.entry}'`);
+            }
+        }
+        return {
+            packageName,
+            version,
+            manifest,
+        };
+    }
+    async resolveInstalledPackageName(packageSpec, beforeDeps, afterDeps, isBatchInstall) {
+        const inferred = parsePackageNameFromSpec(packageSpec);
+        if (inferred && afterDeps[inferred]) {
+            return inferred;
+        }
+        const inferredLocal = await parsePackageNameFromLocalSpec(packageSpec);
+        if (inferredLocal && afterDeps[inferredLocal]) {
+            return inferredLocal;
+        }
+        if (!isBatchInstall) {
+            return pickInstalledPackageName(packageSpec, beforeDeps, afterDeps);
+        }
+        const changedPackages = Object.entries(afterDeps)
+            .filter(([name, version]) => beforeDeps[name] !== version)
+            .map(([name]) => name);
+        if (changedPackages.length === 1) {
+            return changedPackages[0];
+        }
+        throw new Error(`Could not determine installed package from spec '${packageSpec}' in batch install mode. ` +
+            "Use explicit npm package names for init/installMany.");
+    }
+    async runNpm(args) {
+        await new Promise((resolvePromise, rejectPromise) => {
+            const command = process.platform === "win32" ? "npm.cmd" : "npm";
+            const child = spawn(command, args, {
+                stdio: "inherit",
+                env: process.env,
+            });
+            child.once("error", (error) => {
+                rejectPromise(error);
+            });
+            child.once("exit", (code) => {
+                if (code === 0) {
+                    resolvePromise();
+                    return;
+                }
+                rejectPromise(new Error(`npm ${args.join(" ")} failed with exit code ${code ?? "unknown"}`));
+            });
+        });
+    }
+}

package/dist/src/extension/manifest.js

@@ -0,0 +1,21 @@
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+const contributionManifestSchema = z.object({
+    id: z.string().min(1),
+    kind: z.enum(["provider", "connector", "sandbox"]),
+    entry: z.string().min(1),
+    capabilities: z.record(z.string(), z.unknown()).optional(),
+});
+const manifestSchema = z.object({
+    apiVersion: z.string().min(1),
+    name: z.string().min(1),
+    version: z.string().min(1),
+    contributions: z.array(contributionManifestSchema).min(1),
+});
+export function parseExtensionManifest(value) {
+    return manifestSchema.parse(value);
+}
+export async function readExtensionManifest(manifestPath) {
+    const raw = await readFile(manifestPath, "utf-8");
+    return parseExtensionManifest(JSON.parse(raw));
+}

package/dist/src/extension/registry.js

@@ -0,0 +1,137 @@
+import { join } from "node:path";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeContributionSchema(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return value;
+}
+export class ExtensionRegistry {
+    providers = new Map();
+    connectors = new Map();
+    sandboxes = new Map();
+    contributionSchemas = new Map();
+    registerPackages(loadedPackages) {
+        for (const extensionPackage of loadedPackages) {
+            for (const contribution of extensionPackage.contributions) {
+                if (this.contributionSchemas.has(contribution.manifest.id)) {
+                    throw new Error(`Duplicate contribution id '${contribution.manifest.id}'`);
+                }
+                const normalizedSchema = normalizeContributionSchema(contribution.module.configSchema);
+                this.contributionSchemas.set(contribution.manifest.id, {
+                    contributionId: contribution.manifest.id,
+                    packageName: extensionPackage.packageName,
+                    kind: contribution.manifest.kind,
+                    ...(normalizedSchema ? { configSchema: normalizedSchema } : {}),
+                });
+                if (contribution.manifest.kind === "provider") {
+                    const module = contribution.module;
+                    if (this.providers.has(contribution.manifest.id)) {
+                        throw new Error(`Duplicate provider contribution id '${contribution.manifest.id}'`);
+                    }
+                    this.providers.set(contribution.manifest.id, {
+                        contributionId: contribution.manifest.id,
+                        packageName: extensionPackage.packageName,
+                        createInstance: module.createInstance,
+                    });
+                    continue;
+                }
+                if (contribution.manifest.kind === "connector") {
+                    const module = contribution.module;
+                    if (this.connectors.has(contribution.manifest.id)) {
+                        throw new Error(`Duplicate connector contribution id '${contribution.manifest.id}'`);
+                    }
+                    this.connectors.set(contribution.manifest.id, {
+                        contributionId: contribution.manifest.id,
+                        packageName: extensionPackage.packageName,
+                        createInstance: module.createInstance,
+                    });
+                    continue;
+                }
+                const module = contribution.module;
+                if (this.sandboxes.has(contribution.manifest.id)) {
+                    throw new Error(`Duplicate sandbox contribution id '${contribution.manifest.id}'`);
+                }
+                this.sandboxes.set(contribution.manifest.id, {
+                    contributionId: contribution.manifest.id,
+                    packageName: extensionPackage.packageName,
+                    createInstance: module.createInstance,
+                });
+            }
+        }
+    }
+    listContributionSchemas() {
+        return [...this.contributionSchemas.values()]
+            .sort((a, b) => a.contributionId.localeCompare(b.contributionId))
+            .map((item) => ({
+            contributionId: item.contributionId,
+            packageName: item.packageName,
+            kind: item.kind,
+            ...(item.configSchema ? { configSchema: item.configSchema } : {}),
+        }));
+    }
+    getContributionSchema(contributionId) {
+        const found = this.contributionSchemas.get(contributionId);
+        if (!found) {
+            return null;
+        }
+        return {
+            contributionId: found.contributionId,
+            packageName: found.packageName,
+            kind: found.kind,
+            ...(found.configSchema ? { configSchema: found.configSchema } : {}),
+        };
+    }
+    async createProviderInstances(config, context, data) {
+        const instances = new Map();
+        for (const [instanceId, instanceConfig] of Object.entries(config.items)) {
+            const contribution = this.providers.get(instanceConfig.type);
+            if (!contribution) {
+                throw new Error(`Provider instance '${instanceId}' references unknown contribution '${instanceConfig.type}'`);
+            }
+            const instance = await contribution.createInstance({
+                instanceId,
+                config: instanceConfig.config,
+                host: context,
+                data,
+            });
+            instances.set(instanceId, instance);
+        }
+        return instances;
+    }
+    async createConnectorInstances(config, context, attachmentsBaseDir) {
+        const instances = [];
+        for (const [instanceId, instanceConfig] of Object.entries(config.items)) {
+            const contribution = this.connectors.get(instanceConfig.type);
+            if (!contribution) {
+                throw new Error(`Connector instance '${instanceId}' references unknown contribution '${instanceConfig.type}'`);
+            }
+            const connector = await contribution.createInstance({
+                instanceId,
+                config: instanceConfig.config,
+                host: context,
+                attachmentsRoot: join(attachmentsBaseDir, instanceId),
+            });
+            instances.push(connector);
+        }
+        return instances;
+    }
+    async createSandboxInstances(config, context) {
+        const instances = new Map();
+        for (const [instanceId, instanceConfig] of Object.entries(config.items)) {
+            const contribution = this.sandboxes.get(instanceConfig.type);
+            if (!contribution) {
+                throw new Error(`Sandbox instance '${instanceId}' references unknown contribution '${instanceConfig.type}'`);
+            }
+            const sandbox = await contribution.createInstance({
+                instanceId,
+                config: instanceConfig.config,
+                host: context,
+            });
+            instances.set(instanceId, sandbox);
+        }
+        return instances;
+    }
+}

package/dist/src/main.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runCli } from "./cli/index.js";
+void runCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/src/sandbox/executor.js

@@ -0,0 +1 @@
+export {};