@pikku/cli 0.12.20 → 0.12.22

package/dist/src/fabric/fabric-commands.js

@@ -0,0 +1,299 @@
+/**
+ * Pikku addon entrypoint. Exports `fabricCommands` — a `defineCLICommands`
+ * map intended to be nested under the parent pikku CLI's `fabric:` subcommand
+ * group:
+ *
+ * ```ts
+ * import { fabricCommands } from '@pikku/fabric-cli'
+ *
+ * wireCLI({
+ *   program: 'pikku',
+ *   commands: {
+ *     // …existing commands…
+ *     fabric: { description: 'PikkuFabric commands', subcommands: fabricCommands },
+ *   },
+ * })
+ * ```
+ *
+ * There is only one `wireCLI` in the pikku binary — this package contributes
+ * a typed command map, nothing more.
+ */
+import { defineCLICommands, pikkuCLICommand, } from '../../.pikku/cli/pikku-cli-types.gen.js';
+import { FabricLogin } from './functions/login.function.js';
+import { FabricInit } from './functions/init.function.js';
+import { FabricLink } from './functions/link.function.js';
+import { FabricDeployPlan, FabricDeployApply, renderDeployPlan, renderDeployApply, } from './functions/deploy.function.js';
+import { FabricDeployList, renderDeployList, } from './functions/deploy-list.function.js';
+import { FabricDeployUnits, renderDeployUnits, } from './functions/deploy-units.function.js';
+import { FabricStatus, renderStatus } from './functions/status.function.js';
+import { FabricErrors, renderErrors } from './functions/errors.function.js';
+import { FabricDbSchema, renderDbSchema, } from './functions/db-schema.function.js';
+import { FabricRollback } from './functions/rollback.function.js';
+import { FabricSecretsSet } from './functions/secrets-set.function.js';
+import { FabricSecretsList } from './functions/secrets-list.function.js';
+import { FabricLogs } from './functions/logs.function.js';
+import { FabricMetrics } from './functions/metrics.function.js';
+import { FabricTrace } from './functions/trace.function.js';
+import { FabricDomainsList } from './functions/domains-list.function.js';
+import { FabricDomainsAdd } from './functions/domains-add.function.js';
+import { FabricDomainsRemove } from './functions/domains-remove.function.js';
+import { FabricLLMKey, renderLLMKey } from './functions/llm-key.function.js';
+import { FabricValidate, renderValidate, } from './functions/validate.function.js';
+export const fabricCommands = defineCLICommands({
+    validate: pikkuCLICommand({
+        func: FabricValidate,
+        render: renderValidate,
+        description: 'Check the project structure for fabric compatibility — prints all missing or misconfigured items with fix hints',
+    }),
+    login: pikkuCLICommand({
+        func: FabricLogin,
+        description: 'Authenticate against fabric-api',
+        options: {
+            apiKey: { description: 'Use a static API key instead of browser flow' },
+            token: {
+                description: 'Use an existing fabric token instead of browser flow',
+            },
+            apiUrl: { description: 'Override the fabric-api URL for this login' },
+            consoleUrl: { description: 'Override the console URL the browser opens' },
+        },
+    }),
+    init: pikkuCLICommand({
+        parameters: '<repo>',
+        func: FabricInit,
+        description: 'Adopt an existing git repo as a fabric project',
+        options: {
+            name: {
+                description: 'Override the project display name (defaults to repo name)',
+            },
+            branch: { description: 'Default branch (defaults to main)' },
+            force: {
+                description: 'Replace existing fabric.config.json',
+                default: false,
+            },
+            apiUrl: { description: 'Override the fabric-api URL for this call' },
+        },
+    }),
+    link: pikkuCLICommand({
+        func: FabricLink,
+        description: 'Register the current git repo as a fabric project and queue an initial deploy',
+        options: {
+            apiUrl: {
+                description: 'Override the fabric-api URL stored in fabric.config.json',
+            },
+        },
+    }),
+    deploy: {
+        description: 'Plan and apply deploys for a named branch or production',
+        subcommands: {
+            plan: pikkuCLICommand({
+                func: FabricDeployPlan,
+                render: renderDeployPlan,
+                description: 'Resolve the target ref and report what a deploy would do',
+                options: {
+                    branch: { description: 'Target branch to deploy', short: 'b' },
+                    production: {
+                        description: 'Plan production (always main)',
+                        default: false,
+                    },
+                },
+            }),
+            apply: pikkuCLICommand({
+                func: FabricDeployApply,
+                render: renderDeployApply,
+                description: 'Build + deploy a named branch or production (main)',
+                options: {
+                    branch: { description: 'Target branch to deploy', short: 'b' },
+                    production: {
+                        description: 'Deploy production (always main)',
+                        default: false,
+                    },
+                    message: {
+                        description: 'Annotation stored on the deployment',
+                        short: 'm',
+                    },
+                    autoApply: {
+                        description: 'Deploy without the confirmation prompt',
+                        default: false,
+                    },
+                },
+            }),
+            list: pikkuCLICommand({
+                func: FabricDeployList,
+                render: renderDeployList,
+                description: 'List recent deployments for a branch',
+                options: {
+                    branch: { description: 'Target branch', short: 'b' },
+                },
+            }),
+            units: pikkuCLICommand({
+                func: FabricDeployUnits,
+                render: renderDeployUnits,
+                description: 'List the deployed worker units (topology) for a branch',
+                options: {
+                    branch: { description: 'Target branch', short: 'b' },
+                },
+            }),
+        },
+    },
+    rollback: pikkuCLICommand({
+        parameters: '<branch> [target]',
+        func: FabricRollback,
+        description: 'Roll live back to a previous deployment artifact',
+        options: {
+            list: { description: 'List rollback candidates', default: false },
+            dryRun: {
+                description: 'Show schema-compat result without switching',
+                default: false,
+            },
+            yes: {
+                description: 'Skip confirmation prompts',
+                short: 'y',
+                default: false,
+            },
+        },
+    }),
+    secrets: {
+        description: 'Manage stage-scoped secrets',
+        subcommands: {
+            set: pikkuCLICommand({
+                parameters: '<name>',
+                func: FabricSecretsSet,
+                description: 'Set a stage-scoped secret',
+                options: {
+                    branch: { description: 'Target branch', short: 'b' },
+                    value: { description: 'Secret value (prompted if omitted)' },
+                    force: {
+                        description: 'Overwrite without confirmation',
+                        default: false,
+                    },
+                },
+            }),
+            list: pikkuCLICommand({
+                func: FabricSecretsList,
+                description: 'List stage secrets',
+                options: {
+                    branch: { description: 'Target branch', short: 'b' },
+                    json: { description: 'Machine-readable output', default: false },
+                },
+            }),
+        },
+    },
+    logs: pikkuCLICommand({
+        func: FabricLogs,
+        description: 'Stream or fetch logs',
+        options: {
+            branch: { description: 'Target branch', short: 'b' },
+            deployment: { description: 'Specific deployment id' },
+            level: { description: 'Minimum level (debug/info/warn/error)' },
+            since: { description: 'Time window (e.g. 15m, 2h)' },
+            follow: {
+                description: 'Stream new logs (SSE)',
+                short: 'f',
+                default: false,
+            },
+            json: { description: 'Machine-readable output', default: false },
+        },
+    }),
+    metrics: pikkuCLICommand({
+        func: FabricMetrics,
+        description: 'Show request rate / error rate / latency for a stage',
+        options: {
+            branch: { description: 'Target branch', short: 'b' },
+            hours: { description: 'Lookback window in hours (default 24)' },
+            function: { description: 'Filter by wire id (e.g. function name)' },
+            json: { description: 'Machine-readable output', default: false },
+        },
+    }),
+    trace: pikkuCLICommand({
+        parameters: '<traceId>',
+        func: FabricTrace,
+        description: 'Print every event for a single trace across the stage',
+        options: {
+            branch: { description: 'Target branch', short: 'b' },
+            json: { description: 'Machine-readable output', default: false },
+        },
+    }),
+    status: pikkuCLICommand({
+        func: FabricStatus,
+        render: renderStatus,
+        description: 'Show the linked project status (active + in-flight deploy)',
+    }),
+    errors: pikkuCLICommand({
+        func: FabricErrors,
+        render: renderErrors,
+        description: 'Show recent error-level events for a branch (with traceIds)',
+        options: {
+            branch: { description: 'Target branch', short: 'b' },
+            function: { description: 'Filter by function name' },
+        },
+    }),
+    db: {
+        description: 'Inspect the stage database',
+        subcommands: {
+            schema: pikkuCLICommand({
+                func: FabricDbSchema,
+                render: renderDbSchema,
+                description: 'Show the live database schema (tables + columns)',
+                options: {
+                    branch: { description: 'Target branch', short: 'b' },
+                },
+            }),
+        },
+    },
+    domains: {
+        description: 'Manage custom domains for the production stage',
+        subcommands: {
+            list: pikkuCLICommand({
+                func: FabricDomainsList,
+                description: 'List custom domains for the linked project',
+                options: {
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+            add: pikkuCLICommand({
+                parameters: '<hostname>',
+                func: FabricDomainsAdd,
+                description: 'Add a custom domain to the production stage',
+                options: {
+                    target: {
+                        description: 'Route target: api (Backend API) or app (Frontend App)',
+                        default: 'api',
+                    },
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+            remove: pikkuCLICommand({
+                parameters: '<hostname>',
+                func: FabricDomainsRemove,
+                description: 'Remove a custom domain from the production stage',
+                options: {
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+        },
+    },
+    llm: {
+        description: 'Fabric AI gateway developer key commands',
+        subcommands: {
+            key: pikkuCLICommand({
+                func: FabricLLMKey,
+                render: renderLLMKey,
+                description: 'Mint or reuse a developer-scoped Fabric AI gateway key',
+                options: {
+                    shell: {
+                        description: 'Print shell export lines',
+                        default: false,
+                    },
+                    env: {
+                        description: 'Print .env-style key-value lines',
+                        default: false,
+                    },
+                    json: {
+                        description: 'Print machine-readable JSON',
+                        default: false,
+                    },
+                },
+            }),
+        },
+    },
+});

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const FabricDbSchemaInput: z.ZodObject<{
+    branch: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricDbSchemaOutput: z.ZodObject<{
+    branch: z.ZodString;
+    schema: z.ZodAny;
+}, z.core.$strip>;
+export declare const FabricDbSchema: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    branch: string;
+}, {
+    branch: string;
+    schema: any;
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    branch: string;
+}, {
+    branch: string;
+    schema: any;
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    branch: string;
+}, {
+    branch: string;
+    schema: any;
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;
+type Schema = {
+    tables?: {
+        name: string;
+        columns: unknown[];
+    }[];
+} | null;
+export declare const renderDbSchema: (_s: unknown, { branch, schema }: {
+    branch: string;
+    schema: Schema;
+}) => void;
+export {};

package/dist/src/fabric/functions/db-schema.function.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { resolveApiContext } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+import { resolveStageId } from '../lib/stage.js';
+import { table, dim } from '../lib/output.js';
+export const FabricDbSchemaInput = z.object({
+    branch: z.string().default('main'),
+});
+export const FabricDbSchemaOutput = z.object({
+    branch: z.string(),
+    schema: z.any(),
+});
+export const FabricDbSchema = pikkuSessionlessFunc({
+    description: 'Show the live database schema (tables + columns) for a branch',
+    input: FabricDbSchemaInput,
+    output: FabricDbSchemaOutput,
+    func: async (_services, { branch }) => {
+        const ctx = await resolveApiContext();
+        if (!ctx.token)
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        if (!ctx.projectId)
+            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const stageId = await resolveStageId(rpc, ctx.projectId, branch);
+        const { schema } = await rpc.invoke('getStageDatabaseSchema', { stageId });
+        return { branch, schema };
+    },
+});
+export const renderDbSchema = (_s, { branch, schema }) => {
+    const tables = schema?.tables ?? [];
+    if (tables.length === 0) {
+        console.log(dim(`No schema for ${branch} (stage may have no database yet).`));
+        return;
+    }
+    console.log(table(['TABLE', 'COLUMNS'], tables.map((t) => [t.name, t.columns.length])));
+};

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const FabricDeployListInput: z.ZodObject<{
+    branch: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricDeployListOutput: z.ZodObject<{
+    branch: z.ZodString;
+    deployments: z.ZodArray<z.ZodAny>;
+}, z.core.$strip>;
+export declare const FabricDeployList: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    branch: string;
+}, {
+    branch: string;
+    deployments: any[];
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    branch: string;
+}, {
+    branch: string;
+    deployments: any[];
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    branch: string;
+}, {
+    branch: string;
+    deployments: any[];
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;
+type DeploymentRow = {
+    deploymentId: string;
+    status: string;
+    gitSha?: string | null;
+    versionMajor: number;
+    versionMinor: number;
+    versionPatch: number;
+    triggeredBy?: string | null;
+    trigger: string;
+    deployedAt?: string | null;
+    createdAt: string;
+};
+export declare const renderDeployList: (_s: unknown, { branch, deployments }: {
+    branch: string;
+    deployments: DeploymentRow[];
+}) => void;
+export {};

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

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { resolveApiContext } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+import { resolveStageId } from '../lib/stage.js';
+import { table, statusColor, dim } from '../lib/output.js';
+export const FabricDeployListInput = z.object({
+    branch: z.string().default('main'),
+});
+export const FabricDeployListOutput = z.object({
+    branch: z.string(),
+    deployments: z.array(z.any()),
+});
+export const FabricDeployList = pikkuSessionlessFunc({
+    description: 'List recent deployments for a branch',
+    input: FabricDeployListInput,
+    output: FabricDeployListOutput,
+    func: async (_services, { branch }) => {
+        const ctx = await resolveApiContext();
+        if (!ctx.token)
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        if (!ctx.projectId)
+            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const stageId = await resolveStageId(rpc, ctx.projectId, branch);
+        const { deployments } = await rpc.invoke('listDeployments', { stageId });
+        return { branch, deployments };
+    },
+});
+export const renderDeployList = (_s, { branch, deployments }) => {
+    if (deployments.length === 0) {
+        console.log(dim(`No deployments for ${branch}.`));
+        return;
+    }
+    console.log(table(['DEPLOYMENT', 'STATUS', 'SHA', 'VER', 'BY', 'WHEN'], deployments.map((d) => [
+        d.deploymentId,
+        statusColor(d.status === 'suspended' ? 'planned' : d.status),
+        (d.gitSha ?? '').slice(0, 7),
+        `${d.versionMajor}.${d.versionMinor}.${d.versionPatch}`,
+        d.triggeredBy ?? d.trigger,
+        d.deployedAt ?? d.createdAt,
+    ])));
+};

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const FabricDeployUnitsInput: z.ZodObject<{
+    branch: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricDeployUnitsOutput: z.ZodObject<{
+    branch: z.ZodString;
+    workers: z.ZodArray<z.ZodAny>;
+}, z.core.$strip>;
+export declare const FabricDeployUnits: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    branch: string;
+}, {
+    branch: string;
+    workers: any[];
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    branch: string;
+}, {
+    branch: string;
+    workers: any[];
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    branch: string;
+}, {
+    branch: string;
+    workers: any[];
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;
+type WorkerRow = {
+    name: string;
+    role: string;
+    status: string;
+    functionIds: string[];
+};
+export declare const renderDeployUnits: (_s: unknown, { branch, workers }: {
+    branch: string;
+    workers: WorkerRow[];
+}) => void;
+export {};

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { resolveApiContext } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+import { resolveStageId } from '../lib/stage.js';
+import { table, statusColor, dim } from '../lib/output.js';
+export const FabricDeployUnitsInput = z.object({
+    branch: z.string().default('main'),
+});
+export const FabricDeployUnitsOutput = z.object({
+    branch: z.string(),
+    workers: z.array(z.any()),
+});
+export const FabricDeployUnits = pikkuSessionlessFunc({
+    description: 'List the deployed worker units (topology) for a branch',
+    input: FabricDeployUnitsInput,
+    output: FabricDeployUnitsOutput,
+    func: async (_services, { branch }) => {
+        const ctx = await resolveApiContext();
+        if (!ctx.token)
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        if (!ctx.projectId)
+            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const stageId = await resolveStageId(rpc, ctx.projectId, branch);
+        const { workers } = await rpc.invoke('listDeploymentWorkers', { stageId });
+        return { branch, workers };
+    },
+});
+export const renderDeployUnits = (_s, { branch, workers }) => {
+    if (workers.length === 0) {
+        console.log(dim(`No deployed units for ${branch}.`));
+        return;
+    }
+    console.log(table(['WORKER', 'ROLE', 'STATUS', 'FUNCTIONS'], workers.map((w) => [
+        w.name,
+        w.role,
+        statusColor(w.status),
+        w.functionIds.length,
+    ])));
+};

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

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+export declare const FabricDeployInput: z.ZodObject<{
+    branch: z.ZodOptional<z.ZodString>;
+    production: z.ZodOptional<z.ZodBoolean>;
+    ref: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    autoApply: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const FabricDeployValidatedInput: z.ZodObject<{
+    branch: z.ZodOptional<z.ZodString>;
+    production: z.ZodOptional<z.ZodBoolean>;
+    ref: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    autoApply: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const FabricDeployPlanOutput: z.ZodObject<{
+    projectId: z.ZodString;
+    branch: z.ZodString;
+    ref: z.ZodString;
+    requestedRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricDeployApplyOutput: z.ZodObject<{
+    projectId: z.ZodString;
+    branch: z.ZodString;
+    ref: z.ZodString;
+    deploymentId: z.ZodString;
+    stageId: z.ZodString;
+    runId: z.ZodString;
+}, z.core.$strip>;
+export declare const FabricDeployPlan: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    branch?: string | undefined;
+    production?: boolean | undefined;
+    ref?: string | undefined;
+    message?: string | undefined;
+    autoApply?: boolean | undefined;
+}, {
+    projectId: string;
+    branch: string;
+    ref: string;
+    requestedRef?: string | undefined;
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    branch?: string | undefined;
+    production?: boolean | undefined;
+    ref?: string | undefined;
+    message?: string | undefined;
+    autoApply?: boolean | undefined;
+}, {
+    projectId: string;
+    branch: string;
+    ref: string;
+    requestedRef?: string | undefined;
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    branch?: string | undefined;
+    production?: boolean | undefined;
+    ref?: string | undefined;
+    message?: string | undefined;
+    autoApply?: boolean | undefined;
+}, {
+    projectId: string;
+    branch: string;
+    ref: string;
+    requestedRef?: string | undefined;
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;
+export declare const FabricDeployApply: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    branch?: string | undefined;
+    production?: boolean | undefined;
+    ref?: string | undefined;
+    message?: string | undefined;
+    autoApply?: boolean | undefined;
+}, {
+    projectId: string;
+    branch: string;
+    ref: string;
+    deploymentId: string;
+    stageId: string;
+    runId: string;
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    branch?: string | undefined;
+    production?: boolean | undefined;
+    ref?: string | undefined;
+    message?: string | undefined;
+    autoApply?: boolean | undefined;
+}, {
+    projectId: string;
+    branch: string;
+    ref: string;
+    deploymentId: string;
+    stageId: string;
+    runId: string;
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    branch?: string | undefined;
+    production?: boolean | undefined;
+    ref?: string | undefined;
+    message?: string | undefined;
+    autoApply?: boolean | undefined;
+}, {
+    projectId: string;
+    branch: string;
+    ref: string;
+    deploymentId: string;
+    stageId: string;
+    runId: string;
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;
+export declare const renderDeployPlan: (_s: unknown, { projectId, branch, ref, requestedRef, }: z.infer<typeof FabricDeployPlanOutput>) => void;
+export declare const renderDeployApply: (_s: unknown, { branch, ref, deploymentId }: z.infer<typeof FabricDeployApplyOutput>) => void;