openpond 0.0.30-bootstrap.0

package/dist/sandbox/client.d.ts

@@ -0,0 +1,348 @@
+import { OpenPondSandboxInstanceClient } from "./sandbox-instance-client.js";
+import type { SandboxIntegrationConnectionStatusFilter, SandboxAsyncRequestOptions, SandboxScheduleCreateInput, SandboxScheduleUpdateInput, SandboxForkInput, SandboxForkOptions, SandboxTemplateLaunchInput, SandboxPublishedSnapshotBuildCreateInput, SandboxPublishedSnapshotBuildRecord, SandboxSecretMetadata, SandboxSecretCreateInput, SandboxSecretRotateInput, SandboxSecretAttachInput, SandboxSnapshotTemplateVisibility, SandboxTemplateBuildCreateInput, SandboxTemplateBuildRecord, OpenPondOrganization, OpenPondOrganizationCreateInput, OpenPondOrganizationUpdateInput, OpenPondOrganizationMember, OpenPondOrganizationMemberUpsertInput, OpenPondOrganizationMcpServer, OpenPondOrganizationMcpGenerateInput, SandboxProject, OpenPondHostedProfilePushInput, OpenPondHostedProfilePushResponse, OpenPondHostedProfileSummary, SandboxAgent, SandboxProjectUpsertInput, SandboxProjectUpdateInput, SandboxProjectSourceUploadInput, SandboxProjectGitRemoteResponse, SandboxAgentUpsertInput, SandboxAgentUpdateInput, SandboxAgentRunInput, SandboxAgentSourceChecksRequestInput, SandboxAgentSourceChecksRequestResult, SandboxAgentSourceDeployPlan, SandboxAgentSourcePublishInput, SandboxAgentSourcePublishResult, SandboxAgentEditWorkItemOpenInput, SandboxAgentEditWorkItemOpenResult, SandboxCodingWorkItem, SandboxCodingWorkItemActivity, SandboxCodingWorkItemActivityListInput, SandboxCodingWorkItemArtifact, SandboxCodingWorkItemBackgroundInput, SandboxCodingWorkItemBackgroundResult, SandboxCodingWorkItemChatInput, SandboxCodingWorkItemChatResult, SandboxCodingWorkItemGetInput, SandboxCodingWorkItemPromotionInput, SandboxCodingWorkItemStatusResult, SandboxAgentManifestSnapshot, SandboxAgentRunResponse, MicrosoftTeamsBotOverview, MicrosoftTeamsBotBindingTargetInput, MicrosoftTeamsBotBindingResponse, MicrosoftTeamsBotDiagnosticRunInput, MicrosoftTeamsBotDiagnosticRunResponse, SandboxRecord, SandboxSnapshotCatalogResponse, SandboxPublishedSnapshotCatalogResponse, SandboxTemplateCatalogResponse, SandboxRuntime, SandboxRuntimeCreateInput, SandboxRuntimeSandboxCreateInput, SandboxRuntimeEventInput, SandboxRuntimeCheckpointInput, SandboxRuntimePromoteInput, SandboxRuntimeSourcePreserveInput, SandboxRuntimeTransitionInput, SandboxRuntimeSandboxResponse, SandboxRuntimeEventResponse, SandboxRuntimeEventsResponse, SandboxRuntimePromoteResponse, SandboxRuntimeSourcePreserveResponse, SandboxIntegrationConnectionsResponse, SandboxForkResponse, SandboxPublishedSnapshotLaunchResponse, SandboxTemplateLaunchResponse, SandboxScheduleListResponse, SandboxScheduleResponse, SandboxScheduleRunListResponse, SandboxScheduleRunResponse, SandboxReplayInput, SandboxReplayResponse, SandboxReplayListResponse, SandboxReplayLogsResponse, SandboxReplayArtifactsResponse, SandboxPublishedSnapshotBuildLogsResponse, SandboxTemplateBuildLogsResponse, SandboxSmokeOptions, SandboxSmokeSummary, OpenPondSandboxClientOptions, OpenPondSandboxMcpServerConfig, OpenPondSandboxRuntimeHandle } from "./types/index.js";
+export declare class OpenPondSandboxClient extends OpenPondSandboxInstanceClient {
+    readonly runtimes: {
+        list: (input?: {
+            teamId?: string;
+            projectId?: string;
+            agentId?: string;
+        }) => Promise<SandboxRuntime[]>;
+        create: (input: SandboxRuntimeCreateInput) => Promise<SandboxRuntime>;
+        handle: (runtimeId: string, initial?: SandboxRuntime | null) => OpenPondSandboxRuntimeHandle;
+        get: (runtimeId: string) => Promise<SandboxRuntime>;
+        createSandbox: (runtimeId: string, input?: SandboxRuntimeSandboxCreateInput, options?: SandboxAsyncRequestOptions) => Promise<SandboxRuntimeSandboxResponse>;
+        updateStatus: (runtimeId: string, input: SandboxRuntimeTransitionInput) => Promise<SandboxRuntime>;
+        events: (runtimeId: string) => Promise<SandboxRuntimeEventsResponse>;
+        event: (runtimeId: string, input: SandboxRuntimeEventInput) => Promise<SandboxRuntimeEventResponse>;
+        checkpoint: (runtimeId: string, input?: SandboxRuntimeCheckpointInput) => Promise<SandboxRuntime>;
+        promote: (runtimeId: string, input: SandboxRuntimePromoteInput, options?: {
+            teamId?: string;
+        }) => Promise<SandboxRuntimePromoteResponse>;
+        preserveSource: (runtimeId: string, input?: SandboxRuntimeSourcePreserveInput, options?: {
+            teamId?: string;
+        }) => Promise<SandboxRuntimeSourcePreserveResponse>;
+    };
+    readonly sandboxes: {
+        list: (input?: {
+            teamId?: string;
+            projectId?: string;
+            agentId?: string;
+        }) => Promise<SandboxRecord[]>;
+        create: (input: import("src/index.js").SandboxCreateInput) => Promise<SandboxRecord>;
+        get: (sandboxId: string) => Promise<SandboxRecord>;
+        pricing: () => Promise<import("src/index.js").SandboxPricingResponse>;
+        costs: (input?: {
+            teamId?: string;
+            projectId?: string;
+            agentId?: string;
+        }) => Promise<import("src/index.js").SandboxCostSummaryResponse>;
+    };
+    readonly profile: {
+        get(input: {
+            teamId: string;
+        }): Promise<OpenPondHostedProfileSummary | null>;
+        status(input: {
+            teamId: string;
+        }): Promise<OpenPondHostedProfileSummary | null>;
+        ensureHosted(input: {
+            teamId: string;
+        }): Promise<OpenPondHostedProfileSummary>;
+        push(input: OpenPondHostedProfilePushInput): Promise<OpenPondHostedProfilePushResponse>;
+    };
+    readonly projects: {
+        list: (input: {
+            teamId: string;
+        }) => Promise<SandboxProject[]>;
+        upsert: (input: SandboxProjectUpsertInput) => Promise<SandboxProject>;
+        upsertGitRemote: (input: SandboxProjectUpsertInput) => Promise<SandboxProjectGitRemoteResponse>;
+        get: (projectId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxProject>;
+        update: (projectId: string, input: SandboxProjectUpdateInput) => Promise<SandboxProject>;
+        sync: (projectId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxProject>;
+        ensureGitRemote: (projectId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxProjectGitRemoteResponse>;
+        getGitRemote: (projectId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxProjectGitRemoteResponse>;
+        git: (projectId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxProjectGitRemoteResponse>;
+        uploadSource: (projectId: string, input: SandboxProjectSourceUploadInput) => Promise<SandboxProject>;
+        archive: (projectId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxProject>;
+    };
+    readonly agents: {
+        list: (input: {
+            teamId: string;
+        }) => Promise<SandboxAgent[]>;
+        upsert: (input: SandboxAgentUpsertInput) => Promise<SandboxAgent>;
+        get: (agentId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxAgent>;
+        update: (agentId: string, input: SandboxAgentUpdateInput) => Promise<SandboxAgent>;
+        archive: (agentId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxAgent>;
+        run: (agentId: string, input: SandboxAgentRunInput) => Promise<SandboxAgentRunResponse>;
+        sourceDeployPlan: (agentId: string, input: {
+            teamId: string;
+        }) => Promise<SandboxAgentSourceDeployPlan>;
+        manifestSnapshots: (agentId: string, input: {
+            teamId: string;
+            limit?: number;
+        }) => Promise<SandboxAgentManifestSnapshot[]>;
+        requestSourceChecks: (agentId: string, input: SandboxAgentSourceChecksRequestInput) => Promise<SandboxAgentSourceChecksRequestResult>;
+        publishSource: (agentId: string, input: SandboxAgentSourcePublishInput) => Promise<SandboxAgentSourcePublishResult>;
+        openEditWorkItem: (agentId: string, input: SandboxAgentEditWorkItemOpenInput) => Promise<SandboxAgentEditWorkItemOpenResult>;
+    };
+    readonly workItems: {
+        get: (workItemId: string, input: SandboxCodingWorkItemGetInput) => Promise<SandboxCodingWorkItem>;
+        chat: (workItemId: string, input: SandboxCodingWorkItemChatInput) => Promise<SandboxCodingWorkItemChatResult>;
+        activity: (workItemId: string, input: SandboxCodingWorkItemActivityListInput) => Promise<SandboxCodingWorkItemActivity[]>;
+        status: (workItemId: string, input: SandboxCodingWorkItemActivityListInput & {
+            includeArchived?: boolean;
+        }) => Promise<SandboxCodingWorkItemStatusResult>;
+        handleBackground: (workItemId: string, input: SandboxCodingWorkItemBackgroundInput) => Promise<SandboxCodingWorkItemBackgroundResult>;
+        promoteCheckpoint: (workItemId: string, input: SandboxCodingWorkItemPromotionInput) => Promise<SandboxCodingWorkItemArtifact>;
+        promoteCommit: (workItemId: string, input: SandboxCodingWorkItemPromotionInput) => Promise<SandboxCodingWorkItemArtifact>;
+        promotePullRequest: (workItemId: string, input: SandboxCodingWorkItemPromotionInput) => Promise<SandboxCodingWorkItemArtifact>;
+    };
+    list(input?: {
+        teamId?: string;
+        projectId?: string;
+        agentId?: string;
+    }): Promise<SandboxRecord[]>;
+    listSecrets(input?: {
+        teamId?: string;
+    }): Promise<SandboxSecretMetadata[]>;
+    getSecret(secretId: string, input?: {
+        teamId?: string;
+    }): Promise<SandboxSecretMetadata>;
+    createSecret(input: SandboxSecretCreateInput): Promise<SandboxSecretMetadata>;
+    rotateSecret(secretId: string, input: SandboxSecretRotateInput): Promise<SandboxSecretMetadata>;
+    attachSecret(secretId: string, input: SandboxSecretAttachInput): Promise<SandboxSecretMetadata>;
+    revokeSecret(secretId: string, input?: {
+        teamId?: string;
+    }): Promise<SandboxSecretMetadata>;
+    deleteSecret(secretId: string, input?: {
+        teamId?: string;
+    }): Promise<SandboxSecretMetadata>;
+    snapshotCatalog(input?: {
+        teamId?: string;
+        projectId?: string;
+        agentId?: string;
+        q?: string;
+        kind?: "snapshot" | "archive";
+        replayState?: "draft" | "validated" | "published";
+        visibility?: SandboxSnapshotTemplateVisibility;
+        tag?: string;
+        useCase?: string;
+        limit?: number;
+    }): Promise<SandboxSnapshotCatalogResponse>;
+    listSandboxRuntimes(input?: {
+        teamId?: string;
+        projectId?: string;
+        agentId?: string;
+    }): Promise<SandboxRuntime[]>;
+    listProjects(input: {
+        teamId: string;
+    }): Promise<SandboxProject[]>;
+    upsertProject(input: SandboxProjectUpsertInput): Promise<SandboxProject>;
+    getHostedProfile(input: {
+        teamId: string;
+    }): Promise<OpenPondHostedProfileSummary | null>;
+    ensureHostedProfile(input: {
+        teamId: string;
+    }): Promise<OpenPondHostedProfileSummary>;
+    pushHostedProfile(input: OpenPondHostedProfilePushInput): Promise<OpenPondHostedProfilePushResponse>;
+    upsertProjectGitRemote(input: SandboxProjectUpsertInput): Promise<SandboxProjectGitRemoteResponse>;
+    getProject(projectId: string, input: {
+        teamId: string;
+    }): Promise<SandboxProject>;
+    syncProject(projectId: string, input: {
+        teamId: string;
+    }): Promise<SandboxProject>;
+    ensureProjectGitRemote(projectId: string, input: {
+        teamId: string;
+    }): Promise<SandboxProjectGitRemoteResponse>;
+    uploadProjectSource(projectId: string, input: SandboxProjectSourceUploadInput): Promise<SandboxProject>;
+    updateProject(projectId: string, input: SandboxProjectUpdateInput): Promise<SandboxProject>;
+    archiveProject(projectId: string, input: {
+        teamId: string;
+    }): Promise<SandboxProject>;
+    listAgents(input: {
+        teamId: string;
+    }): Promise<SandboxAgent[]>;
+    upsertAgent(input: SandboxAgentUpsertInput): Promise<SandboxAgent>;
+    getAgent(agentId: string, input: {
+        teamId: string;
+    }): Promise<SandboxAgent>;
+    archiveAgent(agentId: string, input: {
+        teamId: string;
+    }): Promise<SandboxAgent>;
+    updateAgent(agentId: string, input: SandboxAgentUpdateInput): Promise<SandboxAgent>;
+    runAgent(agentId: string, input: SandboxAgentRunInput): Promise<SandboxAgentRunResponse>;
+    getAgentSourceDeployPlan(agentId: string, input: {
+        teamId: string;
+    }): Promise<SandboxAgentSourceDeployPlan>;
+    listAgentManifestSnapshots(agentId: string, input: {
+        teamId: string;
+        limit?: number;
+    }): Promise<SandboxAgentManifestSnapshot[]>;
+    requestAgentSourceChecks(agentId: string, input: SandboxAgentSourceChecksRequestInput): Promise<SandboxAgentSourceChecksRequestResult>;
+    publishAgentSource(agentId: string, input: SandboxAgentSourcePublishInput): Promise<SandboxAgentSourcePublishResult>;
+    openAgentEditWorkItem(agentId: string, input: SandboxAgentEditWorkItemOpenInput): Promise<SandboxAgentEditWorkItemOpenResult>;
+    getCodingWorkItem(workItemId: string, input: SandboxCodingWorkItemGetInput): Promise<SandboxCodingWorkItem>;
+    sendCodingWorkItemChat(workItemId: string, input: SandboxCodingWorkItemChatInput): Promise<SandboxCodingWorkItemChatResult>;
+    listCodingWorkItemActivity(workItemId: string, input: SandboxCodingWorkItemActivityListInput): Promise<SandboxCodingWorkItemActivity[]>;
+    getCodingWorkItemStatus(workItemId: string, input: SandboxCodingWorkItemActivityListInput & {
+        includeArchived?: boolean;
+    }): Promise<SandboxCodingWorkItemStatusResult>;
+    handleCodingWorkItemInBackground(workItemId: string, input: SandboxCodingWorkItemBackgroundInput): Promise<SandboxCodingWorkItemBackgroundResult>;
+    promoteCodingWorkItemResult(workItemId: string, action: "checkpoint" | "commit" | "pr", input: SandboxCodingWorkItemPromotionInput): Promise<SandboxCodingWorkItemArtifact>;
+    getMicrosoftTeamsBotOverview(input: {
+        teamId: string;
+    }): Promise<MicrosoftTeamsBotOverview>;
+    bindMicrosoftTeamsBotConversation(input: MicrosoftTeamsBotBindingTargetInput & {
+        token: string;
+    }): Promise<MicrosoftTeamsBotBindingResponse>;
+    rebindMicrosoftTeamsBotConversation(bindingId: string, input: MicrosoftTeamsBotBindingTargetInput): Promise<MicrosoftTeamsBotBindingResponse>;
+    unlinkMicrosoftTeamsBotConversation(input: {
+        teamId: string;
+        bindingId: string;
+    }): Promise<MicrosoftTeamsBotBindingResponse>;
+    sendMicrosoftTeamsBotDiagnostic(input: {
+        teamId: string;
+        bindingId: string;
+    }): Promise<MicrosoftTeamsBotBindingResponse & {
+        diagnosticStatus: string;
+    }>;
+    sendMicrosoftTeamsBotDiagnosticRun(input: MicrosoftTeamsBotDiagnosticRunInput): Promise<MicrosoftTeamsBotDiagnosticRunResponse>;
+    createSandboxRuntime(input: SandboxRuntimeCreateInput): Promise<SandboxRuntime>;
+    sandboxRuntime(runtimeId: string, initial?: SandboxRuntime | null): OpenPondSandboxRuntimeHandle;
+    getSandboxRuntime(runtimeId: string): Promise<SandboxRuntime>;
+    createSandboxRuntimeSandbox(runtimeId: string, input?: SandboxRuntimeSandboxCreateInput, options?: SandboxAsyncRequestOptions): Promise<SandboxRuntimeSandboxResponse>;
+    updateSandboxRuntimeStatus(runtimeId: string, input: SandboxRuntimeTransitionInput): Promise<SandboxRuntime>;
+    listSandboxRuntimeEvents(runtimeId: string): Promise<SandboxRuntimeEventsResponse>;
+    emitSandboxRuntimeEvent(runtimeId: string, input: SandboxRuntimeEventInput): Promise<SandboxRuntimeEventResponse>;
+    checkpointSandboxRuntime(runtimeId: string, input: SandboxRuntimeCheckpointInput): Promise<SandboxRuntime>;
+    promoteSandboxRuntime(runtimeId: string, input: SandboxRuntimePromoteInput, options?: {
+        teamId?: string;
+    }): Promise<SandboxRuntimePromoteResponse>;
+    preserveSandboxRuntimeSource(runtimeId: string, input?: SandboxRuntimeSourcePreserveInput, options?: {
+        teamId?: string;
+    }): Promise<SandboxRuntimeSourcePreserveResponse>;
+    forkSnapshot(snapshotId: string, input?: SandboxForkInput & {
+        teamId?: string;
+        projectId?: string;
+    }, options?: SandboxForkOptions): Promise<SandboxForkResponse>;
+    templates(input?: {
+        teamId?: string;
+        projectId?: string;
+        q?: string;
+        name?: string;
+        version?: string;
+        visibility?: SandboxSnapshotTemplateVisibility;
+        tag?: string;
+        useCase?: string;
+        limit?: number;
+    }): Promise<SandboxTemplateCatalogResponse>;
+    publishedSnapshots(input?: {
+        teamId?: string;
+        projectId?: string;
+        q?: string;
+        name?: string;
+        version?: string;
+        visibility?: SandboxSnapshotTemplateVisibility;
+        tag?: string;
+        useCase?: string;
+        limit?: number;
+    }): Promise<SandboxPublishedSnapshotCatalogResponse>;
+    launchTemplate(input: SandboxTemplateLaunchInput & {
+        teamId?: string;
+        projectId?: string;
+    }): Promise<SandboxTemplateLaunchResponse>;
+    runPublishedSnapshot(input: SandboxTemplateLaunchInput & {
+        teamId?: string;
+        projectId?: string;
+    }): Promise<SandboxPublishedSnapshotLaunchResponse>;
+    listSchedules(input?: {
+        teamId?: string;
+        projectId?: string;
+        sourceSandboxId?: string;
+    }): Promise<SandboxScheduleListResponse>;
+    createSchedule(input: SandboxScheduleCreateInput): Promise<SandboxScheduleResponse>;
+    getSchedule(scheduleId: string): Promise<SandboxScheduleResponse>;
+    updateSchedule(scheduleId: string, input: SandboxScheduleUpdateInput): Promise<SandboxScheduleResponse>;
+    deleteSchedule(scheduleId: string): Promise<SandboxScheduleResponse>;
+    listScheduleRuns(scheduleId: string, input?: {
+        limit?: number;
+    }): Promise<SandboxScheduleRunListResponse>;
+    runScheduleNow(scheduleId: string, input?: {
+        idempotencyKey?: string;
+    }): Promise<SandboxScheduleRunResponse>;
+    listTemplateBuilds(input: {
+        teamId: string;
+    }): Promise<SandboxTemplateBuildRecord[]>;
+    createTemplateBuild(input: SandboxTemplateBuildCreateInput): Promise<SandboxTemplateBuildRecord>;
+    getTemplateBuild(buildId: string): Promise<SandboxTemplateBuildRecord>;
+    getTemplateBuildLogs(buildId: string): Promise<SandboxTemplateBuildLogsResponse>;
+    cancelTemplateBuild(buildId: string): Promise<SandboxTemplateBuildRecord>;
+    listPublishedSnapshotBuilds(input: {
+        teamId: string;
+    }): Promise<SandboxPublishedSnapshotBuildRecord[]>;
+    createPublishedSnapshotBuild(input: SandboxPublishedSnapshotBuildCreateInput): Promise<SandboxPublishedSnapshotBuildRecord>;
+    getPublishedSnapshotBuild(buildId: string): Promise<SandboxPublishedSnapshotBuildRecord>;
+    getPublishedSnapshotBuildLogs(buildId: string): Promise<SandboxPublishedSnapshotBuildLogsResponse>;
+    cancelPublishedSnapshotBuild(buildId: string): Promise<SandboxPublishedSnapshotBuildRecord>;
+    listOrganizations(): Promise<OpenPondOrganization[]>;
+    createOrganization(input: OpenPondOrganizationCreateInput): Promise<OpenPondOrganization>;
+    getOrganization(slug: string): Promise<OpenPondOrganization>;
+    updateOrganization(slug: string, input: OpenPondOrganizationUpdateInput): Promise<OpenPondOrganization>;
+    listOrganizationMembers(slug: string): Promise<OpenPondOrganizationMember[]>;
+    upsertOrganizationMember(slug: string, input: OpenPondOrganizationMemberUpsertInput): Promise<OpenPondOrganizationMember>;
+    getOrganizationMcpServer(slug: string): Promise<OpenPondOrganizationMcpServer | null>;
+    generateOrganizationMcpServer(slug: string, input?: OpenPondOrganizationMcpGenerateInput): Promise<OpenPondOrganizationMcpServer | null>;
+    rotateOrganizationMcpServer(slug: string): Promise<OpenPondOrganizationMcpServer | null>;
+    disableOrganizationMcpServer(slug: string): Promise<OpenPondOrganizationMcpServer | null>;
+    enableOrganizationMcpServer(slug: string): Promise<OpenPondOrganizationMcpServer | null>;
+    startReplay(input: SandboxReplayInput & {
+        teamId?: string;
+        projectId?: string;
+    }): Promise<SandboxReplayResponse>;
+    listReplays(input?: {
+        teamId?: string;
+        projectId?: string;
+    }): Promise<SandboxReplayListResponse>;
+    getReplay(replayId: string, input?: {
+        teamId?: string;
+        projectId?: string;
+    }): Promise<SandboxReplayResponse>;
+    getReplayLogs(replayId: string, input?: {
+        teamId?: string;
+        projectId?: string;
+    }): Promise<SandboxReplayLogsResponse>;
+    getReplayArtifacts(replayId: string, input?: {
+        teamId?: string;
+        projectId?: string;
+    }): Promise<SandboxReplayArtifactsResponse>;
+    cancelReplay(replayId: string, input?: {
+        teamId?: string;
+        projectId?: string;
+    }): Promise<SandboxReplayResponse>;
+    integrationConnections(input?: {
+        teamId?: string;
+        projectId?: string;
+        agentId?: string;
+        status?: SandboxIntegrationConnectionStatusFilter;
+    }): Promise<SandboxIntegrationConnectionsResponse>;
+    mcpServerConfig(): OpenPondSandboxMcpServerConfig;
+    smoke(options?: SandboxSmokeOptions): Promise<SandboxSmokeSummary>;
+}
+export declare function createOpenPondSandboxClient(options: OpenPondSandboxClientOptions): OpenPondSandboxClient;
+export { normalizeSandboxApiUrl } from "./url.js";

package/dist/sandbox/runtime-handle.d.ts

@@ -0,0 +1,36 @@
+import type { OpenPondSandboxRuntimeHandle, SandboxExecInput, SandboxFileDownloadInput, SandboxFileListInput, SandboxFileMkdirInput, SandboxFileMoveInput, SandboxFileSearchInput, SandboxOpenPortInput, SandboxRecord, SandboxRuntime, SandboxRuntimeCheckpointInput, SandboxRuntimeEventInput, SandboxRuntimePromoteInput, SandboxRuntimePromoteResponse, SandboxRuntimeSourcePreserveInput, SandboxRuntimeSourcePreserveResponse, SandboxRuntimeSandboxCreateInput, SandboxRuntimeSandboxResponse, SandboxRuntimeTransitionInput, SandboxRuntimeEventsResponse, SandboxRuntimeEventResponse, SandboxAsyncRequestOptions, SandboxFileUploadResponse, SandboxFileDownloadResponse, SandboxFileDeleteResponse, SandboxFileListResponse, SandboxFileMkdirResponse, SandboxFileMoveResponse, SandboxFileStatResponse, SandboxFileSearchResponse, SandboxOpenPortResponse, SandboxExecResponse } from "./types/index.js";
+export type SandboxRuntimeHandleClient = {
+    getSandboxRuntime(runtimeId: string): Promise<SandboxRuntime>;
+    createSandboxRuntimeSandbox(runtimeId: string, input?: SandboxRuntimeSandboxCreateInput, options?: SandboxAsyncRequestOptions): Promise<SandboxRuntimeSandboxResponse>;
+    updateSandboxRuntimeStatus(runtimeId: string, input: SandboxRuntimeTransitionInput): Promise<SandboxRuntime>;
+    listSandboxRuntimeEvents(runtimeId: string): Promise<SandboxRuntimeEventsResponse>;
+    emitSandboxRuntimeEvent(runtimeId: string, input: SandboxRuntimeEventInput): Promise<SandboxRuntimeEventResponse>;
+    checkpointSandboxRuntime(runtimeId: string, input: SandboxRuntimeCheckpointInput): Promise<SandboxRuntime>;
+    promoteSandboxRuntime(runtimeId: string, input: SandboxRuntimePromoteInput, options?: {
+        teamId?: string;
+    }): Promise<SandboxRuntimePromoteResponse>;
+    preserveSandboxRuntimeSource(runtimeId: string, input?: SandboxRuntimeSourcePreserveInput, options?: {
+        teamId?: string;
+    }): Promise<SandboxRuntimeSourcePreserveResponse>;
+    get(sandboxId: string): Promise<SandboxRecord>;
+    start(sandboxId: string, options?: SandboxAsyncRequestOptions): Promise<{
+        sandbox: SandboxRecord;
+    }>;
+    restore(sandboxId: string): Promise<{
+        sandbox: SandboxRecord;
+    }>;
+    uploadFile(sandboxId: string, path: string, contents: string): Promise<SandboxFileUploadResponse>;
+    downloadFile(sandboxId: string, path: string): Promise<string>;
+    downloadFileResponse(sandboxId: string, input: string | SandboxFileDownloadInput): Promise<SandboxFileDownloadResponse>;
+    listFiles(sandboxId: string, input?: SandboxFileListInput): Promise<SandboxFileListResponse>;
+    deleteFile(sandboxId: string, path: string, input?: {
+        recursive?: boolean;
+    }): Promise<SandboxFileDeleteResponse>;
+    searchFiles(sandboxId: string, input: SandboxFileSearchInput): Promise<SandboxFileSearchResponse>;
+    statFile(sandboxId: string, path: string): Promise<SandboxFileStatResponse>;
+    mkdir(sandboxId: string, input: string | SandboxFileMkdirInput): Promise<SandboxFileMkdirResponse>;
+    moveFile(sandboxId: string, input: SandboxFileMoveInput): Promise<SandboxFileMoveResponse>;
+    exec(sandboxId: string, input: SandboxExecInput): Promise<SandboxExecResponse>;
+    openPort(sandboxId: string, input: SandboxOpenPortInput): Promise<SandboxOpenPortResponse>;
+};
+export declare function createSandboxRuntimeHandle(client: SandboxRuntimeHandleClient, runtimeId: string, initial?: SandboxRuntime | null): OpenPondSandboxRuntimeHandle;

package/dist/sandbox/sandbox-instance-client.d.ts

@@ -0,0 +1,72 @@
+import type { SandboxIntegrationConnectionLeaseInput, SandboxCreateInput, SandboxCreateOptions, SandboxAsyncRequestOptions, SandboxForkInput, SandboxExecInput, SandboxProcessStartInput, SandboxPtyStartInput, SandboxPtyInput, SandboxOpenPortInput, SandboxGitDiffInput, SandboxGitPatchExportInput, SandboxGitBranchInput, SandboxGitCommitInput, SandboxGitPullInput, SandboxGitPushInput, SandboxFileDownloadInput, SandboxFileListInput, SandboxFileMkdirInput, SandboxFileMoveInput, SandboxFileSearchInput, SandboxReceipt, SandboxSnapshotValidateInput, SandboxSnapshotUpdateInput, SandboxSnapshotInput, SandboxRecord, SandboxIntegrationLeasesResponse, SandboxExecResponse, SandboxProcessStartResponse, SandboxProcessListResponse, SandboxProcessStatusResponse, SandboxProcessStopResponse, SandboxPtyStartResponse, SandboxPtyListResponse, SandboxPtyStatusResponse, SandboxPtyInputResponse, SandboxPtyStopResponse, SandboxOpenPortResponse, SandboxSnapshotResponse, SandboxSnapshotValidationResponse, SandboxForkResponse, SandboxReceiptResponse, SandboxLifecycleAcceptedResponse, SandboxStartResponse, SandboxRestoreResponse, SandboxGitStatusResponse, SandboxGitDiffResponse, SandboxGitPatchExportResponse, SandboxGitBranchResponse, SandboxGitCommitResponse, SandboxGitPullResponse, SandboxGitPushResponse, SandboxFileUploadResponse, SandboxFileDownloadResponse, SandboxFileListResponse, SandboxFileDeleteResponse, SandboxFileMkdirResponse, SandboxFileMoveResponse, SandboxFileStatResponse, SandboxFileSearchResponse, SandboxBillingStatusResponse, SandboxPricingResponse, SandboxCostSummaryResponse, OpenPondSandboxClientOptions } from "./types/index.js";
+export declare class OpenPondSandboxInstanceClient {
+    protected readonly apiKey: string;
+    private readonly apiRootUrl;
+    protected readonly sandboxApiUrl: string;
+    constructor(options: OpenPondSandboxClientOptions);
+    create(input: SandboxCreateInput, options?: SandboxCreateOptions): Promise<SandboxRecord>;
+    get(sandboxId: string): Promise<SandboxRecord>;
+    exec(sandboxId: string, input: SandboxExecInput): Promise<SandboxExecResponse>;
+    startProcess(sandboxId: string, input: SandboxProcessStartInput): Promise<SandboxProcessStartResponse>;
+    listProcesses(sandboxId: string): Promise<SandboxProcessListResponse>;
+    getProcess(sandboxId: string, processId: string, input?: {
+        since?: number;
+    }): Promise<SandboxProcessStatusResponse>;
+    stopProcess(sandboxId: string, processId: string): Promise<SandboxProcessStopResponse>;
+    streamProcessOutput(sandboxId: string, processId: string, input?: {
+        since?: number;
+    }): Promise<void>;
+    startPty(sandboxId: string, input?: SandboxPtyStartInput): Promise<SandboxPtyStartResponse>;
+    listPtys(sandboxId: string): Promise<SandboxPtyListResponse>;
+    getPty(sandboxId: string, ptyId: string, input?: {
+        since?: number;
+    }): Promise<SandboxPtyStatusResponse>;
+    writePtyInput(sandboxId: string, ptyId: string, input: string | Uint8Array | SandboxPtyInput): Promise<SandboxPtyInputResponse>;
+    stopPty(sandboxId: string, ptyId: string): Promise<SandboxPtyStopResponse>;
+    streamPtyOutput(sandboxId: string, ptyId: string, input?: {
+        since?: number;
+    }): Promise<void>;
+    uploadFile(sandboxId: string, path: string, contents: string): Promise<SandboxFileUploadResponse>;
+    uploadFileBase64(sandboxId: string, path: string, contentsBase64: string): Promise<SandboxFileUploadResponse>;
+    downloadFile(sandboxId: string, path: string): Promise<string>;
+    downloadFileResponse(sandboxId: string, input: string | SandboxFileDownloadInput): Promise<SandboxFileDownloadResponse>;
+    listFiles(sandboxId: string, input?: SandboxFileListInput): Promise<SandboxFileListResponse>;
+    deleteFile(sandboxId: string, path: string, input?: {
+        recursive?: boolean;
+    }): Promise<SandboxFileDeleteResponse>;
+    statFile(sandboxId: string, path: string): Promise<SandboxFileStatResponse>;
+    mkdir(sandboxId: string, input: string | SandboxFileMkdirInput): Promise<SandboxFileMkdirResponse>;
+    moveFile(sandboxId: string, input: SandboxFileMoveInput): Promise<SandboxFileMoveResponse>;
+    searchFiles(sandboxId: string, input: SandboxFileSearchInput): Promise<SandboxFileSearchResponse>;
+    openPort(sandboxId: string, input: SandboxOpenPortInput): Promise<SandboxOpenPortResponse>;
+    createSnapshot(sandboxId: string, input: SandboxSnapshotInput): Promise<SandboxSnapshotResponse>;
+    updateSnapshot(sandboxId: string, snapshotId: string, input: SandboxSnapshotUpdateInput): Promise<SandboxSnapshotResponse>;
+    validateSnapshot(sandboxId: string, snapshotId: string, input?: SandboxSnapshotValidateInput): Promise<SandboxSnapshotValidationResponse>;
+    publishSnapshot(sandboxId: string, snapshotId: string): Promise<SandboxSnapshotResponse>;
+    fork(sandboxId: string, input?: SandboxForkInput): Promise<SandboxForkResponse>;
+    stop(sandboxId: string, options?: SandboxAsyncRequestOptions): Promise<SandboxReceiptResponse | SandboxLifecycleAcceptedResponse>;
+    start(sandboxId: string, options?: SandboxAsyncRequestOptions): Promise<SandboxStartResponse>;
+    restore(sandboxId: string): Promise<SandboxRestoreResponse>;
+    delete(sandboxId: string, options?: SandboxAsyncRequestOptions): Promise<SandboxRecord>;
+    receipts(sandboxId: string): Promise<SandboxReceipt[]>;
+    logs(sandboxId: string): Promise<string[]>;
+    gitStatus(sandboxId: string): Promise<SandboxGitStatusResponse>;
+    gitDiff(sandboxId: string, input?: SandboxGitDiffInput): Promise<SandboxGitDiffResponse>;
+    gitExportPatch(sandboxId: string, input?: SandboxGitPatchExportInput): Promise<SandboxGitPatchExportResponse>;
+    gitBranch(sandboxId: string, input: SandboxGitBranchInput): Promise<SandboxGitBranchResponse>;
+    gitCommit(sandboxId: string, input: SandboxGitCommitInput): Promise<SandboxGitCommitResponse>;
+    gitPull(sandboxId: string, input?: SandboxGitPullInput): Promise<SandboxGitPullResponse>;
+    gitPush(sandboxId: string, input?: SandboxGitPushInput): Promise<SandboxGitPushResponse>;
+    billing(sandboxId: string): Promise<SandboxBillingStatusResponse>;
+    pricing(): Promise<SandboxPricingResponse>;
+    costs(input?: {
+        teamId?: string;
+        projectId?: string;
+        agentId?: string;
+    }): Promise<SandboxCostSummaryResponse>;
+    integrationLeases(sandboxId: string): Promise<SandboxIntegrationLeasesResponse>;
+    attachIntegrationConnection(sandboxId: string, input: SandboxIntegrationConnectionLeaseInput): Promise<SandboxIntegrationLeasesResponse>;
+    removeIntegrationLease(sandboxId: string, leaseId: string): Promise<SandboxIntegrationLeasesResponse>;
+    protected request<T>(path: string, init?: RequestInit): Promise<T>;
+    protected requestApiRoot<T>(path: string, init?: RequestInit): Promise<T>;
+}

package/dist/sandbox/smoke.d.ts

@@ -0,0 +1,3 @@
+import type { OpenPondSandboxClient } from "./client.js";
+import type { SandboxSmokeOptions, SandboxSmokeSummary } from "./types/index.js";
+export declare function runSandboxSmoke(client: OpenPondSandboxClient, options?: SandboxSmokeOptions): Promise<SandboxSmokeSummary>;

package/dist/sandbox/stream.d.ts

@@ -0,0 +1,7 @@
+import type { SandboxPtyInput } from "./types/index.js";
+export declare function streamSandboxEventOutput(params: {
+    sandboxApiUrl: string;
+    apiKey: string;
+    path: string;
+}): Promise<void>;
+export declare function normalizePtyInput(input: string | Uint8Array | SandboxPtyInput): SandboxPtyInput;

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

@@ -0,0 +1,176 @@
+import type { SandboxPreviewAccess, SandboxPreviewAuthPolicy, SandboxPreviewCorsPolicy, SandboxPreviewHeaderPolicy, SandboxResources, SandboxState } from "./index.js";
+export type SandboxPricingRate = {
+    key: "cpu" | "memory" | "disk" | "durable_volume_storage";
+    label: string;
+    unit: string;
+    unitPriceUsd: string;
+    unitPriceHourlyUsd: string;
+    unitPriceMonthlyUsd: string | null;
+};
+export type SandboxPublicResourceTierKey = "tiny" | "small" | "default" | "builder" | "heavy-builder";
+export type SandboxKeepRunningEstimateLineItem = {
+    label: string;
+    quantity: number;
+    unit: string;
+    hourlyUsd: string;
+    monthlyUsd: string;
+};
+export type SandboxKeepRunningEstimate = {
+    resources: SandboxResources;
+    matchedTierKey: SandboxPublicResourceTierKey | null;
+    hourlyUsd: string;
+    monthlyUsd: string;
+    durationDays: number;
+    pricingSource: "openpond_poc_config";
+    lineItems: SandboxKeepRunningEstimateLineItem[];
+};
+export type SandboxPublicResourceTier = {
+    key: SandboxPublicResourceTierKey;
+    label: string;
+    description: string;
+    resources: SandboxResources;
+    goodFit: string[];
+    poorFit: string[];
+    keepRunningEstimate: SandboxKeepRunningEstimate;
+};
+export type SandboxPricingRateCard = {
+    currency: "USD";
+    source: "openpond_poc_config";
+    effectiveAt: string;
+    rates: SandboxPricingRate[];
+    tiers: SandboxPublicResourceTier[];
+};
+export type SandboxCostLineItemSummary = {
+    label: string;
+    unit: string;
+    quantity: number;
+    amountUsd: string;
+};
+export type SandboxCostSandboxSummary = {
+    sandboxId: string;
+    state: SandboxState;
+    repo: string | null;
+    createdAt: string;
+    updatedAt: string;
+    receiptCount: number;
+    totalUsd: string;
+    durationSeconds: number;
+    latestReceiptRef: string | null;
+    latestReceiptAt: string | null;
+};
+export type SandboxCostSummary = {
+    teamId: string;
+    ownerUserId: string;
+    pricing: SandboxPricingRateCard;
+    summary: {
+        sandboxCount: number;
+        runningCount: number;
+        stoppedCount: number;
+        archivedCount: number;
+        receiptCount: number;
+        totalUsd: string;
+        totalDurationSeconds: number;
+        activeReservedUsd: string;
+        activeRemainingBudgetUsd: string;
+        activeRunnerSlots: number;
+    };
+    lineItems: SandboxCostLineItemSummary[];
+    sandboxes: SandboxCostSandboxSummary[];
+    recentReceipts: SandboxReceipt[];
+    generatedAt: string;
+};
+export type SandboxBillingStatus = {
+    sandboxId: string;
+    state: SandboxState;
+    billingModel: "reserve_capture" | "session";
+    reservationStatus: SandboxReservation["status"];
+    budgetUsd: string;
+    reservedUsd: string;
+    capturedUsd: string;
+    remainingBudgetUsd: string;
+    mppMode: NonNullable<SandboxReservation["mpp"]>["mode"] | null;
+    sessionRef: string | null;
+    channelId: string | null;
+    depositUsd: string | null;
+    acceptedCumulativeUsd: string | null;
+    remainingSessionUsd: string | null;
+    tickCount: number;
+    lastTickAt: string | null;
+    finalizedAt: string | null;
+    lastReceiptRef: string | null;
+    keepRunningEstimate?: SandboxKeepRunningEstimate;
+};
+export type SandboxReservation = {
+    id: string;
+    status: "reserved" | "captured" | "released";
+    reservedUsd: string;
+    capturedUsd: string;
+    mpp?: {
+        mode: "simulated_poc" | "mpp_service_hook" | "mpp_session_hook";
+        settlementRail: "tempo_usdce";
+        reservationRef: string;
+        sessionRef?: string | null;
+        channelId?: string | null;
+        depositUsd?: string | null;
+        acceptedCumulativeUsd?: string | null;
+        remainingUsd?: string | null;
+        tickCount?: number;
+        lastTickAt?: string | null;
+        finalizedAt?: string | null;
+        lastReceiptRef?: string | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+};
+export type SandboxReceiptLineItem = {
+    label: string;
+    quantity: number;
+    unit: string;
+    unitPriceUsd: string;
+    amountUsd: string;
+};
+export type SandboxReceipt = {
+    id: string;
+    sandboxId: string;
+    reservationId: string;
+    status: "captured" | "released";
+    reason: "stopped" | "deleted" | "archived" | "budget_exhausted" | "duration_exceeded" | "idle_timeout" | "manual_capture";
+    totalUsd: string;
+    durationSeconds: number;
+    lineItems: SandboxReceiptLineItem[];
+    mpp: {
+        mode: "simulated_poc" | "mpp_service_hook" | "mpp_session_hook";
+        settlementRail: "tempo_usdce";
+        receiptRef: string;
+        sessionRef?: string | null;
+        channelId?: string | null;
+        acceptedCumulativeUsd?: string | null;
+        depositUsd?: string | null;
+        remainingUsd?: string | null;
+    };
+    createdAt: string;
+};
+export type SandboxCommand = {
+    id: string;
+    command: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "skipped";
+    output: string;
+    exitCode: number | null;
+    startedAt: string;
+    completedAt: string | null;
+};
+export type SandboxPreviewPort = {
+    id: string;
+    port: number;
+    label: string | null;
+    url: string;
+    targetUrl?: string | null;
+    customDomain?: string | null;
+    access: SandboxPreviewAccess;
+    autoStart?: boolean;
+    cors?: SandboxPreviewCorsPolicy;
+    headerPolicy?: SandboxPreviewHeaderPolicy;
+    authPolicy?: SandboxPreviewAuthPolicy;
+    token: string;
+    createdAt: string;
+};