@figulus/schema 0.4.0-alpha-dev → 0.5.0-alpha-dev-1

package/dist/engine/paths/volumes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumes.d.ts","sourceRoot":"","sources":["../../../src/engine/paths/volumes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAI7D,eAAO,MAAM,uBAAuB,EAAE,WA8CrC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,WA2BpC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,WA8CrC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,WAsCrC,CAAC"}

package/dist/engine/paths/volumes.js

@@ -0,0 +1,164 @@
+import { deleteVolumeResponseSchema, ensureVolumeRequestSchema, ensureVolumeResponseSchema, listVolumesResponseSchema, pruneVolumesRequestSchema, pruneVolumesResponseSchema } from "../volumes.js";
+import { errorResponseSchema } from "../response.js";
+export const ensureVolumeRouteSchema = {
+    method: "post",
+    path: "/api/v1/volumes/ensure",
+    operationId: "ensureVolume",
+    summary: "Ensure a Docker volume exists",
+    description: "Creates the volume if it does not exist; no-ops if it does.",
+    tags: [
+        "volumes"
+    ],
+    request: {
+        body: {
+            description: undefined,
+            content: {
+                "application/json": {
+                    schema: ensureVolumeRequestSchema
+                }
+            },
+            required: true
+        }
+    },
+    responses: {
+        200: {
+            description: "Volume exists (created or pre-existing)",
+            content: {
+                "application/json": {
+                    schema: ensureVolumeResponseSchema
+                }
+            }
+        },
+        400: {
+            description: "Missing volume_name",
+            content: {
+                "application/json": {
+                    schema: errorResponseSchema
+                }
+            }
+        },
+        500: {
+            description: "Failed to ensure volume",
+            content: {
+                "application/json": {
+                    schema: errorResponseSchema
+                }
+            }
+        }
+    }
+};
+export const listVolumesRouteSchema = {
+    method: "get",
+    path: "/api/v1/volumes",
+    operationId: "listVolumes",
+    summary: "List Figulus-managed volumes",
+    description: "Returns all Docker volumes managed by this Figulus engine instance.",
+    tags: [
+        "volumes"
+    ],
+    responses: {
+        200: {
+            description: "Volume list",
+            content: {
+                "application/json": {
+                    schema: listVolumesResponseSchema
+                }
+            }
+        },
+        500: {
+            description: "Failed to list volumes",
+            content: {
+                "application/json": {
+                    schema: errorResponseSchema
+                }
+            }
+        }
+    }
+};
+export const deleteVolumeRouteSchema = {
+    method: "delete",
+    path: "/api/v1/volumes/{name}",
+    operationId: "deleteVolume",
+    summary: "Delete a volume",
+    description: "Deletes the named Docker volume. Returns 500 if the volume is in use.",
+    tags: [
+        "volumes"
+    ],
+    parameters: [
+        {
+            name: "name",
+            in: "path",
+            required: true,
+            schema: {
+                type: "string"
+            },
+            example: "figulus-cache-nodejs"
+        }
+    ],
+    responses: {
+        200: {
+            description: "Volume deleted",
+            content: {
+                "application/json": {
+                    schema: deleteVolumeResponseSchema
+                }
+            }
+        },
+        400: {
+            description: "Missing volume name",
+            content: {
+                "application/json": {
+                    schema: errorResponseSchema
+                }
+            }
+        },
+        500: {
+            description: "Delete failed",
+            content: {
+                "application/json": {
+                    schema: errorResponseSchema
+                }
+            }
+        }
+    }
+};
+export const pruneVolumesRouteSchema = {
+    method: "post",
+    path: "/api/v1/volumes/prune",
+    operationId: "pruneVolumes",
+    summary: "Prune unused volumes",
+    description: "Removes unused Docker volumes matching the given filters. Body is optional.",
+    tags: [
+        "volumes"
+    ],
+    request: {
+        body: {
+            description: undefined,
+            content: {
+                "application/json": {
+                    schema: pruneVolumesRequestSchema
+                }
+            },
+            required: false
+        }
+    },
+    responses: {
+        200: {
+            description: "Volumes pruned",
+            content: {
+                "application/json": {
+                    schema: pruneVolumesResponseSchema
+                }
+            }
+        },
+        500: {
+            description: "Prune failed",
+            content: {
+                "application/json": {
+                    schema: errorResponseSchema
+                }
+            }
+        }
+    }
+};
+//# sourceMappingURL=volumes.js.map

package/dist/engine/paths/volumes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumes.js","sourceRoot":"","sources":["../../../src/engine/paths/volumes.ts"],"names":[],"mappings":"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"}

package/dist/engine/response.d.ts

@@ -0,0 +1,8 @@
+import z from "zod";
+export declare const errorResponseSchema: z.ZodObject<{
+    error: z.ZodString;
+    message: z.ZodString;
+    code: z.ZodInt;
+}, z.core.$strip>;
+export type ErrorResponse = z.infer<typeof errorResponseSchema>;
+//# sourceMappingURL=response.d.ts.map

package/dist/engine/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/engine/response.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB,eAAO,MAAM,mBAAmB;;;;iBAIL,CAAC;AAC5B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/engine/response.js

@@ -0,0 +1,9 @@
+import z from "zod";
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+extendZodWithOpenApi(z);
+export const errorResponseSchema = z.object({
+    error: z.string().describe("Machine-readable error code").openapi({ example: "job_not_found" }),
+    message: z.string().describe("Human-readable error detail").openapi({ example: "Job abc123 not found" }),
+    code: z.int().describe("HTTP status code mirrored in body").openapi({ example: 404 }),
+}).openapi("ErrorResponse");
+//# sourceMappingURL=response.js.map

package/dist/engine/response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/engine/response.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAExB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC;IAC/F,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,sBAAsB,EAAE,CAAC;IACxG,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,mCAAmC,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC;CACtF,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC"}

package/dist/engine/sessions.d.ts

@@ -0,0 +1,343 @@
+import { z } from 'zod';
+export declare const sessionStatusSchema: z.ZodEnum<{
+    active: "active";
+    idle: "idle";
+    expired: "expired";
+}>;
+export type SessionStatus = z.infer<typeof sessionStatusSchema>;
+export declare const sessionConfigSchema: z.ZodObject<{
+    working_dir: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    parser_script: z.ZodOptional<z.ZodString>;
+    volumes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        host_path: z.ZodString;
+        container_path: z.ZodOptional<z.ZodString>;
+        read_only: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    named_volumes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        volume_name: z.ZodString;
+        container_path: z.ZodString;
+        read_only: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    init_cmd: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    destroy_cmd: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    execute: z.ZodOptional<z.ZodObject<{
+        startup: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cmd: z.ZodString;
+            async: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        main: z.ZodObject<{
+            cmd: z.ZodString;
+            onExit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodArray<z.ZodObject<{
+                cmd: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+                exitCode: z.ZodInt;
+            }, z.core.$strip>>]>>;
+            parser: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        shutdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cmd: z.ZodString;
+        }, z.core.$strip>>>;
+        scheduled: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cmd: z.ZodString;
+            runAt: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                interval: z.ZodOptional<z.ZodInt>;
+                time: z.ZodOptional<z.ZodString>;
+                cron: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>;
+            onExit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodArray<z.ZodObject<{
+                cmd: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+                exitCode: z.ZodInt;
+            }, z.core.$strip>>]>>;
+            parser: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    ports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        container: z.ZodInt;
+        host: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>>>;
+    start_cmd: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    auto_cleanup: z.ZodOptional<z.ZodBoolean>;
+    block_until_complete: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SessionConfig = z.infer<typeof sessionConfigSchema>;
+export declare const createSessionRequestSchema: z.ZodObject<{
+    image_tag: z.ZodString;
+    ttl: z.ZodOptional<z.ZodInt>;
+    config: z.ZodOptional<z.ZodObject<{
+        working_dir: z.ZodOptional<z.ZodString>;
+        environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        parser_script: z.ZodOptional<z.ZodString>;
+        volumes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            host_path: z.ZodString;
+            container_path: z.ZodOptional<z.ZodString>;
+            read_only: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        named_volumes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            volume_name: z.ZodString;
+            container_path: z.ZodString;
+            read_only: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        init_cmd: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        destroy_cmd: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        execute: z.ZodOptional<z.ZodObject<{
+            startup: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cmd: z.ZodString;
+                async: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            main: z.ZodObject<{
+                cmd: z.ZodString;
+                onExit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodArray<z.ZodObject<{
+                    cmd: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+                    exitCode: z.ZodInt;
+                }, z.core.$strip>>]>>;
+                parser: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            shutdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cmd: z.ZodString;
+            }, z.core.$strip>>>;
+            scheduled: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cmd: z.ZodString;
+                runAt: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    interval: z.ZodOptional<z.ZodInt>;
+                    time: z.ZodOptional<z.ZodString>;
+                    cron: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+                onExit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodArray<z.ZodObject<{
+                    cmd: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+                    exitCode: z.ZodInt;
+                }, z.core.$strip>>]>>;
+                parser: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        ports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            container: z.ZodInt;
+            host: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strip>>>;
+        start_cmd: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        auto_cleanup: z.ZodOptional<z.ZodBoolean>;
+        block_until_complete: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    execute: z.ZodOptional<z.ZodObject<{
+        startup: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cmd: z.ZodString;
+            async: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        main: z.ZodObject<{
+            cmd: z.ZodString;
+            onExit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodArray<z.ZodObject<{
+                cmd: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+                exitCode: z.ZodInt;
+            }, z.core.$strip>>]>>;
+            parser: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        shutdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cmd: z.ZodString;
+        }, z.core.$strip>>>;
+        scheduled: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cmd: z.ZodString;
+            runAt: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                interval: z.ZodOptional<z.ZodInt>;
+                time: z.ZodOptional<z.ZodString>;
+                cron: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>;
+            onExit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodArray<z.ZodObject<{
+                cmd: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+                exitCode: z.ZodInt;
+            }, z.core.$strip>>]>>;
+            parser: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    block_until_complete: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CreateSessionRequest = z.infer<typeof createSessionRequestSchema>;
+export declare const createSessionResponseSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    container_id: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        expired: "expired";
+    }>;
+    created_at: z.ZodISODateTime;
+    ports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        container: z.ZodInt;
+        host: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>>>;
+    exit_code: z.ZodOptional<z.ZodInt>;
+    stdout: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateSessionResponse = z.infer<typeof createSessionResponseSchema>;
+export declare const getSessionResponseSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    container_id: z.ZodString;
+    image_tag: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        expired: "expired";
+    }>;
+    created_at: z.ZodISODateTime;
+    last_used_at: z.ZodISODateTime;
+    ttl: z.ZodInt;
+    ports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        container: z.ZodInt;
+        host: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GetSessionResponse = z.infer<typeof getSessionResponseSchema>;
+export declare const runInSessionRequestSchema: z.ZodObject<{
+    command: z.ZodArray<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodInt>;
+    parser_script: z.ZodOptional<z.ZodString>;
+    working_dir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RunInSessionRequest = z.infer<typeof runInSessionRequestSchema>;
+export declare const runInSessionResponseSchema: z.ZodObject<{
+    run_id: z.ZodString;
+    exit_code: z.ZodInt;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    parsed_output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    duration: z.ZodNumber;
+}, z.core.$strip>;
+export type RunInSessionResponse = z.infer<typeof runInSessionResponseSchema>;
+export declare const getRunResponseSchema: z.ZodObject<{
+    run_id: z.ZodString;
+    session_id: z.ZodString;
+    command: z.ZodArray<z.ZodString>;
+    exit_code: z.ZodInt;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    parsed_output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    started_at: z.ZodISODateTime;
+    completed_at: z.ZodISODateTime;
+    duration: z.ZodNumber;
+}, z.core.$strip>;
+export type GetRunResponse = z.infer<typeof getRunResponseSchema>;
+export declare const listRunsResponseSchema: z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        run_id: z.ZodString;
+        session_id: z.ZodString;
+        command: z.ZodArray<z.ZodString>;
+        exit_code: z.ZodInt;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        parsed_output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        started_at: z.ZodISODateTime;
+        completed_at: z.ZodISODateTime;
+        duration: z.ZodNumber;
+    }, z.core.$strip>>;
+    count: z.ZodInt;
+}, z.core.$strip>;
+export declare const syncFileRequestSchema: z.ZodObject<{
+    targetPath: z.ZodString;
+    content: z.ZodString;
+    encoding: z.ZodDefault<z.ZodEnum<{
+        base64: "base64";
+        utf8: "utf8";
+    }>>;
+}, z.core.$strip>;
+export type SyncFileRequest = z.infer<typeof syncFileRequestSchema>;
+export declare const syncFileResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    path: z.ZodString;
+    bytes_written: z.ZodInt;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SyncFileResponse = z.infer<typeof syncFileResponseSchema>;
+export declare const startStackRequestSchema: z.ZodObject<{
+    spec: z.ZodObject<{
+        schemaVersion: z.ZodString;
+        stackName: z.ZodString;
+        containers: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            spec: z.ZodUnion<readonly [z.ZodObject<{}, z.core.$loose>, z.ZodString]>;
+            ports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                container: z.ZodInt;
+                host: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strip>>>;
+            dependsOn: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                condition: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                    started: "started";
+                    healthy: "healthy";
+                    completed: "completed";
+                }>>>;
+            }, z.core.$strip>>>;
+            healthCheck: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    exec: "exec";
+                    http: "http";
+                    tcp: "tcp";
+                }>;
+                cmd: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodString>;
+                port: z.ZodOptional<z.ZodInt>;
+                method: z.ZodOptional<z.ZodEnum<{
+                    GET: "GET";
+                    HEAD: "HEAD";
+                }>>;
+                expectedStatus: z.ZodOptional<z.ZodInt>;
+                intervalSeconds: z.ZodOptional<z.ZodInt>;
+                timeoutSeconds: z.ZodOptional<z.ZodInt>;
+                retries: z.ZodOptional<z.ZodInt>;
+                startPeriodSeconds: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strip>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+        env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            vars: z.ZodRecord<z.ZodString, z.ZodString>;
+            inject: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        network: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            subnet: z.ZodOptional<z.ZodString>;
+            external: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        volumes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            external: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    build: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    images: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const startStackResponseSchema: z.ZodObject<{
+    stack_name: z.ZodString;
+    sessions: z.ZodObject<{}, z.core.$strip>;
+    network_id: z.ZodString;
+}, z.core.$strip>;
+export declare const stackContainerStatusSchema: z.ZodObject<{
+    container_name: z.ZodString;
+    session_id: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>;
+export declare const getStackResponseSchema: z.ZodObject<{
+    stack_name: z.ZodString;
+    network_id: z.ZodString;
+    containers: z.ZodArray<z.ZodObject<{
+        container_name: z.ZodString;
+        session_id: z.ZodString;
+        status: z.ZodString;
+    }, z.core.$strip>>;
+    created_at: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const listStacksResponseSchema: z.ZodObject<{
+    stacks: z.ZodArray<z.ZodObject<{
+        run_id: z.ZodString;
+        session_id: z.ZodString;
+        command: z.ZodArray<z.ZodString>;
+        exit_code: z.ZodInt;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        parsed_output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        started_at: z.ZodISODateTime;
+        completed_at: z.ZodISODateTime;
+        duration: z.ZodNumber;
+    }, z.core.$strip>>;
+    count: z.ZodInt;
+}, z.core.$strip>;
+//# sourceMappingURL=sessions.d.ts.map

package/dist/engine/sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../src/engine/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,mBAAmB;;;;EAEL,CAAC;AAC5B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaL,CAAC;AAC5B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAML,CAAC;AACnC,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;iBASL,CAAC;AACpC,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBASL,CAAC;AACjC,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,yBAAyB;;;;;iBAKL,CAAC;AAClC,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,0BAA0B;;;;;;;iBAOL,CAAC;AACnC,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAWL,CAAC;AAC7B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBAGL,CAAC;AAE/B,eAAO,MAAM,qBAAqB;;;;;;;iBAIL,CAAC;AAC9B,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,sBAAsB;;;;;iBAKL,CAAC;AAC/B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIL,CAAC;AAEhC,eAAO,MAAM,wBAAwB;;;;iBAIL,CAAC;AAEjC,eAAO,MAAM,0BAA0B;;;;iBAIL,CAAC;AAEnC,eAAO,MAAM,sBAAsB;;;;;;;;;iBAKL,CAAC;AAE/B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;iBAGL,CAAC"}

package/dist/engine/sessions.js

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+import { namedVolumeMountSchema, volumeMountSchema } from '../core/volumes.js';
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { figStackSchema } from '../core/entities/figstack.js';
+import { figSpecExecuteSchema } from '../core/entities/figspec.js';
+import { portMappingSchema } from '../core/generic.js';
+extendZodWithOpenApi(z);
+export const sessionStatusSchema = z.enum([
+    'active', 'idle', 'expired'
+]).openapi("SessionStatus");
+export const sessionConfigSchema = z.object({
+    working_dir: z.string().optional().describe("Default working directory for commands in this session").openapi({ example: "/app" }),
+    environment: z.record(z.string(), z.string()).optional().describe("Environment variables for the session container"),
+    parser_script: z.string().optional().describe("Default JavaScript parser script for command output"),
+    volumes: z.array(volumeMountSchema).optional(),
+    named_volumes: z.array(namedVolumeMountSchema).optional(),
+    init_cmd: z.array(z.string()).optional().describe("Command to run once after container creation"),
+    destroy_cmd: z.array(z.string()).optional().describe("Command to run before container destruction"),
+    execute: figSpecExecuteSchema.optional().describe("Figspec execute configuration (alternative to start_cmd for Figspec-driven sessions)"),
+    ports: z.array(portMappingSchema).optional(),
+    start_cmd: z.array(z.string()).optional().describe("Main container process command (default [\"sleep\", \"infinity\"])"),
+    auto_cleanup: z.boolean().optional().describe("If true, the session is destroyed automatically after the main command (start_cmd or execute.main) completes, regardless of exit code. This is the flag that distinguishes a one-shot execution from a persistent session.").openapi({ example: false }),
+    block_until_complete: z.boolean().optional().describe("If true (on CreateSessionRequest), the HTTP handler blocks until the session reaches a terminal state and returns the full result (exit_code, stdout, stderr) in the response. Intended for use with auto_cleanup: true to implement synchronous one-shot execution.").openapi({ example: false })
+}).openapi("SessionConfig");
+export const createSessionRequestSchema = z.object({
+    image_tag: z.string().min(1).describe("Docker image to use for the session container").openapi({ example: "localhost:5000/figulus:sha256-abc123" }),
+    ttl: z.int().positive().optional().describe("Session TTL in seconds (default 600)").openapi({ example: 600 }),
+    config: sessionConfigSchema.optional(),
+    execute: figSpecExecuteSchema.optional().describe("Figspec execute configuration (preferred over config.start_cmd for Figspec-driven sessions)"),
+    block_until_complete: z.boolean().optional().describe("If true, the HTTP handler blocks until the session reaches a terminal state and returns the full result (exit_code, stdout, stderr) synchronously. Use with config.auto_cleanup: true to implement one-shot execution semantics (replaces the removed /containers/run endpoint).").openapi({ example: false }),
+}).openapi("CreateSessionRequest");
+export const createSessionResponseSchema = z.object({
+    session_id: z.string().openapi({ example: "sess-abc123" }),
+    container_id: z.string().openapi({ example: "a1b2c3d4e5f6" }),
+    status: sessionStatusSchema,
+    created_at: z.iso.datetime().openapi({ format: "date-time" }),
+    ports: z.array(portMappingSchema).optional(),
+    exit_code: z.int().optional().describe("Container exit code. Populated when block_until_complete: true and the session ran to completion (i.e., auto_cleanup: true and the main command finished).").openapi({ example: 0 }),
+    stdout: z.string().optional().describe("Main command stdout. Populated when block_until_complete is true and session ran to completion.").openapi({ example: "Hello, world!\n" }),
+    stderr: z.string().optional().describe("Main command stderr. Populated when block_until_complete is true and session ran to completion.").openapi({ example: "" }),
+}).openapi("CreateSessionResponse");
+export const getSessionResponseSchema = z.object({
+    session_id: z.string(),
+    container_id: z.string(),
+    image_tag: z.string(),
+    status: sessionStatusSchema,
+    created_at: z.iso.datetime().openapi({ format: "date-time" }),
+    last_used_at: z.iso.datetime().openapi({ format: "date-time" }),
+    ttl: z.int().describe("TTL in seconds"),
+    ports: z.array(portMappingSchema).optional(),
+}).openapi("GetSessionResponse");
+export const runInSessionRequestSchema = z.object({
+    command: z.array(z.string()).min(1).describe("Command to execute inside the session container").openapi({ example: ["npm", "test"] }),
+    timeout: z.int().positive().max(86400).optional().describe("Timeout in seconds (default 300)").openapi({ example: 300 }),
+    parser_script: z.string().optional().describe("Optional JavaScript parser for structured output"),
+    working_dir: z.string().optional().describe("Override the session working directory for this run").openapi({ example: "/app/packages/core" }),
+}).openapi("RunInSessionRequest");
+export const runInSessionResponseSchema = z.object({
+    run_id: z.string().openapi({ example: "run-abc123" }),
+    exit_code: z.int(),
+    stdout: z.string(),
+    stderr: z.string(),
+    parsed_output: z.record(z.string(), z.unknown()).optional().describe("Structured output from the parser script, if provided"),
+    duration: z.number().describe("Duration in seconds").openapi({ format: "double" }),
+}).openapi("RunInSessionResponse");
+export const getRunResponseSchema = z.object({
+    run_id: z.string(),
+    session_id: z.string(),
+    command: z.array(z.string()),
+    exit_code: z.int(),
+    stdout: z.string(),
+    stderr: z.string(),
+    parsed_output: z.record(z.string(), z.unknown()).optional(),
+    started_at: z.iso.datetime().openapi({ format: "date-time" }),
+    completed_at: z.iso.datetime().openapi({ format: "date-time" }),
+    duration: z.number().openapi({ format: "double" }),
+}).openapi("GetRunResponse");
+export const listRunsResponseSchema = z.object({
+    runs: z.array(getRunResponseSchema),
+    count: z.int()
+}).openapi("ListRunsResponse");
+export const syncFileRequestSchema = z.object({
+    targetPath: z.string().min(1).describe("Absolute path inside the container where the file will be written").openapi({ example: "/app/src/index.ts" }),
+    content: z.string().min(1).describe("File content, encoded as specified by the encoding field"),
+    encoding: z.enum(['base64', 'utf8']).default('base64').describe("Encoding of the content field (default base64)"),
+}).openapi("SyncFileRequest");
+export const syncFileResponseSchema = z.object({
+    success: z.boolean(),
+    path: z.string().describe("Path written to (echoes targetPath)"),
+    bytes_written: z.int().openapi({ format: "int64" }),
+    message: z.string().optional(),
+}).openapi("SyncFileResponse");
+export const startStackRequestSchema = z.object({
+    spec: figStackSchema,
+    build: z.boolean().optional().default(false).describe("If true, build all required images before starting."),
+    images: z.object({}).optional().describe("Pre-resolved image tags keyed by container entry name."),
+}).openapi("StartStackRequest");
+export const startStackResponseSchema = z.object({
+    stack_name: z.string(),
+    sessions: z.object({}).describe("Map of container name → session ID."),
+    network_id: z.string()
+}).openapi("StartStackResponse");
+export const stackContainerStatusSchema = z.object({
+    container_name: z.string(),
+    session_id: z.string(),
+    status: z.string()
+}).openapi("StackContainerStatus");
+export const getStackResponseSchema = z.object({
+    stack_name: z.string(),
+    network_id: z.string(),
+    containers: z.array(stackContainerStatusSchema),
+    created_at: z.iso.datetime().openapi({ format: "date-time" }),
+}).openapi("GetStackResponse");
+export const listStacksResponseSchema = z.object({
+    stacks: z.array(getRunResponseSchema),
+    count: z.int()
+}).openapi("ListStacksResponse");
+//# sourceMappingURL=sessions.js.map