@laioutr/cli 0.3.2 → 0.4.0

package/dist/commands/deploy/status.js

@@ -0,0 +1,38 @@
+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 --deploymentId dep_abc123'];
+    static flags = {
+        ...DeployBaseCommand.flags,
+        deploymentId: Flags.string({
+            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.cockpitApiHost,
+            apiKey: flags.key,
+            organizationSlug,
+            projectSlug,
+            deploymentId: flags.deploymentId,
+        });
+        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,23 @@
+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>;
+        cockpitApiHost: 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,129 @@
+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.cockpitApiHost,
+            apiKey: flags.key,
+            organizationSlug,
+            projectSlug,
+        };
+        // 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/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,20 @@
+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(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>;

package/dist/deploy/validation.js

@@ -0,0 +1,47 @@
+import { z } from 'zod/v4';
+export const deployTriggerResponseSchema = z.object({
+    deploymentId: z.string(),
+    status: z.string(),
+    environment: z.string(),
+    previewName: z.string().nullable(),
+});
+export const attributionSchema = z.object({
+    principalType: z.enum(['user', 'api-key', 'system']),
+    displayName: z.string(),
+    email: z.string().nullable(),
+    agentName: z.string().nullable(),
+    redacted: z.boolean(),
+});
+export const deploymentStatusResponseSchema = z.object({
+    deploymentId: z.string(),
+    status: z.string(),
+    environment: z.string(),
+    previewName: z.string().nullable(),
+    url: z.string().nullable(),
+    lastError: z.string().nullable(),
+    createdAt: z.string(),
+    stoppedAt: z.string().nullable(),
+    attribution: attributionSchema.nullable(),
+});
+export const deploymentsListResponseSchema = z.object({
+    deployments: z.array(z.object({
+        deploymentId: z.string(),
+        status: z.string(),
+        environment: z.string(),
+        previewName: z.string().nullable(),
+        url: z.string().nullable(),
+        createdAt: z.string(),
+        stoppedAt: z.string().nullable(),
+        attribution: attributionSchema.nullable(),
+    })),
+});
+export const buildLogLineSchema = z.object({
+    text: z.string(),
+    level: z.enum(['error', 'warning']).nullable().optional(),
+    timestamp: z.number().nullable().optional(),
+});
+export const deploymentLogsResponseSchema = z.object({
+    lines: z.array(buildLogLineSchema).nullable(),
+    supported: z.boolean(),
+    deploymentStatus: z.string(),
+});

package/dist/deploy-base-command.d.ts

@@ -0,0 +1,11 @@
+import LaioutrBaseCommand from './laioutr-base-command.js';
+import type { ProjectSlugs } from './project.js';
+export default abstract class DeployBaseCommand extends LaioutrBaseCommand {
+    static flags: {
+        project: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        key: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        cockpitApiHost: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        cwd: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected parseProject(project: string): ProjectSlugs;
+}

package/dist/deploy-base-command.js

@@ -0,0 +1,27 @@
+import { Flags } from '@oclif/core';
+import LaioutrBaseCommand from './laioutr-base-command.js';
+import { parseProjectSlug } from './project.js';
+export default class DeployBaseCommand extends LaioutrBaseCommand {
+    static flags = {
+        ...LaioutrBaseCommand.flags,
+        project: Flags.string({
+            char: 'p',
+            description: 'Project identifier in org/project format',
+            env: 'PROJECT',
+            required: true,
+        }),
+        key: Flags.string({
+            char: 'k',
+            description: 'Organization API key with project:deploy scope',
+            env: 'LAIOUTR_API_KEY',
+            required: true,
+        }),
+    };
+    parseProject(project) {
+        const parsed = parseProjectSlug(project);
+        if (!parsed) {
+            this.error('--project must be in org/project format');
+        }
+        return parsed;
+    }
+}

package/dist/format/detail.d.ts

@@ -0,0 +1,19 @@
+export type DetailField = [label: string, value: string | null | undefined];
+export interface FormatDetailOptions {
+    /** Optional heading printed above the aligned fields. */
+    title?: string;
+    /** Leading indent for each field line. Defaults to two spaces. */
+    indent?: string;
+}
+/**
+ * Formats an object's fields as an aligned `label: value` detail block:
+ *
+ *     Deployment dep_abc123
+ *       Status:      success
+ *       Environment: production
+ *
+ * Labels are padded so every value starts in the same column. Fields whose
+ * value is `null`, `undefined`, or empty are omitted, so a caller can list
+ * every possible field inline without pre-filtering the absent ones.
+ */
+export declare function formatDetail(fields: DetailField[], options?: FormatDetailOptions): string;

package/dist/format/detail.js

@@ -0,0 +1,18 @@
+/**
+ * Formats an object's fields as an aligned `label: value` detail block:
+ *
+ *     Deployment dep_abc123
+ *       Status:      success
+ *       Environment: production
+ *
+ * Labels are padded so every value starts in the same column. Fields whose
+ * value is `null`, `undefined`, or empty are omitted, so a caller can list
+ * every possible field inline without pre-filtering the absent ones.
+ */
+export function formatDetail(fields, options = {}) {
+    const indent = options.indent ?? '  ';
+    const present = fields.filter((field) => Boolean(field[1]));
+    const labelWidth = Math.max(0, ...present.map(([label]) => label.length));
+    const lines = present.map(([label, value]) => `${indent}${`${label}:`.padEnd(labelWidth + 2)}${value}`);
+    return options.title ? [options.title, ...lines].join('\n') : lines.join('\n');
+}

package/dist/project.d.ts

@@ -0,0 +1,14 @@
+export interface ProjectSlugs {
+    organizationSlug: string;
+    projectSlug: string;
+}
+/**
+ * Parses an `org/project` project identifier into its organization and project
+ * slugs.
+ *
+ * Tolerates a `/p/` path segment (e.g. a pasted `org/p/project` URL) by
+ * normalising it to a plain separator. Returns `null` when the input is not
+ * exactly two non-empty slash-separated parts, so callers decide how to report
+ * the error.
+ */
+export declare function parseProjectSlug(project: string): ProjectSlugs | null;

package/dist/project.js

@@ -0,0 +1,16 @@
+/**
+ * Parses an `org/project` project identifier into its organization and project
+ * slugs.
+ *
+ * Tolerates a `/p/` path segment (e.g. a pasted `org/p/project` URL) by
+ * normalising it to a plain separator. Returns `null` when the input is not
+ * exactly two non-empty slash-separated parts, so callers decide how to report
+ * the error.
+ */
+export function parseProjectSlug(project) {
+    const parts = project.replace('/p/', '/').split('/');
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        return null;
+    }
+    return { organizationSlug: parts[0], projectSlug: parts[1] };
+}