@pikku/cli 0.12.153 → 0.12.155

package/dist/src/deploy/build-pipeline.js

@@ -13,6 +13,7 @@ import { withoutScenarios } from '../functions/wirings/scenarios/scenario-partit
 import { generatePerUnitCodegen } from './codegen/per-unit-codegen.js';
 import { materializeFrontend } from './frontend-assets.js';
 import { assertFrontendBuilt } from '../utils/frontend.js';
+import { loadUserConfigForDb, } from '../functions/commands/db-shared.js';
 import { generateServerEntrySource, SERVER_DOCKERFILE, SERVER_DOCKERIGNORE, } from './server-entry.js';
 /**
  * A unit that failed codegen or bundling is an expected build outcome (the
@@ -61,6 +62,44 @@ function findLockfile(projectDir) {
     }
     return null;
 }
+/**
+ * The project's declared version, or nothing.
+ *
+ * Absent is a real answer — a project need not version itself — and is better
+ * reported as unknown than as a number this made up.
+ */
+function resolveProjectVersion(projectDir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(projectDir, 'package.json'), 'utf-8'));
+        return typeof pkg.version === 'string' ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The project's own database declaration, or nothing it could read.
+ *
+ * A config that throws, or names no `createConfig` at all, is reported as no
+ * declaration rather than as a build failure: it is only ever one of two
+ * signals here, and the directory conventions still answer for a project whose
+ * config needs an environment this build does not have.
+ */
+async function loadConfiguredDb(projectDir, srcDirectories, logger) {
+    try {
+        return await loadUserConfigForDb({
+            config: { rootDir: projectDir, srcDirectories },
+            logger: {
+                error: (msg) => logger.debug(msg),
+                warn: (msg) => logger.debug(msg),
+            },
+        });
+    }
+    catch (error) {
+        logger.debug(`Could not read createConfig to resolve the deploy database: ${error?.message ?? error}`);
+        return null;
+    }
+}
 /**
  * The database a standalone bundle has to open for itself.
  *
@@ -71,49 +110,59 @@ function findLockfile(projectDir) {
  * services factory does when the database is missing, which for the generated
  * templates is a throw.
  *
- * Engine comes from the migrations directory rather than the user config,
- * because that is the same signal `loadUserConfigForDb` falls back to and it
- * needs no module loading here. `db/sqlite` and `db/postgres` are the two
- * conventions the migrator already writes to, so a project declares its engine
- * by having written migrations for it.
+ * Engine is resolved the way every other pikku host resolves it: `createConfig`
+ * first, through the same `loadUserConfigForDb` the db commands use, and the
+ * `db/sqlite` / `db/postgres` conventions only as the fallback. Reading the
+ * directory alone left an app that declares its database in config and keeps no
+ * migrations getting a connection under `pikku dev` and none in its artifact —
+ * the same crash, reached a different way. A config that cannot be loaded falls
+ * back to the directories rather than failing the build, because a project with
+ * no database at all must still bundle.
+ *
+ * Both at once is refused rather than resolved, whether the two arrive as two
+ * migration directories or as `sqliteDb` beside `postgresUrl`. Picking one would
+ * be picking which database the deployed app talks to on the strength of
+ * directory order, and the failure — an app running happily against the wrong,
+ * fully valid schema — is invisible until someone reads the data.
  *
- * Both at once is refused rather than resolved. Picking one would be picking
- * which database the deployed app talks to on the strength of directory order,
- * and the failure — an app running happily against the wrong, fully valid
- * schema — is invisible until someone reads the data.
+ * Only the engine travels. A configured SQLite path is a developer's local file
+ * and has no meaning on the target host, which names its own through
+ * `PIKKU_DATA_DIR`.
  *
  * The migrations are copied in beside the bundle under the same `db/<engine>/`
  * path they have in the project, which is also where Fabric's build container
  * stages them. Two producers writing the artifact cannot disagree about where
  * the SQL lives, and `bundle.js db migrate` finds it either way.
  */
-/**
- * The project's declared version, or nothing.
- *
- * Absent is a real answer — a project need not version itself — and is better
- * reported as unknown than as a number this made up.
- */
-function resolveProjectVersion(projectDir) {
-    try {
-        const pkg = JSON.parse(readFileSync(join(projectDir, 'package.json'), 'utf-8'));
-        return typeof pkg.version === 'string' ? pkg.version : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function resolveStandaloneDb(projectDir, pikkuDir, unitDir) {
+export async function resolveStandaloneDb(projectDir, pikkuDir, unitDir, srcDirectories, logger) {
     const hasSqlite = existsSync(join(projectDir, 'db', 'sqlite'));
     const hasPostgres = existsSync(join(projectDir, 'db', 'postgres'));
     if (hasSqlite && hasPostgres) {
         throw new Error('This project has both db/sqlite and db/postgres migrations, so a standalone build cannot tell which database the app is meant to open. Keep the one this app deploys against.');
     }
-    const engine = hasSqlite ? 'sqlite' : hasPostgres ? 'postgres' : undefined;
+    const userConfig = await loadConfiguredDb(projectDir, srcDirectories, logger);
+    if (userConfig?.postgresUrl && userConfig?.sqliteDb) {
+        throw new Error('createConfig sets both postgresUrl and sqliteDb, so a standalone build cannot tell which database the app is meant to open. Configure exactly one database dialect.');
+    }
+    const engine = userConfig?.postgresUrl
+        ? 'postgres'
+        : userConfig?.sqliteDb
+            ? 'sqlite'
+            : hasSqlite
+                ? 'sqlite'
+                : hasPostgres
+                    ? 'postgres'
+                    : undefined;
     if (!engine)
         return undefined;
-    await cp(join(projectDir, 'db', engine), join(unitDir, 'db', engine), {
-        recursive: true,
-    });
+    // Absent for a database whose schema is created outside the migrator, which
+    // is a database to connect to rather than a reason to hand the app none.
+    const migrationsDir = join(projectDir, 'db', engine);
+    if (existsSync(migrationsDir)) {
+        await cp(migrationsDir, join(unitDir, 'db', engine), {
+            recursive: true,
+        });
+    }
     // Absent for an app that annotates no columns, which is a database with
     // nothing to coerce rather than a reason to hand the app no database.
     const coercionFile = join(pikkuDir, 'db', 'coercion.gen.ts');
@@ -199,7 +248,7 @@ export async function runBuildPipeline(options) {
             ...getEntryContext(unitDir, pikkuDir, singleUnit, inspectorState),
             frontend: frontendMount,
             version: resolveProjectVersion(projectDir),
-            db: await resolveStandaloneDb(projectDir, pikkuDir, unitDir),
+            db: await resolveStandaloneDb(projectDir, pikkuDir, unitDir, options.srcDirectories ?? ['src'], logger),
             lifecycle: resolveLifecycle(unitDir, inspectorState),
         };
         const source = provider.generateEntrySource(ctx);

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

@@ -259,7 +259,9 @@ export const fabricCommands = defineCLICommands({
                 description: 'Set a stage-scoped secret',
                 options: {
                     branch: { description: 'Target branch', short: 'b' },
-                    value: { description: 'Secret value (prompted if omitted)' },
+                    value: {
+                        description: 'Secret value (prompted if omitted, or read from stdin when piped)',
+                    },
                     force: {
                         description: 'Overwrite without confirmation',
                         default: false,

package/dist/src/fabric/functions/add.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 FabricAddInput = z.object({
     id: z.string(),
     dir: z.string().optional(),
@@ -97,12 +98,12 @@ export const FabricAdd = pikkuSessionlessFunc({
         // 1. resolve a presigned download URL (public read)
         const metaRes = await fetch(`${ctx.apiUrl}/registry/packages/${encodeURIComponent(id)}/download`);
         if (!metaRes.ok)
-            throw new Error(`download lookup failed → ${metaRes.status}: ${await metaRes.text()}`);
+            throw new FabricPreconditionError(`download lookup failed → ${metaRes.status}: ${await metaRes.text()}`);
         const { url } = (await metaRes.json());
         // 2. fetch the artifact
         const dl = await fetch(url);
         if (!dl.ok)
-            throw new Error(`artifact fetch failed → ${dl.status}`);
+            throw new FabricPreconditionError(`artifact fetch failed → ${dl.status}`);
         const artifact = Buffer.from(await dl.arrayBuffer());
         const root = resolveProjectRoot();
         const addonDir = dir ?? (await readAddonDirFromConfig(root)) ?? 'addons';
@@ -120,7 +121,7 @@ export const FabricAdd = pikkuSessionlessFunc({
             await rm(tmp, { force: true });
             const pkg = JSON.parse(await readFile(join(staging, 'package.json'), 'utf8'));
             if (!pkg.name)
-                throw new Error('artifact package.json is missing a "name" field');
+                throw new FabricPreconditionError('artifact package.json is missing a "name" field');
             const version = pkg.version ?? '0.0.0';
             // shadcn copy: folder is the last segment of the (scoped) package name
             const folder = pkg.name.split('/').pop();

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

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 import { changesContext, requireProjectId } from '../lib/changes.js';
 import { resolveStageId } from '../lib/stage.js';
 import { dim, safe } from '../lib/output.js';
@@ -34,7 +35,7 @@ export const FabricChangesFile = pikkuSessionlessFunc({
     output: FabricChangesFileOutput,
     func: async (_services, input) => {
         if (input.body && input.bodyFile)
-            throw new Error('Pass --body or --body-file, not both.');
+            throw new FabricPreconditionError('Pass --body or --body-file, not both.');
         const { rpc, projectId } = await changesContext(input.apiUrl, input.projectId);
         const stageId = input.stageId ??
             (await resolveStageId(rpc, requireProjectId(projectId), input.branch));

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

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 import { changesContext, imageContentType, } from '../lib/changes.js';
 import { dim, safe } from '../lib/output.js';
 export const FabricChangesShotInput = z.object({
@@ -28,13 +29,13 @@ export const FabricChangesShot = pikkuSessionlessFunc({
     output: FabricChangesShotOutput,
     func: async (_services, input) => {
         if (!input.image && !input.imageBase64)
-            throw new Error('Pass --image <path> or --image-base64 <data>.');
+            throw new FabricPreconditionError('Pass --image <path> or --image-base64 <data>.');
         let contentType = input.contentType;
         let imageBase64 = input.imageBase64;
         if (input.image) {
             const inferred = imageContentType(input.image);
             if (!inferred && !contentType)
-                throw new Error(`Cannot tell the image type from “${input.image}” — pass --content-type.`);
+                throw new FabricPreconditionError(`Cannot tell the image type from “${input.image}” — pass --content-type.`);
             contentType ??= inferred;
             imageBase64 = (await readFile(input.image)).toString('base64');
         }

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

@@ -4,6 +4,7 @@ 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';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricDbSchemaInput = z.object({
     branch: z.string().default('main'),
 });
@@ -18,9 +19,9 @@ export const FabricDbSchema = pikkuSessionlessFunc({
     func: async (_services, { branch }) => {
         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 = await resolveStageId(rpc, ctx.projectId, branch);
         const { schema } = await rpc.invoke('getStageDatabaseSchema', { stageId });

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

@@ -4,6 +4,7 @@ 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';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricDeployListInput = z.object({
     branch: z.string().default('main'),
 });
@@ -18,9 +19,9 @@ export const FabricDeployList = pikkuSessionlessFunc({
     func: async (_services, { branch }) => {
         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 = await resolveStageId(rpc, ctx.projectId, branch);
         const { deployments } = await rpc.invoke('listDeployments', { stageId });

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

@@ -4,6 +4,7 @@ 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';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricDeployUnitsInput = z.object({
     branch: z.string().default('main'),
 });
@@ -18,9 +19,9 @@ export const FabricDeployUnits = pikkuSessionlessFunc({
     func: async (_services, { branch }) => {
         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 = await resolveStageId(rpc, ctx.projectId, branch);
         const { workers } = await rpc.invoke('listDeploymentWorkers', { stageId });

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();