@pikku/cli 0.12.20 → 0.12.22

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

@@ -0,0 +1,122 @@
+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 { assertNamedBranchDeploySafety, resolveRef } from '../lib/git.js';
+import { promptConfirm } from '../lib/prompt.js';
+import { added, changed, dim } from '../lib/output.js';
+export const FabricDeployInput = z.object({
+    branch: z.string().optional(),
+    production: z.boolean().optional(),
+    ref: z.string().optional(),
+    message: z.string().optional(),
+    autoApply: z.boolean().optional(),
+});
+export const FabricDeployValidatedInput = FabricDeployInput.superRefine((value, ctx) => {
+    if (!!value.branch === !!value.production) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Pass exactly one of --branch or --production.',
+        });
+    }
+});
+// `plan` resolves the target ref and reports what a deploy would do — nothing
+// is queued, so there is no deploymentId/stageId/runId yet. `apply` carries
+// those once the deploy is queued. The two intentionally have distinct shapes
+// rather than one shape padded with empty-string sentinels.
+export const FabricDeployPlanOutput = z.object({
+    projectId: z.string(),
+    branch: z.string(),
+    ref: z.string(),
+    requestedRef: z.string().optional(),
+});
+export const FabricDeployApplyOutput = z.object({
+    projectId: z.string(),
+    branch: z.string(),
+    ref: z.string(),
+    deploymentId: z.string(),
+    stageId: z.string(),
+    runId: z.string(),
+});
+/**
+ * Shared prep for `deploy plan` and `deploy apply`: authenticate, resolve the
+ * target branch, and resolve the ref to a concrete sha. Returns everything both
+ * subcommands need; neither prints — human output lives in the renders.
+ */
+async function prepDeploy({ branch, production, ref }) {
+    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 targetBranch = production ? 'main' : branch;
+    const safety = await assertNamedBranchDeploySafety(targetBranch);
+    const resolved = ref ? ((await resolveRef(ref)) ?? ref) : safety.headSha;
+    const requestedRef = ref && resolved !== safety.headSha ? ref : undefined;
+    return {
+        ctx,
+        projectId: ctx.projectId,
+        targetBranch,
+        resolved,
+        requestedRef,
+        safety,
+    };
+}
+export const FabricDeployPlan = pikkuSessionlessFunc({
+    description: 'Resolve the target ref and report what a deploy would do.',
+    input: FabricDeployValidatedInput,
+    output: FabricDeployPlanOutput,
+    func: async (_services, input) => {
+        const { projectId, targetBranch, resolved, requestedRef } = await prepDeploy(input);
+        return { projectId, branch: targetBranch, ref: resolved, requestedRef };
+    },
+});
+export const FabricDeployApply = pikkuSessionlessFunc({
+    description: 'Build + deploy a named branch or production (main).',
+    input: FabricDeployValidatedInput,
+    output: FabricDeployApplyOutput,
+    func: async (_services, input) => {
+        const { ctx, projectId, targetBranch, resolved, safety } = await prepDeploy(input);
+        // Classic yes/no guard. `--auto-apply` skips it; a non-interactive session
+        // has no human to answer, so we refuse rather than hang.
+        if (!input.autoApply) {
+            const target = `${targetBranch} @ ${resolved.slice(0, 8)}`;
+            if (!process.stdin.isTTY) {
+                throw new Error(`Refusing to deploy ${target} without confirmation — re-run with --auto-apply to deploy non-interactively.`);
+            }
+            const ok = await promptConfirm(`Deploy ${target}?`);
+            if (!ok) {
+                throw new Error('Deploy aborted.');
+            }
+        }
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const result = await rpc.invoke('deployByStageKind', {
+            projectId,
+            branch: targetBranch,
+            ref: resolved,
+            expectedHeadSha: safety.headSha,
+        });
+        return {
+            projectId,
+            branch: targetBranch,
+            ref: resolved,
+            deploymentId: result.deploymentId,
+            stageId: result.stageId,
+            runId: result.runId,
+        };
+    },
+});
+export const renderDeployPlan = (_s, { projectId, branch, ref, requestedRef, }) => {
+    if (requestedRef) {
+        console.log(dim(`retargeted ${requestedRef} → ${ref.slice(0, 8)}`));
+    }
+    console.log(`${changed('plan')} ${dim('would deploy')} ${branch} ${dim('@')} ${ref.slice(0, 8)} ${dim(`(${projectId})`)}`);
+    // The coloured added/changed/removed manifest diff lands here once `plan`
+    // returns it from the preview workflow.
+    console.log(dim('Run `pikku fabric deploy apply` to execute.'));
+};
+export const renderDeployApply = (_s, { branch, ref, deploymentId }) => {
+    console.log(`${added('queued')} deploy ${branch} ${dim('@')} ${ref.slice(0, 8)} ${dim('·')} ${deploymentId}`);
+};

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

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

package/dist/src/fabric/functions/domains-add.function.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { findProjectConfig, resolveApiContext } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+export const FabricDomainsAddInput = z.object({
+    hostname: z.string(),
+    target: z.enum(['api', 'app']).optional(),
+    apiUrl: z.string().optional(),
+});
+export const FabricDomainsAddOutput = z.object({
+    hostname: z.string(),
+    cnameTarget: z.string(),
+});
+export const FabricDomainsAdd = pikkuSessionlessFunc({
+    description: 'Add a custom domain to the production stage.',
+    input: FabricDomainsAddInput,
+    output: FabricDomainsAddOutput,
+    func: async (_services, { hostname, target = 'api', apiUrl: apiUrlOverride }) => {
+        const ctx = await resolveApiContext({ apiUrlOverride });
+        if (!ctx.token)
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        const local = await findProjectConfig();
+        if (!local)
+            throw new Error('No fabric.config.json found. Run `pikku fabric link` first.');
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const stagesResult = await rpc.invoke('listStages', {
+            projectId: local.config.projectId,
+        });
+        const production = stagesResult.stages.find((s) => s.type === 'production');
+        if (!production)
+            throw new Error('No production stage exists yet — deploy the project first.');
+        const result = await rpc.invoke('addStageCustomHostname', {
+            stageId: production.stageId,
+            hostname,
+            target,
+        });
+        console.log('');
+        console.log(`  ✓ added   ${hostname}  (${target})`);
+        console.log(`            CNAME: ${hostname}  →  ${result.cnameTarget}`);
+        if (result.ownershipVerification?.name) {
+            console.log(`            Ownership: ${result.ownershipVerification.type ?? 'TXT'} ${result.ownershipVerification.name} = ${result.ownershipVerification.value}`);
+        }
+        console.log('');
+        return { hostname, cnameTarget: result.cnameTarget };
+    },
+});

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const FabricDomainsListInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricDomainsListOutput: z.ZodObject<{
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export declare const FabricDomainsList: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+}, {
+    count: number;
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+}, {
+    count: number;
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+}, {
+    count: number;
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { findProjectConfig, resolveApiContext } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+export const FabricDomainsListInput = z.object({
+    apiUrl: z.string().optional(),
+});
+export const FabricDomainsListOutput = z.object({
+    count: z.number(),
+});
+export const FabricDomainsList = pikkuSessionlessFunc({
+    description: 'List custom domains for the linked project.',
+    input: FabricDomainsListInput,
+    output: FabricDomainsListOutput,
+    func: async (_services, { apiUrl: apiUrlOverride }) => {
+        const ctx = await resolveApiContext({ apiUrlOverride });
+        if (!ctx.token)
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        const local = await findProjectConfig();
+        if (!local)
+            throw new Error('No fabric.config.json found. Run `pikku fabric link` first.');
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const stagesResult = await rpc.invoke('listStages', {
+            projectId: local.config.projectId,
+        });
+        const production = stagesResult.stages.find((s) => s.type === 'production');
+        if (!production) {
+            console.log('');
+            console.log(`Project: ${local.config.projectId}`);
+            console.log('  No production stage exists yet.');
+            console.log('');
+            return { count: 0 };
+        }
+        const result = await rpc.invoke('listStageCustomHostnames', {
+            stageId: production.stageId,
+        });
+        console.log('');
+        console.log(`Project: ${local.config.projectId}`);
+        if (result.hostnames.length === 0) {
+            console.log('  No custom domains attached.');
+        }
+        else {
+            for (const h of result.hostnames) {
+                console.log(`  ${h.hostname.padEnd(40)} ${h.target.padEnd(4)}  ${h.status.padEnd(12)}  CNAME → ${h.cnameTarget}`);
+            }
+        }
+        console.log('');
+        return { count: result.hostnames.length };
+    },
+});

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const FabricDomainsRemoveInput: z.ZodObject<{
+    hostname: z.ZodString;
+    apiUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricDomainsRemoveOutput: z.ZodObject<{
+    removed: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const FabricDomainsRemove: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    hostname: string;
+    apiUrl?: string | undefined;
+}, {
+    removed: boolean;
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    hostname: string;
+    apiUrl?: string | undefined;
+}, {
+    removed: boolean;
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    hostname: string;
+    apiUrl?: string | undefined;
+}, {
+    removed: boolean;
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;

package/dist/src/fabric/functions/domains-remove.function.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { findProjectConfig, resolveApiContext } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+export const FabricDomainsRemoveInput = z.object({
+    hostname: z.string(),
+    apiUrl: z.string().optional(),
+});
+export const FabricDomainsRemoveOutput = z.object({
+    removed: z.boolean(),
+});
+export const FabricDomainsRemove = pikkuSessionlessFunc({
+    description: 'Remove a custom domain from the production stage.',
+    input: FabricDomainsRemoveInput,
+    output: FabricDomainsRemoveOutput,
+    func: async (_services, { hostname, apiUrl: apiUrlOverride }) => {
+        const ctx = await resolveApiContext({ apiUrlOverride });
+        if (!ctx.token)
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        const local = await findProjectConfig();
+        if (!local)
+            throw new Error('No fabric.config.json found. Run `pikku fabric link` first.');
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const stagesResult = await rpc.invoke('listStages', {
+            projectId: local.config.projectId,
+        });
+        const production = stagesResult.stages.find((s) => s.type === 'production');
+        if (!production)
+            throw new Error('No production stage found.');
+        const hostnamesResult = await rpc.invoke('listStageCustomHostnames', {
+            stageId: production.stageId,
+        });
+        const match = hostnamesResult.hostnames.find((h) => h.hostname === hostname.toLowerCase());
+        if (!match)
+            throw new Error(`Hostname "${hostname}" is not attached to this project.`);
+        await rpc.invoke('removeStageCustomHostname', {
+            customHostnameId: match.customHostnameId,
+        });
+        console.log('');
+        console.log(`  ✓ removed ${hostname}`);
+        console.log('');
+        return { removed: true };
+    },
+});

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

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const FabricErrorsInput: z.ZodObject<{
+    branch: z.ZodDefault<z.ZodString>;
+    function: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricErrorsOutput: z.ZodObject<{
+    branch: z.ZodString;
+    errors: z.ZodArray<z.ZodAny>;
+}, z.core.$strip>;
+/**
+ * Recent error-level events for a stage — minimal and actionable, not a
+ * persisted/grouped error tracker. Each row carries a traceId so you can hand
+ * off to `pikku fabric trace <traceId>`. Reuses the existing logs RPC.
+ */
+export declare const FabricErrors: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    branch: string;
+    function?: string | undefined;
+}, {
+    branch: string;
+    errors: any[];
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    branch: string;
+    function?: string | undefined;
+}, {
+    branch: string;
+    errors: any[];
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    branch: string;
+    function?: string | undefined;
+}, {
+    branch: string;
+    errors: any[];
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;
+type ErrorRow = {
+    timestamp: string;
+    functionName: string;
+    message: string;
+    traceId?: string;
+};
+export declare const renderErrors: (_s: unknown, { branch, errors }: {
+    branch: string;
+    errors: ErrorRow[];
+}) => void;
+export {};

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

@@ -0,0 +1,50 @@
+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 { table, removed, dim } from '../lib/output.js';
+export const FabricErrorsInput = z.object({
+    branch: z.string().default('main'),
+    function: z.string().optional(),
+});
+export const FabricErrorsOutput = z.object({
+    branch: z.string(),
+    errors: z.array(z.any()),
+});
+/**
+ * Recent error-level events for a stage — minimal and actionable, not a
+ * persisted/grouped error tracker. Each row carries a traceId so you can hand
+ * off to `pikku fabric trace <traceId>`. Reuses the existing logs RPC.
+ */
+export const FabricErrors = pikkuSessionlessFunc({
+    description: 'Show recent error-level events for a branch (with traceIds)',
+    input: FabricErrorsInput,
+    output: FabricErrorsOutput,
+    func: async (_services, { branch, function: functionName }) => {
+        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 { logs } = await rpc.invoke('getFabricLogsByStageKind', {
+            projectId: ctx.projectId,
+            branch,
+            level: 'error',
+            ...(functionName ? { functionName } : {}),
+        });
+        return { branch, errors: logs };
+    },
+});
+export const renderErrors = (_s, { branch, errors }) => {
+    if (errors.length === 0) {
+        console.log(dim(`No errors for ${branch}.`));
+        return;
+    }
+    console.log(table(['WHEN', 'FUNCTION', 'TRACE', 'MESSAGE'], errors.map((l) => [
+        l.timestamp,
+        l.functionName,
+        l.traceId ?? '',
+        removed(l.message.replace(/\s+/g, ' ').slice(0, 100)),
+    ])));
+};

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const FabricInitInput: z.ZodObject<{
+    repo: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    force: z.ZodOptional<z.ZodBoolean>;
+    apiUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricInitOutput: z.ZodObject<{
+    projectId: z.ZodString;
+    projectSlug: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Adopt an existing repo as a fabric project. Calls `importProject` on
+ * fabric-api which inserts the project + stage rows synchronously, then
+ * writes `fabric.config.json` next to `pikku.config.json` so subsequent
+ * `pikku fabric deploy / secretsSet / rollback` commands resolve the link
+ * automatically.
+ */
+export declare const FabricInit: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    repo: string;
+    name?: string | undefined;
+    branch?: string | undefined;
+    force?: boolean | undefined;
+    apiUrl?: string | undefined;
+}, {
+    projectId: string;
+    projectSlug: string;
+    path: string;
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    repo: string;
+    name?: string | undefined;
+    branch?: string | undefined;
+    force?: boolean | undefined;
+    apiUrl?: string | undefined;
+}, {
+    projectId: string;
+    projectSlug: string;
+    path: string;
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    repo: string;
+    name?: string | undefined;
+    branch?: string | undefined;
+    force?: boolean | undefined;
+    apiUrl?: string | undefined;
+}, {
+    projectId: string;
+    projectSlug: string;
+    path: string;
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;

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

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { findProjectConfig, resolveApiContext, writeProjectConfig, } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+export const FabricInitInput = z.object({
+    repo: z.string(),
+    name: z.string().optional(),
+    branch: z.string().optional(),
+    force: z.boolean().optional(),
+    apiUrl: z.string().optional(),
+});
+export const FabricInitOutput = z.object({
+    projectId: z.string(),
+    projectSlug: z.string(),
+    path: z.string(),
+});
+/**
+ * Adopt an existing repo as a fabric project. Calls `importProject` on
+ * fabric-api which inserts the project + stage rows synchronously, then
+ * writes `fabric.config.json` next to `pikku.config.json` so subsequent
+ * `pikku fabric deploy / secretsSet / rollback` commands resolve the link
+ * automatically.
+ */
+export const FabricInit = pikkuSessionlessFunc({
+    description: 'Adopt an existing repo as a fabric project (writes fabric.config.json).',
+    input: FabricInitInput,
+    output: FabricInitOutput,
+    func: async (_services, { repo, name, branch, force, apiUrl: apiUrlOverride }) => {
+        const ctx = await resolveApiContext({ apiUrlOverride });
+        if (!ctx.token)
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        const existing = await findProjectConfig();
+        if (existing && !force) {
+            throw new Error(`Already linked: ${existing.config.projectId} at ${existing.path}. Pass --force to replace.`);
+        }
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const result = await rpc.invoke('importProject', {
+            repoUrl: repo,
+            name,
+            defaultBranch: branch,
+        });
+        const path = await writeProjectConfig(process.cwd(), {
+            projectId: result.projectId,
+            ...(apiUrlOverride ? { apiUrl: apiUrlOverride } : {}),
+        });
+        console.log(`[fabric] imported ${result.projectSlug} (${result.projectId}) → ${path}`);
+        console.log(`[fabric] main stage: ${result.mainStageId}`);
+        return {
+            projectId: result.projectId,
+            projectSlug: result.projectSlug,
+            path,
+        };
+    },
+});

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const FabricLinkInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricLinkOutput: z.ZodObject<{
+    projectSlug: z.ZodString;
+    deploymentId: z.ZodString;
+    stageId: z.ZodString;
+}, z.core.$strip>;
+export declare const FabricLink: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+}, {
+    projectSlug: string;
+    deploymentId: string;
+    stageId: string;
+}, "rpc" | "session", import("../../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+}, {
+    projectSlug: string;
+    deploymentId: string;
+    stageId: string;
+}, "rpc" | "session", import("../../../types/application-types.js").Services> | import("../../../.pikku/pikku-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+}, {
+    projectSlug: string;
+    deploymentId: string;
+    stageId: string;
+}, "rpc" | "session", import("../../../types/application-types.js").Services>, undefined, undefined>;

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

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { resolveApiContext, writeProjectConfig } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+import { assertDeploySafety, getRemoteUrl } from '../lib/git.js';
+export const FabricLinkInput = z.object({
+    apiUrl: z.string().optional(),
+});
+export const FabricLinkOutput = z.object({
+    projectSlug: z.string(),
+    deploymentId: z.string(),
+    stageId: z.string(),
+});
+const GITHUB_POLL_INTERVAL_MS = 2000;
+const GITHUB_POLL_TIMEOUT_MS = 5 * 60 * 1000;
+export const FabricLink = pikkuSessionlessFunc({
+    description: 'Register the current git repo as a fabric project and queue an initial deploy.',
+    input: FabricLinkInput,
+    output: FabricLinkOutput,
+    func: async (_services, { apiUrl: apiUrlOverride }) => {
+        const ctx = await resolveApiContext({ apiUrlOverride });
+        if (!ctx.token) {
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        }
+        const remoteUrl = await getRemoteUrl();
+        const safety = await assertDeploySafety();
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        // Only check GitHub App installation for github.com repos.
+        // Gitea (local dev) and other hosts use shared tokens — no App needed.
+        const isGithub = /github\.com/i.test(remoteUrl);
+        if (isGithub) {
+            const ghInstall = await rpc.invoke('checkGithubInstall', {});
+            if (!ghInstall.installed) {
+                if (!ghInstall.installUrl) {
+                    throw new Error('GitHub App is not configured on this fabric deployment.');
+                }
+                console.log('');
+                console.log('  GitHub App not installed. Connect GitHub to continue:');
+                console.log('');
+                console.log(`    ${ghInstall.installUrl}`);
+                console.log('');
+                console.log('  Waiting for GitHub App installation...');
+                const deadline = Date.now() + GITHUB_POLL_TIMEOUT_MS;
+                let installed = false;
+                while (Date.now() < deadline) {
+                    await new Promise((r) => setTimeout(r, GITHUB_POLL_INTERVAL_MS));
+                    const check = await rpc.invoke('checkGithubInstall', {});
+                    if (check.installed) {
+                        installed = true;
+                        console.log(`  GitHub connected (${check.accountLogin})`);
+                        break;
+                    }
+                }
+                if (!installed) {
+                    throw new Error('Timed out waiting for GitHub App installation. Run `pikku fabric link` again after installing.');
+                }
+            }
+        }
+        const project = await rpc.invoke('importProject', { repoUrl: remoteUrl });
+        await writeProjectConfig(process.cwd(), {
+            projectId: project.projectId,
+            ...(apiUrlOverride ? { apiUrl: apiUrlOverride } : {}),
+        });
+        console.log(`[fabric] linked ${project.projectSlug}`);
+        const deploy = await rpc.invoke('deployByStageKind', {
+            projectId: project.projectId,
+            branch: safety.branch,
+            expectedHeadSha: safety.headSha,
+        });
+        console.log(`[fabric] queued deploy: branch=${safety.branch} deploymentId=${deploy.deploymentId}`);
+        return {
+            projectSlug: project.projectSlug,
+            deploymentId: deploy.deploymentId,
+            stageId: deploy.stageId,
+        };
+    },
+});