@agentage/extension 0.0.0-stage → 0.1.0

package/dist/health/health.schema.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const HealthStatusSchema: z.ZodEnum<{
+    ok: "ok";
+    degraded: "degraded";
+    unavailable: "unavailable";
+}>;
+export declare const DeployedPartKindSchema: z.ZodEnum<{
+    pages: "pages";
+    ui: "ui";
+    api: "api";
+    mcp: "mcp";
+    worker: "worker";
+    store: "store";
+}>;
+export declare const HealthSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            unavailable: "unavailable";
+        }>;
+        extension: z.ZodString;
+        part: z.ZodEnum<{
+            pages: "pages";
+            ui: "ui";
+            api: "api";
+            mcp: "mcp";
+            worker: "worker";
+            store: "store";
+        }>;
+        version: z.ZodString;
+        commit: z.ZodString;
+        buildTime: z.ZodISODateTime;
+        instance: z.ZodString;
+        uptimeSeconds: z.ZodInt;
+        checkedAt: z.ZodISODateTime;
+        checks: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            unavailable: "unavailable";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type HealthStatus = z.infer<typeof HealthStatusSchema>;
+export type HealthBody = z.infer<typeof HealthSchema>;

package/dist/health/health.schema.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ExtensionIdSchema, VersionSchema } from '../manifest/primitives.schema.js';
+export const HealthStatusSchema = z.enum(['ok', 'degraded', 'unavailable']);
+export const DeployedPartKindSchema = z.enum(['pages', 'ui', 'api', 'mcp', 'worker', 'store']);
+// GET /health of every part container (api-standards section 7); never hostnames, IPs or env values.
+export const HealthSchema = z.strictObject({
+    success: z.boolean(),
+    data: z.strictObject({
+        status: HealthStatusSchema,
+        extension: ExtensionIdSchema,
+        part: DeployedPartKindSchema,
+        version: VersionSchema,
+        commit: z.string().regex(/^[0-9a-f]{7,40}$/),
+        buildTime: z.iso.datetime(),
+        instance: z.string().regex(/^[0-9a-f]{8,32}$/),
+        uptimeSeconds: z.int().min(0),
+        checkedAt: z.iso.datetime(),
+        checks: z.record(z.string().regex(/^[a-z][a-z0-9-]*$/), HealthStatusSchema),
+    }),
+});

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { AGCID_HEADER, agcidOf, isAgcid, uuidv7 } from './agcid/agcid.js';
+export { currentAgcid } from './agcid/scope.js';
+export { createContext, createTestContext, type ExtensionInfo, type LogEntry, type PartContext, type ServerPartKind, type SettingValue, type TestContext, type TestContextOptions, } from './context/context.js';
+export { DEFAULT_RECORD_FILE, discoveryDocument, loadRecord, recordOf, validateRecord, type BuildInfo, type PartImages, } from './discovery/discovery.js';
+export { DiscoveryDocumentSchema, ExtensionRecordSchema, type DiscoveryDocument, type ExtensionRecord, } from './discovery/discovery.schema.js';
+export { ERROR_CODES, ERROR_STATUS, type ErrorCode } from './envelope/codes.js';
+export { errorEnvelope, fail, isFailure, ok, type ErrorDetail, type ErrorEnvelope, type Failure, type FailOptions, type OkEnvelope, } from './envelope/envelope.js';
+export { ErrorEnvelopeSchema, OkEnvelopeSchema } from './envelope/envelope.schema.js';
+export { parse, type ParseSchema } from './envelope/parse.js';
+export { createHealthHandler, type HealthCheck, type HealthOptions } from './health/health.js';
+export { HealthSchema, type HealthBody, type HealthStatus } from './health/health.schema.js';
+export { createLog, type Log, type LogFields } from './log/log.js';
+export { PackageSchema, type ExtensionPackage } from './manifest/manifest.schema.js';
+export { entryOf, imageParts, normalizeParts } from './manifest/parts.js';
+export { readManifest, validateManifest } from './manifest/read-manifest.js';
+export { createApiApp, PUBLIC_CORS, type ApiAppOptions } from './server/app.js';
+export { serve, type ServeOptions } from './server/serve.js';
+export { startTestServer, type TestServer, type TestServerOptions } from './testing/test-server.js';
+export { type ApiCreate, type ApiHandler, type ApiPart } from './server/part.types.js';

package/dist/index.js

@@ -0,0 +1,19 @@
+export { AGCID_HEADER, agcidOf, isAgcid, uuidv7 } from './agcid/agcid.js';
+export { currentAgcid } from './agcid/scope.js';
+export { createContext, createTestContext, } from './context/context.js';
+export { DEFAULT_RECORD_FILE, discoveryDocument, loadRecord, recordOf, validateRecord, } from './discovery/discovery.js';
+export { DiscoveryDocumentSchema, ExtensionRecordSchema, } from './discovery/discovery.schema.js';
+export { ERROR_CODES, ERROR_STATUS } from './envelope/codes.js';
+export { errorEnvelope, fail, isFailure, ok, } from './envelope/envelope.js';
+export { ErrorEnvelopeSchema, OkEnvelopeSchema } from './envelope/envelope.schema.js';
+export { parse } from './envelope/parse.js';
+export { createHealthHandler } from './health/health.js';
+export { HealthSchema } from './health/health.schema.js';
+export { createLog } from './log/log.js';
+export { PackageSchema } from './manifest/manifest.schema.js';
+export { entryOf, imageParts, normalizeParts } from './manifest/parts.js';
+export { readManifest, validateManifest } from './manifest/read-manifest.js';
+export { createApiApp, PUBLIC_CORS } from './server/app.js';
+export { serve } from './server/serve.js';
+export { startTestServer } from './testing/test-server.js';
+export {} from './server/part.types.js';

package/dist/log/log.d.ts

@@ -0,0 +1,13 @@
+export type LogLevel = 'info' | 'warn' | 'error';
+export type LogFields = Record<string, unknown>;
+export interface Log {
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(error: unknown, fields?: LogFields): void;
+}
+export interface LogTags {
+    extension: string;
+    part: string;
+}
+export type LogWrite = (line: string) => void;
+export declare const createLog: (tags: LogTags, write?: LogWrite) => Log;

package/dist/log/log.js

@@ -0,0 +1,21 @@
+import { currentAgcid } from '../agcid/scope.js';
+const errorFields = (error) => {
+    if (!(error instanceof Error))
+        return { err: { message: String(error) } };
+    return { err: { type: error.name, message: error.message, stack: error.stack } };
+};
+const line = (level, message, tags, fields) => {
+    const agcid = currentAgcid();
+    const entry = { time: new Date().toISOString(), level, msg: message, ...tags, ...fields };
+    return `${JSON.stringify(agcid ? { ...entry, agcid } : entry)}\n`;
+};
+const stderrWrite = (text) => void process.stderr.write(text);
+// JSON lines on stderr, tagged with extension, part and the request's agcid.
+export const createLog = (tags, write = stderrWrite) => ({
+    info: (message, fields = {}) => write(line('info', message, tags, fields)),
+    warn: (message, fields = {}) => write(line('warn', message, tags, fields)),
+    error: (error, fields = {}) => {
+        const message = error instanceof Error ? error.message : String(error);
+        write(line('error', message, tags, { ...errorFields(error), ...fields }));
+    },
+});

package/dist/manifest/manifest.schema.d.ts

@@ -0,0 +1,195 @@
+import { z } from 'zod';
+declare const CodePartSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    entry: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+export declare const PartsSchema: z.ZodObject<{
+    pages: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    ui: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    api: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    mcp: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    worker: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    cli: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    store: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        postgres: "postgres";
+        git: "git";
+        signoz: "signoz";
+    }>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            postgres: "postgres";
+            git: "git";
+            signoz: "signoz";
+        }>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare const CommandSchema: z.ZodObject<{
+    name: z.ZodString;
+    summary: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            integer: "integer";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const SettingSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        integer: "integer";
+    }>;
+    default: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const AgentageSchema: z.ZodObject<{
+    id: z.ZodString;
+    parts: z.ZodObject<{
+        pages: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            entry: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        ui: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            entry: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        api: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            entry: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        mcp: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            entry: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        worker: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            entry: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        cli: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            entry: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        store: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            postgres: "postgres";
+            git: "git";
+            signoz: "signoz";
+        }>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                postgres: "postgres";
+                git: "git";
+                signoz: "signoz";
+            }>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>;
+    commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        summary: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                integer: "integer";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            integer: "integer";
+        }>;
+        default: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const PackageSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    engines: z.ZodObject<{
+        agentage: z.ZodString;
+    }, z.core.$loose>;
+    agentage: z.ZodObject<{
+        id: z.ZodString;
+        parts: z.ZodObject<{
+            pages: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                entry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+            ui: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                entry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+            api: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                entry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+            mcp: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                entry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+            worker: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                entry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+            cli: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                entry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+            store: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                postgres: "postgres";
+                git: "git";
+                signoz: "signoz";
+            }>, z.ZodObject<{
+                kind: z.ZodEnum<{
+                    postgres: "postgres";
+                    git: "git";
+                    signoz: "signoz";
+                }>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>;
+        commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            summary: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    integer: "integer";
+                }>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                integer: "integer";
+            }>;
+            default: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$loose>;
+export type CodePart = z.infer<typeof CodePartSchema>;
+export type Parts = z.infer<typeof PartsSchema>;
+export type Agentage = z.infer<typeof AgentageSchema>;
+export type ExtensionPackage = z.infer<typeof PackageSchema>;
+export {};

package/dist/manifest/manifest.schema.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { CommandNameSchema, ExtensionIdSchema, FIRST_PARTY_IDS, PackageNameSchema, PackagePathSchema, SecretNameSchema, SemverRangeSchema, SettingKeySchema, StoreKindSchema, VersionSchema, } from './primitives.schema.js';
+const CodePartSchema = z.union([
+    z.boolean(),
+    z.strictObject({ entry: PackagePathSchema.optional() }),
+]);
+const StorePartSchema = z.union([StoreKindSchema, z.strictObject({ kind: StoreKindSchema })]);
+const ROUTED = ['pages', 'ui', 'api', 'mcp'];
+export const PartsSchema = z
+    .strictObject({
+    pages: CodePartSchema.optional(),
+    ui: CodePartSchema.optional(),
+    api: CodePartSchema.optional(),
+    mcp: CodePartSchema.optional(),
+    worker: CodePartSchema.optional(),
+    cli: CodePartSchema.optional(),
+    store: StorePartSchema.optional(),
+})
+    .refine((parts) => ROUTED.some((kind) => isOn(parts[kind])), {
+    message: 'at least one routed part (pages, ui, api or mcp)',
+});
+const ArgTypeSchema = z.enum(['string', 'integer', 'number', 'boolean']);
+export const CommandSchema = z.strictObject({
+    name: CommandNameSchema,
+    summary: z.string().min(1).max(120),
+    args: z
+        .array(z.strictObject({
+        name: CommandNameSchema,
+        type: ArgTypeSchema,
+        required: z.boolean().optional(),
+        description: z.string().min(1).max(200).optional(),
+    }))
+        .optional(),
+});
+export const SettingSchema = z
+    .strictObject({
+    type: ArgTypeSchema,
+    default: z.union([z.string(), z.number(), z.boolean()]),
+    enum: z.array(z.string()).min(1).optional(),
+    description: z.string().min(1).max(200).optional(),
+})
+    .refine((setting) => defaultFits(setting.type, setting.default), {
+    message: 'default does not match type',
+});
+const AgentageBaseSchema = z.strictObject({
+    id: ExtensionIdSchema,
+    parts: PartsSchema,
+    commands: z.array(CommandSchema).min(1).optional(),
+    settings: z.record(SettingKeySchema, SettingSchema).optional(),
+    secrets: z.array(SecretNameSchema).optional(),
+});
+export const AgentageSchema = AgentageBaseSchema.superRefine(crossFieldRules);
+export const PackageSchema = z
+    .looseObject({
+    name: PackageNameSchema,
+    version: VersionSchema,
+    engines: z.looseObject({ agentage: SemverRangeSchema }),
+    agentage: AgentageSchema,
+})
+    .refine((pkg) => !isFirstParty(pkg.agentage.id) || pkg.name.startsWith('@agentage/'), {
+    message: 'a first-party id is claimed only by an @agentage/ package',
+    path: ['name'],
+});
+function isOn(part) {
+    return part !== undefined && part !== false;
+}
+function isFirstParty(id) {
+    return FIRST_PARTY_IDS.includes(id);
+}
+function defaultFits(type, value) {
+    if (type === 'integer')
+        return Number.isInteger(value);
+    return typeof value === type;
+}
+function crossFieldRules(manifest, ctx) {
+    const issue = (message, path) => ctx.addIssue({ code: 'custom', message, path });
+    const hasCli = isOn(manifest.parts.cli);
+    if (manifest.commands && !hasCli)
+        issue('commands need the cli part', ['commands']);
+    if (hasCli && !manifest.commands)
+        issue('the cli part needs commands', ['parts', 'cli']);
+    const names = (manifest.commands ?? []).map((command) => command.name);
+    if (new Set(names).size !== names.length)
+        issue('command names must be unique', ['commands']);
+    if (manifest.settings?.['mcp.listing'] && !isOn(manifest.parts.mcp)) {
+        issue('mcp.listing needs the mcp part', ['settings', 'mcp.listing']);
+    }
+}

package/dist/manifest/parts.d.ts

@@ -0,0 +1,11 @@
+import { type ExtensionPackage, type Parts } from './manifest.schema.js';
+import { type ImagePartKind, type StoreKind } from './primitives.schema.js';
+export interface NormalizedParts {
+    code: Partial<Record<ImagePartKind | 'cli', {
+        entry?: string;
+    }>>;
+    store?: StoreKind;
+}
+export declare const normalizeParts: (parts: Parts) => NormalizedParts;
+export declare const imageParts: (pkg: ExtensionPackage) => ImagePartKind[];
+export declare const entryOf: (pkg: ExtensionPackage, part: ImagePartKind | "cli") => string;

package/dist/manifest/parts.js

@@ -0,0 +1,24 @@
+import {} from './manifest.schema.js';
+import { IMAGE_PART_KINDS } from './primitives.schema.js';
+const normalizeCode = (part) => {
+    if (part === undefined || part === false)
+        return undefined;
+    return part === true ? {} : part;
+};
+const storeKind = (store) => typeof store === 'object' ? store.kind : store;
+// The manifest accepts `api: true` and `store: "postgres"`; the kit works on one shape.
+export const normalizeParts = (parts) => {
+    const code = {};
+    for (const kind of [...IMAGE_PART_KINDS, 'cli']) {
+        const normalized = normalizeCode(parts[kind]);
+        if (normalized)
+            code[kind] = normalized;
+    }
+    const store = storeKind(parts.store);
+    return store ? { code, store } : { code };
+};
+export const imageParts = (pkg) => {
+    const { code } = normalizeParts(pkg.agentage.parts);
+    return IMAGE_PART_KINDS.filter((kind) => code[kind] !== undefined);
+};
+export const entryOf = (pkg, part) => normalizeParts(pkg.agentage.parts).code[part]?.entry ?? `./dist/${part}/index.js`;

package/dist/manifest/primitives.schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const ExtensionIdSchema: z.ZodString;
+export declare const FIRST_PARTY_IDS: readonly ["root", "cloud", "market", "logs", "memory", "catalog", "dashboard", "docs"];
+export declare const PackageNameSchema: z.ZodString;
+export declare const VersionSchema: z.ZodString;
+export declare const SemverRangeSchema: z.ZodString;
+export declare const CommandNameSchema: z.ZodString;
+export declare const SettingKeySchema: z.ZodString;
+export declare const SecretNameSchema: z.ZodString;
+export declare const PackagePathSchema: z.ZodString;
+export declare const StoreKindSchema: z.ZodEnum<{
+    postgres: "postgres";
+    git: "git";
+    signoz: "signoz";
+}>;
+export declare const CommitSchema: z.ZodString;
+export declare const PrefixedToolNameSchema: z.ZodString;
+export declare const IMAGE_PART_KINDS: readonly ["pages", "ui", "api", "mcp", "worker"];
+export type ImagePartKind = (typeof IMAGE_PART_KINDS)[number];
+export type StoreKind = z.infer<typeof StoreKindSchema>;

package/dist/manifest/primitives.schema.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+const RESERVED_IDS = 'auth|www|api|sync|mail|mcp|ui|git|setup|status|update|extension|add|remove|help|con|prn|aux|nul|com[0-9]|lpt[0-9]';
+export const ExtensionIdSchema = z
+    .string()
+    .max(32)
+    .regex(new RegExp(`^(?!(?:${RESERVED_IDS})$)[a-z][a-z0-9-]*$`), {
+    message: 'lowercase id, never a name the platform owns',
+});
+export const FIRST_PARTY_IDS = [
+    'root',
+    'cloud',
+    'market',
+    'logs',
+    'memory',
+    'catalog',
+    'dashboard',
+    'docs',
+];
+export const PackageNameSchema = z
+    .string()
+    .max(214)
+    .regex(/^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/);
+export const VersionSchema = z
+    .string()
+    .regex(/^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/);
+export const SemverRangeSchema = z
+    .string()
+    .max(64)
+    .regex(/^[0-9xX*^~<>=| .-]+[0-9A-Za-z.-]*$/);
+export const CommandNameSchema = z
+    .string()
+    .max(32)
+    .regex(/^[a-z][a-z0-9-]*$/);
+export const SettingKeySchema = z
+    .string()
+    .max(64)
+    .regex(/^[a-z][A-Za-z0-9]*(\.[a-z][A-Za-z0-9]*)*$/);
+export const SecretNameSchema = z
+    .string()
+    .max(48)
+    .regex(/^[a-z][a-z0-9-]*$/);
+export const PackagePathSchema = z
+    .string()
+    .max(256)
+    .regex(/^\.\/[A-Za-z0-9._/-]+$/);
+export const StoreKindSchema = z.enum(['postgres', 'git', 'signoz']);
+export const CommitSchema = z.string().regex(/^[0-9a-f]{40}$/, { message: 'full 40-hex git sha' });
+export const PrefixedToolNameSchema = z
+    .string()
+    .max(64)
+    .regex(/^[a-z][a-z0-9-]*__[a-z][a-z0-9_-]*$/);
+export const IMAGE_PART_KINDS = ['pages', 'ui', 'api', 'mcp', 'worker'];

package/dist/manifest/read-manifest.d.ts

@@ -0,0 +1,5 @@
+import { type z } from 'zod';
+import { type ExtensionPackage } from './manifest.schema.js';
+export declare const formatIssues: (issues: readonly z.core.$ZodIssue[]) => string;
+export declare const validateManifest: (value: unknown) => ExtensionPackage;
+export declare const readManifest: (dir: string) => Promise<ExtensionPackage>;

package/dist/manifest/read-manifest.js

@@ -0,0 +1,19 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import {} from 'zod';
+import { PackageSchema } from './manifest.schema.js';
+export const formatIssues = (issues) => issues
+    .map((issue) => `${issue.path.map((segment) => String(segment)).join('.')}: ${issue.message}`)
+    .join('; ');
+export const validateManifest = (value) => {
+    const result = PackageSchema.safeParse(value);
+    if (result.success)
+        return result.data;
+    throw new Error(`invalid agentage manifest in package.json: ${formatIssues(result.error.issues)}`);
+};
+// 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));
+};

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

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

package/dist/runtime/build-info.js

@@ -0,0 +1,16 @@
+import {} from '../discovery/discovery.js';
+const UNKNOWN_COMMIT = '0'.repeat(40);
+const isoSeconds = (date) => `${date.toISOString().slice(0, 19)}Z`;
+// 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,
+    buildTime: env['BUILD_TIME'] || isoSeconds(now),
+});
+export const portFromEnv = (env, fallback = 3000) => {
+    const port = Number(env['PORT']);
+    return env['PORT'] !== undefined && Number.isInteger(port) && port >= 0 && port < 65536
+        ? port
+        : fallback;
+};

package/dist/runtime/main.d.ts

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

package/dist/runtime/main.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runPart } from './run-part.js';
+// Image entry: `node node_modules/@agentage/extension/dist/runtime/main.js api` in /app.
+try {
+    await runPart({ dir: process.cwd(), part: process.argv[2] ?? 'api', env: process.env });
+}
+catch (err) {
+    process.stderr.write(`${JSON.stringify({ level: 'error', msg: String(err) })}\n`);
+    process.exit(1);
+}

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

@@ -0,0 +1,13 @@
+import { type Server } from 'node:http';
+import { type ApiCreate } from '../server/part.types.js';
+import { type ServeOptions } from '../server/serve.js';
+import { type Env } from './build-info.js';
+export interface RunPartOptions {
+    dir: string;
+    part: string;
+    env: Env;
+    importModule?: (file: string) => Promise<unknown>;
+    serve?: Pick<ServeOptions, 'signals' | 'exit'>;
+}
+export declare const createOf: (mod: unknown, file: string) => ApiCreate;
+export declare const runPart: (options: RunPartOptions) => Promise<Server>;