@pikku/cli 0.12.133 → 0.12.134

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

@@ -4,7 +4,7 @@ export declare const FabricDeployInput: z.ZodObject<{
     production: z.ZodOptional<z.ZodBoolean>;
     ref: z.ZodOptional<z.ZodString>;
     deploymentId: z.ZodOptional<z.ZodString>;
-    sync: z.ZodOptional<z.ZodBoolean>;
+    detach: z.ZodOptional<z.ZodBoolean>;
     autoApprove: z.ZodOptional<z.ZodBoolean>;
     allowDestructive: z.ZodOptional<z.ZodBoolean>;
     timeout: z.ZodOptional<z.ZodNumber>;
@@ -15,7 +15,7 @@ export declare const FabricDeployValidatedInput: z.ZodObject<{
     production: z.ZodOptional<z.ZodBoolean>;
     ref: z.ZodOptional<z.ZodString>;
     deploymentId: z.ZodOptional<z.ZodString>;
-    sync: z.ZodOptional<z.ZodBoolean>;
+    detach: z.ZodOptional<z.ZodBoolean>;
     autoApprove: z.ZodOptional<z.ZodBoolean>;
     allowDestructive: z.ZodOptional<z.ZodBoolean>;
     timeout: z.ZodOptional<z.ZodNumber>;
@@ -90,12 +90,21 @@ export declare const FabricDeployApplyOutput: z.ZodObject<{
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type ApplyOutput = z.infer<typeof FabricDeployApplyOutput>;
+/**
+ * The branch to deploy when none was named, read off the checkout.
+ *
+ * `git rev-parse --abbrev-ref HEAD` answers the literal string `HEAD` on a
+ * detached checkout, which is not a branch and would be reported downstream as
+ * a branch that does not exist locally. Naming the real problem here is the
+ * difference between "check out a branch" and a puzzle.
+ */
+export declare const branchFromHead: (head: string) => string;
 export declare const FabricDeployApply: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
     branch?: string | undefined;
     production?: boolean | undefined;
     ref?: string | undefined;
     deploymentId?: string | undefined;
-    sync?: boolean | undefined;
+    detach?: boolean | undefined;
     autoApprove?: boolean | undefined;
     allowDestructive?: boolean | undefined;
     timeout?: number | undefined;
@@ -158,7 +167,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     production?: boolean | undefined;
     ref?: string | undefined;
     deploymentId?: string | undefined;
-    sync?: boolean | undefined;
+    detach?: boolean | undefined;
     autoApprove?: boolean | undefined;
     allowDestructive?: boolean | undefined;
     timeout?: number | undefined;
@@ -221,7 +230,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     production?: boolean | undefined;
     ref?: string | undefined;
     deploymentId?: string | undefined;
-    sync?: boolean | undefined;
+    detach?: boolean | undefined;
     autoApprove?: boolean | undefined;
     allowDestructive?: boolean | undefined;
     timeout?: number | undefined;

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

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
-import { assertNamedBranchDeploySafety, resolveRef } from '../lib/git.js';
+import { assertNamedBranchDeploySafety, currentBranch, resolveRef, } from '../lib/git.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';
@@ -12,7 +12,7 @@ export const FabricDeployInput = z.object({
     production: z.boolean().optional(),
     ref: z.string().optional(),
     deploymentId: z.string().optional(),
-    sync: z.boolean().optional(),
+    detach: z.boolean().optional(),
     autoApprove: z.boolean().optional(),
     allowDestructive: z.boolean().optional(),
     timeout: z.number().optional(),
@@ -23,15 +23,15 @@ export const FabricDeployValidatedInput = FabricDeployInput.superRefine((value,
         if (value.branch || value.production) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
-                message: '--deployment-id already names its target — drop --branch/--production.',
+                message: '--deployment-id already names its target — drop the branch/--production.',
             });
         }
         return;
     }
-    if (!!value.branch === !!value.production) {
+    if (value.branch && value.production) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: 'Pass exactly one of --branch or --production.',
+            message: 'Pass a branch or --production, not both — --production is always main.',
         });
     }
 });
@@ -96,16 +96,25 @@ async function prepDeploy({ branch, production, ref }) {
     if (!ctx.projectId) {
         throw new Error('No fabric project linked. Run `pikku fabric link` first.');
     }
-    // Guarded rather than asserted: the schema-level refine is bypassed whenever
-    // the function is called outside CLI arg parsing, and `branch!` turned that
-    // into "local branch undefined does not exist" — an error that names nothing.
-    if (!production && !branch) {
-        throw new Error('Pass exactly one of --branch or --production.');
-    }
-    const targetBranch = production ? 'main' : branch;
+    // With no target named, deploy the branch that is checked out — the common
+    // case, and the one worth not making people type twice. It is only safe to
+    // infer because `assertNamedBranchDeploySafety` below refuses any branch that
+    // is missing an upstream or out of sync with it, so an inferred target cannot
+    // ship something that was never pushed.
+    const inferred = !production && !branch;
+    const targetBranch = production
+        ? 'main'
+        : (branch ?? branchFromHead(await currentBranch()));
     const safety = await assertNamedBranchDeploySafety(targetBranch);
     const resolved = ref ? ((await resolveRef(ref)) ?? ref) : safety.headSha;
-    return { ctx, projectId: ctx.projectId, targetBranch, resolved, safety };
+    return {
+        ctx,
+        projectId: ctx.projectId,
+        targetBranch,
+        resolved,
+        safety,
+        inferred,
+    };
 }
 async function prepAttach() {
     const ctx = await resolveApiContext();
@@ -124,6 +133,20 @@ const EXIT_BY_OUTCOME = {
     blocked: 3,
     timeout: 4,
 };
+/**
+ * The branch to deploy when none was named, read off the checkout.
+ *
+ * `git rev-parse --abbrev-ref HEAD` answers the literal string `HEAD` on a
+ * detached checkout, which is not a branch and would be reported downstream as
+ * a branch that does not exist locally. Naming the real problem here is the
+ * difference between "check out a branch" and a puzzle.
+ */
+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>`.');
+    }
+    return head;
+};
 export const FabricDeployApply = pikkuSessionlessFunc({
     description: 'Build + deploy a named branch or production (main), or attach to an existing deployment.',
     input: FabricDeployValidatedInput,
@@ -137,7 +160,7 @@ export const FabricDeployApply = pikkuSessionlessFunc({
             throw new Error('--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 --branch/--production.');
+            throw new Error('--deployment-id already names its target — drop the branch/--production.');
         }
         const attaching = Boolean(input.deploymentId);
         let projectId;
@@ -158,11 +181,17 @@ export const FabricDeployApply = pikkuSessionlessFunc({
             emit({ event: 'attached', deploymentId, status: current.status });
         }
         else {
-            const { ctx, projectId: id, targetBranch, resolved, safety, } = await prepDeploy(input);
+            const { ctx, projectId: id, targetBranch, resolved, safety, inferred, } = await prepDeploy(input);
             projectId = id;
             branch = targetBranch;
             ref = resolved;
             rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+            // An inferred target is said out loud before anything is built. Under -y
+            // there is no confirmation prompt to name it, and a deploy that never
+            // told you which branch it picked is the one that ships the wrong branch.
+            if (inferred && !input.json) {
+                console.log(dim(`Deploying the current branch: ${targetBranch}`));
+            }
             if (!input.autoApprove) {
                 const target = `${branch} @ ${resolved.slice(0, 8)}`;
                 if (!process.stdin.isTTY) {
@@ -202,7 +231,7 @@ export const FabricDeployApply = pikkuSessionlessFunc({
             ...(stageId ? { stageId } : {}),
             ...(runId ? { runId } : {}),
         };
-        if (!input.sync && !attaching) {
+        if (input.detach && !attaching) {
             return { ...base, outcome: 'queued' };
         }
         let approvalWithheld;
@@ -225,7 +254,7 @@ export const FabricDeployApply = pikkuSessionlessFunc({
                 : '';
             return promptConfirm(`Plan for ${branch ?? deploymentId} is ready to publish (${stateLabel(status.status, status.statusReason)}).${warning} Approve?`);
         };
-        if (!input.sync) {
+        if (input.detach) {
             const status = await readDeploymentStatus(rpc, deploymentId);
             const klass = classifyStatus(status.status);
             const outcome = klass === 'in_flight' ? 'queued' : klass;
@@ -324,7 +353,7 @@ const missingLines = (label, entries) => {
         ...entries.map((e) => `    ${e.name}${e.displayName ? dim(` (${e.displayName})`) : ''}${e.docsUrl ? dim(` — ${e.docsUrl}`) : ''}`),
     ];
 };
-const reattachHint = (deploymentId) => dim(`Re-attach with \`pikku fabric deploy apply --deployment-id ${deploymentId} --sync\`.`);
+const reattachHint = (deploymentId) => dim(`Re-attach with \`pikku fabric deploy apply --deployment-id ${deploymentId}\`.`);
 export const renderDeployApply = (_s, result) => {
     const { outcome, branch, ref, deploymentId, status, statusReason, changes, workers, url, elapsedMs, timeoutSeconds, approved, } = result;
     const where = branch ?? 'deployment';
@@ -363,10 +392,10 @@ export const renderDeployApply = (_s, result) => {
             console.log(line);
         if (result.approvalWithheld === 'destructive_migrations') {
             console.log(dim('The plan drops or rewrites data. Nothing was published — review the migrations above, then re-run with `--allow-destructive` to accept them.'));
-            console.log(dim(`\`pikku fabric deploy apply --deployment-id ${deploymentId} --sync --auto-approve --allow-destructive\``));
+            console.log(dim(`\`pikku fabric deploy apply --deployment-id ${deploymentId} -y --allow-destructive\``));
         }
         else if (isApprovable(reason) && !approved) {
-            console.log(dim(`Approve it with \`pikku fabric deploy apply --deployment-id ${deploymentId} --sync --auto-approve\`.`));
+            console.log(dim(`Approve it with \`pikku fabric deploy apply --deployment-id ${deploymentId} -y\`.`));
         }
         else if (reason === 'needs_config') {
             for (const hint of missingConfigHints(result.missingSecrets, result.missingVariables)) {

package/dist/src/fabric/lib/stage.js

@@ -23,7 +23,7 @@ export async function resolveStage(rpc, projectId, branch) {
             return { stageId: only.stageId, branch: only.branch };
         }
         throw new Error(stages.length === 0
-            ? 'No stages deployed for this project yet — run `pikku fabric deploy apply --branch <branch>` first.'
+            ? 'No stages deployed for this project yet — run `pikku fabric deploy apply <branch>` first.'
             : `--branch is required — this project has ${stages.length} stages: ${known.join(', ')}`);
     }
     const stage = stages.find((s) => s.branch === branch);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.133",
+  "version": "0.12.134",
   "description": "Pikku CLI — code generation, dev server, migrations and deployment",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",

package/surface.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.12.133",
+  "version": "0.12.134",
   "entryPoints": [
     {
       "id": "app",