@pikku/cli 0.12.125 → 0.12.127

package/dist/src/fabric/lib/finding-spool.js

@@ -0,0 +1,105 @@
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { postFinding } from './finding.js';
+/** Oldest entries past this are dropped, so a logged-out machine stays bounded. */
+export const SPOOL_LIMIT = 100;
+export function spoolDir() {
+    return (process.env.FABRIC_FINDINGS_DIR ?? join(homedir(), '.fabric', 'findings'));
+}
+export async function spoolFinding(entry) {
+    const dir = spoolDir();
+    await mkdir(dir, { recursive: true });
+    const stamp = entry.payload.reportedAt.replace(/[:.]/g, '-');
+    const file = join(dir, `${stamp}-${randomBytes(3).toString('hex')}.json`);
+    await writeFile(file, JSON.stringify({
+        spooledAt: new Date().toISOString(),
+        reason: entry.reason,
+        projectId: entry.projectId,
+        payload: entry.payload,
+    }, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+    await pruneSpool();
+    return file;
+}
+/**
+ * Chronological, by the timestamp inside each finding rather than the one its
+ * name carries — the name is for a human reading the directory, and ordering
+ * the queue by it would make the send order a property of how a filename
+ * happens to sort. A file that no longer parses is skipped rather than thrown
+ * for: one corrupt entry is not a reason to lose the rest, or to fail the
+ * command that happened to notice.
+ */
+export async function readSpool() {
+    const dir = spoolDir();
+    if (!existsSync(dir))
+        return [];
+    const names = (await readdir(dir)).filter((n) => n.endsWith('.json'));
+    const entries = [];
+    for (const name of names) {
+        const file = join(dir, name);
+        try {
+            const parsed = JSON.parse(await readFile(file, 'utf8'));
+            if (!parsed?.payload)
+                continue;
+            entries.push({
+                file,
+                spooledAt: parsed.spooledAt ?? '',
+                reason: parsed.reason ?? 'unknown',
+                projectId: parsed.projectId ?? null,
+                payload: parsed.payload,
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return entries.sort((a, b) => a.payload.reportedAt.localeCompare(b.payload.reportedAt) ||
+        a.file.localeCompare(b.file));
+}
+export async function clearSpool() {
+    const entries = await readSpool();
+    for (const entry of entries)
+        await rm(entry.file, { force: true });
+    return entries.length;
+}
+async function pruneSpool() {
+    const entries = await readSpool();
+    const excess = Math.max(0, entries.length - SPOOL_LIMIT);
+    for (const entry of entries.slice(0, excess)) {
+        await rm(entry.file, { force: true });
+    }
+}
+/**
+ * Drain the spool oldest-first, stopping at the first entry fabric does not
+ * accept — a refusal usually means the next one will be refused too, and
+ * hammering an endpoint that just said no is the wrong thing for a command
+ * whose real job is something else.
+ *
+ * An entry keeps the project it was filed against; one spooled before the repo
+ * was linked adopts the project linked now, and sends without one if there is
+ * still none.
+ */
+export async function flushSpool(ctx) {
+    const entries = await readSpool();
+    let sent = 0;
+    for (const [index, entry] of entries.entries()) {
+        const result = await postFinding({
+            apiUrl: ctx.apiUrl,
+            token: ctx.token,
+            projectId: entry.projectId ?? ctx.projectId,
+            payload: entry.payload,
+        });
+        if (!result.sent) {
+            return {
+                sent,
+                remaining: entries.length - index,
+                reason: result.reason,
+            };
+        }
+        await rm(entry.file, { force: true });
+        sent++;
+    }
+    return { sent, remaining: 0 };
+}

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

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import type { ReportEnvironment } from './report-environment.js';
+export declare const FindingInput: z.ZodObject<{
+    title: z.ZodString;
+    kind: z.ZodEnum<{
+        product: "product";
+        harness: "harness";
+    }>;
+    model: z.ZodString;
+    expected: z.ZodString;
+    actual: z.ZodString;
+    skill: z.ZodOptional<z.ZodString>;
+    passage: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    repro: z.ZodOptional<z.ZodString>;
+    workaround: z.ZodOptional<z.ZodString>;
+    proposal: z.ZodOptional<z.ZodString>;
+    tried: z.ZodOptional<z.ZodString>;
+    unresolved: z.ZodOptional<z.ZodBoolean>;
+    area: z.ZodOptional<z.ZodString>;
+    surface: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        deployed: "deployed";
+        both: "both";
+    }>>;
+    cost: z.ZodOptional<z.ZodString>;
+    run: z.ZodOptional<z.ZodString>;
+    deployTarget: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FindingInput = z.infer<typeof FindingInput>;
+export type ParsedFinding = {
+    finding: FindingInput;
+} | {
+    problems: string[];
+};
+/** Shape-check a finding from either path, naming every field that is wrong. */
+export declare function parseFinding(value: unknown): ParsedFinding;
+/**
+ * A finding read as JSON rather than assembled out of flags.
+ *
+ * Half the fields are prose, and prose carries apostrophes, quotes, backticks
+ * and newlines — every one of them a shell metacharacter before it is a
+ * character in a sentence. An error message pasted into `--error` breaks the
+ * command at its first newline; one carrying a backtick runs whatever follows
+ * it. JSON has its own escaping, so this path has none of that.
+ *
+ * Returns the finding or the problems with it, never throws: a malformed
+ * payload is a usage mistake worth naming precisely.
+ */
+export declare function parseFindingJson(raw: string): ParsedFinding;
+export interface FindingPayload extends Omit<FindingInput, 'run'> {
+    runId?: string;
+    environment: ReportEnvironment;
+    reportedAt: string;
+}
+/**
+ * The rules the field set exists to enforce, checked before anything is sent.
+ *
+ * A usage mistake is the agent's own and is worth failing loudly for — unlike a
+ * failed send, which must never surface as a build failure. Every problem is
+ * returned at once so a malformed call is fixed in one pass.
+ */
+export declare function validateFinding(input: FindingInput): string[];
+export declare function buildFindingPayload(input: FindingInput, environment: ReportEnvironment, now?: Date): FindingPayload;
+/**
+ * Best-effort by construction. A finding is worth having and never worth
+ * failing a build for, so a refused, slow or unreachable endpoint is reported
+ * to the terminal and swallowed.
+ */
+export declare function postFinding(opts: {
+    apiUrl: string;
+    token: string;
+    /**
+     * Provenance, not a routing key. A finding is about the framework rather
+     * than about anyone's project, and the reports worth having most — a
+     * scaffold that never produced a config, a first run that went wrong — come
+     * from checkouts that have no project to name.
+     */
+    projectId: string | null;
+    payload: FindingPayload;
+    timeoutMs?: number;
+}): Promise<{
+    sent: boolean;
+    reason?: string;
+}>;
+/**
+ * The receipt. Nothing is written to disk, so the terminal is the only place
+ * the user sees what left their machine. Printed before the request goes out,
+ * so it is there whether or not the send succeeds.
+ */
+export declare function renderReceipt(payload: FindingPayload): string;

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

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+export const FindingInput = z.object({
+    title: z.string(),
+    kind: z.enum(['product', 'harness']),
+    model: z.string(),
+    expected: z.string(),
+    actual: z.string(),
+    skill: z.string().optional(),
+    passage: z.string().optional(),
+    command: z.string().optional(),
+    error: z.string().optional(),
+    repro: z.string().optional(),
+    workaround: z.string().optional(),
+    proposal: z.string().optional(),
+    tried: z.string().optional(),
+    unresolved: z.boolean().optional(),
+    area: z.string().optional(),
+    surface: z.enum(['local', 'deployed', 'both']).optional(),
+    cost: z.string().optional(),
+    run: z.string().optional(),
+    deployTarget: z.string().optional(),
+});
+/** Shape-check a finding from either path, naming every field that is wrong. */
+export function parseFinding(value) {
+    const result = FindingInput.safeParse(value);
+    if (result.success)
+        return { finding: result.data };
+    return {
+        problems: result.error.issues.map((issue) => `${issue.path.join('.') || 'finding'}: ${issue.message}`),
+    };
+}
+/**
+ * A finding read as JSON rather than assembled out of flags.
+ *
+ * Half the fields are prose, and prose carries apostrophes, quotes, backticks
+ * and newlines — every one of them a shell metacharacter before it is a
+ * character in a sentence. An error message pasted into `--error` breaks the
+ * command at its first newline; one carrying a backtick runs whatever follows
+ * it. JSON has its own escaping, so this path has none of that.
+ *
+ * Returns the finding or the problems with it, never throws: a malformed
+ * payload is a usage mistake worth naming precisely.
+ */
+export function parseFindingJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        return {
+            problems: [`--stdin expected a JSON object (${error.message}).`],
+        };
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return { problems: ['--stdin expected a JSON object.'] };
+    }
+    return parseFinding(parsed);
+}
+/**
+ * The rules the field set exists to enforce, checked before anything is sent.
+ *
+ * A usage mistake is the agent's own and is worth failing loudly for — unlike a
+ * failed send, which must never surface as a build failure. Every problem is
+ * returned at once so a malformed call is fixed in one pass.
+ */
+export function validateFinding(input) {
+    const problems = [];
+    if (input.kind === 'harness' && !input.skill) {
+        problems.push('A harness finding names the skill that misled you — pass --skill (and --passage for the line it contradicts).');
+    }
+    if (input.unresolved) {
+        if (!input.tried) {
+            problems.push('An unresolved finding carries what you tried and how each attempt failed — pass --tried.');
+        }
+        if (input.workaround) {
+            problems.push('Unresolved means no workaround was found. Drop --unresolved, or drop --workaround.');
+        }
+    }
+    else if (!input.workaround && !input.proposal) {
+        problems.push('A resolved finding carries the workaround you used — pass --workaround, or --unresolved if there was none.');
+    }
+    return problems;
+}
+export function buildFindingPayload(input, environment, now = new Date()) {
+    const { run, ...rest } = input;
+    return { ...rest, runId: run, environment, reportedAt: now.toISOString() };
+}
+/**
+ * Best-effort by construction. A finding is worth having and never worth
+ * failing a build for, so a refused, slow or unreachable endpoint is reported
+ * to the terminal and swallowed.
+ */
+export async function postFinding(opts) {
+    try {
+        const response = await fetch(`${opts.apiUrl}/findings`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${opts.token}`,
+            },
+            body: JSON.stringify({
+                projectId: opts.projectId,
+                finding: opts.payload,
+            }),
+            signal: AbortSignal.timeout(opts.timeoutMs ?? 5000),
+        });
+        if (!response.ok) {
+            return { sent: false, reason: `fabric answered ${response.status}` };
+        }
+        return { sent: true };
+    }
+    catch (error) {
+        return { sent: false, reason: error?.message ?? 'request failed' };
+    }
+}
+/**
+ * The receipt. Nothing is written to disk, so the terminal is the only place
+ * the user sees what left their machine. Printed before the request goes out,
+ * so it is there whether or not the send succeeds.
+ */
+export function renderReceipt(payload) {
+    const lines = [`[fabric] reporting: ${payload.title}`];
+    const field = (label, value) => {
+        if (value)
+            lines.push(`  ${label}: ${value}`);
+    };
+    field('kind', payload.unresolved ? `${payload.kind} (unresolved)` : payload.kind);
+    field('area', payload.area);
+    field('skill', payload.passage ? `${payload.skill} — ${payload.passage}` : payload.skill);
+    field('command', payload.command);
+    field('expected', payload.expected);
+    field('actual', payload.actual);
+    field('error', payload.error);
+    field('surface', payload.surface);
+    field('cost', payload.cost);
+    field('repro', payload.repro);
+    field('workaround', payload.workaround);
+    field('tried', payload.tried);
+    field('proposal', payload.proposal);
+    field('model', payload.model);
+    field('run', payload.runId);
+    field('deploy target', payload.deployTarget);
+    field('reported at', payload.reportedAt);
+    const env = payload.environment;
+    field('versions', env.packages
+        .map((p) => `${p.name}@${p.version}${p.linked ? ' (linked)' : ''}`)
+        .join(' ') || 'no @pikku/* found');
+    if (env.versionSkew) {
+        lines.push('  note: the installed @pikku/* versions are not all the same');
+    }
+    if (env.linkedFramework) {
+        lines.push('  note: an @pikku/* resolves to a workspace or link — this app is running framework code that may be modified');
+    }
+    field('runtime', `node ${env.node} ${env.platform} ${env.packageManager ?? ''}`.trim());
+    return lines.join('\n');
+}

package/dist/src/fabric/lib/report-environment.d.ts

@@ -0,0 +1,53 @@
+/** One installed `@pikku/*` package as it actually resolves on disk. */
+export interface PikkuPackageVersion {
+    name: string;
+    version: string;
+    /**
+     * Resolved through a symlink — a yarn workspace or a `yarn link`ed checkout
+     * rather than a published tarball. The framework is read-only during a build
+     * run, so a linked package is code that may already have been modified, and a
+     * finding describing it is describing something other than a release.
+     */
+    linked: boolean;
+}
+export interface ReportEnvironment {
+    packages: PikkuPackageVersion[];
+    /**
+     * The resolved `@pikku/*` versions are not all the same. Pinning the CLI does
+     * not pin its `@pikku/*` dependencies, so a mixed tree is a common cause of
+     * behaviour that looks like a framework bug.
+     */
+    versionSkew: boolean;
+    /** Any package is `linked` — see {@link PikkuPackageVersion.linked}. */
+    linkedFramework: boolean;
+    node: string;
+    packageManager: string | null;
+    platform: string;
+}
+/**
+ * Walk up from `startDir` for the first `node_modules/@pikku` that holds
+ * packages. A monorepo hoists to the root, an app installs locally, and either
+ * way the nearest populated scope is the one that was loaded.
+ *
+ * Populated means holding something `readPikkuPackages` would read, so the
+ * hidden entries it skips cannot qualify a scope either: a stray `.DS_Store` in
+ * an empty nested scope would otherwise end the walk there and report a tree
+ * with no packages in it.
+ */
+export declare function findPikkuScope(startDir: string): Promise<string | null>;
+/**
+ * Versions read off the installed tree rather than out of `package.json`. A
+ * range like `^0.12.35` says nothing about what ran, and the version that ran
+ * is the only one worth reporting.
+ */
+export declare function readPikkuPackages(scopeDir: string): Promise<PikkuPackageVersion[]>;
+/**
+ * `packageManager` in the nearest manifest is authoritative when it is set;
+ * otherwise the lockfile is the only evidence of what installed the tree.
+ */
+export declare function detectPackageManager(startDir: string): Promise<string | null>;
+/**
+ * Everything about the run a finding needs and no agent should be asked for.
+ * All of it is a directory read — no network, no prompting.
+ */
+export declare function collectReportEnvironment(startDir?: string): Promise<ReportEnvironment>;

package/dist/src/fabric/lib/report-environment.js

@@ -0,0 +1,119 @@
+import { readFile, lstat, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/**
+ * Walk up from `startDir` for the first `node_modules/@pikku` that holds
+ * packages. A monorepo hoists to the root, an app installs locally, and either
+ * way the nearest populated scope is the one that was loaded.
+ *
+ * Populated means holding something `readPikkuPackages` would read, so the
+ * hidden entries it skips cannot qualify a scope either: a stray `.DS_Store` in
+ * an empty nested scope would otherwise end the walk there and report a tree
+ * with no packages in it.
+ */
+export async function findPikkuScope(startDir) {
+    let dir = startDir;
+    while (true) {
+        const candidate = join(dir, 'node_modules', '@pikku');
+        if (existsSync(candidate)) {
+            const entries = await readdir(candidate).catch(() => []);
+            if (entries.some((entry) => !entry.startsWith('.')))
+                return candidate;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Versions read off the installed tree rather than out of `package.json`. A
+ * range like `^0.12.35` says nothing about what ran, and the version that ran
+ * is the only one worth reporting.
+ */
+export async function readPikkuPackages(scopeDir) {
+    const entries = await readdir(scopeDir).catch(() => []);
+    const packages = [];
+    for (const entry of entries.sort()) {
+        if (entry.startsWith('.'))
+            continue;
+        const packageDir = join(scopeDir, entry);
+        const manifest = join(packageDir, 'package.json');
+        const raw = await readFile(manifest, 'utf8').catch(() => null);
+        if (!raw)
+            continue;
+        let version;
+        try {
+            version = JSON.parse(raw).version;
+        }
+        catch {
+            continue;
+        }
+        if (typeof version !== 'string')
+            continue;
+        const stats = await lstat(packageDir).catch(() => null);
+        packages.push({
+            name: `@pikku/${entry}`,
+            version,
+            linked: stats?.isSymbolicLink() ?? false,
+        });
+    }
+    return packages;
+}
+const LOCKFILES = [
+    ['yarn.lock', 'yarn'],
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['bun.lockb', 'bun'],
+    ['bun.lock', 'bun'],
+    ['package-lock.json', 'npm'],
+];
+/**
+ * `packageManager` in the nearest manifest is authoritative when it is set;
+ * otherwise the lockfile is the only evidence of what installed the tree.
+ */
+export async function detectPackageManager(startDir) {
+    let dir = startDir;
+    while (true) {
+        const manifest = join(dir, 'package.json');
+        if (existsSync(manifest)) {
+            const raw = await readFile(manifest, 'utf8').catch(() => null);
+            if (raw) {
+                try {
+                    const declared = JSON.parse(raw)
+                        .packageManager;
+                    if (typeof declared === 'string' && declared.length > 0) {
+                        return declared;
+                    }
+                }
+                catch {
+                    // An unparseable manifest tells us nothing; keep walking up.
+                }
+            }
+        }
+        for (const [lockfile, manager] of LOCKFILES) {
+            if (existsSync(join(dir, lockfile)))
+                return manager;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Everything about the run a finding needs and no agent should be asked for.
+ * All of it is a directory read — no network, no prompting.
+ */
+export async function collectReportEnvironment(startDir = process.cwd()) {
+    const scope = await findPikkuScope(startDir);
+    const packages = scope ? await readPikkuPackages(scope) : [];
+    const versions = new Set(packages.map((p) => p.version));
+    return {
+        packages,
+        versionSkew: versions.size > 1,
+        linkedFramework: packages.some((p) => p.linked),
+        node: process.version,
+        packageManager: await detectPackageManager(startDir),
+        platform: `${process.platform}-${process.arch}`,
+    };
+}

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

@@ -1,7 +1,23 @@
 import type { PikkuRPC } from '../sdk/pikku-rpc.gen.js';
+export interface ResolvedStage {
+    stageId: string;
+    branch: string;
+}
 /**
- * Resolve a stage UUID from (projectId, branch) via the `listStages` RPC.
- * The stageId-based read RPCs (listDeployments, listDeploymentWorkers,
+ * Resolve a stage from (projectId, branch) via the `listStages` RPC. The
+ * stageId-based read RPCs (listDeployments, listDeploymentWorkers,
  * getStageDatabaseSchema) need a UUID, but the CLI only knows the branch.
+ *
+ * `branch` is optional because it is optional in practice: nothing upstream
+ * guarantees the flag was passed, and interpolating what arrived produced
+ * `No stage for branch "undefined"` — an error naming the missing argument's
+ * value rather than saying the argument is missing, directly above a line
+ * listing the one stage it could have used. With exactly one stage there is
+ * nothing to disambiguate, so that stage is the answer.
+ *
+ * The branch comes back with the id so callers can name the stage they acted
+ * on rather than echoing the argument, which is `undefined` in exactly the
+ * case this function exists to handle.
  */
-export declare function resolveStageId(rpc: PikkuRPC, projectId: string, branch: string): Promise<string>;
+export declare function resolveStage(rpc: PikkuRPC, projectId: string, branch: string | undefined): Promise<ResolvedStage>;
+export declare function resolveStageId(rpc: PikkuRPC, projectId: string, branch: string | undefined): Promise<string>;

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

@@ -1,14 +1,37 @@
 /**
- * Resolve a stage UUID from (projectId, branch) via the `listStages` RPC.
- * The stageId-based read RPCs (listDeployments, listDeploymentWorkers,
+ * Resolve a stage from (projectId, branch) via the `listStages` RPC. The
+ * stageId-based read RPCs (listDeployments, listDeploymentWorkers,
  * getStageDatabaseSchema) need a UUID, but the CLI only knows the branch.
+ *
+ * `branch` is optional because it is optional in practice: nothing upstream
+ * guarantees the flag was passed, and interpolating what arrived produced
+ * `No stage for branch "undefined"` — an error naming the missing argument's
+ * value rather than saying the argument is missing, directly above a line
+ * listing the one stage it could have used. With exactly one stage there is
+ * nothing to disambiguate, so that stage is the answer.
+ *
+ * The branch comes back with the id so callers can name the stage they acted
+ * on rather than echoing the argument, which is `undefined` in exactly the
+ * case this function exists to handle.
  */
-export async function resolveStageId(rpc, projectId, branch) {
+export async function resolveStage(rpc, projectId, branch) {
     const { stages } = await rpc.invoke('listStages', { projectId });
+    const known = stages.map((s) => s.branch);
+    if (!branch) {
+        const only = stages[0];
+        if (stages.length === 1 && only) {
+            return { stageId: only.stageId, branch: only.branch };
+        }
+        throw new Error(stages.length === 0
+            ? 'No stages deployed for this project yet — run `pikku fabric deploy apply --branch <branch>` first.'
+            : `--branch is required — this project has ${stages.length} stages: ${known.join(', ')}`);
+    }
     const stage = stages.find((s) => s.branch === branch);
     if (!stage) {
-        const known = stages.map((s) => s.branch).join(', ');
-        throw new Error(`No stage for branch "${branch}".${known ? ` Existing: ${known}` : ''}`);
+        throw new Error(`No stage for branch "${branch}".${known.length ? ` Existing: ${known.join(', ')}` : ''}`);
     }
-    return stage.stageId;
+    return { stageId: stage.stageId, branch: stage.branch };
+}
+export async function resolveStageId(rpc, projectId, branch) {
+    return (await resolveStage(rpc, projectId, branch)).stageId;
 }

package/dist/src/functions/commands/db-reset.js

@@ -43,13 +43,17 @@ export const dbReset = pikkuSessionlessFunc({
         logger.info(zod.written
             ? `db reset: regenerated ${zod.outFile} (${zod.tables.length} tables)`
             : `db reset: ${zod.outFile} unchanged`);
+        // Both lines report on the SEED STEP, never on the database. A migration
+        // is free to carry rows — data a deployed stage needs is migration data —
+        // so "database is empty" was a verdict this step has no standing to reach,
+        // and it read as a failed reset every time it was wrong.
         if (noSeed) {
-            logger.info('db reset: --no-seed, leaving the database empty');
+            logger.info('db reset: --no-seed, skipping the dev seed');
             return;
         }
         const devSeedResult = await devSeed(resolved);
         logger.info(devSeedResult.applied
             ? `db reset: seeded ${resolved.devSeedFile} (${devSeedResult.bytes} bytes)`
-            : `db reset: no ${resolved.devSeedFile} found, database is empty`);
+            : `db reset: no dev seed applied (${resolved.devSeedFile} not found)`);
     },
 });

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

@@ -24,13 +24,17 @@ import { resolveConsoleMount } from './serve-console.js';
 import { serverReadyLine } from '../../server/server-ready.js';
 import { createEphemeralContentSigningJWT } from '../../server/content-signing-jwt.js';
 import { enableDevActorSignIn } from '../../server/actor-sign-in.js';
+import { resolvePersonas } from '../../utils/resolve-personas.js';
 import { applyModelAliasOverride } from '../../utils/model-alias-override.js';
 export const dev = pikkuSessionlessFunc({
     remote: true,
     func: async ({ logger, config, getInspectorState, invalidateInspectorState, variables, devServerRunner, }, { port, watch, hmr, coverage, test, model }, { rpc }) => {
         process.env.PIKKU_DEV_QUICK_LOGIN ??= 'true';
         process.env.PIKKU_ENV ??= resolveDevEnvironmentName(config.environments ?? {});
-        enableDevActorSignIn(logger);
+        await enableDevActorSignIn(logger, async () => {
+            const state = await getInspectorState(true, false, false, true);
+            return Object.values(resolvePersonas(state.personas?.definitions ?? [], config.scenarios?.emailDomain));
+        });
         applyModelAliasOverride(logger, model, config.models);
         if (test) {
             process.env.PIKKU_TEST_RUN = 'true';

package/dist/src/functions/commands/environment.d.ts

@@ -11,6 +11,11 @@
 export interface PikkuEnvironment {
     apiUrl: string;
     signInPath?: string;
+    /**
+     * Where the session and its roles are read back, for a stage that reports
+     * them somewhere other than `get-session` under the sign-in path's own mount.
+     */
+    sessionPath?: string;
     rpcPath?: string;
     appUrl?: string;
     /**

package/dist/src/functions/commands/persona.d.ts

@@ -55,4 +55,22 @@ export declare const personaRun: import("#pikku/function").PikkuFunctionConfig<{
     out?: string;
 }, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
 /** Who this app is for, and what each of them wants, without running anything. */
+/**
+ * Mint the actor credential for one persona, or for every declared persona.
+ *
+ * The root secret is entitled to all of them, so nothing that only needs to be
+ * one person should ever hold it. What comes out is bound to that persona's
+ * address by the target — presenting it for anyone else is refused — so a CI
+ * job, a container or a virtual user can be handed exactly the people it is
+ * meant to be and no more.
+ *
+ * Printed as `id=secret` lines, which is the shape PIKKU_PERSONA_SECRETS reads.
+ */
+export declare const personaSecret: import("#pikku/function").PikkuFunctionConfig<{
+    personas?: string[];
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+    personas?: string[];
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+    personas?: string[];
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
 export declare const personaList: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;