@agentage/extension 0.0.0-stage → 0.1.1

package/dist/runtime/run-part.js

@@ -0,0 +1,57 @@
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import {} from 'node:http';
+import { createContext } from '../context/context.js';
+import { DEFAULT_RECORD_FILE, loadRecord } from '../discovery/discovery.js';
+import { createLog } from '../log/log.js';
+import { entryOf } from '../manifest/parts.js';
+import { readManifest } from '../manifest/read-manifest.js';
+import { createApiApp } from '../server/app.js';
+import {} from '../server/part.types.js';
+import { serve } from '../server/serve.js';
+import { buildInfoFromEnv, portFromEnv } from './build-info.js';
+const importFile = (file) => import(pathToFileURL(file).href);
+export const createOf = (mod, file) => {
+    const create = mod?.create;
+    if (typeof create !== 'function')
+        throw new Error(`${file} does not export create(ctx)`);
+    return create;
+};
+const recordFor = async (env, log) => {
+    const file = env['AGENTAGE_RECORD_FILE'] || DEFAULT_RECORD_FILE;
+    const record = await loadRecord(file);
+    if (!record)
+        log.warn('no release record mounted; discovery lists this image by tag', { file });
+    return record;
+};
+// The image entry for a server part: manifest, ctx, create(ctx), then the kit's own server.
+export const runPart = async (options) => {
+    if (options.part !== 'api')
+        throw new Error(`part ${options.part} is not served by kit 0.1`);
+    const { env } = options;
+    const pkg = await readManifest(options.dir);
+    const log = createLog({ extension: pkg.agentage.id, part: 'api' });
+    const port = portFromEnv(env);
+    const origin = env['AGENTAGE_ORIGIN'] || undefined;
+    const ctx = createContext({
+        pkg,
+        part: 'api',
+        origin: origin ?? `http://127.0.0.1:${port}`,
+        log,
+    });
+    const file = join(options.dir, entryOf(pkg, 'api'));
+    const mod = await (options.importModule ?? importFile)(file);
+    const router = await createOf(mod, file)(ctx);
+    const build = buildInfoFromEnv(env);
+    const record = await recordFor(env, log);
+    const app = createApiApp({
+        pkg,
+        build,
+        router,
+        log,
+        record,
+        origin,
+        ownImage: env['AGENTAGE_IMAGE'],
+    });
+    return serve({ app, port, log, ...options.serve });
+};

package/dist/schemas/json-schemas.d.ts

@@ -0,0 +1,2 @@
+export declare const jsonSchemas: () => Record<string, Record<string, unknown>>;
+export declare const schemaText: (schema: Record<string, unknown>) => string;

package/dist/schemas/json-schemas.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { DiscoveryDocumentSchema, ExtensionRecordSchema } from '../discovery/discovery.schema.js';
+import { ErrorEnvelopeSchema, OkEnvelopeSchema } from '../envelope/envelope.schema.js';
+import { HealthSchema } from '../health/health.schema.js';
+import { PackageSchema } from '../manifest/manifest.schema.js';
+const BASE = 'https://agentage.io/schemas/';
+const SOURCES = {
+    'extension-package.schema.json': {
+        schema: PackageSchema,
+        title: 'agentage extension package.json',
+    },
+    'extension-record.schema.json': {
+        schema: ExtensionRecordSchema,
+        title: 'agentage-extension.json build record (in the package and the release asset)',
+    },
+    'extension-discovery.schema.json': {
+        schema: DiscoveryDocumentSchema,
+        title: 'GET /.well-known/agentage-extension.json',
+    },
+    'health.schema.json': { schema: HealthSchema, title: 'GET /health of every part container' },
+    'error-envelope.schema.json': { schema: ErrorEnvelopeSchema, title: 'REST error envelope' },
+    'ok-envelope.schema.json': { schema: OkEnvelopeSchema, title: 'REST success envelope' },
+};
+// Generated from the Zod schemas, the source of truth; cross-field rules live in Zod only.
+export const jsonSchemas = () => Object.fromEntries(Object.entries(SOURCES).map(([file, { schema, title }]) => [
+    file,
+    { $id: `${BASE}${file}`, title, ...z.toJSONSchema(schema, { io: 'input' }) },
+]));
+export const schemaText = (schema) => `${JSON.stringify(schema, null, 2)}\n`;

package/dist/schemas/write-schemas.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schemas/write-schemas.js

@@ -0,0 +1,8 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { jsonSchemas, schemaText } from './json-schemas.js';
+const outDir = process.argv[2] ?? 'schemas';
+await mkdir(outDir, { recursive: true });
+for (const [file, schema] of Object.entries(jsonSchemas())) {
+    await writeFile(join(outDir, file), schemaText(schema));
+}

package/dist/server/app.d.ts

@@ -0,0 +1,18 @@
+import { type CorsOptions } from 'cors';
+import { type Express } from 'express';
+import { type BuildInfo } from '../discovery/discovery.js';
+import { type ExtensionRecord } from '../discovery/discovery.schema.js';
+import { type Log } from '../log/log.js';
+import { type ExtensionPackage } from '../manifest/manifest.schema.js';
+import { type ApiHandler } from './part.types.js';
+export interface ApiAppOptions {
+    pkg: ExtensionPackage;
+    build: BuildInfo;
+    router: ApiHandler;
+    log: Log;
+    record?: ExtensionRecord | null;
+    ownImage?: string;
+    origin?: string;
+}
+export declare const PUBLIC_CORS: CorsOptions;
+export declare const createApiApp: (options: ApiAppOptions) => Express;

package/dist/server/app.js

@@ -0,0 +1,47 @@
+import cors, {} from 'cors';
+import express, {} from 'express';
+import helmet from 'helmet';
+import { agcidMiddleware } from '../agcid/scope.js';
+import { discoveryDocument, recordOf, } from '../discovery/discovery.js';
+import {} from '../discovery/discovery.schema.js';
+import { createHealthHandler } from '../health/health.js';
+import {} from '../log/log.js';
+import {} from '../manifest/manifest.schema.js';
+import { errorHandler, notFound } from './errors.js';
+import {} from './part.types.js';
+// api-standards section 6: CORS * without credentials on /.well-known/ and /api/.
+export const PUBLIC_CORS = {
+    origin: '*',
+    credentials: false,
+    allowedHeaders: ['Authorization', 'Content-Type', 'agcid', 'traceparent', 'If-Match'],
+    exposedHeaders: ['agcid', 'ETag', 'Retry-After', 'RateLimit', 'WWW-Authenticate'],
+};
+const BODY_LIMIT = '1mb';
+const requestOrigin = (req) => `${req.protocol}://${req.get('host') ?? ''}`;
+const discoveryHandler = (options) => {
+    const images = options.ownImage ? { api: options.ownImage } : {};
+    const record = options.record ?? recordOf(options.pkg, options.build, images);
+    return (req, res) => {
+        res.json(discoveryDocument(record, options.origin ?? requestOrigin(req)));
+    };
+};
+const healthHandler = (options) => createHealthHandler({
+    extension: options.pkg.agentage.id,
+    part: 'api',
+    version: options.pkg.version,
+    build: options.build,
+});
+// The kit owns the app: agcid, helmet, CORS, /health, discovery, the body limit, 404 and errors.
+export const createApiApp = (options) => {
+    const app = express();
+    app.disable('x-powered-by');
+    app.set('trust proxy', 'loopback, linklocal, uniquelocal');
+    app.use(agcidMiddleware, helmet());
+    app.get('/health', healthHandler(options));
+    app.use('/.well-known', cors(PUBLIC_CORS));
+    app.get('/.well-known/agentage-extension.json', discoveryHandler(options));
+    app.use('/api/v1', cors(PUBLIC_CORS), express.json({ limit: BODY_LIMIT }), options.router);
+    app.use(notFound);
+    app.use(errorHandler(options.log));
+    return app;
+};

package/dist/server/errors.d.ts

@@ -0,0 +1,6 @@
+import { type ErrorRequestHandler, type RequestHandler } from 'express';
+import { type Failure } from '../envelope/envelope.js';
+import { type Log } from '../log/log.js';
+export declare const toFailure: (err: unknown) => Failure;
+export declare const notFound: RequestHandler;
+export declare const errorHandler: (log: Log) => ErrorRequestHandler;

package/dist/server/errors.js

@@ -0,0 +1,29 @@
+import {} from 'express';
+import { agcidOfResponse } from '../agcid/scope.js';
+import { errorEnvelope, fail, isFailure } from '../envelope/envelope.js';
+import {} from '../log/log.js';
+const bodyParserFailure = (err) => {
+    const type = err?.type;
+    if (type === 'entity.too.large')
+        return fail('PAYLOAD_TOO_LARGE', 'Body too large');
+    if (type === 'entity.parse.failed')
+        return fail('VALIDATION_ERROR', 'Invalid JSON body');
+    return null;
+};
+// Anything that is not a kit failure is an INTERNAL 500 with a generic message; the log has it whole.
+export const toFailure = (err) => {
+    if (isFailure(err))
+        return err;
+    return bodyParserFailure(err) ?? fail('INTERNAL', 'Internal error');
+};
+export const notFound = () => {
+    throw fail('NOT_FOUND', 'Not found');
+};
+export const errorHandler = (log) => (err, _req, res, _next) => {
+    const failure = toFailure(err);
+    if (failure.status >= 500)
+        log.error(err);
+    if (failure.retryAfter !== undefined)
+        res.setHeader('Retry-After', String(failure.retryAfter));
+    res.status(failure.status).json(errorEnvelope(failure, agcidOfResponse(res)));
+};

package/dist/server/part.types.d.ts

@@ -0,0 +1,7 @@
+import { type RequestHandler, type Router } from 'express';
+import { type PartContext } from '../context/context.js';
+export type ApiHandler = Router | RequestHandler;
+export type ApiCreate<C extends PartContext = PartContext> = (ctx: C) => ApiHandler | Promise<ApiHandler>;
+export interface ApiPart {
+    create: ApiCreate;
+}

package/dist/server/part.types.js

@@ -0,0 +1,2 @@
+import {} from 'express';
+import {} from '../context/context.js';

package/dist/server/serve.d.ts

@@ -0,0 +1,14 @@
+import { type Server } from 'node:http';
+import { type Express } from 'express';
+import { type Log } from '../log/log.js';
+export interface ServeOptions {
+    app: Express;
+    port: number;
+    log: Log;
+    graceMs?: number;
+    exit?: (code: number) => void;
+    signals?: NodeJS.Signals[];
+}
+export declare const listen: (app: Express, port: number, host?: string) => Promise<Server>;
+export declare const shutdownOn: (server: Server, options: ServeOptions) => (() => void);
+export declare const serve: (options: ServeOptions) => Promise<Server>;

package/dist/server/serve.js

@@ -0,0 +1,27 @@
+import {} from 'node:http';
+import {} from 'node:net';
+import {} from 'express';
+import {} from '../log/log.js';
+export const listen = (app, port, host) => new Promise((resolve, reject) => {
+    const done = (err) => (err ? reject(err) : resolve(server));
+    const server = host === undefined ? app.listen(port, done) : app.listen(port, host, done);
+});
+// SIGTERM drains: no new connections, idle ones closed, a hard exit after the grace period.
+export const shutdownOn = (server, options) => {
+    const exit = options.exit ?? ((code) => process.exit(code));
+    const stop = () => {
+        options.log.info('shutting down');
+        server.close(() => exit(0));
+        server.closeIdleConnections();
+        setTimeout(() => exit(0), options.graceMs ?? 10_000).unref();
+    };
+    for (const signal of options.signals ?? ['SIGTERM', 'SIGINT'])
+        process.once(signal, stop);
+    return stop;
+};
+export const serve = async (options) => {
+    const server = await listen(options.app, options.port);
+    shutdownOn(server, options);
+    options.log.info('listening', { port: server.address().port });
+    return server;
+};

package/dist/testing/test-server.d.ts

@@ -0,0 +1,12 @@
+import { type PartContext } from '../context/context.js';
+import { type ApiCreate } from '../server/part.types.js';
+export interface TestServerOptions<C extends PartContext> {
+    create: ApiCreate<C>;
+    ctx?: C;
+}
+export interface TestServer {
+    url: string;
+    fetch(path: string, init?: RequestInit): Promise<Response>;
+    close(): Promise<void>;
+}
+export declare const startTestServer: <C extends PartContext = PartContext>(options: TestServerOptions<C>) => Promise<TestServer>;

package/dist/testing/test-server.js

@@ -0,0 +1,26 @@
+import {} from 'node:net';
+import { createTestContext } from '../context/context.js';
+import {} from '../manifest/manifest.schema.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) => ({
+    name: `@agentage/extension-${ctx.extension.id}`,
+    version: ctx.extension.version,
+    engines: { agentage: '^0.1.0' },
+    agentage: { id: ctx.extension.id, parts: { api: true } },
+});
+// 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 server = await listen(app, 0, '127.0.0.1');
+    const url = `http://127.0.0.1:${server.address().port}`;
+    return {
+        url,
+        fetch: (path, init) => fetch(`${url}${path}`, init),
+        close: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+};

package/dist/tool/build-info.d.ts

@@ -0,0 +1,4 @@
+import { type BuildInfo } from '../discovery/discovery.js';
+import { type Env } from '../runtime/build-info.js';
+import { type Run } from './exec.js';
+export declare const resolveBuildInfo: (dir: string, env: Env, run: Run, now?: Date) => Promise<BuildInfo>;

package/dist/tool/build-info.js

@@ -0,0 +1,18 @@
+import {} from '../discovery/discovery.js';
+import {} from '../runtime/build-info.js';
+import { mustRun } from './exec.js';
+const FULL_SHA = /^[0-9a-f]{40}$/;
+const isoSeconds = (date) => `${date.toISOString().slice(0, 19)}Z`;
+const commitOf = async (dir, env, run) => {
+    const given = env['COMMIT_SHA'] || env['GITHUB_SHA'];
+    if (given)
+        return given;
+    return (await mustRun(run, 'git', ['rev-parse', 'HEAD'], { cwd: dir })).trim();
+};
+// The commit every image label, /health and the record carry: CI's sha, else the checkout's HEAD.
+export const resolveBuildInfo = async (dir, env, run, now = new Date()) => {
+    const commit = await commitOf(dir, env, run);
+    if (!FULL_SHA.test(commit))
+        throw new Error(`commit is not a full 40-hex sha: ${commit}`);
+    return { commit, buildTime: env['BUILD_TIME'] || isoSeconds(now) };
+};

package/dist/tool/build.d.ts

@@ -0,0 +1,35 @@
+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 declare const SUPPORTED_PARTS: readonly ImagePartKind[];
+export interface BuildOptions {
+    dir?: string;
+    push?: boolean;
+    registry?: string;
+    env?: Env;
+    now?: Date;
+}
+export interface BuildDeps {
+    run: Run;
+    docker?: Docker;
+    tmpRoot?: string;
+}
+export interface BuiltImage {
+    part: ImagePartKind;
+    tag: string;
+    digest?: string;
+    image?: string;
+}
+export interface BuildResult {
+    id: string;
+    version: string;
+    commit: string;
+    buildTime: string;
+    images: BuiltImage[];
+    recordFile?: string;
+}
+export declare const imageTag: (registry: string, pkg: ExtensionPackage, part: ImagePartKind) => string;
+export declare const build: (options?: BuildOptions, deps?: BuildDeps) => Promise<BuildResult>;

package/dist/tool/build.js

@@ -0,0 +1,83 @@
+import { rm, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { recordOf, validateRecord } from '../discovery/discovery.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 { createDocker } from './docker.js';
+import { mustRun, runCommand } from './exec.js';
+import { labelsOf } from './labels.js';
+import { RECORD_FILE, stageContext } from './stage.js';
+export const DEFAULT_REGISTRY = 'ghcr.io/agentage';
+export const SUPPORTED_PARTS = ['api'];
+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 });
+};
+const buildImage = async (job, docker, tmpRoot) => {
+    const context = await stageContext(job.dir, job.pkg, job.part, tmpRoot);
+    try {
+        const buildArgs = {
+            COMMIT_SHA: job.info.commit,
+            BUILD_TIME: job.info.buildTime,
+            IMAGE: job.tag,
+        };
+        await docker.build({
+            context,
+            tag: job.tag,
+            buildArgs,
+            labels: labelsOf(job.pkg, job.part, job.info),
+        });
+    }
+    finally {
+        await rm(context, { recursive: true, force: true });
+    }
+};
+const pushImage = async (job, docker) => {
+    const digest = await docker.push(job.tag);
+    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) => {
+    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);
+    await writeFile(file, `${JSON.stringify(record, null, 2)}\n`);
+    return file;
+};
+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 partsToBuild(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;
+};
+// One image per server part from the kit recipe; with push, the digests go into the build record.
+export const build = async (options = {}, deps = { run: runCommand }) => {
+    const dir = resolve(options.dir ?? '.');
+    const pkg = await readManifest(dir);
+    partsToBuild(pkg);
+    const info = await resolveBuildInfo(dir, options.env ?? process.env, deps.run, options.now);
+    await compile(dir, pkg, deps.run);
+    const images = await buildParts({ dir, pkg, info }, options, deps);
+    const recordFile = options.push ? await writeRecord(dir, pkg, info, images) : undefined;
+    const result = { id: pkg.agentage.id, version: pkg.version, ...info, images };
+    return recordFile ? { ...result, recordFile } : result;
+};

package/dist/tool/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/tool/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from './main.js';
+process.exitCode = await main(process.argv.slice(2));

package/dist/tool/docker.d.ts

@@ -0,0 +1,15 @@
+import { type Run } from './exec.js';
+export interface DockerBuild {
+    context: string;
+    tag: string;
+    buildArgs: Record<string, string>;
+    labels: Record<string, string>;
+}
+export interface Docker {
+    build(options: DockerBuild): Promise<void>;
+    push(tag: string): Promise<string>;
+}
+export declare const PLATFORM = "linux/amd64";
+export declare const buildArgsOf: (options: DockerBuild) => string[];
+export declare const digestOf: (pushOutput: string) => string;
+export declare const createDocker: (run: Run) => Docker;

package/dist/tool/docker.js

@@ -0,0 +1,26 @@
+import { mustRun } from './exec.js';
+export const PLATFORM = 'linux/amd64';
+const flags = (flag, values) => Object.entries(values).flatMap(([key, value]) => [flag, `${key}=${value}`]);
+export const buildArgsOf = (options) => [
+    'build',
+    '--platform',
+    PLATFORM,
+    '--provenance=false',
+    '--tag',
+    options.tag,
+    ...flags('--build-arg', options.buildArgs),
+    ...flags('--label', options.labels),
+    options.context,
+];
+export const digestOf = (pushOutput) => {
+    const match = /digest: (sha256:[0-9a-f]{64})/.exec(pushOutput);
+    if (!match?.[1])
+        throw new Error('docker push printed no digest');
+    return match[1];
+};
+export const createDocker = (run) => ({
+    build: async (options) => {
+        await mustRun(run, 'docker', buildArgsOf(options));
+    },
+    push: async (tag) => digestOf(await mustRun(run, 'docker', ['push', tag], { echo: true })),
+});

package/dist/tool/exec.d.ts

@@ -0,0 +1,12 @@
+export interface RunOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    echo?: boolean;
+}
+export interface RunResult {
+    code: number;
+    stdout: 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>;

package/dist/tool/exec.js

@@ -0,0 +1,24 @@
+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,
+        env: options.env ?? process.env,
+        stdio: ['ignore', 'pipe', 'inherit'],
+    });
+    let stdout = '';
+    child.stdout.on('data', (chunk) => {
+        stdout += chunk.toString();
+        if (options.echo)
+            process.stderr.write(chunk);
+    });
+    child.on('error', reject);
+    child.on('close', (code) => resolve({ code: code ?? 1, stdout }));
+});
+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}`);
+    }
+    return result.stdout;
+};

package/dist/tool/format.d.ts

@@ -0,0 +1,2 @@
+import { type BuildResult } from './build.js';
+export declare const buildLines: (result: BuildResult, cwd?: string) => string[];

package/dist/tool/format.js

@@ -0,0 +1,14 @@
+import { relative } from 'node:path';
+import {} from './build.js';
+const shortDigest = (digest) => digest.slice(0, 'sha256:'.length + 8);
+// One line per image, the record path last: what `agentage extension build` prints.
+export const buildLines = (result, cwd = process.cwd()) => {
+    const width = Math.max(...result.images.map((image) => image.tag.length)) + 2;
+    const lines = result.images.map((image) => {
+        const state = image.digest ? `${shortDigest(image.digest)} pushed` : 'built';
+        return `${image.part.padEnd(8)}${image.tag.padEnd(width)}${state}`;
+    });
+    if (result.recordFile)
+        lines.push(`${'record'.padEnd(8)}${relative(cwd, result.recordFile)}`);
+    return lines;
+};

package/dist/tool/index.d.ts

@@ -0,0 +1,11 @@
+export { build, DEFAULT_REGISTRY, imageTag, SUPPORTED_PARTS, type BuildDeps, type BuildOptions, type BuildResult, type BuiltImage, } from './build.js';
+export { resolveBuildInfo } from './build-info.js';
+export { createDocker, PLATFORM, type Docker, type DockerBuild } from './docker.js';
+export { runCommand, type Run, type RunOptions, type RunResult } from './exec.js';
+export { buildLines } from './format.js';
+export { labelsOf } from './labels.js';
+export { main as runTool, USAGE as TOOL_USAGE } from './main.js';
+export { PART_PORT, serverPartRecipe } from './recipe.js';
+export { RECORD_FILE, stageContext } from './stage.js';
+export { readManifest, validateManifest } from '../manifest/read-manifest.js';
+export { type ExtensionPackage } from '../manifest/manifest.schema.js';

package/dist/tool/index.js

@@ -0,0 +1,11 @@
+export { build, DEFAULT_REGISTRY, imageTag, SUPPORTED_PARTS, } from './build.js';
+export { resolveBuildInfo } from './build-info.js';
+export { createDocker, PLATFORM } from './docker.js';
+export { runCommand } from './exec.js';
+export { buildLines } from './format.js';
+export { labelsOf } from './labels.js';
+export { main as runTool, USAGE as TOOL_USAGE } from './main.js';
+export { PART_PORT, serverPartRecipe } from './recipe.js';
+export { RECORD_FILE, stageContext } from './stage.js';
+export { readManifest, validateManifest } from '../manifest/read-manifest.js';
+export {} from '../manifest/manifest.schema.js';

package/dist/tool/labels.d.ts

@@ -0,0 +1,4 @@
+import { type BuildInfo } from '../discovery/discovery.js';
+import { type ExtensionPackage } from '../manifest/manifest.schema.js';
+import { type ImagePartKind } from '../manifest/primitives.schema.js';
+export declare const labelsOf: (pkg: ExtensionPackage, part: ImagePartKind, build: BuildInfo) => Record<string, string>;

package/dist/tool/labels.js

@@ -0,0 +1,25 @@
+import {} from '../discovery/discovery.js';
+import {} from '../manifest/manifest.schema.js';
+import {} from '../manifest/primitives.schema.js';
+const repositoryUrl = (pkg) => {
+    const repo = pkg.repository;
+    const url = typeof repo === 'string' ? repo : repo?.url;
+    if (typeof url !== 'string')
+        return undefined;
+    return url.replace(/^git\+/, '').replace(/\.git$/, '');
+};
+// OCI labels: revision is the full sha, created the build time; source links the GHCR package.
+export const labelsOf = (pkg, part, build) => {
+    const labels = {
+        'org.opencontainers.image.revision': build.commit,
+        'org.opencontainers.image.created': build.buildTime,
+        'org.opencontainers.image.version': pkg.version,
+        'org.opencontainers.image.title': `${pkg.agentage.id}-${part}`,
+        'io.agentage.extension': pkg.agentage.id,
+        'io.agentage.part': part,
+    };
+    const source = repositoryUrl(pkg);
+    if (source)
+        labels['org.opencontainers.image.source'] = source;
+    return labels;
+};

package/dist/tool/main.d.ts

@@ -0,0 +1,8 @@
+import { type BuildOptions, type BuildResult } from './build.js';
+export interface MainDeps {
+    build: (options: BuildOptions) => Promise<BuildResult>;
+    out: (line: string) => void;
+    err: (line: string) => void;
+}
+export declare const USAGE = "usage: agentage-extension build [--push] [--dir <path>] [--registry <host/owner>]\n\n  build      one image per server part from the kit recipe\n  --push     push the images and write dist/agentage-extension.json with their digests\n  --dir      the extension package folder (default: the current folder)\n  --registry image registry and owner (default: ghcr.io/agentage)";
+export declare const main: (argv: string[], deps?: MainDeps) => Promise<number>;