@pikku/cli 0.12.145 → 0.12.152

package/dist/src/fabric/functions/changes-list.function.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import type { ListChangesOutput } from '../sdk/rpc-map.gen.d.js';
+export declare const FabricChangesListInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    stageId: z.ZodOptional<z.ZodString>;
+    route: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    pickupOnly: z.ZodOptional<z.ZodBoolean>;
+    includeDone: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const FabricChangesListOutput: z.ZodObject<{
+    changes: z.ZodAny;
+    groups: z.ZodAny;
+}, z.core.$strip>;
+export declare const FabricChangesList: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    route?: string | undefined;
+    groupId?: string | undefined;
+    pickupOnly?: boolean | undefined;
+    includeDone?: boolean | undefined;
+    limit?: number | undefined;
+}, {
+    changes: any;
+    groups: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    route?: string | undefined;
+    groupId?: string | undefined;
+    pickupOnly?: boolean | undefined;
+    includeDone?: boolean | undefined;
+    limit?: number | undefined;
+}, {
+    changes: any;
+    groups: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    route?: string | undefined;
+    groupId?: string | undefined;
+    pickupOnly?: boolean | undefined;
+    includeDone?: boolean | undefined;
+    limit?: number | undefined;
+}, {
+    changes: any;
+    groups: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
+type Change = ListChangesOutput['changes'][number];
+type Group = ListChangesOutput['groups'][number];
+export declare const renderChangesList: (_s: unknown, { changes, groups }: {
+    changes: Change[];
+    groups: Group[];
+}) => void;
+export {};

package/dist/src/fabric/functions/changes-list.function.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { age, changesContext, remaining, requireProjectId, } from '../lib/changes.js';
+import { dim, safe, statusColor } from '../lib/output.js';
+export const FabricChangesListInput = z.object({
+    apiUrl: z.string().optional(),
+    projectId: z.string().optional(),
+    stageId: z.string().optional(),
+    route: z.string().optional(),
+    groupId: z.string().optional(),
+    pickupOnly: z.boolean().optional(),
+    includeDone: z.boolean().optional(),
+    limit: z.number().optional(),
+});
+export const FabricChangesListOutput = z.object({
+    changes: z.any(),
+    groups: z.any(),
+});
+export const FabricChangesList = pikkuSessionlessFunc({
+    description: 'List the open changes filed against a project.',
+    input: FabricChangesListInput,
+    output: FabricChangesListOutput,
+    func: async (_services, input) => {
+        const { rpc, projectId } = await changesContext(input.apiUrl, input.projectId);
+        return await rpc.invoke('listChanges', {
+            projectId: requireProjectId(projectId),
+            stageId: input.stageId,
+            route: input.route,
+            groupId: input.groupId,
+            pickupOnly: input.pickupOnly ?? false,
+            includeDone: input.includeDone ?? false,
+            limit: input.limit ?? 50,
+        });
+    },
+});
+const line = (change) => {
+    const flags = [
+        statusColor(change.status),
+        change.held ? dim('held') : null,
+        change.route ? safe(change.route) : null,
+    ]
+        .filter(Boolean)
+        .join('  ');
+    console.log(`  #${safe(change.shortId)}  ${safe(change.title)}`);
+    console.log(`      ${flags}  ${age(change.createdAt)} ago  ${dim(safe(change.changeId))}`);
+    const named = (change.capture?.elements ?? [])
+        .map((element) => element.testId ?? element.sourceAnchor ?? element.cssPath)
+        .filter((name) => !!name)
+        .map(safe);
+    if (named.length)
+        console.log(dim(`      circled: ${named.join(', ')}`));
+};
+export const renderChangesList = (_s, { changes, groups }) => {
+    if (!changes.length) {
+        console.log(dim('  Nothing open.'));
+        return;
+    }
+    const listed = new Set(groups.map((group) => group.groupId));
+    const ungrouped = changes.filter((change) => !change.groupId);
+    const grouped = changes.filter((change) => change.groupId);
+    if (ungrouped.length) {
+        console.log(`unclaimed (${ungrouped.length})`);
+        ungrouped.forEach(line);
+    }
+    for (const group of groups) {
+        const members = grouped.filter((change) => change.groupId === group.groupId);
+        if (!members.length)
+            continue;
+        const lease = group.claimedBy && group.claimExpiresAt
+            ? `claimed by ${safe(group.claimedBy)}, ${remaining(group.claimExpiresAt)} left`
+            : 'unclaimed';
+        console.log('');
+        console.log(`${safe(group.title)}  ${dim(`(${lease})  ${safe(group.groupId)}`)}`);
+        members.forEach(line);
+    }
+    const orphaned = grouped.filter((change) => !listed.has(change.groupId));
+    if (orphaned.length) {
+        console.log('');
+        console.log(dim('grouped, group not listed'));
+        orphaned.forEach(line);
+    }
+};

package/dist/src/fabric/functions/changes-shot.function.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import type { AttachChangeShotOutput } from '../sdk/rpc-map.gen.d.js';
+export declare const FabricChangesShotInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    changeId: z.ZodString;
+    label: z.ZodString;
+    image: z.ZodOptional<z.ZodString>;
+    imageBase64: z.ZodOptional<z.ZodString>;
+    contentType: z.ZodOptional<z.ZodEnum<{
+        "image/jpeg": "image/jpeg";
+        "image/png": "image/png";
+        "image/webp": "image/webp";
+    }>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        evidence: "evidence";
+        option: "option";
+    }>>;
+    authorName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricChangesShotOutput: z.ZodObject<{
+    message: z.ZodAny;
+    key: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `--image <path>` rather than only the raw base64 the API takes: this command
+ * runs on the machine that rendered the variant, so making the caller shell out
+ * to `base64` puts a multi-megabyte argument on the command line for no reason.
+ */
+export declare const FabricChangesShot: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    label: string;
+    image?: string | undefined;
+    imageBase64?: string | undefined;
+    contentType?: "image/jpeg" | "image/png" | "image/webp" | undefined;
+    kind?: "evidence" | "option" | undefined;
+    authorName?: string | undefined;
+}, {
+    message: any;
+    key: string;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    label: string;
+    image?: string | undefined;
+    imageBase64?: string | undefined;
+    contentType?: "image/jpeg" | "image/png" | "image/webp" | undefined;
+    kind?: "evidence" | "option" | undefined;
+    authorName?: string | undefined;
+}, {
+    message: any;
+    key: string;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    label: string;
+    image?: string | undefined;
+    imageBase64?: string | undefined;
+    contentType?: "image/jpeg" | "image/png" | "image/webp" | undefined;
+    kind?: "evidence" | "option" | undefined;
+    authorName?: string | undefined;
+}, {
+    message: any;
+    key: string;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
+export declare const renderChangesShot: (_s: unknown, { message, key }: AttachChangeShotOutput) => void;

package/dist/src/fabric/functions/changes-shot.function.js

@@ -0,0 +1,56 @@
+import { readFile } from 'node:fs/promises';
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { changesContext, imageContentType, } from '../lib/changes.js';
+import { dim, safe } from '../lib/output.js';
+export const FabricChangesShotInput = z.object({
+    apiUrl: z.string().optional(),
+    changeId: z.string(),
+    label: z.string(),
+    image: z.string().optional(),
+    imageBase64: z.string().optional(),
+    contentType: z.enum(['image/png', 'image/jpeg', 'image/webp']).optional(),
+    kind: z.enum(['option', 'evidence']).optional(),
+    authorName: z.string().optional(),
+});
+export const FabricChangesShotOutput = z.object({
+    message: z.any(),
+    key: z.string(),
+});
+/**
+ * `--image <path>` rather than only the raw base64 the API takes: this command
+ * runs on the machine that rendered the variant, so making the caller shell out
+ * to `base64` puts a multi-megabyte argument on the command line for no reason.
+ */
+export const FabricChangesShot = pikkuSessionlessFunc({
+    description: 'Attach a rendered option or a piece of evidence to a change.',
+    input: FabricChangesShotInput,
+    output: FabricChangesShotOutput,
+    func: async (_services, input) => {
+        if (!input.image && !input.imageBase64)
+            throw new Error('Pass --image <path> or --image-base64 <data>.');
+        let contentType = input.contentType;
+        let imageBase64 = input.imageBase64;
+        if (input.image) {
+            const inferred = imageContentType(input.image);
+            if (!inferred && !contentType)
+                throw new Error(`Cannot tell the image type from “${input.image}” — pass --content-type.`);
+            contentType ??= inferred;
+            imageBase64 = (await readFile(input.image)).toString('base64');
+        }
+        const { rpc } = await changesContext(input.apiUrl);
+        return await rpc.invoke('attachChangeShot', {
+            changeId: input.changeId,
+            label: input.label,
+            kind: input.kind ?? 'option',
+            contentType: contentType ?? 'image/png',
+            imageBase64: imageBase64,
+            authorName: input.authorName ?? 'pikku-cli',
+        });
+    },
+});
+export const renderChangesShot = (_s, { message, key }) => {
+    const count = message.attachments.length;
+    console.log(`Attached — the item now has ${count} attachment${count === 1 ? '' : 's'} in the panel.`);
+    console.log(dim(`key ${safe(key)}`));
+};

package/dist/src/fabric/functions/changes-show.function.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import type { GetChangeOutput } from '../sdk/rpc-map.gen.d.js';
+export declare const FabricChangesShowInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    changeId: z.ZodString;
+}, z.core.$strip>;
+export declare const FabricChangesShowOutput: z.ZodObject<{
+    change: z.ZodAny;
+    thread: z.ZodAny;
+    stageUrl: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricChangesShow: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+    changeId: string;
+}, {
+    change: any;
+    thread: any;
+    stageUrl: string | null;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+    changeId: string;
+}, {
+    change: any;
+    thread: any;
+    stageUrl: string | null;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+    changeId: string;
+}, {
+    change: any;
+    thread: any;
+    stageUrl: string | null;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
+type Change = GetChangeOutput['change'];
+type Message = GetChangeOutput['thread'][number];
+export declare const renderChangesShow: (_s: unknown, { change, thread, stageUrl, }: {
+    change: Change;
+    thread: Message[];
+    stageUrl: string | null;
+}) => void;
+export {};

package/dist/src/fabric/functions/changes-show.function.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { age, changesContext } from '../lib/changes.js';
+import { dim, keyValue, safe, safeBlock, statusColor } from '../lib/output.js';
+export const FabricChangesShowInput = z.object({
+    apiUrl: z.string().optional(),
+    changeId: z.string(),
+});
+export const FabricChangesShowOutput = z.object({
+    change: z.any(),
+    thread: z.any(),
+    stageUrl: z.string().nullable(),
+});
+export const FabricChangesShow = pikkuSessionlessFunc({
+    description: 'Read one change with its thread and its circled elements.',
+    input: FabricChangesShowInput,
+    output: FabricChangesShowOutput,
+    func: async (_services, input) => {
+        const { rpc } = await changesContext(input.apiUrl);
+        return await rpc.invoke('getChange', { changeId: input.changeId });
+    },
+});
+export const renderChangesShow = (_s, { change, thread, stageUrl, }) => {
+    console.log(`#${safe(change.shortId)}  ${safe(change.title)}`);
+    console.log(`${statusColor(change.status)}${change.held ? dim(' (held)') : ''}  ${dim(safe(change.changeId))}`);
+    if (change.body) {
+        console.log('');
+        console.log(safeBlock(change.body));
+    }
+    const rows = [];
+    if (change.route)
+        rows.push([
+            'route',
+            `${safe(change.route)}${stageUrl ? dim(`  (${safe(stageUrl)})`) : ''}`,
+        ]);
+    if (change.gitSha)
+        rows.push(['filed at', safe(change.gitSha)]);
+    if (change.viewport)
+        rows.push([
+            'viewport',
+            `${change.viewport.width}×${change.viewport.height}`,
+        ]);
+    if (change.screenshotUrl)
+        rows.push(['screenshot', safe(change.screenshotUrl)]);
+    let anchored = false;
+    for (const element of change.capture?.elements ?? []) {
+        const asOf = change.gitSha ? ` as of ${safe(change.gitSha)}` : '';
+        const addresses = [
+            element.sourceAnchor ? `${safe(element.sourceAnchor)}${asOf}` : null,
+            element.testId ? `testid ${safe(element.testId)}` : null,
+            element.cssPath ? safe(element.cssPath) : null,
+        ].filter((address) => !!address);
+        if (!addresses.length)
+            continue;
+        anchored ||= !!element.sourceAnchor;
+        rows.push([
+            'circled',
+            `${addresses[0]}${element.text ? dim(`  “${safe(element.text)}”`) : ''}`,
+        ]);
+        for (const fallback of addresses.slice(1))
+            rows.push(['', dim(fallback)]);
+    }
+    if (rows.length) {
+        console.log('');
+        console.log(keyValue(rows));
+    }
+    if (anchored && change.gitSha) {
+        console.log(dim(`The anchored line is where it was at ${safe(change.gitSha)} — find today's equivalent.`));
+    }
+    for (const message of thread) {
+        console.log('');
+        console.log(`${safe(message.authorName ?? message.authorKind)} ${dim(`· ${age(message.createdAt)} ago`)}`);
+        console.log(`  ${safeBlock(message.body)}`);
+        for (const attachment of message.attachments) {
+            console.log(`  ${dim(`[${safe(attachment.kind)}]`)} ${safe(attachment.label)}${attachment.url ? dim(`  ${safe(attachment.url)}`) : ''}`);
+        }
+        if (message.chosenOption)
+            console.log(`  picked: ${safe(message.chosenOption)}`);
+    }
+};

package/dist/src/fabric/functions/db-schema.function.d.ts

@@ -11,17 +11,17 @@ export declare const FabricDbSchema: import("../../../.pikku/function/pikku-func
 }, {
     branch: string;
     schema: any;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
     branch: string;
 }, {
     branch: string;
     schema: any;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
     branch: string;
 }, {
     branch: string;
     schema: any;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
 type Schema = {
     tables?: {
         name: string;

package/dist/src/fabric/functions/deploy-list.function.d.ts

@@ -11,17 +11,17 @@ export declare const FabricDeployList: import("../../../.pikku/function/pikku-fu
 }, {
     branch: string;
     deployments: any[];
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
     branch: string;
 }, {
     branch: string;
     deployments: any[];
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
     branch: string;
 }, {
     branch: string;
     deployments: any[];
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
 type DeploymentRow = {
     deploymentId: string;
     status: string;

package/dist/src/fabric/functions/deploy-units.function.d.ts

@@ -11,17 +11,17 @@ export declare const FabricDeployUnits: import("../../../.pikku/function/pikku-f
 }, {
     branch: string;
     workers: any[];
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
     branch: string;
 }, {
     branch: string;
     workers: any[];
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
     branch: string;
 }, {
     branch: string;
     workers: any[];
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
 type WorkerRow = {
     name: string;
     role: string;

package/dist/src/fabric/functions/deploy.function.d.ts

@@ -24,10 +24,10 @@ export declare const FabricDeployValidatedInput: z.ZodObject<{
 export declare const FabricDeployApplyOutput: z.ZodObject<{
     event: z.ZodLiteral<"result">;
     outcome: z.ZodEnum<{
+        blocked: "blocked";
         failed: "failed";
         queued: "queued";
         succeeded: "succeeded";
-        blocked: "blocked";
         timeout: "timeout";
     }>;
     projectId: z.ZodString;
@@ -39,10 +39,10 @@ export declare const FabricDeployApplyOutput: z.ZodObject<{
     stageId: z.ZodOptional<z.ZodString>;
     runId: z.ZodOptional<z.ZodString>;
     blockedReason: z.ZodOptional<z.ZodEnum<{
-        unknown: "unknown";
         awaiting_approval: "awaiting_approval";
-        needs_config: "needs_config";
         needs_attention: "needs_attention";
+        needs_config: "needs_config";
+        unknown: "unknown";
     }>>;
     missingSecrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -111,7 +111,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     json?: boolean | undefined;
 }, {
     event: "result";
-    outcome: "failed" | "queued" | "succeeded" | "blocked" | "timeout";
+    outcome: "blocked" | "failed" | "queued" | "succeeded" | "timeout";
     projectId: string;
     deploymentId: string;
     branch?: string | undefined;
@@ -120,7 +120,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     statusReason?: string | null | undefined;
     stageId?: string | undefined;
     runId?: string | undefined;
-    blockedReason?: "unknown" | "awaiting_approval" | "needs_config" | "needs_attention" | undefined;
+    blockedReason?: "awaiting_approval" | "needs_attention" | "needs_config" | "unknown" | undefined;
     missingSecrets?: {
         name: string;
         displayName: string | null;
@@ -162,7 +162,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     approved?: boolean | undefined;
     elapsedMs?: number | undefined;
     timeoutSeconds?: number | undefined;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
     branch?: string | undefined;
     production?: boolean | undefined;
     ref?: string | undefined;
@@ -174,7 +174,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     json?: boolean | undefined;
 }, {
     event: "result";
-    outcome: "failed" | "queued" | "succeeded" | "blocked" | "timeout";
+    outcome: "blocked" | "failed" | "queued" | "succeeded" | "timeout";
     projectId: string;
     deploymentId: string;
     branch?: string | undefined;
@@ -183,7 +183,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     statusReason?: string | null | undefined;
     stageId?: string | undefined;
     runId?: string | undefined;
-    blockedReason?: "unknown" | "awaiting_approval" | "needs_config" | "needs_attention" | undefined;
+    blockedReason?: "awaiting_approval" | "needs_attention" | "needs_config" | "unknown" | undefined;
     missingSecrets?: {
         name: string;
         displayName: string | null;
@@ -225,7 +225,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     approved?: boolean | undefined;
     elapsedMs?: number | undefined;
     timeoutSeconds?: number | undefined;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
     branch?: string | undefined;
     production?: boolean | undefined;
     ref?: string | undefined;
@@ -237,7 +237,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     json?: boolean | undefined;
 }, {
     event: "result";
-    outcome: "failed" | "queued" | "succeeded" | "blocked" | "timeout";
+    outcome: "blocked" | "failed" | "queued" | "succeeded" | "timeout";
     projectId: string;
     deploymentId: string;
     branch?: string | undefined;
@@ -246,7 +246,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     statusReason?: string | null | undefined;
     stageId?: string | undefined;
     runId?: string | undefined;
-    blockedReason?: "unknown" | "awaiting_approval" | "needs_config" | "needs_attention" | undefined;
+    blockedReason?: "awaiting_approval" | "needs_attention" | "needs_config" | "unknown" | undefined;
     missingSecrets?: {
         name: string;
         displayName: string | null;
@@ -288,6 +288,6 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     approved?: boolean | undefined;
     elapsedMs?: number | undefined;
     timeoutSeconds?: number | undefined;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
 export declare const renderDeployApply: (_s: unknown, result: ApplyOutput) => void;
 export {};

package/dist/src/fabric/functions/deploy.function.js

@@ -3,6 +3,7 @@ import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
 import { assertNamedBranchDeploySafety, currentBranch, resolveRef, } from '../lib/git.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 import { promptConfirm } from '../lib/prompt.js';
 import { added, changed, removed, dim, table } from '../lib/output.js';
 import { blockedReason, blockedSummary, missingConfigHints, changesAreEmpty, classifyStatus, describeDeployment, destructiveMigrations, isApprovable, readDeploymentStatus, readWorkers, reconcileDeployedRef, stateLabel, waitForDeployment, } from '../lib/deployment.js';
@@ -143,7 +144,7 @@ const EXIT_BY_OUTCOME = {
  */
 export const branchFromHead = (head) => {
     if (head === 'HEAD' || head === '') {
-        throw new Error('Deployment blocked: HEAD is detached, so there is no current branch to deploy.\nCheck out a branch, or name the target: `pikku fabric deploy apply <branch>`.');
+        throw new FabricPreconditionError('Deployment blocked: HEAD is detached, so there is no current branch to deploy.\nCheck out a branch, or name the target: `pikku fabric deploy apply <branch>`.');
     }
     return head;
 };
@@ -157,10 +158,10 @@ export const FabricDeployApply = pikkuSessionlessFunc({
             : () => { };
         const timeoutSeconds = input.timeout ?? DEFAULT_TIMEOUT_SECONDS;
         if (timeoutSeconds <= 0) {
-            throw new Error('--timeout must be a positive number of seconds.');
+            throw new FabricPreconditionError('--timeout must be a positive number of seconds.');
         }
         if (input.deploymentId && (input.branch || input.production)) {
-            throw new Error('--deployment-id already names its target — drop the branch/--production.');
+            throw new FabricPreconditionError('--deployment-id already names its target — drop the branch/--production.');
         }
         const attaching = Boolean(input.deploymentId);
         let projectId;
@@ -195,10 +196,10 @@ export const FabricDeployApply = pikkuSessionlessFunc({
             if (!input.autoApprove) {
                 const target = `${branch} @ ${resolved.slice(0, 8)}`;
                 if (!process.stdin.isTTY) {
-                    throw new Error(`Refusing to deploy ${target} without confirmation — re-run with --auto-approve to deploy non-interactively.`);
+                    throw new FabricPreconditionError(`Refusing to deploy ${target} without confirmation — re-run with --auto-approve to deploy non-interactively.`);
                 }
                 if (!(await promptConfirm(`Deploy ${target}?`))) {
-                    throw new Error('Deploy aborted.');
+                    throw new FabricPreconditionError('Deploy aborted.');
                 }
             }
             const created = await rpc.invoke('deployByStageKind', {

package/dist/src/fabric/functions/domains-add.function.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare const FabricDomainsAddInput: z.ZodObject<{
     hostname: z.ZodString;
     target: z.ZodOptional<z.ZodEnum<{
-        app: "app";
         api: "api";
+        app: "app";
     }>>;
     apiUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -13,23 +13,23 @@ export declare const FabricDomainsAddOutput: z.ZodObject<{
 }, z.core.$strip>;
 export declare const FabricDomainsAdd: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
     hostname: string;
-    target?: "app" | "api" | undefined;
+    target?: "api" | "app" | undefined;
     apiUrl?: string | undefined;
 }, {
     hostname: string;
     cnameTarget: string;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
     hostname: string;
-    target?: "app" | "api" | undefined;
+    target?: "api" | "app" | undefined;
     apiUrl?: string | undefined;
 }, {
     hostname: string;
     cnameTarget: string;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
     hostname: string;
-    target?: "app" | "api" | undefined;
+    target?: "api" | "app" | undefined;
     apiUrl?: string | undefined;
 }, {
     hostname: string;
     cnameTarget: string;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;