@pikku/cli 0.12.154 → 0.12.156

package/dist/src/fabric/functions/variables-get.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 FabricVariablesGetInput = z.object({
     name: z.string(),
     branch: z.string().optional(),
@@ -20,9 +21,9 @@ export const FabricVariablesGet = pikkuSessionlessFunc({
     func: async (_services, { name, 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 { exists, value } = await rpc.invoke('getStageConsoleVariable', {

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

@@ -4,6 +4,7 @@ import { resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
 import { resolveStage } from '../lib/stage.js';
 import { parseVariableValue } from '../lib/variable-value.js';
+import { FabricPreconditionError } from '../lib/errors.js';
 export const FabricVariablesSetInput = z.object({
     name: z.string(),
     branch: z.string().optional(),
@@ -20,9 +21,9 @@ export const FabricVariablesSet = 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.');
+            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);
         // Deliberately not sealed, and deliberately not prompted for. A variable is

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

@@ -1,6 +1,7 @@
 import { extname } from 'node:path';
 import { resolveApiContext } from './config.js';
 import { getFabricRPC } from './http.js';
+import { FabricPreconditionError } from './errors.js';
 /**
  * Resolve the three things every `changes` command needs: the api url, a
  * bearer, and the project the queue belongs to.
@@ -12,7 +13,7 @@ import { getFabricRPC } from './http.js';
 export async function changesContext(apiUrlOverride, projectIdOverride) {
     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.');
     return {
         rpc: getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token }),
         projectId: projectIdOverride ?? ctx.projectId,
@@ -20,7 +21,7 @@ export async function changesContext(apiUrlOverride, projectIdOverride) {
 }
 export function requireProjectId(projectId) {
     if (!projectId)
-        throw new Error('No fabric project. Pass --project-id, or run `pikku fabric link` in the checkout.');
+        throw new FabricPreconditionError('No fabric project. Pass --project-id, or run `pikku fabric link` in the checkout.');
     return projectId;
 }
 /**

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

@@ -2,6 +2,7 @@ import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
+import { FabricPreconditionError } from './errors.js';
 const DEFAULT_API_URL = 'https://api.pikkufabric.com';
 const projectConfigName = 'pikkufabric.config.json';
 const authFilePath = join(homedir(), '.fabric', 'auth.json');
@@ -52,7 +53,7 @@ export async function writeProjectConfig(cwd, config) {
             raw = await readFile(path, 'utf8');
         }
         catch (error) {
-            throw new Error(`Cannot read ${projectConfigName} at ${path} (${error.message}) — refusing to overwrite it`);
+            throw new FabricPreconditionError(`Cannot read ${projectConfigName} at ${path} (${error.message}) — refusing to overwrite it`);
         }
         try {
             const parsed = JSON.parse(raw);

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

@@ -1,3 +1,4 @@
+import { FabricPreconditionError } from './errors.js';
 const IN_FLIGHT = new Set(['queued', 'planning', 'building', 'deploying']);
 const SUCCEEDED = new Set(['active']);
 const FAILED = new Set([
@@ -313,7 +314,7 @@ export function reconcileDeployedRef({ requested, actual, deploymentId, }) {
     if (actual === requested)
         return actual;
     const short = (sha) => sha.slice(0, 8);
-    throw new Error([
+    throw new FabricPreconditionError([
         `Refusing to continue: deployment ${deploymentId} is pinned to ${short(actual)}, not the ${short(requested)} you asked for.`,
         'A deployment already parked for this branch was attached to rather than a new one being cut,',
         'so continuing would deploy a different commit than the one named.',

package/dist/src/fabric/lib/git.d.ts

@@ -1,9 +1,18 @@
+import { PikkuError } from '@pikku/core/errors';
 /**
  * Local git probes for the deploy safety checks (clean tree, HEAD == remote,
  * ref resolution). Shell out to `git` rather than depend on simple-git —
  * matches what wrangler/vercel/fly do, no runtime dep.
  */
-export declare class GitError extends Error {
+/**
+ * A `git` invocation that came back non-zero.
+ *
+ * A `PikkuError`, because the message already carries the whole diagnosis —
+ * which command, which exit code, and git's own stderr — and ten frames of the
+ * spawn helper in front of "fatal: not a git repository" answer a question
+ * nobody asked. `--verbose` / `PIKKU_DEBUG` still prints the stack.
+ */
+export declare class GitError extends PikkuError {
     command: string;
     exitCode: number;
     stderr: string;

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

@@ -1,11 +1,20 @@
 import { spawn } from 'node:child_process';
 import { FabricPreconditionError } from './errors.js';
+import { PikkuError } from '@pikku/core/errors';
 /**
  * Local git probes for the deploy safety checks (clean tree, HEAD == remote,
  * ref resolution). Shell out to `git` rather than depend on simple-git —
  * matches what wrangler/vercel/fly do, no runtime dep.
  */
-export class GitError extends Error {
+/**
+ * A `git` invocation that came back non-zero.
+ *
+ * A `PikkuError`, because the message already carries the whole diagnosis —
+ * which command, which exit code, and git's own stderr — and ten frames of the
+ * spawn helper in front of "fatal: not a git repository" answer a question
+ * nobody asked. `--verbose` / `PIKKU_DEBUG` still prints the stack.
+ */
+export class GitError extends PikkuError {
     command;
     exitCode;
     stderr;

package/dist/src/fabric/lib/prompt.d.ts

@@ -1,12 +1,21 @@
 /**
- * Read a line from stdin with optional masking. Used for secret-set when the
- * user didn't pass `--value` on the command line so we can avoid leaving
- * the plaintext in shell history.
+ * Ask for a value that should not end up in shell history.
+ *
+ * With a tty this is a prompt. Without one — piped input, CI, an agent — the
+ * value is read from stdin instead, because scripting `pikku fabric secrets
+ * set` is a reasonable thing to want, and because a prompt with nobody to
+ * answer it is a hang. If stdin is closed or empty, `nonInteractiveHint` tells
+ * the caller which flag to reach for; it is raised as a `PikkuError` so
+ * `formatCLIError` prints that sentence and nothing else.
  */
-export declare function promptSecret(label: string): Promise<string>;
+export declare function promptSecret(label: string, { nonInteractiveHint }: {
+    nonInteractiveHint: string;
+}): Promise<string>;
 /**
  * Classic yes/no confirmation. Returns `defaultYes` on an empty answer.
  * Callers must gate on `process.stdin.isTTY` first — there is no human to
- * answer in a non-interactive session, so prompting there would hang.
+ * answer in a non-interactive session, so prompting there would hang. The
+ * guard below is the backstop for a caller that forgets: a refusal naming the
+ * question beats a process that never returns.
  */
 export declare function promptConfirm(label: string, defaultYes?: boolean): Promise<boolean>;

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

@@ -1,32 +1,95 @@
 import { createInterface } from 'node:readline/promises';
+import { createInterface as createLineInterface } from 'node:readline';
 import { stdin, stdout } from 'node:process';
+import { FabricPreconditionError } from './errors.js';
 /**
- * Read a line from stdin with optional masking. Used for secret-set when the
- * user didn't pass `--value` on the command line so we can avoid leaving
- * the plaintext in shell history.
+ * Read the first line stdin has to offer, or `null` if it has none.
+ *
+ * Resolves on the first newline rather than on EOF, so a pipe that stays open
+ * after the value has been written (a harness holding the write end, `cat |`)
+ * does not hang the command. `terminal: false` matters: readline's terminal
+ * mode tries to drive a tty it does not have, and on a closed stdin the
+ * `question()` promise it returns never settles at all — which is how
+ * `pikku fabric secrets set NAME < /dev/null` used to end in node's
+ * "Detected unsettled top-level await" warning instead of an error.
  */
-export async function promptSecret(label) {
+const readFirstLine = async () => {
+    const rl = createLineInterface({ input: stdin, terminal: false });
+    try {
+        return await new Promise((resolve) => {
+            rl.once('line', (line) => resolve(line));
+            rl.once('close', () => resolve(null));
+        });
+    }
+    finally {
+        rl.close();
+    }
+};
+/**
+ * Ask for a value that should not end up in shell history.
+ *
+ * With a tty this is a prompt. Without one — piped input, CI, an agent — the
+ * value is read from stdin instead, because scripting `pikku fabric secrets
+ * set` is a reasonable thing to want, and because a prompt with nobody to
+ * answer it is a hang. If stdin is closed or empty, `nonInteractiveHint` tells
+ * the caller which flag to reach for; it is raised as a `PikkuError` so
+ * `formatCLIError` prints that sentence and nothing else.
+ */
+export async function promptSecret(label, { nonInteractiveHint }) {
+    if (!stdin.isTTY) {
+        const piped = await readFirstLine();
+        const value = piped?.trim() ?? '';
+        if (!value) {
+            throw new FabricPreconditionError(`${label}: stdin is not a tty and nothing was piped in.\n${nonInteractiveHint}`);
+        }
+        return value;
+    }
     const rl = createInterface({ input: stdin, output: stdout, terminal: true });
     // Best-effort masking — the readline API doesn't suppress echo natively;
     // for hardened input you'd want `read -s` or a tty trick, but for our
     // CLI the standard prompt is fine and matches what wrangler does.
     process.stdout.write(`${label}: `);
-    const value = await rl.question('');
-    rl.close();
-    return value.trim();
+    try {
+        // `question()` never rejects when the stream ends under it, so the close is
+        // raced explicitly: ^D at a prompt is an abort, not an infinite wait.
+        const value = await Promise.race([
+            rl.question(''),
+            new Promise((resolve) => rl.once('close', () => resolve(null))),
+        ]);
+        if (value === null) {
+            throw new FabricPreconditionError(`${label}: input closed before a value was given.\n${nonInteractiveHint}`);
+        }
+        return value.trim();
+    }
+    finally {
+        rl.close();
+    }
 }
 /**
  * Classic yes/no confirmation. Returns `defaultYes` on an empty answer.
  * Callers must gate on `process.stdin.isTTY` first — there is no human to
- * answer in a non-interactive session, so prompting there would hang.
+ * answer in a non-interactive session, so prompting there would hang. The
+ * guard below is the backstop for a caller that forgets: a refusal naming the
+ * question beats a process that never returns.
  */
 export async function promptConfirm(label, defaultYes = false) {
+    if (!stdin.isTTY) {
+        throw new FabricPreconditionError(`Cannot ask "${label}" — stdin is not a tty. Re-run interactively, or pass the flag that answers it (--force / --auto-approve / --yes).`);
+    }
     const rl = createInterface({ input: stdin, output: stdout });
-    const answer = (await rl.question(`${label} [${defaultYes ? 'Y/n' : 'y/N'}] `))
-        .trim()
-        .toLowerCase();
-    rl.close();
-    if (!answer)
-        return defaultYes;
-    return answer === 'y' || answer === 'yes';
+    try {
+        const answer = await Promise.race([
+            rl.question(`${label} [${defaultYes ? 'Y/n' : 'y/N'}] `),
+            new Promise((resolve) => rl.once('close', () => resolve(null))),
+        ]);
+        if (answer === null)
+            return false;
+        const normalized = answer.trim().toLowerCase();
+        if (!normalized)
+            return defaultYes;
+        return normalized === 'y' || normalized === 'yes';
+    }
+    finally {
+        rl.close();
+    }
 }

package/dist/src/fabric/lib/sealed-box.js

@@ -16,6 +16,7 @@
  * business having one; opening a value happens in the worker.
  */
 import { createCipheriv, createPublicKey, diffieHellman, generateKeyPairSync, hkdfSync, randomBytes, } from 'node:crypto';
+import { FabricPreconditionError } from './errors.js';
 /** Algorithm tag carried by every sealed value. Must match fabric's. */
 export const SEALED_BOX_ALGORITHM = 'sealed-x25519-v1';
 /** HKDF domain separator. Must match fabric's byte for byte. */
@@ -60,13 +61,13 @@ function importPublicKey(publicKey) {
         });
     }
     catch (error) {
-        throw new Error(`Not a valid X25519 public key (${error instanceof Error ? error.message : String(error)})`);
+        throw new FabricPreconditionError(`Not a valid X25519 public key (${error instanceof Error ? error.message : String(error)})`);
     }
     // A public key of the wrong curve would still ECDH, just against a key the
     // stage's worker cannot match — the failure would surface as an unopenable
     // secret much later, so refuse it at the point the type is still knowable.
     if (key.asymmetricKeyType !== 'x25519') {
-        throw new Error(`Stage sealing key is ${key.asymmetricKeyType}, expected x25519 — this CLI is too old for it, run \`npm i -g @pikku/cli\``);
+        throw new FabricPreconditionError(`Stage sealing key is ${key.asymmetricKeyType}, expected x25519 — this CLI is too old for it, run \`npm i -g @pikku/cli\``);
     }
     return key;
 }

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

@@ -1,3 +1,4 @@
+import { FabricPreconditionError } from './errors.js';
 /**
  * Resolve a stage from (projectId, branch) via the `listStages` RPC. The
  * stageId-based read RPCs (listDeployments, listDeploymentWorkers,
@@ -22,13 +23,13 @@ export async function resolveStage(rpc, projectId, branch) {
         if (stages.length === 1 && only) {
             return { stageId: only.stageId, branch: only.branch };
         }
-        throw new Error(stages.length === 0
+        throw new FabricPreconditionError(stages.length === 0
             ? '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);
     if (!stage) {
-        throw new Error(`No stage for branch "${branch}".${known.length ? ` Existing: ${known.join(', ')}` : ''}`);
+        throw new FabricPreconditionError(`No stage for branch "${branch}".${known.length ? ` Existing: ${known.join(', ')}` : ''}`);
     }
     return { stageId: stage.stageId, branch: stage.branch };
 }

package/dist/src/functions/commands/audit.js

@@ -118,6 +118,8 @@ export function semverLevel(current, latest) {
     return 'unknown';
 }
 // bun outdated has no --json; it prints a table: | Package | Current | Update | Latest |
+// Under `--filter` it appends a fifth Workspace column, so both widths are read.
+// Latest sits at index 3 either way.
 export function parseBunOutdated(raw) {
     const updates = [];
     const seen = new Set();
@@ -128,7 +130,7 @@ export function parseBunOutdated(raw) {
             .split('|')
             .map((c) => c.trim())
             .filter((c) => c.length > 0);
-        if (cells.length !== 4)
+        if (cells.length !== 4 && cells.length !== 5)
             continue;
         const [cell, current, , latest] = cells;
         if (cell === 'Package' || /^-+$/.test(cell))
@@ -183,7 +185,7 @@ export const pikkuAudit = pikkuSessionlessFunc({
             try {
                 const issues = parseBunAudit(runBun(['audit', '--json'], root));
                 const updates = includeOutdated
-                    ? parseBunOutdated(runBun(['outdated'], root))
+                    ? parseBunOutdated(runBun(['outdated', '--filter', '*'], root))
                     : [];
                 const latestByPkg = new Map(updates.map((u) => [u.package, u.latest]));
                 for (const i of issues)

package/dist/src/functions/commands/watch.js

@@ -30,8 +30,11 @@ export const watch = pikkuSessionlessFunc({
                     });
                 }
                 catch (err) {
-                    console.error(err);
-                    logger.error('Error running watch');
+                    // Through the logger, so it obeys --log-level and the dev server's
+                    // formatting. `console.error(err)` printed a bare stack over the top
+                    // of the watch output no matter what verbosity was asked for.
+                    logger.error(`Error running watch: ${err instanceof Error ? err.message : String(err)}`);
+                    logger.debug(err instanceof Error ? (err.stack ?? '') : String(err));
                 }
             };
             // A codegen pass holds a whole ts.Program, so two overlapping passes double

package/dist/src/functions/wirings/agent/serialize-public-agent.js

@@ -203,6 +203,7 @@ export const agentRoutes = defineHTTPRoutes({
       route: '${globalHTTPPrefix}/rpc/agent/:agentName/stream',
       method: 'post',
       sse: true,
+      streamProtocol: 'agui',
       func: agentStreamCaller,
     },
     agentApprove: {
@@ -214,6 +215,7 @@ export const agentRoutes = defineHTTPRoutes({
       route: '${globalHTTPPrefix}/rpc/agent/:agentName/resume',
       method: 'post',
       sse: true,
+      streamProtocol: 'agui',
       func: agentResumeCaller,
     },
   },

package/dist/src/functions/wirings/cli/serialize-channel-cli-client.js

@@ -112,6 +112,7 @@ export function serializeChannelCLIClient(programName, programMeta, clientFile,
         : '';
     return `
 import { executeRawCLIViaChannel } from '@pikku/core/cli/channel'
+import { formatCLIError, wantsStackTrace } from '@pikku/core/cli'
 import type { CorePikkuCLIClientRender } from '@pikku/core/cli/channel'
 import type { Capabilities } from '@pikku/core/channel'
 import { CorePikkuWebsocket } from '@pikku/websocket'
@@ -218,12 +219,25 @@ if (isDirectExecution) {
     ws = new WebSocket(url)
   }
 
+  // Whatever comes back is printed the way the rest of the CLI prints errors:
+  // a deliberate error as its message, anything unexpected with its stack, and
+  // either with a stack under --verbose / PIKKU_DEBUG.
+  const reportFatal = (error: unknown): void => {
+    // stderr is asynchronous when it is a pipe, so exiting on the next line can
+    // truncate the diagnostic. Exit from the write callback, with exitCode set
+    // first in case the stream is already gone and the callback never fires.
+    process.exitCode = 1
+    process.stderr.write(
+      formatCLIError(error, { verbose: wantsStackTrace(process.argv.slice(2)) }) + '\\n',
+      () => process.exit(1)
+    )
+  }
+  process.on('uncaughtException', reportFatal)
+  process.on('unhandledRejection', reportFatal)
+
   ${capitalizedName}CLIClient(ws, process.argv.slice(2))
     .then((exitCode) => process.exit(exitCode))
-    .catch(error => {
-      console.error('Fatal channel CLI error:', error)
-      process.exit(1)
-    })
+    .catch(reportFatal)
 }
 `;
 }

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.js

@@ -14,7 +14,7 @@ export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapF
         : null;
     const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFile, config.packageMappings);
     return `
-import { executeCLI, CLIError } from '@pikku/core/cli'
+import { executeCLI, CLIError, formatCLIError, wantsStackTrace } from '@pikku/core/cli'
 ${pikkuConfigFactory ? `import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'` : ''}
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
 ${wireServicesFactory ? `import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'` : ''}
@@ -44,10 +44,21 @@ export default ${capitalizedName}CLI
 ${DIRECT_EXECUTION_GUARD}
 
 if (isDirectExecution) {
-  ${capitalizedName}CLI(process.argv.slice(2)).catch(error => {
-    console.error('Fatal error:', error.message)
-    process.exit(1)
-  })
+  const reportFatal = (error: unknown): void => {
+    // executeCLI already printed a CLIError; it carries the exit code, not text.
+    if (error instanceof CLIError) process.exit(error.exitCode)
+    // stderr is asynchronous when it is a pipe, so exiting on the next line can
+    // truncate the diagnostic. Exit from the write callback, with exitCode set
+    // first in case the stream is already gone and the callback never fires.
+    process.exitCode = 1
+    process.stderr.write(
+      formatCLIError(error, { verbose: wantsStackTrace(process.argv.slice(2)) }) + '\\n',
+      () => process.exit(1)
+    )
+  }
+  process.on('uncaughtException', reportFatal)
+  process.on('unhandledRejection', reportFatal)
+  ${capitalizedName}CLI(process.argv.slice(2)).catch(reportFatal)
 }
 `;
 }

package/dist/src/functions/wirings/credentials/pikku-command-credentials.js

@@ -2,7 +2,28 @@ import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeCredentialsTypes } from './serialize-credentials-types.js';
-import { validateAndBuildCredentialDefinitionsMeta, } from '@pikku/core/credential';
+import { validateAndBuildCredentialDefinitionsMeta } from '@pikku/core/credential';
+/**
+ * A credential's mode is the addon author's default until a `wireAddon`
+ * overrides it, and the console reads the mode from this file rather than from
+ * runtime state — so the override has to be resolved here, at generation time,
+ * or the connect flow stays hidden for a credential the deployment made
+ * per-user.
+ */
+const applyWiredCredentialModes = (meta, wireAddonDeclarations) => {
+    for (const declaration of wireAddonDeclarations?.values() ?? []) {
+        for (const [logicalName, override] of Object.entries(declaration.credentialOverrides ?? {})) {
+            if (typeof override === 'string')
+                continue;
+            const target = meta[override.name ?? logicalName];
+            if (!target)
+                continue;
+            if (override.mode) {
+                target.type = override.mode;
+            }
+        }
+    }
+};
 export const pikkuCredentials = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { credentialsFile, credentialsMetaJsonFile, packageMappings } = config;
@@ -13,15 +34,18 @@ export const pikkuCredentials = pikkuSessionlessFunc({
         if (!state.credentials || state.credentials.definitions.length === 0) {
             return;
         }
+        const meta = validateAndBuildCredentialDefinitionsMeta(state.credentials.definitions, state.schemaLookup);
+        applyWiredCredentialModes(meta, state.rpc?.wireAddonDeclarations);
         const content = serializeCredentialsTypes({
             definitions: state.credentials.definitions,
+            credentials: meta,
             schemaLookup: state.schemaLookup,
             credentialsFile,
             packageMappings,
+            registerAppMeta: !config.addon,
         });
         await writeFileInDir(logger, credentialsFile, content);
         if (credentialsMetaJsonFile) {
-            const meta = validateAndBuildCredentialDefinitionsMeta(state.credentials.definitions, state.schemaLookup);
             await writeFileInDir(logger, credentialsMetaJsonFile, JSON.stringify(meta, null, 2));
         }
     },

package/dist/src/functions/wirings/credentials/serialize-credentials-types.d.ts

@@ -1,9 +1,13 @@
-import type { CredentialDefinitions } from '@pikku/core/credential';
+import type { CredentialDefinitions, CredentialDefinitionsMeta } from '@pikku/core/credential';
 import type { SchemaRef } from '@pikku/inspector';
 export interface SerializeCredentialsOptions {
     definitions: CredentialDefinitions;
+    /** The already-resolved meta, so a mode a `wireAddon` overrode is the one that reaches the generated file. */
+    credentials?: CredentialDefinitionsMeta;
     schemaLookup: Map<string, SchemaRef>;
     credentialsFile: string;
     packageMappings: Record<string, string>;
+    /** Registers the meta into the app's pikku state so `wire.getCredential` can resolve a credential the project itself declares. Addons register theirs from their package file instead. */
+    registerAppMeta?: boolean;
 }
-export declare const serializeCredentialsTypes: ({ definitions, schemaLookup, credentialsFile, packageMappings, }: SerializeCredentialsOptions) => string;
+export declare const serializeCredentialsTypes: ({ definitions, credentials: resolvedCredentials, schemaLookup, credentialsFile, packageMappings, registerAppMeta, }: SerializeCredentialsOptions) => string;

package/dist/src/functions/wirings/credentials/serialize-credentials-types.js

@@ -1,8 +1,9 @@
 import { validateAndBuildCredentialDefinitionsMeta } from '@pikku/core/credential';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { tsLiteral } from '../../../utils/ts-literal.js';
-export const serializeCredentialsTypes = ({ definitions, schemaLookup, credentialsFile, packageMappings, }) => {
-    const credentials = validateAndBuildCredentialDefinitionsMeta(definitions, schemaLookup);
+export const serializeCredentialsTypes = ({ definitions, credentials: resolvedCredentials, schemaLookup, credentialsFile, packageMappings, registerAppMeta, }) => {
+    const credentials = resolvedCredentials ??
+        validateAndBuildCredentialDefinitionsMeta(definitions, schemaLookup);
     const credentialEntries = Object.entries(credentials);
     const schemaImports = new Map();
     let needsZod = false;
@@ -39,6 +40,9 @@ export const serializeCredentialsTypes = ({ definitions, schemaLookup, credentia
     imports.push(`import { TypedCredentialService as CoreTypedCredentialService } from '@pikku/core/services'
 import type { CredentialMetaInfo } from '@pikku/core/services'`);
     imports.push(`import type { CredentialService } from '@pikku/core/services'`);
+    if (registerAppMeta) {
+        imports.push(`import { pikkuState } from '@pikku/core/state'`);
+    }
     if (oauth2Entries.length > 0) {
         imports.push(`import type { OAuth2CredentialConfig } from '@pikku/core/secret'`);
     }
@@ -72,7 +76,9 @@ ${mapEntries.join('\n')}
 const CREDENTIALS_META: Record<string, CredentialMetaInfo> = {
 ${metaEntries.join(',\n')}
 }
-${oauth2Configs}
+${registerAppMeta
+        ? `\npikkuState(null, 'package', 'credentialsMeta', CREDENTIALS_META)\n`
+        : ''}${oauth2Configs}
 
 export class TypedCredentialService extends CoreTypedCredentialService<CredentialsMap> {
   constructor(credentials: CredentialService) {

package/dist/src/functions/wirings/functions/pikku-command-addon-types.js

@@ -5,6 +5,25 @@ import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeAddonInstallTypes, serializeAddonTypes, } from './serialize-addon-types.js';
+/**
+ * The functions each installed addon publishes, by package — what `mcp` on a
+ * `wireAddon` is typed against. A package wired twice contributes the same
+ * names under both namespaces, and a remote addon contributes none: its
+ * functions run on the host, and it is `wireRemoteAddon` that installs it.
+ */
+const addonFunctionNames = (state) => {
+    const names = {};
+    for (const [namespace, decl] of state.rpc.wireAddonDeclarations) {
+        if (decl.remote) {
+            continue;
+        }
+        const meta = state.addonFunctions[namespace];
+        if (meta) {
+            names[decl.package] = Object.keys(meta);
+        }
+    }
+    return names;
+};
 export const pikkuAddonTypes = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, input) => {
         const { addonTypesFile, addonSetupTypesFile, packageMappings, servicesFile, secretsFile, credentialsFile, variablesFile, } = config;
@@ -15,14 +34,16 @@ export const pikkuAddonTypes = pikkuSessionlessFunc({
         await rm(config.addon ? addonTypesFile : addonSetupTypesFile, {
             force: true,
         });
-        // An application installs addons; an addon package declares itself. Both
-        // halves are static, so the app half needs no inspector pass and is written
-        // on the bootstrap run as readily as on the full one.
+        const bootstrap = input?.bootstrap === true;
+        // An application installs addons; an addon package declares itself. The app
+        // half is written on the bootstrap run too — `wireAddon` has to resolve
+        // before the inspector can read the calls that say which addons are
+        // installed — but only the full run knows what each addon publishes, so
+        // that is when `mcp` gets its names.
         if (!config.addon) {
-            await writeFileInDir(logger, addonTypesFile, serializeAddonInstallTypes());
+            await writeFileInDir(logger, addonTypesFile, serializeAddonInstallTypes(bootstrap ? {} : addonFunctionNames(await getInspectorState())));
             return;
         }
-        const bootstrap = input?.bootstrap === true;
         if (bootstrap) {
             await writeFileInDir(logger, addonSetupTypesFile, 'export {}\n');
             return;

package/dist/src/functions/wirings/functions/serialize-addon-types.d.ts

@@ -10,5 +10,5 @@
  * `#pikku/addon/<leaf>` — a depth at which an application has nothing to match,
  * leaving the resolver to fall back to Node's per-package `imports`.
  */
-export declare const serializeAddonInstallTypes: () => string;
+export declare const serializeAddonInstallTypes: (addonFunctionNames?: Record<string, string[]>) => string;
 export declare const serializeAddonTypes: (singletonServicesTypeImport: string, singletonServicesTypeName: string, configTypeImport: string, requiredServicesTypeImport: string, typedSecretServiceImport: string, typedVariablesServiceImport: string, typedCredentialServiceImport?: string | null) => string;