@agentage/extension 0.1.2 → 0.2.1

package/dist/testing/test-server.js

@@ -1,21 +1,21 @@
 import {} from 'node:net';
-import { createTestContext } from '../context/context.js';
+import {} from 'express';
+import {} from '../context/context.js';
+import { createTestContext } from '../context/test-context.js';
 import {} from '../manifest/manifest.schema.js';
+import { createMcpApp } from '../mcp/mcp-app.js';
+import { createToolRegistry } from '../mcp/tools.js';
 import { createApiApp } from '../server/app.js';
 import {} from '../server/part.types.js';
 import { listen } from '../server/serve.js';
 const TEST_BUILD = { commit: '0'.repeat(40), buildTime: '2026-01-01T00:00:00Z' };
-const testPackage = (ctx) => ({
+const testPackage = (ctx, parts) => ({
     name: `@agentage/extension-${ctx.extension.id}`,
     version: ctx.extension.version,
-    engines: { agentage: '^0.1.0' },
-    agentage: { id: ctx.extension.id, parts: { api: true } },
+    engines: { agentage: '^0.2.0' },
+    agentage: { id: ctx.extension.id, parts },
 });
-// Runs an api part's create(ctx) inside the kit's real app on 127.0.0.1, port chosen by the OS.
-export const startTestServer = async (options) => {
-    const ctx = options.ctx ?? createTestContext();
-    const router = await options.create(ctx);
-    const app = createApiApp({ pkg: testPackage(ctx), build: TEST_BUILD, router, log: ctx.log });
+const startOn = async (app) => {
     const server = await listen(app, 0, '127.0.0.1');
     const url = `http://127.0.0.1:${server.address().port}`;
     return {
@@ -24,3 +24,25 @@ export const startTestServer = async (options) => {
         close: () => new Promise((resolve) => server.close(() => resolve())),
     };
 };
+// Runs an api part's create(ctx) inside the kit's real app on 127.0.0.1, port chosen by the OS.
+export const startTestServer = async (options) => {
+    const ctx = options.ctx ?? createTestContext();
+    const router = await options.create(ctx);
+    const pkg = testPackage(ctx, { api: true });
+    return startOn(createApiApp({ pkg, build: TEST_BUILD, router, log: ctx.log }));
+};
+// Runs an mcp part's create(ctx) inside the kit's real /mcp app: tools named {id}__{name}.
+export const startTestMcp = async (options) => {
+    const ctx = options.ctx ?? createTestContext();
+    const registry = createToolRegistry();
+    await options.create({ ...ctx, tool: registry.tool });
+    const pkg = testPackage(ctx, { mcp: true });
+    const app = createMcpApp({
+        pkg,
+        build: TEST_BUILD,
+        log: ctx.log,
+        tools: registry.tools,
+        listing: 'open',
+    });
+    return startOn(app);
+};

package/dist/tool/build.d.ts

@@ -1,8 +1,11 @@
+import { type BuildInfo } from '../discovery/discovery.js';
+import { type ExtensionRecord } from '../discovery/discovery.schema.js';
 import { type ExtensionPackage } from '../manifest/manifest.schema.js';
 import { type ImagePartKind } from '../manifest/primitives.schema.js';
 import { type Env } from '../runtime/build-info.js';
 import { type Docker } from './docker.js';
 import { type Run } from './exec.js';
+export declare const DEFAULT_REGISTRY = "ghcr.io/agentage";
 export interface BuildOptions {
     dir?: string;
     push?: boolean;
@@ -29,4 +32,5 @@ export interface BuildResult {
     recordFile?: string;
 }
 export declare const imageTag: (registry: string, pkg: ExtensionPackage, part: ImagePartKind) => string;
+export declare const recordFor: (dir: string, pkg: ExtensionPackage, info: BuildInfo, images: BuiltImage[]) => Promise<ExtensionRecord>;
 export declare const build: (options?: BuildOptions, deps?: BuildDeps) => Promise<BuildResult>;

package/dist/tool/build.js

@@ -1,31 +1,26 @@
 import { rm, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { recordOf, validateRecord } from '../discovery/discovery.js';
+import {} from '../discovery/discovery.schema.js';
 import {} from '../manifest/manifest.schema.js';
 import { imageParts } from '../manifest/parts.js';
 import {} from '../manifest/primitives.schema.js';
 import { readManifest } from '../manifest/read-manifest.js';
 import {} from '../runtime/build-info.js';
 import { resolveBuildInfo } from './build-info.js';
+import { assertConforms } from './check.js';
 import { createDocker } from './docker.js';
 import { mustRun, runCommand } from './exec.js';
 import { labelsOf } from './labels.js';
+import { recordExtras } from './record-extras.js';
 import { RECORD_FILE, stageContext } from './stage.js';
-const DEFAULT_REGISTRY = 'ghcr.io/agentage';
-const SUPPORTED_PARTS = ['api'];
+import { TIMEOUTS } from './timeouts.js';
+export const DEFAULT_REGISTRY = 'ghcr.io/agentage';
 export const imageTag = (registry, pkg, part) => `${registry}/${pkg.agentage.id}-${part}:${pkg.version}`;
-const partsToBuild = (pkg) => {
-    const parts = imageParts(pkg);
-    const unsupported = parts.filter((part) => !SUPPORTED_PARTS.includes(part));
-    if (unsupported.length > 0) {
-        throw new Error(`@agentage/extension 0.1 builds the api part only, not: ${unsupported.join(', ')}`);
-    }
-    return parts;
-};
 const compile = async (dir, pkg, run) => {
     const scripts = pkg.scripts;
     if (typeof scripts?.['build'] === 'string')
-        await mustRun(run, 'npm', ['run', 'build'], { cwd: dir });
+        await mustRun(run, 'npm', ['run', 'build'], { cwd: dir, timeoutMs: TIMEOUTS.compile });
 };
 const buildImage = async (job, docker, tmpRoot) => {
     const context = await stageContext(job.dir, job.pkg, job.part, tmpRoot);
@@ -35,12 +30,8 @@ const buildImage = async (job, docker, tmpRoot) => {
             BUILD_TIME: job.info.buildTime,
             IMAGE: job.tag,
         };
-        await docker.build({
-            context,
-            tag: job.tag,
-            buildArgs,
-            labels: labelsOf(job.pkg, job.part, job.info),
-        });
+        const labels = labelsOf(job.pkg, job.part, job.info);
+        await docker.build({ context, tag: job.tag, buildArgs, labels });
     }
     finally {
         await rm(context, { recursive: true, force: true });
@@ -51,32 +42,36 @@ const pushImage = async (job, docker) => {
     const repository = job.tag.slice(0, job.tag.lastIndexOf(':'));
     return { part: job.part, tag: job.tag, digest, image: `${repository}@${digest}` };
 };
-const writeRecord = async (dir, pkg, info, images) => {
+// The record from the code and the images by digest; `up` writes the same shape from local digests.
+export const recordFor = async (dir, pkg, info, images) => {
     const byPart = Object.fromEntries(images.map((built) => [built.part, built.image]));
-    const record = validateRecord(recordOf(pkg, info, byPart));
-    const file = join(dir, 'dist', RECORD_FILE);
+    return validateRecord(recordOf(pkg, info, byPart, await recordExtras(dir, pkg)));
+};
+const writeRecord = async (dir, record, file = join(dir, 'dist', RECORD_FILE)) => {
     await writeFile(file, `${JSON.stringify(record, null, 2)}\n`);
     return file;
 };
-const buildParts = async (base, parts, options, deps) => {
+const buildParts = async (base, options, deps) => {
     const docker = deps.docker ?? createDocker(deps.run);
     const registry = options.registry ?? DEFAULT_REGISTRY;
     const images = [];
-    for (const part of parts) {
+    for (const part of imageParts(base.pkg)) {
         const job = { ...base, part, tag: imageTag(registry, base.pkg, part) };
         await buildImage(job, docker, deps.tmpRoot);
         images.push(options.push ? await pushImage(job, docker) : { part, tag: job.tag });
     }
     return images;
 };
+// Validate, compile, check, one image per part from the kit recipe; --push pushes, writes the record.
 export const build = async (options = {}, deps = { run: runCommand }) => {
     const dir = resolve(options.dir ?? '.');
     const pkg = await readManifest(dir);
-    const parts = partsToBuild(pkg);
     const info = await resolveBuildInfo(dir, options.env ?? process.env, deps.run);
     await compile(dir, pkg, deps.run);
-    const images = await buildParts({ dir, pkg, info }, parts, options, deps);
-    const recordFile = options.push ? await writeRecord(dir, pkg, info, images) : undefined;
+    await assertConforms({ dir, pkg });
+    const images = await buildParts({ dir, pkg, info }, options, deps);
     const result = { id: pkg.agentage.id, version: pkg.version, ...info, images };
-    return recordFile ? { ...result, recordFile } : result;
+    if (!options.push)
+        return result;
+    return { ...result, recordFile: await writeRecord(dir, await recordFor(dir, pkg, info, images)) };
 };

package/dist/tool/check.d.ts

@@ -0,0 +1,16 @@
+import { type ExtensionPackage } from '../manifest/manifest.schema.js';
+export interface CheckInput {
+    dir: string;
+    pkg: ExtensionPackage;
+}
+export interface CheckRule {
+    name: string;
+    run(input: CheckInput): Promise<string[]>;
+}
+export interface CheckProblem {
+    rule: string;
+    problem: string;
+}
+export declare const RULES: readonly CheckRule[];
+export declare const check: (input: CheckInput, rules?: readonly CheckRule[]) => Promise<CheckProblem[]>;
+export declare const assertConforms: (input: CheckInput, rules?: readonly CheckRule[]) => Promise<void>;

package/dist/tool/check.js

@@ -0,0 +1,30 @@
+import { checkCli } from '../command/check-cli.js';
+import {} from '../manifest/manifest.schema.js';
+import { imageParts, normalizeParts } from '../manifest/parts.js';
+import { assertBuilt } from './stage.js';
+const problemsOf = (work) => work.then(() => [], (err) => [err.message]);
+// Every image part built where its image looks for it; the cli handlers are exactly the commands.
+const entries = {
+    name: 'entries',
+    run: async ({ dir, pkg }) => {
+        const built = imageParts(pkg).map((part) => problemsOf(assertBuilt(dir, pkg, part)));
+        const cli = normalizeParts(pkg.agentage.parts).code.cli ? await checkCli(dir) : null;
+        return [...(await Promise.all(built)).flat(), ...(cli ? [`cli part: ${cli}`] : [])];
+    },
+};
+// Kit 0.2 has the entries rule; M4 adds manifest, surface, stack, store and sealing beside it.
+export const RULES = [entries];
+export const check = async (input, rules = RULES) => {
+    const found = [];
+    for (const rule of rules)
+        for (const problem of await rule.run(input))
+            found.push({ rule: rule.name, problem });
+    return found;
+};
+// What build runs after the compile and before any image: one failure stops everything.
+export const assertConforms = async (input, rules = RULES) => {
+    const problems = await check(input, rules);
+    if (problems.length === 0)
+        return;
+    throw new Error(`check failed: ${problems.map((p) => `${p.rule}: ${p.problem}`).join('; ')}`);
+};

package/dist/tool/docker.js

@@ -1,4 +1,5 @@
 import { mustRun } from './exec.js';
+import { TIMEOUTS } from './timeouts.js';
 const PLATFORM = 'linux/amd64';
 const flags = (flag, values) => Object.entries(values).flatMap(([key, value]) => [flag, `${key}=${value}`]);
 // No provenance attestation: the pushed digest is then the image itself, as the record expects.
@@ -21,7 +22,7 @@ export const digestOf = (pushOutput) => {
 };
 export const createDocker = (run) => ({
     build: async (options) => {
-        await mustRun(run, 'docker', buildArgsOf(options));
+        await mustRun(run, 'docker', buildArgsOf(options), { timeoutMs: TIMEOUTS.build });
     },
-    push: async (tag) => digestOf(await mustRun(run, 'docker', ['push', tag], { echo: true })),
+    push: async (tag) => digestOf(await mustRun(run, 'docker', ['push', tag], { echo: true, timeoutMs: TIMEOUTS.push })),
 });

package/dist/tool/exec.d.ts

@@ -1,11 +1,16 @@
 export interface RunOptions {
     cwd?: string;
     echo?: boolean;
+    quiet?: boolean;
+    env?: Record<string, string | undefined>;
+    timeoutMs?: number;
 }
 export interface RunResult {
     code: number;
     stdout: string;
+    stderr?: string;
 }
 export type Run = (command: string, args: string[], options?: RunOptions) => Promise<RunResult>;
 export declare const runCommand: Run;
 export declare const mustRun: (run: Run, command: string, args: string[], options?: RunOptions) => Promise<string>;
+export declare const quietly: (run: Run) => Run;

package/dist/tool/exec.js

@@ -1,20 +1,59 @@
 import { spawn } from 'node:child_process';
-// stdout is captured (and echoed to stderr with `echo`); stderr streams through as progress.
-export const runCommand = (command, args, options = {}) => new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd: options.cwd, stdio: ['ignore', 'pipe', 'inherit'] });
-    let stdout = '';
+import {} from 'node:stream';
+import { KILL_GRACE_MS, TIMEOUTS } from './timeouts.js';
+const spawnFor = (command, args, options) => spawn(command, args, {
+    cwd: options.cwd,
+    stdio: ['ignore', 'pipe', options.quiet ? 'pipe' : 'inherit'],
+    env: options.env ? { ...process.env, ...options.env } : process.env,
+});
+// Resolves true once the command is past its time and has been told to stop.
+const expiry = (child, ms) => {
+    let timer;
+    const expired = { value: false };
+    timer = setTimeout(() => {
+        expired.value = true;
+        child.kill('SIGTERM');
+        timer = setTimeout(() => child.kill('SIGKILL'), KILL_GRACE_MS).unref();
+    }, ms).unref();
+    return { expired, clear: () => clearTimeout(timer) };
+};
+const timedOut = (command, args, ms) => new Error(`${command} ${args[0] ?? ''} did not finish in ${Math.round(ms / 1000)} s`);
+// stdout is captured (and echoed to stderr with `echo`); a piped stderr is captured too.
+const collect = (child, echo) => {
+    const out = { stdout: '', stderr: '' };
     child.stdout.on('data', (chunk) => {
-        stdout += chunk.toString();
-        if (options.echo)
+        out.stdout += chunk.toString();
+        if (echo)
             process.stderr.write(chunk);
     });
-    child.on('error', (err) => reject(err.code === 'ENOENT' ? new Error(`${command} is not installed or not on PATH`) : err));
-    child.on('close', (code) => resolve({ code: code ?? 1, stdout }));
+    child.stderr?.on('data', (chunk) => void (out.stderr += chunk.toString()));
+    return out;
+};
+// stderr streams through as progress unless `quiet`; past its timeout the command is killed.
+export const runCommand = (command, args, options = {}) => new Promise((resolve, reject) => {
+    const child = spawnFor(command, args, options);
+    const ms = options.timeoutMs ?? TIMEOUTS.command;
+    const timer = expiry(child, ms);
+    const out = collect(child, options.echo);
+    child.on('error', (err) => {
+        timer.clear();
+        reject(err.code === 'ENOENT' ? new Error(`${command} is not installed or not on PATH`) : err);
+    });
+    child.on('close', (code) => {
+        timer.clear();
+        if (timer.expired.value)
+            return reject(timedOut(command, args, ms));
+        const stderr = options.quiet ? { stderr: out.stderr } : {};
+        resolve({ code: code ?? 1, stdout: out.stdout, ...stderr });
+    });
 });
+const tail = (text) => text ? `\n${text.trim().split('\n').slice(-15).join('\n')}` : '';
 export const mustRun = async (run, command, args, options) => {
     const result = await run(command, args, options);
     if (result.code !== 0) {
-        throw new Error(`${command} ${args[0] ?? ''} failed with exit code ${result.code}`);
+        throw new Error(`${command} ${args[0] ?? ''} failed with exit code ${result.code}${tail(result.stderr)}`);
     }
     return result.stdout;
 };
+// Every command a runner starts runs quiet: what `up` and `down` print are their own lines.
+export const quietly = (run) => (command, args, options) => run(command, args, { ...options, quiet: true });

package/dist/tool/index.d.ts

@@ -1,2 +1,10 @@
+export { checkCli } from '../command/check-cli.js';
+export { runCommand, type RunCommandOptions } from '../command/run-command.js';
+export { type ExtensionPackage, type CommandSpec } from '../manifest/manifest.schema.js';
+export { readManifest, validateManifest } from '../manifest/read-manifest.js';
 export { build, type BuildDeps, type BuildOptions, type BuildResult, type BuiltImage, } from './build.js';
 export { buildLines } from './format.js';
+export { KIT_VERSION } from './kit-version.js';
+export { down, type DownOptions, type DownResult } from './up/down.js';
+export { token, type TokenOptions } from './up/token.js';
+export { up, type UpDeps, type UpOptions, type UpResult } from './up/up.js';

package/dist/tool/index.js

@@ -1,2 +1,10 @@
+export { checkCli } from '../command/check-cli.js';
+export { runCommand } from '../command/run-command.js';
+export {} from '../manifest/manifest.schema.js';
+export { readManifest, validateManifest } from '../manifest/read-manifest.js';
 export { build, } from './build.js';
 export { buildLines } from './format.js';
+export { KIT_VERSION } from './kit-version.js';
+export { down } from './up/down.js';
+export { token } from './up/token.js';
+export { up } from './up/up.js';

package/dist/tool/kit-version.d.ts

@@ -0,0 +1 @@
+export declare const KIT_VERSION: string;

package/dist/tool/kit-version.js

@@ -0,0 +1,3 @@
+import { readFileSync } from 'node:fs';
+// The kit's own version: what a kit-shaped manifest's engines.agentage ranges over.
+export const KIT_VERSION = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;

package/dist/tool/main.d.ts

@@ -1,6 +1,12 @@
 import { type BuildOptions, type BuildResult } from './build.js';
+import { type DownOptions } from './up/down.js';
+import { type TokenOptions } from './up/token.js';
+import { type UpOptions } from './up/up.js';
 export interface MainDeps {
     build: (options: BuildOptions) => Promise<BuildResult>;
+    up: (options: UpOptions) => Promise<unknown>;
+    down: (options: DownOptions) => Promise<unknown>;
+    token: (options: TokenOptions) => Promise<string>;
     out: (line: string) => void;
     err: (line: string) => void;
 }

package/dist/tool/main.js

@@ -1,56 +1,81 @@
 import { parseArgs } from 'node:util';
+import { UsageError } from '../command/args.js';
+import { EXIT_FAILED, EXIT_OK, EXIT_USAGE } from '../command/run-command.js';
 import { build } from './build.js';
 import { buildLines } from './format.js';
-const USAGE = `usage: agentage-extension build [--push] [--dir <path>] [--registry <host/owner>]
+import { down } from './up/down.js';
+import { token } from './up/token.js';
+import { up } from './up/up.js';
+const USAGE = `usage: agentage-extension <build|up|down|token> [options]
 
-  build      one image per server part from the kit recipe
-  --push     push the images and write dist/agentage-extension.json with their digests
-  --dir      the extension package folder (default: the current folder)
-  --registry image registry and owner (default: ghcr.io/agentage)`;
+  build      one image per part from the kit recipe
+    --push     push the images and write dist/agentage-extension.json with their digests
+    --registry image registry and owner (default: ghcr.io/agentage)
+  up         the release images on Docker: store, dev issuer, gateway on localhost:4280
+  down       remove what up started; --keep-data keeps the store volume
+  token      a dev token: --scope <id>:<verb> [--issuer <url>]
+  --dir      the extension package folder (default: the current folder)`;
 const defaultDeps = {
-    build: (options) => build(options),
+    build,
+    up,
+    down,
+    token,
     out: (line) => void process.stdout.write(`${line}\n`),
     err: (line) => void process.stderr.write(`${line}\n`),
 };
-const parse = (argv) => parseArgs({
-    args: argv,
-    allowPositionals: true,
-    options: {
-        push: { type: 'boolean' },
-        dir: { type: 'string' },
-        registry: { type: 'string' },
-        help: { type: 'boolean', short: 'h' },
+const OPTIONS = {
+    push: { type: 'boolean' },
+    dir: { type: 'string' },
+    registry: { type: 'string' },
+    'keep-data': { type: 'boolean' },
+    scope: { type: 'string' },
+    issuer: { type: 'string' },
+    help: { type: 'boolean', short: 'h' },
+};
+const parse = (argv) => parseArgs({ args: argv, allowPositionals: true, options: OPTIONS });
+const COMMANDS = {
+    build: async (v, deps) => {
+        for (const line of buildLines(await deps.build({ push: v.push, dir: v.dir, registry: v.registry })))
+            deps.out(line);
+    },
+    up: async (v, deps) => void (await deps.up({ dir: v.dir, onLine: deps.out })),
+    down: async (v, deps) => void (await deps.down({ dir: v.dir, keepData: v['keep-data'], onLine: deps.out })),
+    token: async (v, deps) => {
+        if (!v.scope)
+            throw new UsageError('token needs --scope <id>:<verb>');
+        deps.out(await deps.token({ scope: v.scope, issuer: v.issuer }));
     },
-});
-const runBuild = async (options, deps) => {
+};
+const runOne = async (name, values, deps) => {
     try {
-        for (const line of buildLines(await deps.build(options)))
-            deps.out(line);
-        return 0;
+        await COMMANDS[name]?.(values, deps);
+        return EXIT_OK;
     }
     catch (err) {
-        deps.err(`build failed: ${err.message}`);
-        return 1;
+        const usage = err instanceof UsageError;
+        deps.err(usage ? `${err.message}\n${USAGE}` : `${name} failed: ${err.message}`);
+        return usage ? EXIT_USAGE : EXIT_FAILED;
     }
 };
-// Exit codes: 0 ok, 1 the build failed, 2 usage.
-export const main = async (argv, deps = defaultDeps) => {
-    let parsed;
+const parsedOrUsage = (argv, deps) => {
     try {
-        parsed = parse(argv);
+        return parse(argv);
     }
     catch (err) {
         deps.err(`${err.message}\n${USAGE}`);
-        return 2;
+        return null;
     }
+};
+// Exit codes: 0 ok, 1 the step failed, 2 usage.
+export const main = async (argv, deps = defaultDeps) => {
+    const parsed = parsedOrUsage(argv, deps);
+    if (!parsed)
+        return EXIT_USAGE;
     const { positionals, values } = parsed;
-    if (values.help) {
-        deps.out(USAGE);
-        return 0;
-    }
-    if (positionals[0] !== 'build' || positionals.length !== 1) {
-        deps.err(USAGE);
-        return 2;
-    }
-    return runBuild({ push: values.push, dir: values.dir, registry: values.registry }, deps);
+    if (values.help)
+        return (deps.out(USAGE), EXIT_OK);
+    const name = positionals[0] ?? '';
+    if (!(name in COMMANDS) || positionals.length !== 1)
+        return (deps.err(USAGE), EXIT_USAGE);
+    return runOne(name, values, deps);
 };

package/dist/tool/record-extras.d.ts

@@ -0,0 +1,4 @@
+import { type RecordExtras } from '../discovery/discovery.js';
+import { type ExtensionPackage } from '../manifest/manifest.schema.js';
+export declare const toolNames: (dir: string, pkg: ExtensionPackage) => Promise<string[]>;
+export declare const recordExtras: (dir: string, pkg: ExtensionPackage) => Promise<RecordExtras>;

package/dist/tool/record-extras.js

@@ -0,0 +1,56 @@
+import { join } from 'node:path';
+import { z } from 'zod';
+import { createContext } from '../context/context.js';
+import {} from '../discovery/discovery.js';
+import { WidgetSchema } from '../discovery/discovery.schema.js';
+import { OPENAPI_PATH, readOpenapi } from '../discovery/openapi.js';
+import { createLog } from '../log/log.js';
+import { loadCreate } from '../manifest/entry.js';
+import { readJsonIfExists } from '../manifest/read-manifest.js';
+import {} from '../manifest/manifest.schema.js';
+import { hasPostgres, normalizeParts } from '../manifest/parts.js';
+import { createToolRegistry, prefixed } from '../mcp/tools.js';
+import { sqlFiles } from '../store/migrations.js';
+import {} from '../store/store.types.js';
+const WidgetsSchema = z.array(WidgetSchema).min(1);
+const noStore = {
+    query: async () => {
+        throw new Error('the store is not open while the build lists tools');
+    },
+};
+const silent = createLog({ extension: 'build', part: 'mcp' }, () => undefined);
+// The tool names the mcp part registers, read by running its create(ctx) with a recording ctx.
+export const toolNames = async (dir, pkg) => {
+    const registry = createToolRegistry();
+    const base = createContext({
+        pkg,
+        part: 'mcp',
+        origin: 'http://127.0.0.1',
+        commit: '0'.repeat(40),
+        log: silent,
+        store: noStore,
+    });
+    await (await loadCreate(dir, pkg, 'mcp'))({ ...base, tool: registry.tool });
+    return registry.tools.map((tool) => prefixed(pkg.agentage.id, tool.name));
+};
+const widgetsOf = async (dir) => {
+    const value = await readJsonIfExists(join(dir, 'dist', 'ui', 'widgets.json'));
+    return value === undefined ? undefined : WidgetsSchema.parse(value);
+};
+// What the code serves, for the record: tools, widgets and the migration count.
+export const recordExtras = async (dir, pkg) => {
+    const { code } = normalizeParts(pkg.agentage.parts);
+    const extras = {};
+    if (code.mcp) {
+        const tools = await toolNames(dir, pkg);
+        if (tools.length > 0)
+            extras.tools = tools;
+    }
+    if (code.ui)
+        extras.widgets = await widgetsOf(dir);
+    if (code.api && (await readOpenapi(dir)))
+        extras.openapi = OPENAPI_PATH;
+    if (hasPostgres(pkg))
+        extras.migrations = (await sqlFiles(join(dir, 'migrations'))).length;
+    return extras;
+};

package/dist/tool/stage.d.ts

@@ -1,5 +1,9 @@
 import { type ExtensionPackage } from '../manifest/manifest.schema.js';
 import { type ImagePartKind } from '../manifest/primitives.schema.js';
 export declare const RECORD_FILE = "agentage-extension.json";
+export declare const MIGRATE_SHIM = "// Generated by @agentage/extension build.\nimport '@agentage/extension/migrate';\n";
 export declare const localTarballs: (pkg: ExtensionPackage) => string[];
+export declare const exists: (path: string) => Promise<boolean>;
+export declare const appPaths: (dir: string, pkg: ExtensionPackage, part: ImagePartKind) => Promise<string[]>;
+export declare const assertBuilt: (dir: string, pkg: ExtensionPackage, part: ImagePartKind) => Promise<void>;
 export declare const stageContext: (dir: string, pkg: ExtensionPackage, part: ImagePartKind, tmpRoot?: string) => Promise<string>;