@agentage/extension 0.1.1 → 0.2.0

package/dist/manifest/read-manifest.js

@@ -11,9 +11,32 @@ export const validateManifest = (value) => {
         return result.data;
     throw new Error(`invalid agentage manifest in package.json: ${formatIssues(result.error.issues)}`);
 };
+const parseJson = (text, file) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`${file} is not valid JSON: ${err.message}`);
+    }
+};
+// undefined only for a missing file (JSON never parses to it); any other read error is thrown.
+export const readJsonIfExists = async (file) => {
+    let text;
+    try {
+        text = await readFile(file, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return undefined;
+        throw err;
+    }
+    return parseJson(text, file);
+};
 // The manifest is the `agentage` block of package.json, read as data without running code.
 export const readManifest = async (dir) => {
-    const file = join(dir, 'package.json');
-    const text = await readFile(file, 'utf8');
-    return validateManifest(JSON.parse(text));
+    const pkg = await readJsonIfExists(join(dir, 'package.json'));
+    if (pkg === undefined) {
+        throw new Error(`no package.json in ${dir}: run it in an extension package folder`);
+    }
+    return validateManifest(pkg);
 };

package/dist/mcp/mcp-app.d.ts

@@ -0,0 +1,8 @@
+import { type Express } from 'express';
+import { type PartAppBase } from '../server/app.js';
+import { type ToolEntry } from './tools.js';
+export interface McpAppOptions extends PartAppBase {
+    tools: ToolEntry[];
+    listing: 'open' | 'token';
+}
+export declare const createMcpApp: (options: McpAppOptions) => Express;

package/dist/mcp/mcp-app.js

@@ -0,0 +1,74 @@
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import cors from 'cors';
+import express, {} from 'express';
+import { createMcpHandler } from '@modelcontextprotocol/server';
+import { fail } from '../envelope/envelope.js';
+import { BODY_LIMIT, createPartApp, PUBLIC_CORS } from '../server/app.js';
+import { serverFactory } from './server.js';
+import {} from './tools.js';
+const MCP_HEADERS = ['Mcp-Protocol-Version', 'Mcp-Method', 'Mcp-Name', 'Accept'];
+const MCP_CORS = {
+    ...PUBLIC_CORS,
+    allowedHeaders: [...PUBLIC_CORS.allowedHeaders, ...MCP_HEADERS],
+};
+const parsed = (body) => {
+    try {
+        return JSON.parse(body.toString('utf8'));
+    }
+    catch {
+        return undefined;
+    }
+};
+const isListing = (body) => (Array.isArray(body) ? body : [body]).some((message) => message?.method === 'tools/list');
+const webRequest = (req, body) => {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === 'string')
+            headers.set(key, value);
+    }
+    return new globalThis.Request(`http://${req.get('host') ?? 'mcp'}/mcp`, {
+        method: 'POST',
+        headers,
+        body,
+    });
+};
+const send = async (response, res) => {
+    res.status(response.status);
+    response.headers.forEach((value, key) => void res.setHeader(key, value));
+    if (!response.body)
+        return void res.end();
+    await pipeline(Readable.fromWeb(response.body), res);
+};
+// The kit verifies no token yet, so a closed listing refuses every tools/list.
+const handle = (handler, listing) => async (req, res) => {
+    const body = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
+    const message = parsed(body);
+    if (listing === 'token' && isListing(message))
+        throw fail('UNAUTHORIZED', 'tools/list needs a token');
+    await send(await handler.fetch(webRequest(req, body), { parsedBody: message }), res);
+};
+const methodNotAllowed = (_req, res) => {
+    res.setHeader('Allow', 'POST');
+    res
+        .status(405)
+        .json({ jsonrpc: '2.0', error: { code: -32000, message: 'Method not allowed.' }, id: null });
+};
+// Stateless Streamable HTTP on SDK v2: POST /mcp only, GET and DELETE (sessions) answer 405.
+export const createMcpApp = (options) => {
+    const identity = { id: options.pkg.agentage.id, version: options.pkg.version };
+    const handler = createMcpHandler(serverFactory(identity, options.tools, options.log), {
+        legacy: 'stateless',
+        onerror: (err) => options.log.warn('mcp request refused', { reason: err.message }),
+    });
+    const raw = express.raw({ type: () => true, limit: BODY_LIMIT });
+    return createPartApp({
+        ...options,
+        part: 'mcp',
+        mount: (app) => {
+            app.use('/mcp', cors(MCP_CORS));
+            app.post('/mcp', raw, handle(handler, options.listing));
+            app.all('/mcp', methodNotAllowed);
+        },
+    });
+};

package/dist/mcp/server.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import { type Log } from '../log/log.js';
+import { type ToolEntry } from './tools.js';
+export interface ServerIdentity {
+    id: string;
+    version: string;
+}
+export declare const serverFactory: (identity: ServerIdentity, tools: ToolEntry[], log: Log) => () => McpServer;

package/dist/mcp/server.js

@@ -0,0 +1,36 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import { currentAgcid } from '../agcid/current.js';
+import { fail, isFailure } from '../envelope/envelope.js';
+import {} from '../log/log.js';
+import { prefixed } from './tools.js';
+const text = (value) => [{ type: 'text', text: JSON.stringify(value) }];
+// A failed tool is isError with the REST error shape; anything unexpected is a generic INTERNAL.
+const errorResult = (err, log) => {
+    const failure = isFailure(err) ? err : fail('INTERNAL', 'Internal error');
+    if (failure.status >= 500)
+        log.error(err);
+    const error = { code: failure.code, message: failure.message, agcid: currentAgcid() ?? '' };
+    return { isError: true, content: text({ error }), structuredContent: { error } };
+};
+const callback = (entry, log) => async (args) => {
+    try {
+        const output = entry.spec.output.parse(await entry.handler(args));
+        return { content: text(output), structuredContent: output };
+    }
+    catch (err) {
+        return errorResult(err, log);
+    }
+};
+// One fresh server per request (stateless); serverInfo agentage-{id} at the package version.
+export const serverFactory = (identity, tools, log) => () => {
+    const server = new McpServer({ name: `agentage-${identity.id}`, version: identity.version });
+    for (const entry of tools) {
+        const config = {
+            description: entry.spec.description,
+            inputSchema: entry.spec.input,
+            outputSchema: entry.spec.output,
+        };
+        server.registerTool(prefixed(identity.id, entry.name), config, callback(entry, log));
+    }
+    return server;
+};

package/dist/mcp/snapshot.d.ts

@@ -0,0 +1,11 @@
+export declare const PROTOCOL_VERSIONS: readonly ["2025-11-25", "2026-07-28"];
+export type ProtocolVersion = (typeof PROTOCOL_VERSIONS)[number];
+export interface McpSnapshot {
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+    tools: Record<string, unknown>[];
+}
+export declare const canonical: (value: unknown) => unknown;
+export declare const mcpSnapshot: (url: string, version: ProtocolVersion) => Promise<McpSnapshot>;

package/dist/mcp/snapshot.js

@@ -0,0 +1,69 @@
+export const PROTOCOL_VERSIONS = ['2025-11-25', '2026-07-28'];
+const CLIENT = { name: 'agentage-snapshot', version: '1.0.0' };
+// Key order never counts: the two eras serialize the same schema in different orders.
+export const canonical = (value) => {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+    return Object.fromEntries(entries.map(([key, v]) => [key, canonical(v)]));
+};
+// A JSON answer or the stateless legacy leg's one-message SSE stream.
+const payload = async (res) => {
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`mcp answered ${res.status}: ${text.slice(0, 200)}`);
+    const data = (res.headers.get('content-type') ?? '').includes('text/event-stream')
+        ? (text
+            .split('\n')
+            .find((line) => line.startsWith('data:'))
+            ?.slice(5) ?? '{}')
+        : text;
+    const message = JSON.parse(data);
+    if (message['error'])
+        throw new Error(`mcp error: ${JSON.stringify(message['error'])}`);
+    return message['result'];
+};
+const META = {
+    'io.modelcontextprotocol/protocolVersion': '2026-07-28',
+    'io.modelcontextprotocol/clientInfo': CLIENT,
+    'io.modelcontextprotocol/clientCapabilities': {},
+};
+const post = async (url, version, method, params) => {
+    const modern = version === '2026-07-28';
+    const headers = {
+        'content-type': 'application/json',
+        accept: 'application/json, text/event-stream',
+        'mcp-protocol-version': version,
+        ...(modern ? { 'mcp-method': method } : {}),
+    };
+    const body = {
+        jsonrpc: '2.0',
+        id: 1,
+        method,
+        params: modern ? { ...params, _meta: META } : params,
+    };
+    return payload(await fetch(url, { method: 'POST', headers, body: JSON.stringify(body) }));
+};
+const serverInfoOf = async (url, version) => {
+    if (version === '2025-11-25') {
+        const init = await post(url, version, 'initialize', {
+            protocolVersion: version,
+            capabilities: {},
+            clientInfo: CLIENT,
+        });
+        return init['serverInfo'];
+    }
+    const found = await post(url, version, 'server/discover', {});
+    return found['_meta']['io.modelcontextprotocol/serverInfo'];
+};
+// What a client of that protocol version sees: serverInfo and tools/list, canonical; the contract test diffs it.
+export const mcpSnapshot = async (url, version) => {
+    const { name, version: serverVersion } = await serverInfoOf(url, version);
+    const listed = await post(url, version, 'tools/list', {});
+    return canonical({
+        serverInfo: { name, version: serverVersion },
+        tools: listed['tools'],
+    });
+};

package/dist/mcp/tools.d.ts

@@ -0,0 +1,24 @@
+import { type z } from 'zod';
+import { type PartContext } from '../context/context.js';
+type ObjectSchema = z.ZodObject;
+export interface ToolSpec<I extends ObjectSchema, O extends ObjectSchema> {
+    description: string;
+    input: I;
+    output: O;
+}
+export type ToolHandler<I extends ObjectSchema, O extends ObjectSchema> = (args: z.output<I>) => z.input<O> | Promise<z.input<O>>;
+export type ToolRegistrar = <I extends ObjectSchema, O extends ObjectSchema>(name: string, spec: ToolSpec<I, O>, handler: ToolHandler<I, O>) => void;
+export interface McpContext extends PartContext {
+    readonly tool: ToolRegistrar;
+}
+export interface ToolEntry {
+    name: string;
+    spec: ToolSpec<ObjectSchema, ObjectSchema>;
+    handler: (args: Record<string, unknown>) => unknown;
+}
+export declare const createToolRegistry: () => {
+    tool: ToolRegistrar;
+    tools: ToolEntry[];
+};
+export declare const prefixed: (id: string, name: string) => string;
+export {};

package/dist/mcp/tools.js

@@ -0,0 +1,17 @@
+import {} from 'zod';
+import {} from '../context/context.js';
+const TOOL_NAME = /^[a-z][a-z0-9_-]*$/;
+export const createToolRegistry = () => {
+    const tools = [];
+    const tool = (name, spec, handler) => {
+        if (!TOOL_NAME.test(name))
+            throw new Error(`tool name ${name}: lowercase, digits, _ and -`);
+        if (tools.some((entry) => entry.name === name))
+            throw new Error(`tool ${name} is registered twice`);
+        if (!spec.description)
+            throw new Error(`tool ${name} needs a description: it routes the model`);
+        tools.push({ name, spec, handler: handler });
+    };
+    return { tool, tools };
+};
+export const prefixed = (id, name) => `${id}__${name}`;

package/dist/pages/pages-app.d.ts

@@ -0,0 +1,8 @@
+import { type Express } from 'express';
+import { type PartAppBase } from '../server/app.js';
+import { type PagesSite } from './pages.js';
+export interface PagesAppOptions extends PartAppBase {
+    site: PagesSite;
+}
+export declare const NOT_FOUND_PAGE = "<!doctype html>\n<html lang=\"en\"><head><meta charset=\"utf-8\"><title>Not found</title></head><body><p>Not found</p></body></html>\n";
+export declare const createPagesApp: (options: PagesAppOptions) => Express;

package/dist/pages/pages-app.js

@@ -0,0 +1,29 @@
+import {} from 'express';
+import { z } from 'zod';
+import { createPartApp } from '../server/app.js';
+import {} from './pages.js';
+const SiteSchema = z.record(z.string().regex(/^\/[A-Za-z0-9._~/-]*$/), z.string());
+export const NOT_FOUND_PAGE = '<!doctype html>\n<html lang="en"><head><meta charset="utf-8"><title>Not found</title></head><body><p>Not found</p></body></html>\n';
+const serve = (site) => (req, res, next) => {
+    const html = site[req.path];
+    if (html === undefined)
+        return next();
+    res.type('html').setHeader('Cache-Control', 'no-cache');
+    res.send(html);
+};
+const missing = (_req, res) => {
+    res.status(404).type('html').send(NOT_FOUND_PAGE);
+};
+// Everything the gateway does not reserve comes here: a page from the site map, or an HTML 404.
+export const createPagesApp = (options) => {
+    const site = SiteSchema.parse(options.site);
+    return createPartApp({
+        ...options,
+        part: 'pages',
+        helmet: { contentSecurityPolicy: { directives: { upgradeInsecureRequests: null } } },
+        mount: (app) => {
+            app.get(/.*/, serve(site));
+            app.get(/.*/, missing);
+        },
+    });
+};

package/dist/pages/pages.d.ts

@@ -0,0 +1,4 @@
+import { type PartContext } from '../context/context.js';
+export type PagesContext = PartContext;
+export type PagesSite = Readonly<Record<string, string>>;
+export declare const versionPage: (ctx: PagesContext) => string;

package/dist/pages/pages.js

@@ -0,0 +1,16 @@
+import {} from '../context/context.js';
+const escape = (value) => value.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+const STYLE = 'body{font:16px/1.5 system-ui,sans-serif;margin:3rem;color:#1d1d1f;background:#fff}' +
+    '@media (prefers-color-scheme:dark){body{color:#f5f5f7;background:#111}}code{font-size:.9em}';
+// One static page that names what runs: "{id} {version} · {commit}".
+export const versionPage = (ctx) => {
+    const { id, version, commit } = ctx.extension;
+    const title = escape(id);
+    return [
+        '<!doctype html>',
+        `<html lang="en"><head><meta charset="utf-8"><title>${title}</title>`,
+        `<meta name="viewport" content="width=device-width, initial-scale=1"><style>${STYLE}</style></head>`,
+        `<body><main><h1>${title}</h1><p>${title} ${escape(version)} · <code>${escape(commit)}</code></p></main></body></html>`,
+        '',
+    ].join('\n');
+};

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

@@ -1,4 +1,5 @@
 import { type BuildInfo } from '../discovery/discovery.js';
 export type Env = Readonly<Record<string, string | undefined>>;
+export declare const isoSeconds: (date: Date) => string;
 export declare const buildInfoFromEnv: (env: Env, now?: Date) => BuildInfo;
 export declare const portFromEnv: (env: Env, fallback?: number) => number;

package/dist/runtime/build-info.js

@@ -1,11 +1,11 @@
 import {} from '../discovery/discovery.js';
+import { FULL_SHA } from '../manifest/primitives.schema.js';
 const UNKNOWN_COMMIT = '0'.repeat(40);
-const isoSeconds = (date) => `${date.toISOString().slice(0, 19)}Z`;
+export const isoSeconds = (date) => `${date.toISOString().slice(0, 19)}Z`;
+const commitOf = (sha = '') => (FULL_SHA.test(sha) ? sha : UNKNOWN_COMMIT);
 // COMMIT_SHA and BUILD_TIME are baked into every image by the recipe; a bare dev run shows zeros.
 export const buildInfoFromEnv = (env, now = new Date()) => ({
-    commit: env['COMMIT_SHA'] && /^[0-9a-f]{40}$/.test(env['COMMIT_SHA'])
-        ? env['COMMIT_SHA']
-        : UNKNOWN_COMMIT,
+    commit: commitOf(env['COMMIT_SHA']),
     buildTime: env['BUILD_TIME'] || isoSeconds(now),
 });
 export const portFromEnv = (env, fallback = 3000) => {

package/dist/runtime/main.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
+import { createLog } from '../log/log.js';
 import { runPart } from './run-part.js';
 // Image entry: `node node_modules/@agentage/extension/dist/runtime/main.js api` in /app.
+const part = process.argv[2] ?? 'api';
 try {
-    await runPart({ dir: process.cwd(), part: process.argv[2] ?? 'api', env: process.env });
+    await runPart({ dir: process.cwd(), part, env: process.env });
 }
 catch (err) {
-    process.stderr.write(`${JSON.stringify({ level: 'error', msg: String(err) })}\n`);
+    // The manifest may be what failed, so the id is not known here; the line keeps the stack.
+    createLog({ extension: 'unknown', part }).error(err);
     process.exit(1);
 }

package/dist/runtime/part-runners.d.ts

@@ -0,0 +1,20 @@
+import { type Express } from 'express';
+import { type PartContext } from '../context/context.js';
+import { type ExtensionPackage } from '../manifest/manifest.schema.js';
+import { type ImagePartKind } from '../manifest/primitives.schema.js';
+import { type PartAppBase } from '../server/app.js';
+export interface RunnerInput {
+    dir: string;
+    pkg: ExtensionPackage;
+    ctx: PartContext;
+    base: PartAppBase;
+    importModule?: (file: string) => Promise<unknown>;
+}
+export interface Running {
+    app: Express;
+    stop?: () => void;
+}
+type PartCreate = (ctx: never) => unknown;
+export declare const createOf: (mod: unknown, file: string) => PartCreate;
+export declare const RUNNERS: Record<ImagePartKind, (input: RunnerInput) => Promise<Running>>;
+export {};

package/dist/runtime/part-runners.js

@@ -0,0 +1,68 @@
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import {} from 'express';
+import {} from '../context/context.js';
+import { readOpenapi } from '../discovery/openapi.js';
+import {} from '../manifest/manifest.schema.js';
+import { entryOf, normalizeParts } from '../manifest/parts.js';
+import {} from '../manifest/primitives.schema.js';
+import { createMcpApp } from '../mcp/mcp-app.js';
+import { createToolRegistry } from '../mcp/tools.js';
+import { createPagesApp } from '../pages/pages-app.js';
+import { createApiApp, createPartApp } from '../server/app.js';
+import {} from '../server/part.types.js';
+import { createUiApp } from '../ui/ui-app.js';
+import { runLog } from '../worker/run-log.js';
+import { memoryRuns, storeRuns } from '../worker/runs.js';
+import { createScheduler } from '../worker/scheduler.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;
+};
+// Imports the part's entry and calls its create(ctx); ui has no code to run.
+const callCreate = async (input, part, ctx) => {
+    const file = join(input.dir, entryOf(input.pkg, part));
+    const mod = await (input.importModule ?? importFile)(file);
+    return createOf(mod, file)(ctx);
+};
+const api = async (input) => {
+    const router = (await callCreate(input, 'api', input.ctx));
+    const openapi = await readOpenapi(input.dir);
+    return { app: createApiApp({ ...input.base, router, openapi }) };
+};
+const mcp = async (input) => {
+    const registry = createToolRegistry();
+    await callCreate(input, 'mcp', { ...input.ctx, tool: registry.tool });
+    const listing = input.ctx.settings['mcp.listing'] === 'token' ? 'token' : 'open';
+    return { app: createMcpApp({ ...input.base, tools: registry.tools, listing }) };
+};
+const pages = async (input) => {
+    const site = (await callCreate(input, 'pages', input.ctx));
+    return { app: createPagesApp({ ...input.base, site }) };
+};
+const ui = async (input) => ({
+    app: createUiApp({ ...input.base, dir: join(input.dir, 'dist', 'ui') }),
+});
+const worker = async (input) => {
+    const log = runLog(input.ctx.log);
+    const hasStore = normalizeParts(input.pkg.agentage.parts).store === 'postgres';
+    const runs = hasStore ? storeRuns(input.ctx.store) : memoryRuns();
+    const scheduler = createScheduler({ runs, log });
+    await callCreate(input, 'worker', { ...input.ctx, log, schedule: scheduler.schedule });
+    const checks = { ...input.base.checks, ...scheduler.checks() };
+    scheduler.start();
+    return {
+        app: createPartApp({ ...input.base, checks, part: 'worker', mount: () => undefined }),
+        stop: scheduler.stop,
+    };
+};
+export const RUNNERS = {
+    api,
+    mcp,
+    pages,
+    ui,
+    worker,
+};

package/dist/runtime/run-part.d.ts

@@ -1,7 +1,9 @@
 import { type Server } from 'node:http';
-import { type ApiCreate } from '../server/part.types.js';
+import { type ExtensionPackage } from '../manifest/manifest.schema.js';
+import { type ImagePartKind } from '../manifest/primitives.schema.js';
 import { type ServeOptions } from '../server/serve.js';
 import { type Env } from './build-info.js';
+export { createOf } from './part-runners.js';
 export interface RunPartOptions {
     dir: string;
     part: string;
@@ -9,5 +11,5 @@ export interface RunPartOptions {
     importModule?: (file: string) => Promise<unknown>;
     serve?: Pick<ServeOptions, 'signals' | 'exit'>;
 }
-export declare const createOf: (mod: unknown, file: string) => ApiCreate;
+export declare const partOf: (pkg: ExtensionPackage, part: string) => ImagePartKind;
 export declare const runPart: (options: RunPartOptions) => Promise<Server>;

package/dist/runtime/run-part.js

@@ -1,22 +1,18 @@
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
 import {} from 'node:http';
 import { createContext } from '../context/context.js';
+import { settingsFromEnv } from '../context/settings.js';
 import { DEFAULT_RECORD_FILE, loadRecord } from '../discovery/discovery.js';
+import {} from '../health/health.js';
 import { createLog } from '../log/log.js';
-import { entryOf } from '../manifest/parts.js';
+import {} from '../manifest/manifest.schema.js';
+import { imageParts, normalizeParts } from '../manifest/parts.js';
+import {} from '../manifest/primitives.schema.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 { createStore, storeCheck } from '../store/store.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;
-};
+import { RUNNERS } from './part-runners.js';
+export { createOf } from './part-runners.js';
 const recordFor = async (env, log) => {
     const file = env['AGENTAGE_RECORD_FILE'] || DEFAULT_RECORD_FILE;
     const record = await loadRecord(file);
@@ -24,34 +20,51 @@ const recordFor = async (env, log) => {
         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`);
+export const partOf = (pkg, part) => {
+    const parts = imageParts(pkg);
+    if (!parts.includes(part))
+        throw new Error(`part ${part} is not an image part of this manifest`);
+    return part;
+};
+// ui serves files and gets no ctx; every other part gets the store when the manifest has postgres.
+const storeFor = (pkg, part, env, log) => part !== 'ui' && normalizeParts(pkg.agentage.parts).store === 'postgres'
+    ? createStore(env, log)
+    : undefined;
+const inputFor = async (options, pkg, part, log) => {
     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 build = buildInfoFromEnv(env);
+    const store = storeFor(pkg, part, env, log);
+    const settings = settingsFromEnv(pkg, env, log);
+    const ctxOrigin = origin ?? `http://127.0.0.1:${portFromEnv(env)}`;
+    const ctxPart = (part === 'ui' ? 'pages' : part);
     const ctx = createContext({
         pkg,
-        part: 'api',
-        origin: origin ?? `http://127.0.0.1:${port}`,
+        part: ctxPart,
+        origin: ctxOrigin,
+        commit: build.commit,
         log,
+        settings,
+        store,
     });
-    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({
+    const checks = store ? { store: storeCheck(store) } : {};
+    const base = { pkg, build, log, record, origin, ownImage: env['AGENTAGE_IMAGE'], checks };
+    return {
+        dir: options.dir,
         pkg,
-        build,
-        router,
-        log,
-        record,
-        origin,
-        ownImage: env['AGENTAGE_IMAGE'],
-    });
-    return serve({ app, port, log, ...options.serve });
+        ctx,
+        base,
+        importModule: options.importModule,
+    };
+};
+export const runPart = async (options) => {
+    const pkg = await readManifest(options.dir);
+    const part = partOf(pkg, options.part);
+    const log = createLog({ extension: pkg.agentage.id, part });
+    const { app, stop } = await RUNNERS[part](await inputFor(options, pkg, part, log));
+    if (stop)
+        for (const signal of options.serve?.signals ?? ['SIGTERM', 'SIGINT'])
+            process.once(signal, stop);
+    return serve({ app, port: portFromEnv(options.env), log, ...options.serve });
 };

package/dist/server/app.d.ts

@@ -1,18 +1,32 @@
 import { type CorsOptions } from 'cors';
 import { type Express } from 'express';
+import { type HelmetOptions } from 'helmet';
 import { type BuildInfo } from '../discovery/discovery.js';
 import { type ExtensionRecord } from '../discovery/discovery.schema.js';
+import { type HealthCheck } from '../health/health.js';
 import { type Log } from '../log/log.js';
 import { type ExtensionPackage } from '../manifest/manifest.schema.js';
+import { type ImagePartKind } from '../manifest/primitives.schema.js';
 import { type ApiHandler } from './part.types.js';
-export interface ApiAppOptions {
+export interface PartAppBase {
     pkg: ExtensionPackage;
     build: BuildInfo;
-    router: ApiHandler;
     log: Log;
     record?: ExtensionRecord | null;
     ownImage?: string;
     origin?: string;
+    checks?: Record<string, HealthCheck>;
+}
+export interface PartAppOptions extends PartAppBase {
+    part: ImagePartKind;
+    mount: (app: Express) => void;
+    helmet?: HelmetOptions;
+}
+export interface ApiAppOptions extends PartAppBase {
+    router: ApiHandler;
+    openapi?: Record<string, unknown> | null;
 }
 export declare const PUBLIC_CORS: CorsOptions;
+export declare const BODY_LIMIT = "1mb";
+export declare const createPartApp: (options: PartAppOptions) => Express;
 export declare const createApiApp: (options: ApiAppOptions) => Express;