@pikku/cli 0.12.154 → 0.12.156

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

@@ -92,10 +92,10 @@ export const FabricDeployApplyOutput = z.object({
 async function prepDeploy({ branch, production, ref }) {
     const ctx = await resolveApiContext();
     if (!ctx.token) {
-        throw new Error('Not logged in. Run `pikku fabric login` first.');
+        throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
     }
     if (!ctx.projectId) {
-        throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+        throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
     }
     // 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
@@ -120,10 +120,10 @@ async function prepDeploy({ branch, production, ref }) {
 async function prepAttach() {
     const ctx = await resolveApiContext();
     if (!ctx.token) {
-        throw new Error('Not logged in. Run `pikku fabric login` first.');
+        throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
     }
     if (!ctx.projectId) {
-        throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+        throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
     }
     return { ctx, projectId: ctx.projectId };
 }

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { findProjectConfig, resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricDomainsAddInput = z.object({
     hostname: z.string(),
     target: z.enum(['api', 'app']).optional(),
@@ -18,17 +19,17 @@ export const FabricDomainsAdd = pikkuSessionlessFunc({
     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.');
+            throw new FabricPreconditionError('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.');
+            throw new FabricPreconditionError('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.');
+            throw new FabricPreconditionError('No production stage exists yet — deploy the project first.');
         const result = await rpc.invoke('addStageCustomHostname', {
             stageId: production.stageId,
             hostname,

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { findProjectConfig, resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricDomainsListInput = z.object({
     apiUrl: z.string().optional(),
 });
@@ -15,10 +16,10 @@ export const FabricDomainsList = pikkuSessionlessFunc({
     func: async (_services, { apiUrl: apiUrlOverride }) => {
         const ctx = await resolveApiContext({ apiUrlOverride });
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('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.');
+            throw new FabricPreconditionError('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,

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { findProjectConfig, resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricDomainsRemoveInput = z.object({
     hostname: z.string(),
     apiUrl: z.string().optional(),
@@ -16,23 +17,23 @@ export const FabricDomainsRemove = pikkuSessionlessFunc({
     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.');
+            throw new FabricPreconditionError('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.');
+            throw new FabricPreconditionError('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.');
+            throw new FabricPreconditionError('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.`);
+            throw new FabricPreconditionError(`Hostname "${hostname}" is not attached to this project.`);
         await rpc.invoke('removeStageCustomHostname', {
             customHostnameId: match.customHostnameId,
         });

package/dist/src/fabric/functions/errors.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 { table, removed, dim } from '../lib/output.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricErrorsInput = z.object({
     branch: z.string().default('main'),
     function: z.string().optional(),
@@ -23,9 +24,9 @@ export const FabricErrors = pikkuSessionlessFunc({
     func: async (_services, { branch, function: functionName }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('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,

package/dist/src/fabric/functions/findings-flush.function.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { resolveApiContext } from '../lib/config.js';
 import { flushSpool } from '../lib/finding-spool.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricFindingsFlushInput = z.object({
     apiUrl: z.string().optional(),
 });
@@ -22,7 +23,7 @@ export const FabricFindingsFlush = pikkuSessionlessFunc({
     func: async (_services, { apiUrl: apiUrlOverride }) => {
         const ctx = await resolveApiContext({ apiUrlOverride });
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         const result = await flushSpool({
             apiUrl: ctx.apiUrl,
             token: ctx.token,

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { findProjectConfig, isLinkedProjectId, resolveApiContext, writeProjectConfig, } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricInitInput = z.object({
     repo: z.string(),
     name: z.string().optional(),
@@ -28,10 +29,10 @@ export const FabricInit = pikkuSessionlessFunc({
     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.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         const existing = await findProjectConfig();
         if (existing && isLinkedProjectId(existing.config.projectId) && !force) {
-            throw new Error(`Already linked: ${existing.config.projectId} at ${existing.path}. Pass --force to replace.`);
+            throw new FabricPreconditionError(`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', {

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

@@ -32,10 +32,10 @@ export const FabricLink = pikkuSessionlessFunc({
     func: async (_services, { apiUrl: apiUrlOverride, github, gitea, repoName }) => {
         const ctx = await resolveApiContext({ apiUrlOverride });
         if (!ctx.token) {
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         }
         if (github && gitea) {
-            throw new Error('--github and --gitea name two different places to keep one repo. Pass one, or neither to use whatever `origin` already points at.');
+            throw new FabricPreconditionError('--github and --gitea name two different places to keep one repo. Pass one, or neither to use whatever `origin` already points at.');
         }
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         // Both of these are checked BEFORE anything is created. `assertDeploySafety`
@@ -58,7 +58,7 @@ export const FabricLink = pikkuSessionlessFunc({
             const ghInstall = await rpc.invoke('checkGithubInstall', {});
             if (!ghInstall.installed) {
                 if (!ghInstall.installUrl) {
-                    throw new Error('GitHub App is not configured on this fabric deployment.');
+                    throw new FabricPreconditionError('GitHub App is not configured on this fabric deployment.');
                 }
                 console.log('');
                 console.log('  GitHub App not installed. Connect GitHub to continue:');
@@ -78,7 +78,7 @@ export const FabricLink = pikkuSessionlessFunc({
                     }
                 }
                 if (!installed) {
-                    throw new Error('Timed out waiting for GitHub App installation. Run `pikku fabric link` again after installing.');
+                    throw new FabricPreconditionError('Timed out waiting for GitHub App installation. Run `pikku fabric link` again after installing.');
                 }
             }
         }
@@ -118,10 +118,10 @@ async function adoptExistingRemote({ github, gitea, }) {
     const remoteUrl = await getRemoteUrl();
     const onGithub = isGithubUrl(remoteUrl);
     if (github && !onGithub) {
-        throw new Error(`--github was passed, but origin is ${remoteUrl}, which is not on github.com.\nDrop the flag to link that remote, or repoint origin at the GitHub repo you meant.`);
+        throw new FabricPreconditionError(`--github was passed, but origin is ${remoteUrl}, which is not on github.com.\nDrop the flag to link that remote, or repoint origin at the GitHub repo you meant.`);
     }
     if (gitea && onGithub) {
-        throw new Error(`--gitea was passed, but origin is already ${remoteUrl}.\nDrop the flag to link the GitHub repo. To host it on fabric instead, remove the remote first (\`git remote remove origin\`) and run link again.`);
+        throw new FabricPreconditionError(`--gitea was passed, but origin is already ${remoteUrl}.\nDrop the flag to link the GitHub repo. To host it on fabric instead, remove the remote first (\`git remote remove origin\`) and run link again.`);
     }
     return remoteUrl;
 }
@@ -141,15 +141,15 @@ async function adoptExistingRemote({ github, gitea, }) {
  */
 async function createRemote({ rpc, github, gitea, repoName, }) {
     if (github) {
-        throw new Error('There is no `origin` to link, and fabric cannot create a GitHub repository for you.\nCreate it on github.com, `git remote add origin <url>`, and run `pikku fabric link` again — or pass --gitea to host it on fabric instead.');
+        throw new FabricPreconditionError('There is no `origin` to link, and fabric cannot create a GitHub repository for you.\nCreate it on github.com, `git remote add origin <url>`, and run `pikku fabric link` again — or pass --gitea to host it on fabric instead.');
     }
     if (!gitea) {
         if (!process.stdin.isTTY) {
-            throw new Error('There is no `origin` to link.\nPass --gitea to create a repository on fabric and push to it, or add a remote yourself and run link again.');
+            throw new FabricPreconditionError('There is no `origin` to link.\nPass --gitea to create a repository on fabric and push to it, or add a remote yourself and run link again.');
         }
         const confirmed = await promptConfirm('This project has no git remote. Create one on fabric and push this branch to it?', true);
         if (!confirmed) {
-            throw new Error('Nothing linked. Add a remote yourself (`git remote add origin <url>`) and run `pikku fabric link` again.');
+            throw new FabricPreconditionError('Nothing linked. Add a remote yourself (`git remote add origin <url>`) and run `pikku fabric link` again.');
         }
     }
     const name = repoName ?? basename(process.cwd());
@@ -165,7 +165,7 @@ async function createRemote({ rpc, github, gitea, repoName, }) {
         // ago — so removing it is safe, and it is what stops a retry dying on
         // "remote origin already exists" instead of on the real problem.
         await removeRemote('origin');
-        throw new Error(`Created ${repo.repoUrl} but could not push to it: ${error instanceof Error ? error.message : String(error)}\nThe repository exists and is empty; push to it yourself, or run link again to get a fresh one.`);
+        throw new FabricPreconditionError(`Created ${repo.repoUrl} but could not push to it: ${error instanceof Error ? error.message : String(error)}\nThe repository exists and is empty; push to it yourself, or run link again to get a fresh one.`);
     }
     console.log(`[fabric] pushed ${branch} to origin`);
     return repo.repoUrl;

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

@@ -4,6 +4,7 @@ import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { readAuthFile, writeAuthFile, resolveApiContext, } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
 import { deriveConsoleUrl } from '../lib/console-url.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricLoginInput = z.object({
     apiKey: z.string().optional(),
     token: z.string().optional(),
@@ -89,12 +90,12 @@ export const FabricLogin = pikkuSessionlessFunc({
             await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
             const result = await rpc.invoke('pollCliAuth', { code });
             if (result.status === 'expired') {
-                throw new Error('Code expired before confirmation. Run `pikku fabric login` again.');
+                throw new FabricPreconditionError('Code expired before confirmation. Run `pikku fabric login` again.');
             }
             // Distinct from expired: the user pressed Cancel, so stop immediately
             // rather than sitting here until the TTL runs out.
             if (result.status === 'rejected') {
-                throw new Error('Sign-in was cancelled in the browser. Run `pikku fabric login` again to retry.');
+                throw new FabricPreconditionError('Sign-in was cancelled in the browser. Run `pikku fabric login` again to retry.');
             }
             if (result.status === 'confirmed' && result.token) {
                 const auth = await readAuthFile();
@@ -104,6 +105,6 @@ export const FabricLogin = pikkuSessionlessFunc({
                 return { ok: true, apiUrl };
             }
         }
-        throw new Error('Login timed out.');
+        throw new FabricPreconditionError('Login timed out.');
     },
 });

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

@@ -31,9 +31,9 @@ export const FabricLogs = pikkuSessionlessFunc({
     func: async (_services, { branch, level, json, follow }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
         if (!branch)
             throw new FabricPreconditionError('Specify --branch <branch-name>.');
         const seen = new Set();

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

@@ -2,6 +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 { FabricPreconditionError } from '../lib/errors.js';
 export const FabricMetricsInput = z.object({
     branch: z.string(),
     hours: z.number().optional(),
@@ -20,9 +21,9 @@ export const FabricMetrics = pikkuSessionlessFunc({
     func: async (_services, { branch, hours, function: functionName, json }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         const res = await rpc.invoke('getProjectMetricsByStageKind', {
             projectId: ctx.projectId,

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

@@ -3,6 +3,7 @@ import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { findProjectConfig, resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
 import { dim } from '../lib/output.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricProjectsListInput = z.object({
     apiUrl: z.string().optional(),
 });
@@ -31,7 +32,7 @@ export const FabricProjectsList = pikkuSessionlessFunc({
     func: async (_services, { apiUrl: apiUrlOverride }) => {
         const ctx = await resolveApiContext({ apiUrlOverride });
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         const { projects } = await rpc.invoke('fabricCliProjects', {});
         const local = await findProjectConfig();

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

@@ -6,6 +6,7 @@ import { tmpdir } from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { resolveApiContext } from '../lib/config.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricPublishInput = z.object({
     dir: z.string().optional(),
     apiUrl: z.string().optional(),
@@ -33,18 +34,18 @@ export const FabricPublish = pikkuSessionlessFunc({
         const verification = await rpc.invoke('FabricAddonVerify', { dir });
         await cli?.channel.send(verification);
         if (!verification.ok) {
-            throw new Error('Addon verification failed — fix the errors above before publishing.');
+            throw new FabricPreconditionError('Addon verification failed — fix the errors above before publishing.');
         }
         const ctx = await resolveApiContext({ apiUrlOverride });
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         const packageDir = dir ?? process.cwd();
         const pkgPath = join(packageDir, 'package.json');
         if (!existsSync(pkgPath))
-            throw new Error(`No package.json found in ${packageDir}`);
+            throw new FabricPreconditionError(`No package.json found in ${packageDir}`);
         const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
         if (!pkg.name || !pkg.version)
-            throw new Error('package.json must have a name and version');
+            throw new FabricPreconditionError('package.json must have a name and version');
         // Pack via `npm pack` so the artifact honours the package's `files` field
         // (ship src/.pikku/types, not build/VCS noise) and matches the layout a
         // normal install produces. npm nests contents under `package/`; the
@@ -65,7 +66,7 @@ export const FabricPublish = pikkuSessionlessFunc({
                 body: JSON.stringify(body),
             });
             if (!r.ok)
-                throw new Error(`POST ${path} → ${r.status}: ${await r.text()}`);
+                throw new FabricPreconditionError(`POST ${path} → ${r.status}: ${await r.text()}`);
             return r.json();
         };
         // 1. presigned upload URL (short-lived)
@@ -74,7 +75,7 @@ export const FabricPublish = pikkuSessionlessFunc({
         //    is signed over host only; mismatched headers break the signature).
         const put = await fetch(uploadUrl, { method: 'PUT', body: artifact });
         if (!put.ok)
-            throw new Error(`upload failed → ${put.status}: ${await put.text()}`);
+            throw new FabricPreconditionError(`upload failed → ${put.status}: ${await put.text()}`);
         // 3. finalize — server reads the artifact back, extracts meta, indexes it
         const entry = await post('/registry/addons/publish', { artifactKey });
         const publisher = entry.publisher?.name ?? null;

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

@@ -4,6 +4,7 @@ import { resolveApiContext } from '../lib/config.js';
 import { collectReportEnvironment } from '../lib/report-environment.js';
 import { FindingInput, buildFindingPayload, parseFinding, parseFindingJson, postFinding, renderReceipt, validateFinding, } from '../lib/finding.js';
 import { flushSpool, readSpool, spoolFinding } from '../lib/finding-spool.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 /**
  * Every field is optional here and the strictness lives in `FindingInput`,
  * because `--stdin` supplies the whole finding at once and the flags then
@@ -21,7 +22,7 @@ export const FabricReportOutput = z.object({
 });
 const readStdin = async () => {
     if (process.stdin.isTTY) {
-        throw new Error('--stdin expects the finding as JSON on standard input, and nothing was piped in.');
+        throw new FabricPreconditionError('--stdin expects the finding as JSON on standard input, and nothing was piped in.');
     }
     const chunks = [];
     for await (const chunk of process.stdin)
@@ -49,11 +50,11 @@ export const FabricReport = pikkuSessionlessFunc({
             ? parseFindingJson(await readStdin())
             : parseFinding(flags);
         if ('problems' in parsed) {
-            throw new Error(parsed.problems.join('\n'));
+            throw new FabricPreconditionError(parsed.problems.join('\n'));
         }
         const problems = validateFinding(parsed.finding);
         if (problems.length > 0) {
-            throw new Error(problems.join('\n'));
+            throw new FabricPreconditionError(problems.join('\n'));
         }
         const payload = buildFindingPayload(parsed.finding, await collectReportEnvironment());
         console.log(renderReceipt(payload));

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

@@ -2,6 +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 { FabricPreconditionError } from '../lib/errors.js';
 export const FabricRollbackInput = z.object({
     branch: z.string(),
     target: z.string().optional(),
@@ -29,9 +30,9 @@ export const FabricRollback = pikkuSessionlessFunc({
     func: async (_services, { target, list, dryRun }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         // --list (or no target) → just show candidates.
         if (list || !target) {

package/dist/src/fabric/functions/secrets-delete.function.js

@@ -4,6 +4,7 @@ import { resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
 import { promptConfirm } from '../lib/prompt.js';
 import { resolveStage } from '../lib/stage.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricSecretsDeleteInput = z.object({
     name: z.string(),
     branch: z.string().optional(),
@@ -21,21 +22,21 @@ export const FabricSecretsDelete = pikkuSessionlessFunc({
     func: async (_services, { name, branch: requested, force }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
         // Resolved before the prompt so the confirmation names the stage that
         // would actually lose the secret, not an argument that may be absent.
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         const { stageId, branch } = await resolveStage(rpc, ctx.projectId, requested);
         if (!force) {
             if (!process.stdin.isTTY) {
-                throw new Error(`Refusing to delete ${name} from ${branch} without confirmation — re-run with --force to delete non-interactively.`);
+                throw new FabricPreconditionError(`Refusing to delete ${name} from ${branch} without confirmation — re-run with --force to delete non-interactively.`);
             }
             // Fabric cannot read the sealed value back, so this is not recoverable
             // by re-reading it — the plaintext has to be supplied again.
             if (!(await promptConfirm(`Delete ${name} from ${branch}? It cannot be recovered — the value must be set again.`))) {
-                throw new Error('Delete aborted.');
+                throw new FabricPreconditionError('Delete aborted.');
             }
         }
         const result = await rpc.invoke('deleteStageSecret', { stageId, name });

package/dist/src/fabric/functions/secrets-list.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 { resolveStage } from '../lib/stage.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricSecretsListInput = z.object({
     branch: z.string().optional(),
     json: z.boolean().optional(),
@@ -17,9 +18,9 @@ export const FabricSecretsList = pikkuSessionlessFunc({
     func: async (_services, { branch: requested, json }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         const { stageId, branch } = await resolveStage(rpc, ctx.projectId, requested);
         const result = await rpc.invoke('listStageSecretNames', { stageId });

package/dist/src/fabric/functions/secrets-rotate.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 { resolveStage } from '../lib/stage.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricSecretsRotateInput = z.object({
     branch: z.string().optional(),
     force: z.boolean().optional(),
@@ -17,9 +18,9 @@ export const FabricSecretsRotate = pikkuSessionlessFunc({
     func: async (_services, { branch: requested, force }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
         // Resolved before the refusal, so the one message standing between a
         // typo and unreadable secrets names the stage that would actually be
         // rotated rather than echoing an argument that may not have been passed.
@@ -29,7 +30,7 @@ export const FabricSecretsRotate = pikkuSessionlessFunc({
             // Not a confirmation for politeness — this is the one operation here
             // that destroys access to data. Fabric cannot read the sealed values, so
             // it cannot carry them over, and nobody can undo it afterwards.
-            throw new Error(`Rotating the sealing key on ${branch} makes every secret already set on it unreadable — fabric cannot re-seal values it cannot open, so each one must be set again after the next deploy. Re-run with --force if that is what you want.`);
+            throw new FabricPreconditionError(`Rotating the sealing key on ${branch} makes every secret already set on it unreadable — fabric cannot re-seal values it cannot open, so each one must be set again after the next deploy. Re-run with --force if that is what you want.`);
         }
         const result = await rpc.invoke('rotateStageSealingKey', { stageId });
         console.log(`[fabric] retired sealing key ${result.retiredKeyId} on ${branch}`);

package/dist/src/fabric/functions/secrets-set.function.js

@@ -2,6 +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 { FabricPreconditionError } from '../lib/errors.js';
 import { promptSecret } from '../lib/prompt.js';
 import { resolveStage } from '../lib/stage.js';
 import { seal, serializeSealedValue } from '../lib/sealed-box.js';
@@ -22,12 +23,18 @@ export const FabricSecretsSet = pikkuSessionlessFunc({
     func: async (_services, { name, branch: requested, value }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
-        const plaintext = value ?? (await promptSecret(`${name} value`));
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
+        // A value on the command line wins; otherwise the prompt, which reads
+        // piped stdin when there is no tty rather than waiting for a human who is
+        // not there. Both paths are scriptable, so neither can hang a CI job.
+        const plaintext = value ??
+            (await promptSecret(`${name} value`, {
+                nonInteractiveHint: `Pass the value with \`--value\`, or pipe it: \`echo '<value>' | pikku fabric secrets set ${name}\`.`,
+            }));
         if (!plaintext)
-            throw new Error('Empty secret value — aborting.');
+            throw new FabricPreconditionError('Empty secret value — aborting.');
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         const { stageId, branch } = await resolveStage(rpc, ctx.projectId, requested);
         // Fabric holds only the public half of this keypair. The private half went

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

@@ -11,6 +11,7 @@ import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { findProjectRoot, readJsonSafe, } from '../../functions/validate/validate.js';
 import { headSha, isWorkingTreeClean } from '../lib/git.js';
 import { added, changed, dim, removed } from '../lib/output.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 const DEFAULT_BUN_VERSION = 'bun@1.4.0';
 const DEFAULT_STEP_TIMEOUT_SECONDS = 300;
 const DEFAULT_STARTUP_TIMEOUT_SECONDS = 60;
@@ -146,7 +147,7 @@ async function waitForHealth(args) {
 }
 function rewriteFrontendCommand(command) {
     if (command.length === 0) {
-        throw new Error('frontend dev.command must not be empty');
+        throw new FabricPreconditionError('frontend dev.command must not be empty');
     }
     if (command[0] === 'yarn') {
         return {
@@ -461,7 +462,7 @@ async function createTempWorktree(root) {
         timeoutMs: 60_000,
     });
     if (!cloneStep.ok) {
-        throw new Error(`Failed to create temp checkout.\nworktree: ${step.tail || 'git worktree add failed.'}\nclone: ${cloneStep.tail || 'git clone failed.'}`);
+        throw new FabricPreconditionError(`Failed to create temp checkout.\nworktree: ${step.tail || 'git worktree add failed.'}\nclone: ${cloneStep.tail || 'git clone failed.'}`);
     }
     const detachStep = await runCommandStep({
         name: 'git checkout --detach',
@@ -471,7 +472,7 @@ async function createTempWorktree(root) {
         timeoutMs: 60_000,
     });
     if (!detachStep.ok) {
-        throw new Error(`Failed to detach temp checkout.\n${detachStep.tail || 'git checkout --detach failed.'}`);
+        throw new FabricPreconditionError(`Failed to detach temp checkout.\n${detachStep.tail || 'git checkout --detach failed.'}`);
     }
     return tempDir;
 }

package/dist/src/fabric/functions/status.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 { keyValue, statusColor, dim } from '../lib/output.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricStatusInput = z.object({});
 export const FabricStatusOutput = z.object({
     projectId: z.string(),
@@ -15,9 +16,9 @@ export const FabricStatus = pikkuSessionlessFunc({
     func: async (_services) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         const status = await rpc.invoke('getProjectStatus', {
             projectId: ctx.projectId,

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

@@ -2,6 +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 { FabricPreconditionError } from '../lib/errors.js';
 export const FabricTraceInput = z.object({
     branch: z.string(),
     traceId: z.string(),
@@ -21,9 +22,9 @@ export const FabricTrace = pikkuSessionlessFunc({
     func: async (_services, { branch, traceId, json }) => {
         const ctx = await resolveApiContext();
         if (!ctx.token)
-            throw new Error('Not logged in. Run `pikku fabric login` first.');
+            throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
         if (!ctx.projectId)
-            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+            throw new FabricPreconditionError('No fabric project linked. Run `pikku fabric link` first.');
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
         const res = await rpc.invoke('getTraceByStageKind', {
             projectId: ctx.projectId,