openpond 0.0.30-bootstrap.0

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

@@ -0,0 +1,103 @@
+import type { SandboxExecInput, SandboxExecResponse, SandboxFileDeleteResponse, SandboxFileDownloadInput, SandboxFileDownloadResponse, SandboxFileListInput, SandboxFileListResponse, SandboxFileMkdirInput, SandboxFileMkdirResponse, SandboxFileMoveInput, SandboxFileMoveResponse, SandboxFileSearchInput, SandboxFileSearchResponse, SandboxFileStatResponse, SandboxFileUploadResponse, SandboxOpenPortInput, SandboxOpenPortResponse, SandboxRecord, SandboxReservation, SandboxRuntime, SandboxRuntimeCheckpointInput, SandboxRuntimeDriver, SandboxRuntimeEventInput, SandboxRuntimeEventResponse, SandboxRuntimeEventsResponse, SandboxRuntimePromoteInput, SandboxRuntimePromoteResponse, SandboxRuntimeSourcePreserveInput, SandboxRuntimeSourcePreserveResponse, SandboxRuntimeSandboxCreateInput, SandboxRuntimeSandboxResponse, SandboxRuntimeTransitionInput, SandboxState, SandboxAsyncRequestOptions } from "./index.js";
+export type SandboxSmokeOptions = {
+    repo?: string;
+    budgetUsd?: string;
+    cpu?: number;
+    memoryGb?: number;
+    diskGb?: number;
+    keep?: boolean;
+    preview?: boolean;
+    snapshot?: boolean;
+    fork?: boolean;
+    expectedRuntimeDriver?: SandboxRuntimeDriver;
+    expectedMppMode?: NonNullable<SandboxReservation["mpp"]>["mode"];
+};
+export type SandboxSmokeSummary = {
+    deleted: boolean;
+    execOutput: string;
+    fileRoundtrip: boolean;
+    forkSandboxId: string | null;
+    previewStatus: number | null;
+    receiptRefs: Array<string | null>;
+    reservationRef: string | null;
+    runId: string;
+    sandboxId: string;
+    snapshotId: string | null;
+    state: SandboxState;
+};
+export type OpenPondSandboxClientOptions = {
+    baseUrl?: string;
+    sandboxApiUrl?: string;
+    apiKey: string;
+};
+export type OpenPondSandboxMcpServerConfig = {
+    name: "openpond-sandboxes";
+    transport: "streamable-http";
+    url: string;
+    headers: Record<string, string>;
+};
+export type OpenPondRuntimeFilesHandle = {
+    write(path: string, contents: string): Promise<SandboxFileUploadResponse>;
+    read(path: string): Promise<string>;
+    readResponse(input: string | SandboxFileDownloadInput): Promise<SandboxFileDownloadResponse>;
+    list(input?: SandboxFileListInput): Promise<SandboxFileListResponse>;
+    delete(path: string, input?: {
+        recursive?: boolean;
+    }): Promise<SandboxFileDeleteResponse>;
+    search(input: SandboxFileSearchInput): Promise<SandboxFileSearchResponse>;
+    stat(path: string): Promise<SandboxFileStatResponse>;
+    mkdir(input: string | SandboxFileMkdirInput): Promise<SandboxFileMkdirResponse>;
+    move(input: SandboxFileMoveInput): Promise<SandboxFileMoveResponse>;
+};
+export type OpenPondRuntimeCommandsHandle = {
+    run(command: string | SandboxExecInput): Promise<SandboxExecResponse>;
+};
+export type OpenPondRuntimePortsHandle = {
+    expose(port: number | SandboxOpenPortInput): Promise<SandboxOpenPortResponse>;
+};
+export type RuntimeWorkflowCheckpointHintInput = {
+    reason?: string;
+    summary?: string | null;
+    payload?: Record<string, unknown>;
+    artifactRefs?: string[];
+};
+export type RuntimeWorkflowWaitForUserInput = {
+    reason?: string;
+    summary?: string | null;
+    payload?: Record<string, unknown>;
+};
+export type RuntimeWorkflowKeepAliveInput = {
+    reason?: string;
+    summary?: string | null;
+    payload?: Record<string, unknown>;
+    until?: string | Date;
+    seconds?: number;
+};
+export type OpenPondSandboxRuntimeHandle = {
+    id: string;
+    initial: SandboxRuntime | null;
+    get(): Promise<SandboxRuntime>;
+    sandbox(input?: SandboxRuntimeSandboxCreateInput, options?: SandboxAsyncRequestOptions): Promise<SandboxRecord>;
+    resume(input?: SandboxRuntimeSandboxCreateInput, options?: SandboxAsyncRequestOptions): Promise<SandboxRecord>;
+    createSandbox(input?: SandboxRuntimeSandboxCreateInput, options?: SandboxAsyncRequestOptions): Promise<SandboxRuntimeSandboxResponse>;
+    status(input: SandboxRuntimeTransitionInput | SandboxRuntime["status"]): Promise<SandboxRuntime>;
+    events(): Promise<SandboxRuntimeEventsResponse>;
+    event(input: SandboxRuntimeEventInput): Promise<SandboxRuntimeEventResponse>;
+    recordCommit(commitSha: string, input?: Omit<SandboxRuntimeEventInput, "commitSha" | "type"> & {
+        type?: string;
+    }): Promise<SandboxRuntimeEventResponse>;
+    checkpointHint(input?: RuntimeWorkflowCheckpointHintInput): Promise<SandboxRuntimeEventResponse>;
+    waitForUser(input?: RuntimeWorkflowWaitForUserInput): Promise<SandboxRuntime>;
+    keepAlive(input?: RuntimeWorkflowKeepAliveInput): Promise<SandboxRuntimeEventResponse>;
+    checkpoint(input: SandboxRuntimeCheckpointInput): Promise<SandboxRuntime>;
+    files: OpenPondRuntimeFilesHandle;
+    commands: OpenPondRuntimeCommandsHandle;
+    ports: OpenPondRuntimePortsHandle;
+    promote(input: SandboxRuntimePromoteInput, options?: {
+        teamId?: string;
+    }): Promise<SandboxRuntimePromoteResponse>;
+    preserveSource(input?: SandboxRuntimeSourcePreserveInput, options?: {
+        teamId?: string;
+    }): Promise<SandboxRuntimeSourcePreserveResponse>;
+    archive(expectedVersion?: number): Promise<SandboxRuntime>;
+};

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

@@ -0,0 +1,140 @@
+export type SandboxState = "creating" | "running" | "stopped" | "archived" | "deleted" | "error";
+export type SandboxRuntimeDriver = "simulated-firecracker" | "remote-firecracker";
+export type SandboxResources = {
+    cpu: number;
+    memoryGb: number;
+    diskGb: number;
+};
+export type SandboxBudget = {
+    maxUsd: string;
+};
+export type SandboxEnvVarInput = {
+    name: string;
+    value?: string;
+    secretRef?: string;
+};
+export type SandboxQuotaPolicy = {
+    maxDurationSeconds: number;
+    idleTimeoutSeconds: number;
+    maxCommands: number;
+    maxOpenPorts: number;
+    maxSnapshots: number;
+    maxSpendUsd: string;
+};
+export type SandboxVolumeProvisionInput = {
+    name?: string;
+    mountPath?: string;
+    storageGb?: number;
+    deleteOnSandboxDelete?: boolean;
+};
+export type SandboxIntegrationProvider = "google" | "github" | "x";
+export type SandboxIntegrationConnectionStatus = "active" | "revoked" | "error";
+export type SandboxIntegrationConnectionStatusFilter = SandboxIntegrationConnectionStatus | "all";
+export type SandboxIntegrationConnection = {
+    id: string;
+    provider: SandboxIntegrationProvider;
+    ownerUserId: string;
+    teamId: string;
+    providerAccountId: string;
+    providerAccountName: string | null;
+    providerWorkspaceId: string | null;
+    providerWorkspaceName: string | null;
+    scopes: string[];
+    status: SandboxIntegrationConnectionStatus;
+    connectedAt: string;
+    lastRefreshedAt: string | null;
+    revokedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type SandboxIntegrationLeaseInput = {
+    leaseId: string;
+    provider: SandboxIntegrationProvider;
+    scopes?: string[];
+    capabilities?: string[];
+    resourcePolicy?: Record<string, unknown>;
+    expiresAt?: string;
+    proxyUrl?: string;
+    required?: boolean;
+};
+export type SandboxIntegrationConnectionLeaseInput = {
+    connectionId: string;
+    scopes?: string[];
+    capabilities: string[];
+    resourcePolicy?: Record<string, unknown>;
+    expiresAt?: string;
+    ttlSeconds?: number;
+    required?: boolean;
+};
+export type SandboxIntegrationLeaseRef = {
+    leaseId: string;
+    provider: SandboxIntegrationProvider;
+    scopes: string[];
+    capabilities: string[];
+    resourcePolicy: Record<string, unknown>;
+    expiresAt: string | null;
+    proxyUrl: string | null;
+    required: boolean;
+};
+export type SandboxRuntimeImageSourceInput = {
+    ref: string;
+    digest?: string;
+    registrySecretRef?: string;
+    platform?: "linux/amd64";
+    workspaceRoot?: string;
+};
+export type SandboxRuntimeDockerfileSourceInput = {
+    context?: string;
+    path?: string;
+    target?: string;
+    buildArgs?: Record<string, string>;
+    registrySecretRefs?: string[];
+    platform?: "linux/amd64";
+    workspaceRoot?: string;
+};
+export type SandboxRuntimeSourceInput = {
+    image?: SandboxRuntimeImageSourceInput;
+    dockerfile?: SandboxRuntimeDockerfileSourceInput;
+};
+export type SandboxSourceArchiveEntry = {
+    path: string;
+    type: "directory" | "file";
+    contentsBase64?: string;
+};
+export type SandboxCreateSourceArchive = {
+    source?: "internal_project" | "template_repo" | "client_upload";
+    ref?: string;
+    commitSha?: string | null;
+    archive: {
+        version: 1;
+        createdAt: string;
+        entries: SandboxSourceArchiveEntry[];
+        tarBase64?: string;
+    };
+};
+export type SandboxCreateInput = {
+    repo?: string;
+    teamId?: string;
+    projectId?: string;
+    agentId?: string;
+    runtimeProfileId?: import("./runtime-profiles.js").SandboxRuntimeProfileId;
+    command?: string;
+    visibility?: "private" | "team";
+    resources?: Partial<SandboxResources>;
+    budget?: Partial<SandboxBudget>;
+    env?: SandboxEnvVarInput[];
+    networkPolicy?: Record<string, unknown>;
+    quotas?: Partial<SandboxQuotaPolicy>;
+    volumes?: SandboxVolumeProvisionInput[];
+    integrationLeases?: SandboxIntegrationLeaseInput[];
+    integrationConnectionLeases?: SandboxIntegrationConnectionLeaseInput[];
+    workloadSource?: SandboxRuntimeSourceInput;
+    sourceArchive?: SandboxCreateSourceArchive;
+    metadata?: Record<string, unknown>;
+};
+export type SandboxAsyncRequestOptions = {
+    async?: boolean;
+    respondAsync?: boolean;
+    failOnUnpreservedChanges?: boolean;
+};
+export type SandboxCreateOptions = SandboxAsyncRequestOptions;

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

@@ -0,0 +1,14 @@
+export * from "./core.js";
+export * from "./schedules.js";
+export * from "./io.js";
+export * from "./billing.js";
+export * from "./snapshots.js";
+export * from "./org-project-agent.js";
+export * from "./microsoft-teams-bot.js";
+export * from "./record.js";
+export * from "./runtime-profiles.js";
+export * from "./workflow-modes.js";
+export * from "./workload-sources.js";
+export * from "./runtime.js";
+export * from "./responses.js";
+export * from "./client.js";

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

@@ -0,0 +1,240 @@
+export type SandboxSecretScope = "team" | "project" | "template";
+export type SandboxSecretStatus = "active" | "revoked" | "deleted";
+export type SandboxSecretAttachmentTarget = "sandbox" | "template" | "project" | "agent" | "replay";
+export type SandboxSecretAttachmentMetadata = {
+    envName: string;
+    targetType: SandboxSecretAttachmentTarget;
+    targetId: string;
+    attachedAt: string;
+    detachedAt: string | null;
+};
+export type SandboxSecretMetadata = {
+    id: string;
+    teamId: string;
+    ownerUserId: string;
+    name: string;
+    description: string | null;
+    scope: SandboxSecretScope;
+    status: SandboxSecretStatus;
+    secretRef: string;
+    currentVersion: number | null;
+    createdAt: string;
+    updatedAt: string;
+    lastUsedAt: string | null;
+    deletedAt: string | null;
+    attachments?: SandboxSecretAttachmentMetadata[];
+};
+export type SandboxSecretCreateInput = {
+    teamId?: string;
+    name: string;
+    value: string;
+    description?: string;
+    scope?: SandboxSecretScope;
+};
+export type SandboxSecretRotateInput = {
+    teamId?: string;
+    value: string;
+};
+export type SandboxSecretAttachInput = {
+    teamId?: string;
+    envName: string;
+    targetType: SandboxSecretAttachmentTarget;
+    targetId: string;
+};
+export type SandboxSecretListResponse = {
+    secrets: SandboxSecretMetadata[];
+};
+export type SandboxSecretResponse = {
+    secret: SandboxSecretMetadata;
+};
+export type SandboxExecInput = {
+    command: string;
+    timeoutSeconds?: number;
+};
+export type SandboxProcessStartInput = {
+    command: string;
+    timeoutSeconds?: number;
+};
+export type SandboxProcessStatus = "running" | "succeeded" | "failed" | "timed_out" | "stopped";
+export type SandboxProcess = {
+    id: string;
+    command: string;
+    status: SandboxProcessStatus;
+    output: string;
+    exitCode: number | null;
+    startedAt: string;
+    completedAt: string | null;
+    durationMs: number | null;
+    outputBytes: number;
+    truncated?: boolean;
+};
+export type SandboxPreviewAccess = "private" | "public";
+export type SandboxPreviewCorsPolicy = {
+    allowOrigins?: string[];
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    exposeHeaders?: string[];
+    allowCredentials?: boolean;
+    maxAgeSeconds?: number;
+};
+export type SandboxPreviewHeaderPolicy = {
+    responseHeaders?: Record<string, string>;
+};
+export type SandboxPreviewAuthPolicyInput = {
+    mode: "bearer";
+    token: string;
+} | {
+    mode: "header";
+    headerName: string;
+    headerValue: string;
+};
+export type SandboxPreviewAuthPolicy = {
+    mode: "bearer";
+    tokenSha256: string;
+} | {
+    mode: "header";
+    headerName: string;
+    headerValueSha256: string;
+};
+export type SandboxPtyStartInput = {
+    command?: string;
+    timeoutSeconds?: number;
+    rows?: number;
+    cols?: number;
+};
+export type SandboxPtyInput = {
+    dataBase64: string;
+};
+export type SandboxPtyStatus = "running" | "exited" | "failed" | "timed_out" | "stopped";
+export type SandboxPtySession = {
+    id: string;
+    command: string;
+    status: SandboxPtyStatus;
+    output: string;
+    exitCode: number | null;
+    startedAt: string;
+    completedAt: string | null;
+    durationMs: number | null;
+    outputBytes: number;
+    rows: number;
+    cols: number;
+    truncated?: boolean;
+};
+export type SandboxOpenPortInput = {
+    port: number;
+    label?: string;
+    access?: SandboxPreviewAccess;
+    autoStart?: boolean;
+    customDomain?: string;
+    cors?: SandboxPreviewCorsPolicy;
+    headerPolicy?: SandboxPreviewHeaderPolicy;
+    authPolicy?: SandboxPreviewAuthPolicyInput;
+};
+export type SandboxGitStatus = {
+    isRepo: boolean;
+    branch: string | null;
+    upstream: string | null;
+    ahead: number;
+    behind: number;
+    clean: boolean;
+    porcelain: string;
+};
+export type SandboxGitDiffInput = {
+    baseRef?: string;
+};
+export type SandboxGitDiff = {
+    isRepo: boolean;
+    baseRef: string | null;
+    diff: string;
+};
+export type SandboxGitPatchExportInput = SandboxGitDiffInput;
+export type SandboxGitPatchExport = {
+    isRepo: boolean;
+    baseRef: string | null;
+    patch: string;
+    filename: string;
+    sha256: string;
+    bytes: number;
+    lineCount: number;
+    empty: boolean;
+};
+export type SandboxGitBranchInput = {
+    branch: string;
+    create?: boolean;
+    startPoint?: string;
+};
+export type SandboxGitBranch = {
+    isRepo: boolean;
+    branch: string | null;
+    output: string;
+    status: SandboxGitStatus;
+};
+export type SandboxGitCommitInput = {
+    message: string;
+    paths?: string[];
+    all?: boolean;
+};
+export type SandboxGitCommit = {
+    isRepo: boolean;
+    commitHash: string | null;
+    output: string;
+    status: SandboxGitStatus;
+};
+export type SandboxGitPullInput = {
+    remote?: string;
+    branch?: string;
+    rebase?: boolean;
+    ffOnly?: boolean;
+};
+export type SandboxGitPushInput = {
+    remote?: string;
+    branch?: string;
+    setUpstream?: boolean;
+    forceWithLease?: boolean;
+};
+export type SandboxGitRemoteOperation = {
+    isRepo: boolean;
+    remote: string | null;
+    branch: string | null;
+    output: string;
+    status: SandboxGitStatus;
+};
+export type SandboxFileRef = {
+    path: string;
+    sizeBytes: number;
+    updatedAt: string;
+    isBinary?: boolean | null;
+    previewable?: boolean;
+};
+export type SandboxFileEntry = SandboxFileRef & {
+    type: "file" | "directory";
+};
+export type SandboxFileDownloadInput = {
+    path: string;
+    offsetBytes?: number;
+    maxBytes?: number;
+};
+export type SandboxFileListInput = {
+    path?: string;
+    recursive?: boolean;
+    maxEntries?: number;
+};
+export type SandboxFileMkdirInput = {
+    path: string;
+    recursive?: boolean;
+};
+export type SandboxFileMoveInput = {
+    fromPath: string;
+    toPath: string;
+    overwrite?: boolean;
+};
+export type SandboxFileSearchInput = {
+    query: string;
+    path?: string;
+    maxResults?: number;
+};
+export type SandboxFileSearchMatch = {
+    path: string;
+    line: number;
+    preview: string;
+};

package/dist/sandbox/types/microsoft-teams-bot.d.ts

@@ -0,0 +1,51 @@
+export type MicrosoftTeamsBotBinding = {
+    id: string;
+    installationId: string;
+    tenantId: string;
+    teamsTeamId: string | null;
+    teamsChannelId: string | null;
+    conversationId: string;
+    threadRootActivityId: string | null;
+    openpondTeamId: string;
+    sandboxId: string | null;
+    projectId: string | null;
+    agentId: string | null;
+    defaultRoute: string;
+    createdByUserId: string | null;
+    status: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+};
+export type MicrosoftTeamsBotOverview = {
+    teamsBotTablesReady: boolean;
+    teamId: string;
+    role: string;
+    canManage: boolean;
+    bindings: MicrosoftTeamsBotBinding[];
+    installations: Array<Record<string, unknown>>;
+    auditEvents: Array<Record<string, unknown>>;
+    entitlement: Record<string, unknown>;
+    config: Record<string, unknown>;
+};
+export type MicrosoftTeamsBotBindingTargetInput = {
+    teamId: string;
+    sandboxId?: string | null;
+    projectId?: string | null;
+    agentId?: string | null;
+    microsoftConnectionId?: string | null;
+};
+export type MicrosoftTeamsBotBindingResponse = {
+    binding: MicrosoftTeamsBotBinding;
+};
+export type MicrosoftTeamsBotDiagnosticRunInput = {
+    teamId: string;
+    bindingId: string;
+    prompt: string;
+    attachments?: Array<Record<string, unknown>>;
+    actionInput?: Record<string, unknown>;
+};
+export type MicrosoftTeamsBotDiagnosticRunResponse = MicrosoftTeamsBotBindingResponse & {
+    diagnosticRunStatus: string;
+    route: Record<string, unknown>;
+};