@laioutr/cli 0.3.2 → 0.4.1

package/dist/commands/deploy/list.d.ts

@@ -0,0 +1,32 @@
+import DeployBaseCommand from '../../deploy-base-command.js';
+export default class DeployList extends DeployBaseCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        key: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'no-color': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'cockpit-api-host': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        cwd: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<{
+        deployments: {
+            deploymentId: string;
+            status: string;
+            environment: string;
+            previewName: string | null;
+            url: string | null;
+            createdAt: string;
+            stoppedAt: string | null;
+            attribution: {
+                principalType: "user" | "api-key" | "system";
+                displayName: string;
+                email: string | null;
+                agentName: string | null;
+                redacted: boolean;
+            } | null;
+        }[];
+    }>;
+}

package/dist/commands/deploy/list.js

@@ -0,0 +1,55 @@
+import { Flags } from '@oclif/core';
+import { makeTable } from '@oclif/table';
+import { fetchDeployments } from '../../api/deploy.js';
+import { formatAttribution } from '../../deploy/attribution.js';
+import DeployBaseCommand from '../../deploy-base-command.js';
+export default class DeployList extends DeployBaseCommand {
+    static description = 'List recent deployments for a project.';
+    static enableJsonFlag = true;
+    static examples = [
+        '<%= config.bin %> deploy list --project org/project --key orgKey_xxx',
+        '<%= config.bin %> deploy list --project org/project --key orgKey_xxx --limit 50',
+    ];
+    static flags = {
+        ...DeployBaseCommand.flags,
+        limit: Flags.integer({
+            default: 20,
+            description: 'Maximum number of deployments to list (1-100)',
+            max: 100,
+            min: 1,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DeployList);
+        const { organizationSlug, projectSlug } = this.parseProject(flags.project);
+        const result = await fetchDeployments({
+            cockpitApiHost: flags['cockpit-api-host'],
+            apiKey: flags.key,
+            organizationSlug,
+            projectSlug,
+            userAgent: this.config.userAgent,
+            limit: flags.limit,
+        });
+        if (result.deployments.length === 0) {
+            this.log('No deployments found.');
+            return result;
+        }
+        const rows = result.deployments.map((d) => ({
+            ID: d.deploymentId,
+            Type: d.environment,
+            Preview: d.previewName ?? '—',
+            Status: d.status,
+            URL: d.url ?? '—',
+            'Created by': formatAttribution(d.attribution),
+        }));
+        this.log(makeTable({
+            data: rows,
+            // Keep our exact header casing (ID / URL / Created by) instead of the
+            // default case-formatter, and truncate the middle of long cells (URLs)
+            // so both ends stay visible.
+            headerOptions: { formatter: (header) => header },
+            overflow: 'truncate-middle',
+        }));
+        return result;
+    }
+}

package/dist/commands/deploy/logs.d.ts

@@ -0,0 +1,23 @@
+import DeployBaseCommand from '../../deploy-base-command.js';
+export default class DeployLogs extends DeployBaseCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        'deployment-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        key: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'no-color': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'cockpit-api-host': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        cwd: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<{
+        lines: {
+            text: string;
+            level?: "error" | "warning" | null | undefined;
+            timestamp?: number | null | undefined;
+        }[] | null;
+        supported: boolean;
+        deploymentStatus: string;
+    }>;
+}

package/dist/commands/deploy/logs.js

@@ -0,0 +1,54 @@
+import { Flags } from '@oclif/core';
+import { fetchDeploymentLogs } from '../../api/deploy.js';
+import { LogRenderer } from '../../deploy/log-renderer.js';
+import { isTerminalStatus, POLL_INTERVAL_MS, sleep } from '../../deploy/polling.js';
+import DeployBaseCommand from '../../deploy-base-command.js';
+export default class DeployLogs extends DeployBaseCommand {
+    static description = 'Fetch and display build logs for a deployment.';
+    static enableJsonFlag = true;
+    static examples = ['<%= config.bin %> deploy logs --project org/project --key orgKey_xxx --deployment-id dep_abc123'];
+    static flags = {
+        ...DeployBaseCommand.flags,
+        'deployment-id': Flags.string({
+            aliases: ['deploymentId'],
+            deprecateAliases: true,
+            description: 'Deployment ID',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DeployLogs);
+        const { organizationSlug, projectSlug } = this.parseProject(flags.project);
+        const apiOptions = {
+            cockpitApiHost: flags['cockpit-api-host'],
+            apiKey: flags.key,
+            organizationSlug,
+            projectSlug,
+            userAgent: this.config.userAgent,
+            deploymentId: flags['deployment-id'],
+        };
+        // Initial fetch
+        const initial = await fetchDeploymentLogs(apiOptions);
+        if (!initial.supported) {
+            this.log("Build logs are not available for this deployment's hosting provider.");
+            return initial;
+        }
+        const isFollowing = !isTerminalStatus(initial.deploymentStatus);
+        this.log(`Build log for deployment ${flags['deployment-id']}${isFollowing ? ' (following)' : ''}`);
+        this.log('');
+        const renderer = new LogRenderer();
+        renderer.render(initial.lines, (msg) => this.log(msg));
+        if (!isFollowing) {
+            return initial;
+        }
+        // Follow mode — poll until terminal
+        while (true) {
+            await sleep(POLL_INTERVAL_MS);
+            const result = await fetchDeploymentLogs(apiOptions);
+            renderer.render(result.lines, (msg) => this.log(msg));
+            if (isTerminalStatus(result.deploymentStatus)) {
+                return result;
+            }
+        }
+    }
+}

package/dist/commands/deploy/status.d.ts

@@ -0,0 +1,31 @@
+import DeployBaseCommand from '../../deploy-base-command.js';
+export default class DeployStatus extends DeployBaseCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        'deployment-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        key: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'no-color': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'cockpit-api-host': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        cwd: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<{
+        deploymentId: string;
+        status: string;
+        environment: string;
+        previewName: string | null;
+        url: string | null;
+        lastError: string | null;
+        createdAt: string;
+        stoppedAt: string | null;
+        attribution: {
+            principalType: "user" | "api-key" | "system";
+            displayName: string;
+            email: string | null;
+            agentName: string | null;
+            redacted: boolean;
+        } | null;
+    }>;
+}

package/dist/commands/deploy/status.js

@@ -0,0 +1,41 @@
+import { Flags } from '@oclif/core';
+import { fetchDeploymentStatus } from '../../api/deploy.js';
+import { formatAttribution } from '../../deploy/attribution.js';
+import DeployBaseCommand from '../../deploy-base-command.js';
+import { formatDetail } from '../../format/detail.js';
+export default class DeployStatus extends DeployBaseCommand {
+    static description = 'Show status of a deployment.';
+    static enableJsonFlag = true;
+    static examples = ['<%= config.bin %> deploy status --project org/project --key orgKey_xxx --deployment-id dep_abc123'];
+    static flags = {
+        ...DeployBaseCommand.flags,
+        'deployment-id': Flags.string({
+            aliases: ['deploymentId'],
+            deprecateAliases: true,
+            description: 'Deployment ID',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DeployStatus);
+        const { organizationSlug, projectSlug } = this.parseProject(flags.project);
+        const status = await fetchDeploymentStatus({
+            cockpitApiHost: flags['cockpit-api-host'],
+            apiKey: flags.key,
+            organizationSlug,
+            projectSlug,
+            userAgent: this.config.userAgent,
+            deploymentId: flags['deployment-id'],
+        });
+        this.log(formatDetail([
+            ['Status', status.status],
+            ['Environment', status.environment],
+            ['Preview', status.previewName],
+            ['URL', status.url],
+            ['Created by', formatAttribution(status.attribution)],
+            ['Created at', status.createdAt],
+            ['Stopped at', status.stoppedAt],
+        ], { title: `Deployment ${status.deploymentId}` }));
+        return status;
+    }
+}

package/dist/commands/deploy/trigger.d.ts

@@ -0,0 +1,24 @@
+import DeployBaseCommand from '../../deploy-base-command.js';
+export default class DeployTrigger extends DeployBaseCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        logs: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        preview: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        key: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'no-color': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'cockpit-api-host': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        cwd: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<{
+        deploymentId: string;
+        status: string;
+        environment: string;
+        previewName: string | null;
+    }>;
+    private pollWithSpinner;
+    private pollWithLogs;
+}

package/dist/commands/deploy/trigger.js

@@ -0,0 +1,130 @@
+import { Flags, ux } from '@oclif/core';
+import { fetchDeploymentLogs, fetchDeploymentStatus, triggerDeployment } from '../../api/deploy.js';
+import { LogRenderer } from '../../deploy/log-renderer.js';
+import { isTerminalStatus, POLL_INTERVAL_MS, sleep } from '../../deploy/polling.js';
+import DeployBaseCommand from '../../deploy-base-command.js';
+export default class DeployTrigger extends DeployBaseCommand {
+    static description = 'Trigger a project deployment.';
+    static enableJsonFlag = true;
+    static examples = [
+        '<%= config.bin %> deploy trigger --project org/project --key orgKey_xxx',
+        '<%= config.bin %> deploy trigger --project org/project --key orgKey_xxx --no-wait',
+        '<%= config.bin %> deploy trigger --project org/project --key orgKey_xxx --logs',
+        '<%= config.bin %> deploy trigger --project org/project --key orgKey_xxx --preview my-feature',
+    ];
+    static flags = {
+        ...DeployBaseCommand.flags,
+        wait: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Wait for deployment to complete',
+        }),
+        logs: Flags.boolean({
+            default: false,
+            description: 'Stream build log output instead of spinner',
+        }),
+        preview: Flags.string({
+            description: 'Create a preview deployment with optional name',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DeployTrigger);
+        const { organizationSlug, projectSlug } = this.parseProject(flags.project);
+        const apiOptions = {
+            cockpitApiHost: flags['cockpit-api-host'],
+            apiKey: flags.key,
+            organizationSlug,
+            projectSlug,
+            userAgent: this.config.userAgent,
+        };
+        // A named preview requires a non-empty name — the deploy route rejects an
+        // empty `previewName`, and an unnamed preview is not supported by this contract.
+        if (flags.preview !== undefined && flags.preview.trim() === '') {
+            this.error('--preview requires a non-empty name');
+        }
+        const isPreview = flags.preview !== undefined;
+        const label = isPreview ? `preview deployment for ${flags.project} (${flags.preview})` : `deployment for ${flags.project}`;
+        this.log(`Triggering ${label}...`);
+        // Trigger
+        const result = await triggerDeployment({
+            ...apiOptions,
+            previewName: flags.preview,
+        });
+        this.log(`Deployment ID: ${result.deploymentId}`);
+        this.log('');
+        if (!flags.wait) {
+            this.log(`Status: ${result.status}`);
+            this.log('');
+            this.log('Deployment triggered. Use `laioutr deploy status` to check progress.');
+            return result;
+        }
+        // Poll until terminal
+        if (flags.logs) {
+            return this.pollWithLogs(apiOptions, result.deploymentId);
+        }
+        return this.pollWithSpinner(apiOptions, result.deploymentId);
+    }
+    async pollWithSpinner(apiOptions, deploymentId) {
+        let lastStatus = '';
+        while (true) {
+            const status = await fetchDeploymentStatus({ ...apiOptions, deploymentId });
+            if (status.status !== lastStatus) {
+                if (lastStatus)
+                    ux.action.stop();
+                if (!isTerminalStatus(status.status)) {
+                    ux.action.start(`Status: ${status.status}`);
+                }
+                lastStatus = status.status;
+            }
+            if (isTerminalStatus(status.status)) {
+                ux.action.stop();
+                this.log('');
+                // `not_available` is a success outcome: the provider does not report
+                // live status, so the deployment is promoted straight to live. Only
+                // `error`/`canceled` (and any unexpected terminal status) are failures.
+                if (status.status === 'success' || status.status === 'not_available') {
+                    this.log(status.status === 'success' ? '✓ Deployment successful' : '✓ Deployment live (provider does not report build status)');
+                    if (status.url)
+                        this.log(`  URL: ${status.url}`);
+                }
+                else {
+                    this.log(`✗ Deployment ${status.status}`);
+                    if (status.lastError)
+                        this.log(`  Error: ${status.lastError}`);
+                    this.exit(1);
+                }
+                return status;
+            }
+            await sleep(POLL_INTERVAL_MS);
+        }
+    }
+    async pollWithLogs(apiOptions, deploymentId) {
+        const renderer = new LogRenderer();
+        let lastStatus = '';
+        while (true) {
+            const logsResult = await fetchDeploymentLogs({ ...apiOptions, deploymentId });
+            if (logsResult.deploymentStatus !== lastStatus) {
+                this.log(`── Status: ${logsResult.deploymentStatus} ──`);
+                lastStatus = logsResult.deploymentStatus;
+            }
+            renderer.render(logsResult.lines, (msg) => this.log(msg));
+            if (isTerminalStatus(logsResult.deploymentStatus)) {
+                this.log('');
+                // `success` and `not_available` are both live outcomes (see pollWithSpinner);
+                // fetch the final status for the URL. Everything else is a failure.
+                if (logsResult.deploymentStatus === 'success' || logsResult.deploymentStatus === 'not_available') {
+                    const finalStatus = await fetchDeploymentStatus({ ...apiOptions, deploymentId });
+                    this.log(logsResult.deploymentStatus === 'success' ?
+                        '✓ Deployment successful'
+                        : '✓ Deployment live (provider does not report build status)');
+                    if (finalStatus.url)
+                        this.log(`  URL: ${finalStatus.url}`);
+                    return finalStatus;
+                }
+                this.log(`✗ Deployment ${logsResult.deploymentStatus}`);
+                this.exit(1);
+            }
+            await sleep(POLL_INTERVAL_MS);
+        }
+    }
+}

package/dist/commands/rc/fetch.d.ts

@@ -6,10 +6,11 @@ export default class ProjectRcFetch extends LaioutrBaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        environmentName: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        projectSecret: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'environment-name': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'project-secret': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         project: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        cockpitApiHost: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'no-color': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'cockpit-api-host': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         cwd: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     static aliases: string[];

package/dist/commands/rc/fetch.js

@@ -12,15 +12,36 @@ export default class ProjectRcFetch extends LaioutrBaseCommand {
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
         ...LaioutrBaseCommand.flags,
-        environmentName: Flags.string({ char: 'e', default: 'main', description: 'environment name', env: 'ENVIRONMENT_NAME', required: true }),
-        projectSecret: Flags.string({ char: 's', description: 'project secret', env: 'PROJECT_SECRET', required: true }),
+        'environment-name': Flags.string({
+            aliases: ['environmentName'],
+            char: 'e',
+            default: 'main',
+            deprecateAliases: true,
+            description: 'Environment name',
+            env: 'ENVIRONMENT_NAME',
+            required: true,
+        }),
+        'project-secret': Flags.string({
+            aliases: ['projectSecret'],
+            char: 's',
+            deprecateAliases: true,
+            description: 'Project secret',
+            env: 'PROJECT_SECRET',
+            required: true,
+        }),
         project: Flags.string({ char: 'p', description: '<organization slug>/<project slug>', env: 'PROJECT', required: true }),
     };
     static aliases = ['project:fetch-rc'];
     static deprecateAliases = true;
     async run() {
         const { args, flags } = await this.parse(ProjectRcFetch);
-        const rc = await fetchRc(flags);
+        const rc = await fetchRc({
+            cockpitApiHost: flags['cockpit-api-host'],
+            environmentName: flags['environment-name'],
+            project: flags.project,
+            projectSecret: flags['project-secret'],
+            userAgent: this.config.userAgent,
+        });
         const filePath = path.join(flags.cwd, args.fileName);
         this.log('Writing RC file', filePath);
         return writeFile(filePath, rc);

package/dist/commands/rc/update.d.ts

@@ -6,7 +6,8 @@ export default class ProjectRcUpdate extends LaioutrBaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        cockpitApiHost: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'no-color': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'cockpit-api-host': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         cwd: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/rc/update.js

@@ -19,10 +19,11 @@ export default class ProjectRcUpdate extends LaioutrBaseCommand {
         const currentRcRaw = await readFile(path.join(flags.cwd, args.fileName), 'utf-8');
         const currentRc = rcWithLaioutrMetaSchema.parse(JSON.parse(currentRcRaw));
         const options = {
-            ...flags,
+            cockpitApiHost: flags['cockpit-api-host'],
             project: currentRc.laioutr.projectSlug,
             projectSecret: currentRc.laioutr.projectSecretKey,
             environmentName: currentRc.laioutr.environmentName,
+            userAgent: this.config.userAgent,
         };
         this.log('Fetching latest RC for project', options.project);
         const rc = await fetchRc(options);

package/dist/deploy/attribution.d.ts

@@ -0,0 +1,12 @@
+import type { attributionSchema } from './validation.js';
+import type { z } from 'zod/v4';
+type Attribution = z.infer<typeof attributionSchema>;
+/**
+ * Renders the deploy read-path "Created by" prose. This display string is
+ * derived here, never stored server-side.
+ *
+ * `redacted` wins over `agentName`: a redacted row's `displayName` is scrubbed
+ * server-side, so it must never be rendered — not even with an agent suffix.
+ */
+export declare function formatAttribution(attribution: Attribution | null): string;
+export {};

package/dist/deploy/attribution.js

@@ -0,0 +1,16 @@
+/**
+ * Renders the deploy read-path "Created by" prose. This display string is
+ * derived here, never stored server-side.
+ *
+ * `redacted` wins over `agentName`: a redacted row's `displayName` is scrubbed
+ * server-side, so it must never be rendered — not even with an agent suffix.
+ */
+export function formatAttribution(attribution) {
+    if (!attribution)
+        return 'Unknown';
+    if (attribution.redacted)
+        return 'Deleted user';
+    if (attribution.agentName)
+        return `${attribution.displayName} (via ${attribution.agentName})`;
+    return attribution.displayName;
+}

package/dist/deploy/log-renderer.d.ts

@@ -0,0 +1,13 @@
+import type { buildLogLineSchema } from './validation.js';
+import type { z } from 'zod/v4';
+type BuildLogLine = z.infer<typeof buildLogLineSchema>;
+export declare class LogRenderer {
+    private lastIndex;
+    /**
+     * Renders new log lines since the last call.
+     * Returns the number of new lines rendered.
+     */
+    render(lines: BuildLogLine[] | null, log: (msg: string) => void): number;
+    reset(): void;
+}
+export {};

package/dist/deploy/log-renderer.js

@@ -0,0 +1,21 @@
+import { stripColorsIfDisabled } from '../format/color.js';
+export class LogRenderer {
+    lastIndex = 0;
+    /**
+     * Renders new log lines since the last call.
+     * Returns the number of new lines rendered.
+     */
+    render(lines, log) {
+        if (!lines)
+            return 0;
+        const newLines = lines.slice(this.lastIndex);
+        for (const line of newLines) {
+            log(stripColorsIfDisabled(line.text));
+        }
+        this.lastIndex = lines.length;
+        return newLines.length;
+    }
+    reset() {
+        this.lastIndex = 0;
+    }
+}

package/dist/deploy/polling.d.ts

@@ -0,0 +1,4 @@
+declare const POLL_INTERVAL_MS = 5000;
+export declare function isTerminalStatus(status: string): boolean;
+export declare function sleep(ms: number): Promise<void>;
+export { POLL_INTERVAL_MS };

package/dist/deploy/polling.js

@@ -0,0 +1,12 @@
+const POLL_INTERVAL_MS = 5000;
+// Mirrors the terminal members of the DB `project_deployment_status` enum.
+// `not_available` is terminal: the hosting facade sets it (and promotes) when a
+// provider lacks live status updates, so a poll loop must treat it as final.
+const TERMINAL_STATUSES = new Set(['success', 'error', 'canceled', 'not_available']);
+export function isTerminalStatus(status) {
+    return TERMINAL_STATUSES.has(status);
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export { POLL_INTERVAL_MS };

package/dist/deploy/validation.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod/v4';
+export declare const deployTriggerResponseSchema: z.ZodObject<{
+    deploymentId: z.ZodString;
+    status: z.ZodString;
+    environment: z.ZodString;
+    previewName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const attributionSchema: z.ZodObject<{
+    principalType: z.ZodEnum<{
+        user: "user";
+        "api-key": "api-key";
+        system: "system";
+    }>;
+    displayName: z.ZodString;
+    email: z.ZodNullable<z.ZodString>;
+    agentName: z.ZodNullable<z.ZodString>;
+    redacted: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const deploymentStatusResponseSchema: z.ZodObject<{
+    deploymentId: z.ZodString;
+    status: z.ZodString;
+    environment: z.ZodString;
+    previewName: z.ZodNullable<z.ZodString>;
+    url: z.ZodNullable<z.ZodString>;
+    lastError: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    stoppedAt: z.ZodNullable<z.ZodString>;
+    attribution: z.ZodNullable<z.ZodObject<{
+        principalType: z.ZodEnum<{
+            user: "user";
+            "api-key": "api-key";
+            system: "system";
+        }>;
+        displayName: z.ZodString;
+        email: z.ZodNullable<z.ZodString>;
+        agentName: z.ZodNullable<z.ZodString>;
+        redacted: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const deploymentsListResponseSchema: z.ZodObject<{
+    deployments: z.ZodArray<z.ZodObject<{
+        deploymentId: z.ZodString;
+        status: z.ZodString;
+        environment: z.ZodString;
+        previewName: z.ZodNullable<z.ZodString>;
+        url: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        stoppedAt: z.ZodNullable<z.ZodString>;
+        attribution: z.ZodNullable<z.ZodObject<{
+            principalType: z.ZodEnum<{
+                user: "user";
+                "api-key": "api-key";
+                system: "system";
+            }>;
+            displayName: z.ZodString;
+            email: z.ZodNullable<z.ZodString>;
+            agentName: z.ZodNullable<z.ZodString>;
+            redacted: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const buildLogLineSchema: z.ZodObject<{
+    text: z.ZodString;
+    level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>>>;
+    timestamp: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const deploymentLogsResponseSchema: z.ZodObject<{
+    lines: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+        }>>>;
+        timestamp: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    supported: z.ZodBoolean;
+    deploymentStatus: z.ZodString;
+}, z.core.$strip>;