openpond 0.0.30-bootstrap.0

package/dist/sandbox/types/snapshots.d.ts

@@ -0,0 +1,205 @@
+import type { SandboxCommand, SandboxState } from "./index.js";
+export type SandboxSnapshotTemplateVisibility = "private" | "team";
+export type SandboxSnapshotTemplateInput = {
+    name: string;
+    version: string;
+    description?: string;
+    tags?: string[];
+    visibility?: SandboxSnapshotTemplateVisibility;
+    useCase?: string;
+};
+export type SandboxSnapshotTemplate = {
+    name: string;
+    version: string;
+    description: string | null;
+    tags: string[];
+    visibility: SandboxSnapshotTemplateVisibility;
+    useCase: string | null;
+};
+export type SandboxSnapshotReplayRetentionClass = "ephemeral" | "cached" | "pinned";
+export type SandboxSnapshotReplayState = "draft" | "validated" | "published";
+export type SandboxSnapshotReplayManifest = {
+    state: SandboxSnapshotReplayState;
+    retention: {
+        class: SandboxSnapshotReplayRetentionClass;
+        ttlSeconds: number | null;
+    };
+    metadata?: Record<string, unknown>;
+};
+export type SandboxSnapshotValidationCommandResult = {
+    command: string;
+    cwd: string | null;
+    status: SandboxCommand["status"];
+    exitCode: number | null;
+    output: string;
+    startedAt: string;
+    completedAt: string | null;
+};
+export type SandboxSnapshotValidationProbeResult = {
+    name: string | null;
+    port: number;
+    path: string;
+    expectedStatus: number;
+    actualStatus: number | null;
+    ok: boolean;
+    error: string | null;
+    startedAt: string;
+    completedAt: string | null;
+};
+export type SandboxSnapshotValidationResult = {
+    id: string;
+    status: "passed" | "failed";
+    sourceSandboxId: string;
+    validationSandboxId: string | null;
+    snapshotId: string;
+    commands: SandboxSnapshotValidationCommandResult[];
+    probes: SandboxSnapshotValidationProbeResult[];
+    cleanup: {
+        action: "stop" | "delete" | "archive";
+        status: "succeeded" | "failed" | "skipped";
+        error: string | null;
+    };
+    error: string | null;
+    startedAt: string;
+    completedAt: string;
+};
+export type SandboxSnapshotValidateInput = {
+    cleanup?: "stop" | "delete" | "archive";
+};
+export type SandboxSnapshotTemplateUpdateInput = {
+    description?: string | null;
+    tags?: string[];
+    visibility?: SandboxSnapshotTemplateVisibility;
+    useCase?: string | null;
+};
+export type SandboxSnapshotRetentionUpdateInput = {
+    class?: SandboxSnapshotReplayRetentionClass;
+    ttlSeconds?: number | null;
+};
+export type SandboxSnapshotUpdateInput = {
+    template?: SandboxSnapshotTemplateUpdateInput;
+    retention?: SandboxSnapshotRetentionUpdateInput;
+};
+export type SandboxSnapshotInput = Record<string, unknown>;
+export type SandboxSnapshot = {
+    id: string;
+    sandboxId: string;
+    name: string;
+    state: "ready";
+    sizeGb: number;
+    template?: SandboxSnapshotTemplate | null;
+    replay?: SandboxSnapshotReplayManifest | null;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+};
+export type SandboxSnapshotJob = {
+    id: string;
+    snapshotId: string;
+    name: string;
+    status: "queued" | "running" | "succeeded" | "failed";
+    error: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+};
+export type SandboxArchiveRef = {
+    id: string;
+    sandboxId: string;
+    snapshotId: string | null;
+    storage: "simulated" | "runner_local" | "s3";
+    createdAt: string;
+    restoredAt: string | null;
+};
+export type SandboxSnapshotCatalogEntry = {
+    id: string;
+    kind: "snapshot" | "archive";
+    sandboxId: string;
+    sandboxState: SandboxState;
+    sandboxRepo: string | null;
+    teamId: string;
+    projectId?: string | null;
+    agentId?: string | null;
+    name: string;
+    snapshot: SandboxSnapshot | null;
+    archive: SandboxArchiveRef | null;
+    sizeGb: number | null;
+    storage: SandboxArchiveRef["storage"] | "snapshot" | null;
+    storageCost?: {
+        sizeGb: number | null;
+        retentionClass: SandboxSnapshotReplayRetentionClass | null;
+        estimatedMonthlyUsd: string | null;
+        pricingSource: "configured" | "not_configured";
+    };
+    template: SandboxSnapshotTemplate | null;
+    replay?: SandboxSnapshotReplayManifest | null;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+};
+export type SandboxTemplateCatalogEntry = {
+    id: string;
+    snapshotId: string;
+    sandboxId: string;
+    sandboxState: SandboxState;
+    sandboxRepo: string | null;
+    teamId: string;
+    projectId: string | null;
+    agentId: string | null;
+    name: string;
+    version: string;
+    description: string | null;
+    tags: string[];
+    visibility: SandboxSnapshotTemplateVisibility;
+    useCase: string | null;
+    sizeGb: number | null;
+    source?: {
+        repo: string | null;
+        ref: string | null;
+        commitSha: string | null;
+        projectId: string | null;
+        agentId: string | null;
+    };
+    storageCost?: SandboxSnapshotCatalogEntry["storageCost"];
+    replay: SandboxSnapshotReplayManifest;
+    snapshot: SandboxSnapshot;
+    createdAt: string;
+};
+export type SandboxPublishedSnapshotCatalogEntry = SandboxTemplateCatalogEntry;
+export type SandboxTemplateBuildStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled";
+export type SandboxTemplateBuildPublishStatus = "skipped" | "published" | "failed";
+export type SandboxTemplateBuildCreateInput = {
+    teamId?: string;
+    sourceRepoUrl?: string;
+    sourceProjectId?: string;
+    branch?: string;
+    manifestPath?: string;
+    publish?: boolean;
+};
+export type SandboxTemplateBuildRecord = {
+    id: string;
+    teamId: string;
+    sourceProjectId: string | null;
+    sourceRepoUrl: string;
+    sourceOwner: string;
+    sourceRepo: string;
+    sourceBranch: string;
+    sourceCommitSha: string | null;
+    manifestPath: string;
+    manifestHash: string | null;
+    manifest: Record<string, unknown> | null;
+    status: SandboxTemplateBuildStatus;
+    buildSandboxId: string | null;
+    snapshotId: string | null;
+    validationSandboxId: string | null;
+    validation: Record<string, unknown> | null;
+    publishStatus: SandboxTemplateBuildPublishStatus | null;
+    logs: string[];
+    error: string | null;
+    requestedByUserId: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+export type SandboxPublishedSnapshotBuildStatus = SandboxTemplateBuildStatus;
+export type SandboxPublishedSnapshotBuildPublishStatus = SandboxTemplateBuildPublishStatus;
+export type SandboxPublishedSnapshotBuildCreateInput = SandboxTemplateBuildCreateInput;
+export type SandboxPublishedSnapshotBuildRecord = SandboxTemplateBuildRecord;

package/dist/sandbox/types/workflow-modes.d.ts

@@ -0,0 +1 @@
+export type SandboxWorkflowMode = "readonly" | "attempt" | "feature" | "rollout" | "replay" | "template_build" | "scheduled_run" | "patch_only" | "hotfix" | "multi_feature_batch";

package/dist/sandbox/types/workload-sources.d.ts

@@ -0,0 +1,20 @@
+export type SandboxWorkloadImageSourceInput = {
+    ref: string;
+    digest?: string;
+    registrySecretRef?: string;
+    platform?: "linux/amd64";
+    workspaceRoot?: string;
+};
+export type SandboxWorkloadDockerfileSourceInput = {
+    context: string;
+    path: string;
+    target?: string;
+    buildArgs?: Record<string, string>;
+    registrySecretRefs?: string[];
+    platform?: "linux/amd64";
+    workspaceRoot?: string;
+};
+export type SandboxWorkloadSourceInput = {
+    image?: SandboxWorkloadImageSourceInput;
+    dockerfile?: SandboxWorkloadDockerfileSourceInput;
+};

package/dist/sandbox/url.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeSandboxApiUrl(baseUrlOrApiUrl: string): string;
+export declare function apiRootUrlFromSandboxApiUrl(sandboxApiUrl: string): string;

package/dist/sandbox-template/manifest.d.ts

@@ -0,0 +1,304 @@
+import { z } from "zod";
+export declare const SANDBOX_TEMPLATE_PREVIEW_PORT_MIN = 3000;
+export declare const SANDBOX_TEMPLATE_PREVIEW_PORT_MAX = 9999;
+export declare const OPENPOND_MANIFEST_FILE_NAME = "openpond.yaml";
+export declare const SANDBOX_TEMPLATE_BUILD_PLAN_FILE_NAME = "openpond-template-plan.json";
+export declare const SANDBOX_TEMPLATE_BUILD_PLAN_KIND = "openpond.sandboxTemplate.buildPlan.v1";
+export declare const SandboxTemplateManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    name: z.ZodString;
+    version: z.ZodString;
+    useCase: z.ZodString;
+    description: z.ZodString;
+    runtime: z.ZodObject<{
+        base: z.ZodOptional<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.ZodString>;
+            registrySecretRef: z.ZodOptional<z.ZodString>;
+            platform: z.ZodOptional<z.ZodLiteral<"linux/amd64">>;
+            workspaceRoot: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        dockerfile: z.ZodOptional<z.ZodObject<{
+            context: z.ZodDefault<z.ZodString>;
+            path: z.ZodDefault<z.ZodString>;
+            target: z.ZodOptional<z.ZodString>;
+            buildArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            registrySecretRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            platform: z.ZodOptional<z.ZodLiteral<"linux/amd64">>;
+            workspaceRoot: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    resources: z.ZodOptional<z.ZodObject<{
+        cpu: z.ZodOptional<z.ZodNumber>;
+        memoryGb: z.ZodOptional<z.ZodNumber>;
+        diskGb: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    setup: z.ZodDefault<z.ZodObject<{
+        commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    validation: z.ZodObject<{
+        commands: z.ZodArray<z.ZodString>;
+        probes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            port: z.ZodNumber;
+            path: z.ZodDefault<z.ZodString>;
+            expectedStatus: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    start: z.ZodObject<{
+        command: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        requiresStart: z.ZodDefault<z.ZodBoolean>;
+        ports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            port: z.ZodNumber;
+            protocol: z.ZodDefault<z.ZodLiteral<"http">>;
+            label: z.ZodOptional<z.ZodString>;
+            access: z.ZodDefault<z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>>;
+            path: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>>>;
+        artifactPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        requiresStart: z.ZodDefault<z.ZodBoolean>;
+        ports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            port: z.ZodNumber;
+            protocol: z.ZodDefault<z.ZodLiteral<"http">>;
+            label: z.ZodOptional<z.ZodString>;
+            access: z.ZodDefault<z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>>;
+            path: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>>>;
+        artifactPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+    services: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        requiresStart: z.ZodDefault<z.ZodBoolean>;
+        ports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            port: z.ZodNumber;
+            protocol: z.ZodDefault<z.ZodLiteral<"http">>;
+            label: z.ZodOptional<z.ZodString>;
+            access: z.ZodDefault<z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>>;
+            path: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>>>;
+        artifactPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+    schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        cron: z.ZodOptional<z.ZodString>;
+        rate: z.ZodOptional<z.ZodString>;
+        once: z.ZodOptional<z.ZodString>;
+        scheduleType: z.ZodOptional<z.ZodEnum<{
+            rate: "rate";
+            cron: "cron";
+            once: "once";
+        }>>;
+        scheduleExpression: z.ZodOptional<z.ZodString>;
+        timezone: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        startAt: z.ZodOptional<z.ZodString>;
+        endAt: z.ZodOptional<z.ZodString>;
+        maxRuns: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        runtimePolicy: z.ZodDefault<z.ZodEnum<{
+            run_and_stop: "run_and_stop";
+            run_and_archive: "run_and_archive";
+            run_and_delete: "run_and_delete";
+            use_existing_running: "use_existing_running";
+        }>>;
+        action: z.ZodOptional<z.ZodString>;
+        actionName: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodEnum<{
+                action: "action";
+                service: "service";
+                command: "command";
+                start: "start";
+            }>>;
+            name: z.ZodOptional<z.ZodString>;
+            actionName: z.ZodOptional<z.ZodString>;
+            command: z.ZodOptional<z.ZodString>;
+            requiresStart: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        requiresStart: z.ZodOptional<z.ZodBoolean>;
+        budget: z.ZodOptional<z.ZodObject<{
+            maxUsd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        resources: z.ZodOptional<z.ZodObject<{
+            cpu: z.ZodOptional<z.ZodNumber>;
+            memoryGb: z.ZodOptional<z.ZodNumber>;
+            diskGb: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        quotas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        lifecycle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        retentionPolicy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodOptional<z.ZodString>;
+            secretRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        integrationLeases: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    mcp: z.ZodDefault<z.ZodObject<{
+        endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            service: z.ZodOptional<z.ZodString>;
+            port: z.ZodNumber;
+            path: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    volumes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        mountPath: z.ZodOptional<z.ZodString>;
+        storageGb: z.ZodOptional<z.ZodNumber>;
+        deleteOnSandboxDelete: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    integrations: z.ZodDefault<z.ZodObject<{
+        requiredLeases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            provider: z.ZodEnum<{
+                google: "google";
+                github: "github";
+                x: "x";
+            }>;
+            scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    permissions: z.ZodDefault<z.ZodObject<{
+        opchat: z.ZodOptional<z.ZodObject<{
+            models: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$catchall<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+    inputs: z.ZodDefault<z.ZodObject<{
+        schema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        env: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            secret: z.ZodDefault<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    artifacts: z.ZodDefault<z.ZodObject<{
+        paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    network: z.ZodDefault<z.ZodObject<{
+        egress: z.ZodDefault<z.ZodEnum<{
+            block: "block";
+            restricted: "restricted";
+            allow: "allow";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SandboxTemplateManifest = z.infer<typeof SandboxTemplateManifestSchema>;
+export type SandboxTemplateResources = NonNullable<SandboxTemplateManifest["resources"]>;
+export type SandboxTemplatePort = SandboxTemplateManifest["start"]["ports"][number];
+export type SandboxTemplateCommand = SandboxTemplateManifest["start"];
+export type SandboxTemplateNamedCommand = SandboxTemplateManifest["actions"][number];
+export type SandboxTemplateSchedule = SandboxTemplateManifest["schedules"][number];
+export type SandboxTemplateVolume = SandboxTemplateManifest["volumes"][number];
+export type SandboxTemplateExecutableKind = "start" | "action" | "service";
+export type SandboxTemplateExecutable = SandboxTemplateCommand & {
+    kind: SandboxTemplateExecutableKind;
+    name: string;
+};
+export type SandboxTemplateBuildPlan = {
+    kind: typeof SANDBOX_TEMPLATE_BUILD_PLAN_KIND;
+    schemaVersion: 1;
+    manifestFile: string;
+    projectRoot: string;
+    manifest: SandboxTemplateManifest;
+    metadata: Record<string, unknown>;
+    executables: SandboxTemplateExecutable[];
+};
+export type SandboxTemplateValidationDiagnostic = {
+    path: string;
+    message: string;
+    code: string;
+};
+export type SandboxTemplateValidationResult = {
+    ok: true;
+    manifest: SandboxTemplateManifest;
+    diagnostics: [];
+} | {
+    ok: false;
+    manifest: null;
+    diagnostics: SandboxTemplateValidationDiagnostic[];
+};
+export declare const SandboxTemplateValidationDiagnosticSchema: z.ZodObject<{
+    path: z.ZodString;
+    message: z.ZodString;
+    code: z.ZodString;
+}, z.core.$strip>;
+export declare function validateSandboxTemplateYaml(source: string): SandboxTemplateValidationResult;
+export declare function validateSandboxTemplateManifest(value: unknown): SandboxTemplateValidationResult;
+export declare function parseSandboxTemplateYaml(source: string): SandboxTemplateManifest;
+export declare function formatSandboxTemplateDiagnostics(diagnostics: SandboxTemplateValidationDiagnostic[]): string;
+export declare function defineSandboxTemplate<T extends SandboxTemplateManifest>(template: T): T;
+export declare function sandboxTemplateResources(resources?: Partial<SandboxTemplateResources>): SandboxTemplateResources;
+export declare function sandboxTemplateDurableVolume(volume: SandboxTemplateVolume): SandboxTemplateVolume;
+export declare function sandboxTemplatePreviewPort(port: number, options?: Omit<Partial<SandboxTemplatePort>, "port">): SandboxTemplatePort;
+export type SandboxTemplateFileInputOptions = {
+    targetPath: string;
+    title?: string;
+    description?: string;
+    accept?: string[];
+    multiple?: boolean;
+};
+export type SandboxTemplateFileInputSchema = {
+    type: "string";
+    format: "file";
+    title?: string;
+    description?: string;
+    "x-openpond-upload": {
+        targetPath: string;
+        accept?: string[];
+        multiple?: false;
+    };
+} | {
+    type: "array";
+    title?: string;
+    description?: string;
+    items: {
+        type: "string";
+        format: "file";
+    };
+    "x-openpond-upload": {
+        targetPath: string;
+        accept?: string[];
+        multiple: true;
+    };
+};
+export declare function sandboxTemplateFileInput(options: SandboxTemplateFileInputOptions): SandboxTemplateFileInputSchema;
+export declare function sandboxTemplateExecutableEntries(manifest: SandboxTemplateManifest): SandboxTemplateExecutable[];
+export declare function sandboxTemplateBuildMetadata(manifest: SandboxTemplateManifest): Record<string, unknown>;
+export declare function sandboxTemplateBuildPlan(input: {
+    manifest: SandboxTemplateManifest;
+    manifestFile: string;
+    projectRoot: string;
+}): SandboxTemplateBuildPlan;
+export type SandboxTemplateScaffoldInput = {
+    name: string;
+    description?: string;
+};
+export declare function sandboxTemplateScaffoldFiles(input: SandboxTemplateScaffoldInput): Record<string, string>;
+export declare function sandboxTemplateJsonSchema(): Record<string, unknown>;