@ekairos/sandbox 1.22.100-beta.development.0 → 1.22.101-beta.feature-lab-task-sandbox-beta.0

package/dist/actions.d.ts

@@ -1,263 +1,6 @@
-import { z } from "zod";
-import type { CommandResult } from "./commands.js";
-import { type SandboxProcessRunResult, type SandboxProcessStreamChunk } from "./service.js";
-import type { SandboxConfig } from "./types.js";
-export declare const sandboxDomain: import("@ekairos/domain").DomainSchemaResult<{
-    [x: string]: any;
-    [x: number]: any;
-    [x: symbol]: any;
-}, {
-    [x: string]: any;
-    [x: number]: any;
-    [x: symbol]: any;
-}, import("@instantdb/core").RoomsDef, {
-    createSandbox: import("@ekairos/domain").DomainActionRegistration<z.ZodType<SandboxConfig, unknown, z.core.$ZodTypeInternals<SandboxConfig, unknown>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodObject<{
-            sandboxId: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    stopSandbox: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    runCommand: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        command: z.ZodString;
-        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodType<CommandResult, unknown, z.core.$ZodTypeInternals<CommandResult, unknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    runCommandProcess: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        command: z.ZodString;
-        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        cwd: z.ZodOptional<z.ZodString>;
-        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        kind: z.ZodOptional<z.ZodEnum<{
-            command: "command";
-            service: "service";
-            "codex-app-server": "codex-app-server";
-            "dev-server": "dev-server";
-            "test-runner": "test-runner";
-            watcher: "watcher";
-        }>>;
-        mode: z.ZodOptional<z.ZodEnum<{
-            foreground: "foreground";
-            background: "background";
-        }>>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodType<SandboxProcessRunResult, unknown, z.core.$ZodTypeInternals<SandboxProcessRunResult, unknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    readProcessStream: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        processId: z.ZodString;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodObject<{
-            chunks: z.ZodArray<z.ZodType<SandboxProcessStreamChunk, unknown, z.core.$ZodTypeInternals<SandboxProcessStreamChunk, unknown>>>;
-            byteOffset: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    startObservedProcess: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        command: z.ZodString;
-        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        cwd: z.ZodOptional<z.ZodString>;
-        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        kind: z.ZodOptional<z.ZodEnum<{
-            command: "command";
-            service: "service";
-            "codex-app-server": "codex-app-server";
-            "dev-server": "dev-server";
-            "test-runner": "test-runner";
-            watcher: "watcher";
-        }>>;
-        mode: z.ZodOptional<z.ZodEnum<{
-            foreground: "foreground";
-            background: "background";
-        }>>;
-        externalProcessId: z.ZodOptional<z.ZodString>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodType<SandboxProcessRunResult, unknown, z.core.$ZodTypeInternals<SandboxProcessRunResult, unknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    appendObservedProcessChunk: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        processId: z.ZodString;
-        type: z.ZodEnum<{
-            error: "error";
-            status: "status";
-            stdout: "stdout";
-            stderr: "stderr";
-            exit: "exit";
-            heartbeat: "heartbeat";
-            metadata: "metadata";
-        }>;
-        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    finishObservedProcess: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        processId: z.ZodString;
-        status: z.ZodOptional<z.ZodEnum<{
-            exited: "exited";
-            failed: "failed";
-            killed: "killed";
-            lost: "lost";
-        }>>;
-        exitCode: z.ZodOptional<z.ZodNumber>;
-        errorText: z.ZodOptional<z.ZodString>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    writeFiles: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        files: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            contentBase64: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    readFile: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        path: z.ZodString;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodObject<{
-            contentBase64: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    installCodexAuth: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        codexHome: z.ZodOptional<z.ZodString>;
-        authJsonPath: z.ZodOptional<z.ZodString>;
-        credentialsJsonPath: z.ZodOptional<z.ZodString>;
-        configTomlPath: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodObject<{
-            authJson: z.ZodBoolean;
-            credentialsJson: z.ZodBoolean;
-            configToml: z.ZodBoolean;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    getSandbox: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    createCheckpoint: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        comment: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodObject<{
-            checkpointId: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    getPortUrl: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        port: z.ZodNumber;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-    createEkairosApp: import("@ekairos/domain").DomainActionRegistration<z.ZodObject<{
-        sandboxId: z.ZodString;
-        appDir: z.ZodString;
-        packageManager: z.ZodOptional<z.ZodString>;
-        instantTokenEnvName: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-        data: z.ZodType<SandboxProcessRunResult, unknown, z.core.$ZodTypeInternals<SandboxProcessRunResult, unknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        ok: z.ZodLiteral<false>;
-        error: z.ZodString;
-    }, z.core.$strip>], "ok">, {
-        db: unknown;
-    }, any>;
-}, "sandbox", string>;
+import { sandboxSchemaDomain } from "./schema.js";
+declare function createSandboxDomain(): ReturnType<typeof sandboxSchemaDomain.withActions>;
+export type SandboxDomain = ReturnType<typeof createSandboxDomain>;
+export declare const sandboxDomain: SandboxDomain;
+export {};
 //# sourceMappingURL=actions.d.ts.map

package/dist/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AA0BlD,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC/B,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AA6B/C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoLtB,CAAA"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAkCjD,iBAAS,mBAAmB,IAAI,UAAU,CAAC,OAAO,mBAAmB,CAAC,WAAW,CAAC,CAqLjF;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAClE,eAAO,MAAM,aAAa,EAAE,aAAqC,CAAA"}

package/dist/actions.js

@@ -24,185 +24,187 @@ const serviceVoidResult = z.discriminatedUnion("ok", [
 const commandResult = sandboxCommandResultSchema;
 const processStreamChunk = sandboxProcessStreamChunkSchema;
 const processRunResult = sandboxProcessRunResultSchema;
-export const sandboxDomain = sandboxSchemaDomain
-    .withActions({
-    createSandbox: defineAction({
-        name: "sandbox.createSandbox",
-        input: z.object({
-            provider: z.enum(["vercel", "daytona", "sprites"]).optional(),
-            runtime: z.string().optional(),
-            timeoutMs: z.number().optional(),
-            ports: z.array(z.number()).optional(),
-            resources: z.object({ vcpus: z.number().optional() }).passthrough().optional(),
-            purpose: z.string().optional(),
-            params: z.record(z.string(), z.unknown()).optional(),
-            env: z.record(z.string(), z.unknown()).optional(),
-            domain: z.unknown().optional(),
-            dataset: z.object({ enabled: z.boolean().optional() }).passthrough().optional(),
-            skills: z.array(z.object({
-                name: z.string(),
-                description: z.string().optional(),
-                files: z.array(z.object({
-                    path: z.string(),
-                    contentBase64: z.string(),
-                })),
-            })).optional(),
-            vercel: z.record(z.string(), z.unknown()).optional(),
-            daytona: z.record(z.string(), z.unknown()).optional(),
-            sprites: z.record(z.string(), z.unknown()).optional(),
-        }).passthrough(),
-        output: serviceResult(z.object({ sandboxId: z.string() })),
-        execute: createSandboxStep,
-    }),
-    stopSandbox: defineAction({
-        name: "sandbox.stopSandbox",
-        input: z.object({ sandboxId: z.string() }),
-        output: serviceVoidResult,
-        execute: stopSandboxStep,
-    }),
-    runCommand: defineAction({
-        name: "sandbox.runCommand",
-        input: z.object({
-            sandboxId: z.string(),
-            command: z.string(),
-            args: z.array(z.string()).optional(),
+function createSandboxDomain() {
+    return sandboxSchemaDomain.withActions({
+        createSandbox: defineAction({
+            name: "sandbox.createSandbox",
+            input: z.object({
+                provider: z.enum(["vercel", "daytona", "sprites"]).optional(),
+                runtime: z.string().optional(),
+                timeoutMs: z.number().optional(),
+                ports: z.array(z.number()).optional(),
+                resources: z.object({ vcpus: z.number().optional() }).passthrough().optional(),
+                purpose: z.string().optional(),
+                params: z.record(z.string(), z.unknown()).optional(),
+                env: z.record(z.string(), z.unknown()).optional(),
+                domain: z.unknown().optional(),
+                dataset: z.object({ enabled: z.boolean().optional() }).passthrough().optional(),
+                skills: z.array(z.object({
+                    name: z.string(),
+                    description: z.string().optional(),
+                    files: z.array(z.object({
+                        path: z.string(),
+                        contentBase64: z.string(),
+                    })),
+                })).optional(),
+                vercel: z.record(z.string(), z.unknown()).optional(),
+                daytona: z.record(z.string(), z.unknown()).optional(),
+                sprites: z.record(z.string(), z.unknown()).optional(),
+            }).passthrough(),
+            output: serviceResult(z.object({ sandboxId: z.string() })),
+            execute: createSandboxStep,
         }),
-        output: serviceResult(commandResult),
-        execute: runCommandStep,
-    }),
-    runCommandProcess: defineAction({
-        name: "sandbox.runCommandProcess",
-        input: z.object({
-            sandboxId: z.string(),
-            command: z.string(),
-            args: z.array(z.string()).optional(),
-            cwd: z.string().optional(),
-            env: z.record(z.string(), z.unknown()).optional(),
-            kind: z.enum(SANDBOX_PROCESS_KINDS).optional(),
-            mode: z.enum(SANDBOX_PROCESS_MODES).optional(),
-            metadata: z.record(z.string(), z.unknown()).optional(),
+        stopSandbox: defineAction({
+            name: "sandbox.stopSandbox",
+            input: z.object({ sandboxId: z.string() }),
+            output: serviceVoidResult,
+            execute: stopSandboxStep,
         }),
-        output: serviceResult(processRunResult),
-        execute: runCommandProcessStep,
-    }),
-    readProcessStream: defineAction({
-        name: "sandbox.readProcessStream",
-        input: z.object({ processId: z.string() }),
-        output: serviceResult(z.object({
-            chunks: z.array(processStreamChunk),
-            byteOffset: z.number(),
-        })),
-        execute: readProcessStreamStep,
-    }),
-    startObservedProcess: defineAction({
-        name: "sandbox.startObservedProcess",
-        input: z.object({
-            sandboxId: z.string(),
-            command: z.string(),
-            args: z.array(z.string()).optional(),
-            cwd: z.string().optional(),
-            env: z.record(z.string(), z.unknown()).optional(),
-            kind: z.enum(SANDBOX_PROCESS_KINDS).optional(),
-            mode: z.enum(SANDBOX_PROCESS_MODES).optional(),
-            externalProcessId: z.string().optional(),
-            metadata: z.record(z.string(), z.unknown()).optional(),
+        runCommand: defineAction({
+            name: "sandbox.runCommand",
+            input: z.object({
+                sandboxId: z.string(),
+                command: z.string(),
+                args: z.array(z.string()).optional(),
+            }),
+            output: serviceResult(commandResult),
+            execute: runCommandStep,
         }),
-        output: serviceResult(processRunResult),
-        execute: startObservedProcessStep,
-    }),
-    appendObservedProcessChunk: defineAction({
-        name: "sandbox.appendObservedProcessChunk",
-        input: z.object({
-            processId: z.string(),
-            type: z.enum(["stdout", "stderr", "status", "exit", "error", "heartbeat", "metadata"]),
-            data: z.record(z.string(), z.unknown()).optional(),
+        runCommandProcess: defineAction({
+            name: "sandbox.runCommandProcess",
+            input: z.object({
+                sandboxId: z.string(),
+                command: z.string(),
+                args: z.array(z.string()).optional(),
+                cwd: z.string().optional(),
+                env: z.record(z.string(), z.unknown()).optional(),
+                kind: z.enum(SANDBOX_PROCESS_KINDS).optional(),
+                mode: z.enum(SANDBOX_PROCESS_MODES).optional(),
+                metadata: z.record(z.string(), z.unknown()).optional(),
+            }),
+            output: serviceResult(processRunResult),
+            execute: runCommandProcessStep,
         }),
-        output: serviceVoidResult,
-        execute: appendObservedProcessChunkStep,
-    }),
-    finishObservedProcess: defineAction({
-        name: "sandbox.finishObservedProcess",
-        input: z.object({
-            processId: z.string(),
-            status: z.enum(["exited", "failed", "killed", "lost"]).optional(),
-            exitCode: z.number().optional(),
-            errorText: z.string().optional(),
-            metadata: z.record(z.string(), z.unknown()).optional(),
+        readProcessStream: defineAction({
+            name: "sandbox.readProcessStream",
+            input: z.object({ processId: z.string() }),
+            output: serviceResult(z.object({
+                chunks: z.array(processStreamChunk),
+                byteOffset: z.number(),
+            })),
+            execute: readProcessStreamStep,
         }),
-        output: serviceVoidResult,
-        execute: finishObservedProcessStep,
-    }),
-    writeFiles: defineAction({
-        name: "sandbox.writeFiles",
-        input: z.object({
-            sandboxId: z.string(),
-            files: z.array(z.object({
+        startObservedProcess: defineAction({
+            name: "sandbox.startObservedProcess",
+            input: z.object({
+                sandboxId: z.string(),
+                command: z.string(),
+                args: z.array(z.string()).optional(),
+                cwd: z.string().optional(),
+                env: z.record(z.string(), z.unknown()).optional(),
+                kind: z.enum(SANDBOX_PROCESS_KINDS).optional(),
+                mode: z.enum(SANDBOX_PROCESS_MODES).optional(),
+                externalProcessId: z.string().optional(),
+                metadata: z.record(z.string(), z.unknown()).optional(),
+            }),
+            output: serviceResult(processRunResult),
+            execute: startObservedProcessStep,
+        }),
+        appendObservedProcessChunk: defineAction({
+            name: "sandbox.appendObservedProcessChunk",
+            input: z.object({
+                processId: z.string(),
+                type: z.enum(["stdout", "stderr", "status", "exit", "error", "heartbeat", "metadata"]),
+                data: z.record(z.string(), z.unknown()).optional(),
+            }),
+            output: serviceVoidResult,
+            execute: appendObservedProcessChunkStep,
+        }),
+        finishObservedProcess: defineAction({
+            name: "sandbox.finishObservedProcess",
+            input: z.object({
+                processId: z.string(),
+                status: z.enum(["exited", "failed", "killed", "lost"]).optional(),
+                exitCode: z.number().optional(),
+                errorText: z.string().optional(),
+                metadata: z.record(z.string(), z.unknown()).optional(),
+            }),
+            output: serviceVoidResult,
+            execute: finishObservedProcessStep,
+        }),
+        writeFiles: defineAction({
+            name: "sandbox.writeFiles",
+            input: z.object({
+                sandboxId: z.string(),
+                files: z.array(z.object({
+                    path: z.string(),
+                    contentBase64: z.string(),
+                })),
+            }),
+            output: serviceVoidResult,
+            execute: writeFilesStep,
+        }),
+        readFile: defineAction({
+            name: "sandbox.readFile",
+            input: z.object({
+                sandboxId: z.string(),
                 path: z.string(),
-                contentBase64: z.string(),
+            }),
+            output: serviceResult(z.object({ contentBase64: z.string() })),
+            execute: readFileStep,
+        }),
+        installCodexAuth: defineAction({
+            name: "sandbox.installCodexAuth",
+            input: z.object({
+                sandboxId: z.string(),
+                codexHome: z.string().optional(),
+                authJsonPath: z.string().optional(),
+                credentialsJsonPath: z.string().optional(),
+                configTomlPath: z.string().optional(),
+            }),
+            output: serviceResult(z.object({
+                authJson: z.boolean(),
+                credentialsJson: z.boolean(),
+                configToml: z.boolean(),
             })),
+            execute: installCodexAuthStep,
         }),
-        output: serviceVoidResult,
-        execute: writeFilesStep,
-    }),
-    readFile: defineAction({
-        name: "sandbox.readFile",
-        input: z.object({
-            sandboxId: z.string(),
-            path: z.string(),
+        getSandbox: defineAction({
+            name: "sandbox.getSandbox",
+            input: z.object({ sandboxId: z.string() }),
+            output: serviceResult(z.record(z.string(), z.unknown())),
+            execute: getSandboxStep,
         }),
-        output: serviceResult(z.object({ contentBase64: z.string() })),
-        execute: readFileStep,
-    }),
-    installCodexAuth: defineAction({
-        name: "sandbox.installCodexAuth",
-        input: z.object({
-            sandboxId: z.string(),
-            codexHome: z.string().optional(),
-            authJsonPath: z.string().optional(),
-            credentialsJsonPath: z.string().optional(),
-            configTomlPath: z.string().optional(),
+        createCheckpoint: defineAction({
+            name: "sandbox.createCheckpoint",
+            input: z.object({
+                sandboxId: z.string(),
+                comment: z.string().optional(),
+            }),
+            output: serviceResult(z.object({ checkpointId: z.string() })),
+            execute: createCheckpointStep,
         }),
-        output: serviceResult(z.object({
-            authJson: z.boolean(),
-            credentialsJson: z.boolean(),
-            configToml: z.boolean(),
-        })),
-        execute: installCodexAuthStep,
-    }),
-    getSandbox: defineAction({
-        name: "sandbox.getSandbox",
-        input: z.object({ sandboxId: z.string() }),
-        output: serviceResult(z.record(z.string(), z.unknown())),
-        execute: getSandboxStep,
-    }),
-    createCheckpoint: defineAction({
-        name: "sandbox.createCheckpoint",
-        input: z.object({
-            sandboxId: z.string(),
-            comment: z.string().optional(),
+        getPortUrl: defineAction({
+            name: "sandbox.getPortUrl",
+            input: z.object({
+                sandboxId: z.string(),
+                port: z.number(),
+            }),
+            output: serviceResult(z.object({ url: z.string() })),
+            execute: getPortUrlStep,
         }),
-        output: serviceResult(z.object({ checkpointId: z.string() })),
-        execute: createCheckpointStep,
-    }),
-    getPortUrl: defineAction({
-        name: "sandbox.getPortUrl",
-        input: z.object({
-            sandboxId: z.string(),
-            port: z.number(),
+        createEkairosApp: defineAction({
+            name: "sandbox.createEkairosApp",
+            input: z.object({
+                sandboxId: z.string(),
+                appDir: z.string(),
+                packageManager: z.string().optional(),
+                instantTokenEnvName: z.string().optional(),
+            }),
+            output: serviceResult(processRunResult),
+            execute: createEkairosAppStep,
         }),
-        output: serviceResult(z.object({ url: z.string() })),
-        execute: getPortUrlStep,
-    }),
-    createEkairosApp: defineAction({
-        name: "sandbox.createEkairosApp",
-        input: z.object({
-            sandboxId: z.string(),
-            appDir: z.string(),
-            packageManager: z.string().optional(),
-            instantTokenEnvName: z.string().optional(),
-        }),
-        output: serviceResult(processRunResult),
-        execute: createEkairosAppStep,
-    }),
-});
+    });
+}
+export const sandboxDomain = createSandboxDomain();
 //# sourceMappingURL=actions.js.map