@phpsandbox/sdk 0.0.57 → 0.0.58

package/dist/schemas/deployments.d.ts

@@ -0,0 +1,417 @@
+import { z } from 'zod';
+export declare const DeploymentTargetProviderSchema: z.ZodEnum<{
+    okraCloudflareContainer: "okraCloudflareContainer";
+    okraSshAgent: "okraSshAgent";
+    okraLaravelCloud: "okraLaravelCloud";
+}>;
+export declare const DeploymentStatusSchema: z.ZodEnum<{
+    stopped: "stopped";
+    deleted: "deleted";
+    pending: "pending";
+    queued: "queued";
+    building: "building";
+    deploying: "deploying";
+    healthy: "healthy";
+    failed: "failed";
+    deleting: "deleting";
+    delete_failed: "delete_failed";
+}>;
+export declare const DeploymentBuildStatusSchema: z.ZodEnum<{
+    running: "running";
+    pending: "pending";
+    queued: "queued";
+    failed: "failed";
+    succeeded: "succeeded";
+    cancelled: "cancelled";
+}>;
+export declare const DeploymentReleaseStatusSchema: z.ZodEnum<{
+    created: "created";
+    deleted: "deleted";
+    ready: "ready";
+}>;
+export declare const DeploymentSizeSchema: z.ZodEnum<{
+    small: "small";
+    basic: "basic";
+    nano: "nano";
+    medium: "medium";
+    large: "large";
+    lite: "lite";
+    "standard-1": "standard-1";
+    "standard-2": "standard-2";
+}>;
+export declare const DeploymentRegionSchema: z.ZodEnum<{
+    ENAM: "ENAM";
+    WNAM: "WNAM";
+    EEUR: "EEUR";
+    WEUR: "WEUR";
+    APAC: "APAC";
+    SAM: "SAM";
+    ME: "ME";
+    OC: "OC";
+    AFR: "AFR";
+}>;
+export declare const DeploymentJurisdictionSchema: z.ZodEnum<{
+    eu: "eu";
+    fedramp: "fedramp";
+}>;
+export declare const DeploymentDomainDnsRecordTypeSchema: z.ZodEnum<{
+    CNAME: "CNAME";
+    ALIAS: "ALIAS";
+    ANAME: "ANAME";
+}>;
+export declare const DeploymentProtectionModeSchema: z.ZodEnum<{
+    none: "none";
+    password: "password";
+}>;
+export declare const DeploymentLogStreamSchema: z.ZodEnum<{
+    build: "build";
+    runtime: "runtime";
+}>;
+export declare const DeployStreamLogStreamSchema: z.ZodEnum<{
+    build: "build";
+    runtime: "runtime";
+    deploy: "deploy";
+}>;
+export declare const DeploymentEventDataSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    sequence: z.ZodNumber;
+    type: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export declare const DeploymentLogChunkDataSchema: z.ZodObject<{
+    sequence: z.ZodNumber;
+    stream: z.ZodEnum<{
+        build: "build";
+        runtime: "runtime";
+    }>;
+    content: z.ZodString;
+    createdAt: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export declare const DeployStreamPhaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+    }>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const DeployStreamLogSchema: z.ZodObject<{
+    stream: z.ZodEnum<{
+        build: "build";
+        runtime: "runtime";
+        deploy: "deploy";
+    }>;
+    content: z.ZodString;
+}, z.core.$strict>;
+export declare const DeployStreamResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    deploymentId: z.ZodString;
+    buildId: z.ZodString;
+    releaseId: z.ZodString;
+    status: z.ZodEnum<{
+        stopped: "stopped";
+        deleted: "deleted";
+        pending: "pending";
+        queued: "queued";
+        building: "building";
+        deploying: "deploying";
+        healthy: "healthy";
+        failed: "failed";
+        deleting: "deleting";
+        delete_failed: "delete_failed";
+    }>;
+}, z.core.$strict>;
+export declare const DeployStreamPhaseEventSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+    }>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"phase">;
+}, z.core.$strict>;
+export declare const DeployStreamLogEventSchema: z.ZodObject<{
+    stream: z.ZodEnum<{
+        build: "build";
+        runtime: "runtime";
+        deploy: "deploy";
+    }>;
+    content: z.ZodString;
+    type: z.ZodLiteral<"log">;
+}, z.core.$strict>;
+export declare const DeployStreamResultEventSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    deploymentId: z.ZodString;
+    buildId: z.ZodString;
+    releaseId: z.ZodString;
+    status: z.ZodEnum<{
+        stopped: "stopped";
+        deleted: "deleted";
+        pending: "pending";
+        queued: "queued";
+        building: "building";
+        deploying: "deploying";
+        healthy: "healthy";
+        failed: "failed";
+        deleting: "deleting";
+        delete_failed: "delete_failed";
+    }>;
+    type: z.ZodLiteral<"result">;
+}, z.core.$strict>;
+export declare const DeployStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+    }>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"phase">;
+}, z.core.$strict>, z.ZodObject<{
+    stream: z.ZodEnum<{
+        build: "build";
+        runtime: "runtime";
+        deploy: "deploy";
+    }>;
+    content: z.ZodString;
+    type: z.ZodLiteral<"log">;
+}, z.core.$strict>, z.ZodObject<{
+    success: z.ZodBoolean;
+    deploymentId: z.ZodString;
+    buildId: z.ZodString;
+    releaseId: z.ZodString;
+    status: z.ZodEnum<{
+        stopped: "stopped";
+        deleted: "deleted";
+        pending: "pending";
+        queued: "queued";
+        building: "building";
+        deploying: "deploying";
+        healthy: "healthy";
+        failed: "failed";
+        deleting: "deleting";
+        delete_failed: "delete_failed";
+    }>;
+    type: z.ZodLiteral<"result">;
+}, z.core.$strict>], "type">;
+export declare const DeployStreamErrorSchema: z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const DeployStreamSseEventNameSchema: z.ZodEnum<{
+    error: "error";
+    log: "log";
+    phase: "phase";
+    result: "result";
+    done: "done";
+}>;
+export declare const DeployStreamSsePhaseEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"phase">;
+    data: z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodOptional<z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            completed: "completed";
+        }>>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeployStreamSseLogEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"log">;
+    data: z.ZodObject<{
+        stream: z.ZodEnum<{
+            build: "build";
+            runtime: "runtime";
+            deploy: "deploy";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeployStreamSseDoneEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"done">;
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+        deploymentId: z.ZodString;
+        buildId: z.ZodString;
+        releaseId: z.ZodString;
+        status: z.ZodEnum<{
+            stopped: "stopped";
+            deleted: "deleted";
+            pending: "pending";
+            queued: "queued";
+            building: "building";
+            deploying: "deploying";
+            healthy: "healthy";
+            failed: "failed";
+            deleting: "deleting";
+            delete_failed: "delete_failed";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeployStreamSseResultEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"result">;
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+        deploymentId: z.ZodString;
+        buildId: z.ZodString;
+        releaseId: z.ZodString;
+        status: z.ZodEnum<{
+            stopped: "stopped";
+            deleted: "deleted";
+            pending: "pending";
+            queued: "queued";
+            building: "building";
+            deploying: "deploying";
+            healthy: "healthy";
+            failed: "failed";
+            deleting: "deleting";
+            delete_failed: "delete_failed";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeployStreamSseErrorEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"error">;
+    data: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strict>;
+export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    event: z.ZodLiteral<"phase">;
+    data: z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodOptional<z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            completed: "completed";
+        }>>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"log">;
+    data: z.ZodObject<{
+        stream: z.ZodEnum<{
+            build: "build";
+            runtime: "runtime";
+            deploy: "deploy";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"done">;
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+        deploymentId: z.ZodString;
+        buildId: z.ZodString;
+        releaseId: z.ZodString;
+        status: z.ZodEnum<{
+            stopped: "stopped";
+            deleted: "deleted";
+            pending: "pending";
+            queued: "queued";
+            building: "building";
+            deploying: "deploying";
+            healthy: "healthy";
+            failed: "failed";
+            deleting: "deleting";
+            delete_failed: "delete_failed";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"result">;
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+        deploymentId: z.ZodString;
+        buildId: z.ZodString;
+        releaseId: z.ZodString;
+        status: z.ZodEnum<{
+            stopped: "stopped";
+            deleted: "deleted";
+            pending: "pending";
+            queued: "queued";
+            building: "building";
+            deploying: "deploying";
+            healthy: "healthy";
+            failed: "failed";
+            deleting: "deleting";
+            delete_failed: "delete_failed";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"error">;
+    data: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strict>], "event">, z.ZodTransform<{
+    name: string;
+    type: "phase";
+    status?: "running" | "failed" | "completed";
+    data?: Record<string, unknown>;
+} | {
+    stream: "build" | "runtime" | "deploy";
+    content: string;
+    type: "log";
+} | {
+    success: boolean;
+    deploymentId: string;
+    buildId: string;
+    releaseId: string;
+    status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
+    type: "result";
+}, {
+    event: "phase";
+    data: {
+        name: string;
+        status?: "running" | "failed" | "completed";
+        data?: Record<string, unknown>;
+    };
+} | {
+    event: "log";
+    data: {
+        stream: "build" | "runtime" | "deploy";
+        content: string;
+    };
+} | {
+    event: "done";
+    data: {
+        success: boolean;
+        deploymentId: string;
+        buildId: string;
+        releaseId: string;
+        status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
+    };
+} | {
+    event: "result";
+    data: {
+        success: boolean;
+        deploymentId: string;
+        buildId: string;
+        releaseId: string;
+        status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
+    };
+} | {
+    event: "error";
+    data: {
+        [x: string]: unknown;
+        message?: string;
+    };
+}>>;
+export type DeploymentTargetProvider = z.infer<typeof DeploymentTargetProviderSchema>;
+export type DeploymentStatus = z.infer<typeof DeploymentStatusSchema>;
+export type DeploymentBuildStatus = z.infer<typeof DeploymentBuildStatusSchema>;
+export type DeploymentReleaseStatus = z.infer<typeof DeploymentReleaseStatusSchema>;
+export type DeploymentSize = z.infer<typeof DeploymentSizeSchema>;
+export type DeploymentRegion = z.infer<typeof DeploymentRegionSchema>;
+export type DeploymentJurisdiction = z.infer<typeof DeploymentJurisdictionSchema>;
+export type DeploymentDomainDnsRecordType = z.infer<typeof DeploymentDomainDnsRecordTypeSchema>;
+export type DeploymentProtectionMode = z.infer<typeof DeploymentProtectionModeSchema>;
+export type DeploymentLogStream = z.infer<typeof DeploymentLogStreamSchema>;
+export type DeploymentEventData = z.infer<typeof DeploymentEventDataSchema>;
+export type DeploymentLogChunkData = z.infer<typeof DeploymentLogChunkDataSchema>;
+export type DeployStreamPhase = z.infer<typeof DeployStreamPhaseSchema>;
+export type DeployStreamLog = z.infer<typeof DeployStreamLogSchema>;
+export type DeployStreamResult = z.infer<typeof DeployStreamResultSchema>;
+export type DeployStreamEvent = z.infer<typeof DeployStreamEventSchema>;
+export type DeployStreamSseEvent = z.infer<typeof DeployStreamSseEventSchema>;

package/dist/schemas/deployments.js

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+export const DeploymentTargetProviderSchema = z.enum([
+    'okraCloudflareContainer',
+    'okraSshAgent',
+    'okraLaravelCloud',
+]);
+export const DeploymentStatusSchema = z.enum([
+    'pending',
+    'queued',
+    'building',
+    'deploying',
+    'healthy',
+    'failed',
+    'stopped',
+    'deleting',
+    'deleted',
+    'delete_failed',
+]);
+export const DeploymentBuildStatusSchema = z.enum([
+    'pending',
+    'queued',
+    'running',
+    'succeeded',
+    'failed',
+    'cancelled',
+]);
+export const DeploymentReleaseStatusSchema = z.enum(['created', 'ready', 'deleted']);
+export const DeploymentSizeSchema = z.enum([
+    'nano',
+    'small',
+    'medium',
+    'large',
+    'lite',
+    'basic',
+    'standard-1',
+    'standard-2',
+]);
+export const DeploymentRegionSchema = z.enum([
+    'ENAM',
+    'WNAM',
+    'EEUR',
+    'WEUR',
+    'APAC',
+    'SAM',
+    'ME',
+    'OC',
+    'AFR',
+]);
+export const DeploymentJurisdictionSchema = z.enum(['eu', 'fedramp']);
+export const DeploymentDomainDnsRecordTypeSchema = z.enum(['CNAME', 'ALIAS', 'ANAME']);
+export const DeploymentProtectionModeSchema = z.enum(['none', 'password']);
+export const DeploymentLogStreamSchema = z.enum(['build', 'runtime']);
+export const DeployStreamLogStreamSchema = z.enum(['build', 'deploy', 'runtime']);
+export const DeploymentEventDataSchema = z.object({
+    id: z.union([z.number(), z.string()]).optional(),
+    sequence: z.number(),
+    type: z.string(),
+    payload: z.record(z.string(), z.unknown()),
+    createdAt: z.string().nullable(),
+}).passthrough();
+export const DeploymentLogChunkDataSchema = z.object({
+    sequence: z.number(),
+    stream: DeploymentLogStreamSchema,
+    content: z.string(),
+    createdAt: z.string().nullable(),
+}).passthrough();
+export const DeployStreamPhaseSchema = z.object({
+    name: z.string(),
+    status: z.enum(['running', 'completed', 'failed']).optional(),
+    data: z.record(z.string(), z.unknown()).optional(),
+}).strict();
+export const DeployStreamLogSchema = z.object({
+    stream: DeployStreamLogStreamSchema,
+    content: z.string(),
+}).strict();
+export const DeployStreamResultSchema = z.object({
+    success: z.boolean(),
+    deploymentId: z.string(),
+    buildId: z.string(),
+    releaseId: z.string(),
+    status: DeploymentStatusSchema,
+}).strict();
+export const DeployStreamPhaseEventSchema = DeployStreamPhaseSchema.extend({
+    type: z.literal('phase'),
+}).strict();
+export const DeployStreamLogEventSchema = DeployStreamLogSchema.extend({
+    type: z.literal('log'),
+}).strict();
+export const DeployStreamResultEventSchema = DeployStreamResultSchema.extend({
+    type: z.literal('result'),
+}).strict();
+export const DeployStreamEventSchema = z.discriminatedUnion('type', [
+    DeployStreamPhaseEventSchema,
+    DeployStreamLogEventSchema,
+    DeployStreamResultEventSchema,
+]);
+export const DeployStreamErrorSchema = z.object({
+    message: z.string().optional(),
+}).passthrough();
+export const DeployStreamSseEventNameSchema = z.enum(['phase', 'log', 'done', 'result', 'error']);
+export const DeployStreamSsePhaseEventSchema = z.object({
+    event: z.literal('phase'),
+    data: DeployStreamPhaseSchema,
+}).strict();
+export const DeployStreamSseLogEventSchema = z.object({
+    event: z.literal('log'),
+    data: DeployStreamLogSchema,
+}).strict();
+export const DeployStreamSseDoneEventSchema = z.object({
+    event: z.literal('done'),
+    data: DeployStreamResultSchema,
+}).strict();
+export const DeployStreamSseResultEventSchema = z.object({
+    event: z.literal('result'),
+    data: DeployStreamResultSchema,
+}).strict();
+export const DeployStreamSseErrorEventSchema = z.object({
+    event: z.literal('error'),
+    data: DeployStreamErrorSchema,
+}).strict();
+export const DeployStreamSseEventSchema = z.discriminatedUnion('event', [
+    DeployStreamSsePhaseEventSchema,
+    DeployStreamSseLogEventSchema,
+    DeployStreamSseDoneEventSchema,
+    DeployStreamSseResultEventSchema,
+    DeployStreamSseErrorEventSchema,
+]).transform((event) => {
+    if (event.event === 'error') {
+        throw new Error(event.data.message ?? 'Deploy failed');
+    }
+    const type = event.event === 'done' ? 'result' : event.event;
+    return DeployStreamEventSchema.parse({ type, ...event.data });
+});

package/dist/servers.d.ts

@@ -0,0 +1,42 @@
+import type { Client, PaginatedApiResponse } from './index.js';
+export interface ServerData {
+    id: string;
+    name: string;
+    host: string;
+    provider: string;
+    status: string;
+    token?: string;
+    sshPublicKey?: string;
+    installCommand?: string;
+    connectedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+export interface ServerSshOptions {
+    user?: string;
+    port?: number;
+}
+export interface CreateServerInput {
+    name: string;
+    host: string;
+    ssh?: ServerSshOptions;
+}
+export declare class ServerApi {
+    private readonly client;
+    constructor(client: Client);
+    list(): Promise<PaginatedApiResponse<ServerData>>;
+    create(input: CreateServerInput): Promise<ServerInstance>;
+    get(id: string): Promise<ServerInstance>;
+    delete(id: string): Promise<void>;
+}
+export declare class ServerInstance {
+    readonly data: ServerData;
+    private readonly client;
+    constructor(data: ServerData, client: Client);
+    refresh(): Promise<ServerInstance>;
+    delete(): Promise<void>;
+    waitReady(options?: {
+        timeout?: number;
+        interval?: number;
+    }): Promise<ServerInstance>;
+}

package/dist/servers.js

@@ -0,0 +1,48 @@
+export class ServerApi {
+    constructor(client) {
+        this.client = client;
+    }
+    async list() {
+        const response = await this.client.get('/servers');
+        return response.data;
+    }
+    async create(input) {
+        const response = await this.client.post('/servers', input);
+        return new ServerInstance(response.data, this.client);
+    }
+    async get(id) {
+        const response = await this.client.get(`/servers/${id}`);
+        return new ServerInstance(response.data, this.client);
+    }
+    async delete(id) {
+        await this.client.delete(`/servers/${id}`);
+    }
+}
+export class ServerInstance {
+    constructor(data, client) {
+        this.data = data;
+        this.client = client;
+    }
+    refresh() {
+        return this.client.servers.get(this.data.id);
+    }
+    delete() {
+        return this.client.servers.delete(this.data.id);
+    }
+    async waitReady(options) {
+        const timeout = options?.timeout ?? 300000; // 5 minutes default
+        const interval = options?.interval ?? 3000; // poll every 3s
+        const deadline = Date.now() + timeout;
+        while (Date.now() < deadline) {
+            const server = await this.refresh();
+            if (server.data.status === 'connected') {
+                return server;
+            }
+            if (server.data.status === 'failed') {
+                throw new Error(`Server provisioning failed: ${server.data.id}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, interval));
+        }
+        throw new Error(`Server did not become ready within ${timeout}ms`);
+    }
+}

package/docs/api-summary.md

@@ -75,7 +75,7 @@ const client = new PHPSandbox(token, 'https://api.phpsandbox.io/v1', {
 ### Git (`notebook.git`)
 
 - `checkpoint(author, message, branch = 'main')`
-- `sync(url, author, ref?, token?, direction?, force?)`
+- `sync({ provider, repository, author, branch?, credential, direction?, visibility?, setDefault? })`
 - `diff({ url?, token?, ref?, base?, target? })`
 - `merge({ url?, token?, ref?, target?, expectedBaseRef?, author?, message? })`
 - `conflicts()`

package/examples/README.md

@@ -6,6 +6,34 @@
 PHPSANDBOX_TOKEN=your-token npx tsx examples/basic.ts
 ```
 
+### Running Deployment Examples
+
+Cloudflare Containers target:
+
+```bash
+PHPSANDBOX_TOKEN=your-token PHPSANDBOX_NOTEBOOK_ID=notebook-id \
+  npx tsx examples/deploy-cloudflare-container.ts
+```
+
+SSH agent target:
+
+```bash
+PHPSANDBOX_TOKEN=your-token PHPSANDBOX_NOTEBOOK_ID=notebook-id \
+  npx tsx examples/deploy-ssh-agent.ts
+```
+
+Laravel Cloud target:
+
+```bash
+PHPSANDBOX_TOKEN=your-token PHPSANDBOX_NOTEBOOK_ID=notebook-id \
+  PHPSANDBOX_LARAVEL_CLOUD_REPOSITORY=owner/repo \
+  PHPSANDBOX_GITHUB_TOKEN=github-token \
+  PHPSANDBOX_LARAVEL_CLOUD_API_KEY=lc-api-key \
+  npx tsx examples/deploy-laravel-cloud.ts
+```
+
+Deployment examples accept `PHPSANDBOX_API_URL` and `PHPSANDBOX_DEPLOY_SLUG`. On the first run they create the notebook's deployment; later runs publish the existing deployment without changing slug or provider. The SSH example creates a server registration when `PHPSANDBOX_DEPLOY_SERVER_ID` is not set; on local `.test` APIs it also starts local Rook from `PHPSANDBOX_ROOK_DIR` or the sibling `rook` repo. The Laravel Cloud example syncs the notebook to `PHPSANDBOX_LARAVEL_CLOUD_REPOSITORY`, upserts `PHPSANDBOX_GITHUB_TOKEN` into `GITHUB_TOKEN`, and upserts `PHPSANDBOX_LARAVEL_CLOUD_API_KEY` into `LARAVEL_CLOUD_API_KEY` on first publish.
+
 ### Running The Laravel Load Test
 
 When stdout is a TTY, the load test renders a live dashboard with current stage, active scenarios, and rolling results. When output is redirected or piped, it falls back to plain logs.