@makaio/contracts 1.0.0-dev-1779051654000

package/dist/extension/manifest.d.ts

@@ -0,0 +1,624 @@
+/**
+ * Pure-data manifest types and Zod schemas for Makaio extensions.
+ *
+ * All types in this module are fully serializable — no functions, no class
+ * instances. They are safe to inspect, gate, and transmit across process
+ * boundaries. The manifest layer sits below {@link MakaioExtension} and is the
+ * source of truth for what an extension declares about itself structurally
+ * before executable code is loaded. Runtime wiring remains owned by the
+ * executable `MakaioExtension` fields.
+ * @see {@link MakaioExtension} for the executable extension of these types.
+ */
+import { z } from 'zod';
+import type { BrowserEntrypoint } from './browser-entrypoint.js';
+import { type CapabilityToken } from './capability-token.js';
+import type { ContributionManifest } from './contribution-manifest.js';
+import { type VersionLiteral, type VersionRange } from '../version/index.js';
+/**
+ * Visual presentation style for an extension window.
+ *
+ * - `'tray-popover'` — small overlay anchored to the system tray icon.
+ * - `'utility'` — standalone auxiliary window (e.g., settings panel).
+ * - `'panel'` — docked or floating workspace panel.
+ */
+export type WindowStyle = 'tray-popover' | 'utility' | 'panel';
+/**
+ * Describes a window surface an extension can open.
+ *
+ * The shell uses this declaration to pre-register the window and manage
+ * its lifecycle without requiring the extension to be initialized first.
+ */
+export interface WindowManifest {
+    /**
+     * Identifier unique within the declaring extension.
+     * Referenced by {@link TrayManifest.opensWindow} to associate tray
+     * actions with specific windows.
+     */
+    readonly id: string;
+    /** Visual presentation style that governs how the shell positions and sizes the window. */
+    readonly style: WindowStyle;
+    /** Preferred initial width in logical pixels. */
+    readonly width?: number;
+    /** Preferred initial height in logical pixels. */
+    readonly height?: number;
+    /**
+     * When `true`, the shell ensures at most one instance of this window is
+     * open at a time, focusing the existing window instead of opening a new one.
+     */
+    readonly singleton?: boolean;
+    /**
+     * Named route parameters this window accepts.
+     * The shell uses these to map URL path segments to query params and
+     * to generalize window deduplication without hardcoding host IDs.
+     */
+    readonly params?: readonly WindowParamSpec[];
+}
+/**
+ * Specification for a named window route parameter.
+ */
+export interface WindowParamSpec {
+    /** Parameter name (e.g. `'projectId'`). */
+    readonly name: string;
+    /** Whether this parameter is required for window creation. */
+    readonly required?: boolean;
+}
+/** Zod schema for {@link WindowParamSpec}. */
+export declare const WindowParamSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Zod schema for {@link WindowManifest}. */
+export declare const WindowManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    style: z.ZodEnum<{
+        panel: "panel";
+        "tray-popover": "tray-popover";
+        utility: "utility";
+    }>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    singleton: z.ZodOptional<z.ZodBoolean>;
+    params: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Describes an extension's entry in the system tray menu.
+ *
+ * The shell renders tray items grouped by {@link section}. Only one of
+ * {@link opensWindow} or {@link action} should be set; if both are present
+ * the shell prefers {@link opensWindow}.
+ */
+export interface TrayManifest {
+    /** Human-readable label shown in the tray menu. */
+    readonly label: string;
+    /**
+     * Logical grouping for tray menu layout.
+     *
+     * - `'utilities'` — system / account tools (e.g., auth switcher).
+     * - `'tools'` — productivity tools (e.g., code review).
+     * - `'views'` — windows or panels that present content.
+     */
+    readonly section?: 'utilities' | 'tools' | 'views';
+    /**
+     * {@link WindowManifest.id} of the window to open when this tray item is
+     * clicked. Takes precedence over {@link action} when both are defined.
+     */
+    readonly opensWindow?: string;
+    /**
+     * Opaque action identifier echoed in `host:tray.item.clicked` metadata when
+     * this tray item is clicked.
+     */
+    readonly action?: string;
+}
+/** Zod schema for {@link TrayManifest}. */
+export declare const TrayManifestSchema: z.ZodObject<{
+    label: z.ZodString;
+    section: z.ZodOptional<z.ZodEnum<{
+        tools: "tools";
+        utilities: "utilities";
+        views: "views";
+    }>>;
+    opensWindow: z.ZodOptional<z.ZodString>;
+    action: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Describes a single positional argument or named option for a CLI subcommand.
+ *
+ * This is the serializable, framework-agnostic counterpart to
+ * `CliSubcommandDefinition` — it carries only metadata, no handler.
+ */
+export interface CliArgManifest {
+    /**
+     * Argument or option name.
+     * For positional args this is the display name shown in usage text.
+     * For named options it is the schema field name. The CLI adapter converts it
+     * to a kebab-case long flag when registering Commander options
+     * (e.g. `'clientId'` -\> `--client-id`).
+     */
+    readonly name: string;
+    /** One-line description shown in help text. */
+    readonly description: string;
+    /** When `true`, the CLI parser rejects invocations that omit this argument. */
+    readonly required?: boolean;
+    /** When `true`, treat as a positional argument rather than a named option. */
+    readonly positional?: boolean;
+    /** Short single-character flag alias (e.g. `'-p'`). */
+    readonly short?: string;
+    /**
+     * Value type for this argument or option.
+     * Used by manifest-based CLI registration to determine whether an option
+     * takes a value or is a boolean flag. Defaults to `'string'` when omitted.
+     * Manifest-based registration also uses this metadata to coerce numeric
+     * values before they reach the subcommand's Zod schema.
+     */
+    readonly type?: 'string' | 'boolean' | 'number';
+}
+/** Zod schema for {@link CliArgManifest}. */
+export declare const CliArgManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+    positional: z.ZodOptional<z.ZodBoolean>;
+    short: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        boolean: "boolean";
+        number: "number";
+        string: "string";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Describes a single subcommand nested under the extension's top-level CLI command.
+ *
+ * Pure metadata — no handler. Used for help generation and manifest inspection.
+ */
+export interface CliSubcommandManifest {
+    /** Subcommand name (e.g. `'list'`, `'switch'`). */
+    readonly name: string;
+    /** One-line description shown in help text. */
+    readonly description: string;
+    /** Arguments and options accepted by this subcommand. */
+    readonly args?: readonly CliArgManifest[];
+}
+/** Zod schema for {@link CliSubcommandManifest}. */
+export declare const CliSubcommandManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    args: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        positional: z.ZodOptional<z.ZodBoolean>;
+        short: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<{
+            boolean: "boolean";
+            number: "number";
+            string: "string";
+        }>>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Describes the top-level CLI command an extension contributes.
+ *
+ * Serializable and framework-agnostic. The executable extension,
+ * `ExtensionCliContribution`, adds the interactive handler and typed subcommand
+ * definitions. The CLI router uses this manifest for help generation and
+ * command discovery without loading handler code.
+ */
+export interface CliManifest {
+    /** Top-level command name (e.g. `'account-manager'`). */
+    readonly name: string;
+    /** One-line description shown in help text. */
+    readonly description: string;
+    /** Non-interactive subcommands registered under this command. */
+    readonly subcommands?: readonly CliSubcommandManifest[];
+    /**
+     * Whether this extension provides an interactive TUI handler.
+     *
+     * When `true`, invoking the bare command (without a subcommand) launches
+     * the interactive handler. When `false` or omitted, bare invocation shows
+     * help. This is a serializable declaration in `descriptor.json`; the
+     * executable handler itself lives in `ExtensionCliContribution.interactive`.
+     *
+     * Named `hasInteractive` (not `interactive`) to avoid a type conflict with
+     * the `ExtensionCliContribution` property of the same short name, which carries
+     * the function implementation rather than a boolean flag.
+     */
+    readonly hasInteractive?: boolean;
+}
+/** Zod schema for {@link CliManifest}. */
+export declare const CliManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    subcommands: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        args: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            positional: z.ZodOptional<z.ZodBoolean>;
+            short: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodEnum<{
+                boolean: "boolean";
+                number: "number";
+                string: "string";
+            }>>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>>;
+    hasInteractive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Describes the storage requirements of an extension.
+ *
+ * Serializable metadata that the runtime uses to run migrations before
+ * starting the extension's service. The migrations path is relative to the
+ * extension root and resolved to an absolute path by the composition root.
+ * Bundled hosts may also provide a stable `migrationSourceId` so migration
+ * identity does not collapse onto packaged output paths.
+ */
+export interface StorageManifest {
+    /**
+     * Path to the Drizzle migration folder, relative to the extension root.
+     *
+     * The runtime resolves this to an absolute path and passes it to the
+     * host-supplied `runMigrations` callback
+     * before any extension services are started. The callback is responsible for
+     * applying pending migrations against the shared database using a
+     * per-extension tracking table to avoid filename collisions.
+     * @example 'drizzle'
+     */
+    readonly migrations?: string;
+    /**
+     * Stable runtime identity for the migration bundle.
+     *
+     * Hosts use this to key deduplication, ledger tables, and bundled migration
+     * lookup independently of the on-disk discovery path. When omitted, the
+     * resolved migration folder path remains the identity.
+     */
+    readonly migrationSourceId?: string;
+}
+/** Zod schema for {@link StorageManifest}. */
+export declare const StorageManifestSchema: z.ZodObject<{
+    migrations: z.ZodOptional<z.ZodString>;
+    migrationSourceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * A structured dependency declaration on another extension.
+ *
+ * Carries the dependency name, a semver version range the declared extension
+ * must satisfy, and an optional `optional` flag for non-fatal dependencies.
+ */
+export interface ExtensionDependency {
+    /** Discriminant — always `'extension'`. */
+    readonly type: 'extension';
+    /**
+     * {@link ExtensionManifest.name} of the required extension.
+     *
+     * Accepts the same plain or scoped npm identifier format as
+     * {@link ExtensionManifest.name}.
+     */
+    readonly name: string;
+    /**
+     * Semver range the installed extension version must satisfy.
+     *
+     * Uses the same syntax as npm range strings (e.g. `'>=1.0.0 <2.0.0'`,
+     * `'^1.5.0'`).
+     */
+    readonly version: VersionRange;
+    /**
+     * When `true` the extension may start even if this dependency is absent or
+     * fails to activate.
+     *
+     * Omitting this field is equivalent to `false`.
+     */
+    readonly optional?: boolean;
+}
+/** Zod schema for {@link ExtensionDependency}. */
+export declare const ExtensionDependencySchema: z.ZodObject<{
+    type: z.ZodLiteral<"extension">;
+    name: z.ZodString;
+    version: z.ZodString;
+    optional: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Default semver range for extension dependencies when no explicit range is provided. */
+export declare const DEFAULT_EXTENSION_DEPENDENCY_RANGE: VersionRange;
+/**
+ * Factory that creates an {@link ExtensionDependency} with `type: 'extension'`.
+ *
+ * Prefer this helper over inline object literals to keep dependency
+ * declarations concise and consistent across package descriptors.
+ * @param name - {@link ExtensionManifest.name} of the required extension.
+ * @param version - Semver range the required extension must satisfy.
+ * @param optional - When `true`, activation continues if the dependency is absent.
+ * @returns A fully-typed {@link ExtensionDependency} object.
+ * @example
+ * dependencies: [dep('provider-anthropic'), dep('makaio.clients-core')]
+ */
+export declare function dep(name: string, version?: VersionRange, optional?: boolean): ExtensionDependency;
+/**
+ * A typed runtime-environment gate that an extension declares it needs before
+ * the kernel will activate it.
+ *
+ * Two flavors are supported:
+ * - `'host'` — the runtime host must be present (e.g. `{ type: 'host', id: 'node' }`).
+ * - `'capability'` — the host must advertise the named capability token
+ *   (e.g. `{ type: 'capability', id: 'storage.drizzle' }`). The optional
+ *   `version` field requires the host capability to declare a satisfying
+ *   concrete version.
+ *
+ * This is an environment compatibility gate, not an extension-to-extension
+ * dependency. Use {@link ExtensionManifest.dependencies} for structural ordering.
+ */
+export type RuntimeRequirement = {
+    readonly type: 'host';
+    readonly id: string;
+} | {
+    readonly type: 'capability';
+    readonly id: string;
+    readonly version?: VersionRange;
+};
+/** Zod schema for {@link RuntimeRequirement}. */
+export declare const RuntimeRequirementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"host">;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"capability">;
+    id: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+/**
+ * Pure-data manifest for a Makaio extension.
+ *
+ * Fully serializable and safe to inspect or transmit without executing any
+ * extension code. The shell and registry use this to discover extension surfaces
+ * (windows, tray, CLI, storage) before deciding whether to initialize them.
+ * @see {@link MakaioExtension} for the executable extension that adds `create`,
+ * typed CLI handlers, and storage registration.
+ */
+export interface ExtensionManifest {
+    /**
+     * Unique extension identifier.
+     *
+     * Accepts plain identifiers (e.g. `'account-manager'`) and npm-scoped
+     * names (e.g. `'@acme/weather-tools'`). Used as the primary key in the
+     * extension registry and as the top-level CLI command name when no
+     * {@link cli} override is provided.
+     */
+    readonly name: string;
+    /** Human-readable display name shown in UI surfaces (e.g. `'Auth Switcher'`). */
+    readonly displayName: string;
+    /**
+     * SemVer version of this extension package.
+     *
+     * Descriptor-only synthesized packages receive this from `descriptor.json`;
+     * code-defined executable packages declare the same field directly on their
+     * package object.
+     */
+    readonly version: VersionLiteral;
+    /**
+     * Execution surface the extension targets.
+     *
+     * - `'interactive'` — requires a UI shell (e.g., Electron renderer).
+     * - `'headless'` — suitable for daemon or CLI-only runtimes.
+     * - `'any'` — works in any surface (default when omitted).
+     */
+    readonly surface?: 'interactive' | 'headless' | 'any';
+    /**
+     * Structured dependencies on other extensions.
+     *
+     * The registry ensures all listed extensions are initialized before this
+     * extension starts. Each entry carries the dependency name, a semver version
+     * range the installed extension must satisfy, and an optional `optional` flag.
+     * @see {@link ExtensionDependency}
+     */
+    readonly dependencies?: readonly ExtensionDependency[];
+    /**
+     * Runtime-environment gates this extension must satisfy before the kernel
+     * activates it.
+     *
+     * Each entry is a {@link RuntimeRequirement} that declares either a required
+     * host identity (e.g. `'node'`) or a host-advertised capability token (e.g.
+     * `'storage.drizzle'`). All entries must be satisfied (AND semantics).
+     *
+     * This is an environment compatibility gate, not an extension-to-extension
+     * dependency. Use {@link dependencies} for structural extension ordering.
+     */
+    readonly requires?: readonly RuntimeRequirement[];
+    /**
+     * Capability tokens this extension provides when active.
+     *
+     * Consumers and onboarding surfaces can inspect these declarations to decide
+     * whether a capability exists at all before prompting the user to configure it.
+     */
+    readonly provides?: readonly CapabilityToken[];
+    /** Windows this extension can open, keyed by {@link WindowManifest.id}. */
+    readonly windows?: readonly WindowManifest[];
+    /** System tray entry for this extension. */
+    readonly tray?: TrayManifest;
+    /**
+     * CLI command contributed by this extension.
+     *
+     * On {@link ExtensionManifest} this is pure metadata. On {@link MakaioExtension}
+     * this is widened to `ExtensionCliContribution` with executable handlers.
+     */
+    readonly cli?: CliManifest;
+    /** Storage requirements (migrations) declared by this extension. */
+    readonly storage?: StorageManifest;
+    /**
+     * Browser entry point for this extension.
+     * URL path the renderer fetches to load the extension's UI.
+     * @example '/extensions/my-extension/browser/index.js'
+     */
+    readonly browser?: BrowserEntrypoint;
+    /**
+     * Adapters and client binaries contributed by this extension.
+     *
+     * Discovery-time metadata only — serializable and safe to inspect without
+     * loading any extension code. Runtime activation and registration use the
+     * executable contribution fields on {@link MakaioExtension}; descriptor
+     * metadata may mirror those fields for pre-load introspection but is not
+     * used as a fallback wiring source.
+     */
+    readonly contributions?: ContributionManifest;
+}
+/** Zod schema for {@link ExtensionManifest}. */
+export declare const ExtensionManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodString;
+    version: z.ZodString;
+    surface: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        headless: "headless";
+        interactive: "interactive";
+    }>>;
+    dependencies: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"extension">;
+        name: z.ZodString;
+        version: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
+    requires: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"host">;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"capability">;
+        id: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>>>;
+    provides: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<"adapters", unknown, z.core.$ZodTypeInternals<"adapters", unknown>>>>>;
+    windows: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        style: z.ZodEnum<{
+            panel: "panel";
+            "tray-popover": "tray-popover";
+            utility: "utility";
+        }>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        singleton: z.ZodOptional<z.ZodBoolean>;
+        params: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>>;
+    tray: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        section: z.ZodOptional<z.ZodEnum<{
+            tools: "tools";
+            utilities: "utilities";
+            views: "views";
+        }>>;
+        opensWindow: z.ZodOptional<z.ZodString>;
+        action: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    cli: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        subcommands: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            args: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodOptional<z.ZodBoolean>;
+                positional: z.ZodOptional<z.ZodBoolean>;
+                short: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                }>>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>>>;
+        hasInteractive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    storage: z.ZodOptional<z.ZodObject<{
+        migrations: z.ZodOptional<z.ZodString>;
+        migrationSourceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    browser: z.ZodOptional<z.ZodObject<{
+        entrypoint: z.ZodString;
+    }, z.core.$strip>>;
+    contributions: z.ZodOptional<z.ZodObject<{
+        adapters: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            clients: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                version: z.ZodString;
+                binaryVersion: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+            protocols: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                anthropic: "anthropic";
+                openai: "openai";
+            }>, z.ZodObject<{
+                anthropic: z.ZodOptional<z.ZodObject<{
+                    endpoint: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                openai: z.ZodOptional<z.ZodObject<{
+                    endpoint: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>]>>>;
+            defaultProvider: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+        clients: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            binary: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                managed: z.ZodOptional<z.ZodBoolean>;
+                version: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>>;
+        providers: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+        triggers: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            prefix: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            stage: z.ZodOptional<z.ZodEnum<{
+                action: "action";
+                gather: "gather";
+                transform: "transform";
+            }>>;
+        }, z.core.$strip>>>>;
+        logImporters: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            adapterName: z.ZodString;
+            displayName: z.ZodString;
+            logFilePattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+        sessionEventActions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            selectionMode: z.ZodEnum<{
+                multi: "multi";
+                single: "single";
+            }>;
+            messageRoles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                assistant: "assistant";
+                user: "user";
+            }>>>>;
+        }, z.core.$strip>>>>;
+        create: z.ZodOptional<z.ZodBoolean>;
+        tools: z.ZodOptional<z.ZodBoolean>;
+        bootstrap: z.ZodOptional<z.ZodBoolean>;
+        namespace: z.ZodOptional<z.ZodBoolean>;
+        configSchema: z.ZodOptional<z.ZodBoolean>;
+        uiConfig: z.ZodOptional<z.ZodBoolean>;
+        ui: z.ZodOptional<z.ZodObject<{
+            tiles: z.ZodOptional<z.ZodBoolean>;
+            widgets: z.ZodOptional<z.ZodBoolean>;
+            pages: z.ZodOptional<z.ZodBoolean>;
+            routes: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/extension/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/extension/manifest.ts"],"names":[],"mappings":"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"}

package/dist/extension/parse-extension-config.d.ts

@@ -0,0 +1,21 @@
+import type { z } from 'zod';
+/**
+ * Parse raw extension config with a Zod schema, applying schema defaults.
+ *
+ * Handles the common extension initialization pattern where `ctx.config` may be
+ * `undefined` (no stored config) or a partial object. The schema is expected
+ * to provide defaults for all optional fields so that parsing `{}` always
+ * yields a valid config.
+ * @param schema - Zod schema with defaults for all optional fields.
+ * @param rawConfig - Raw config value from {@link ExtensionContext.config} (may be undefined).
+ * @returns Validated and defaulted config object.
+ * @example
+ * ```typescript
+ * create: (ctx) => {
+ *   const config = parseExtensionConfig(MyConfigSchema, ctx.config);
+ *   return new MyService(ctx.bus, config);
+ * },
+ * ```
+ */
+export declare function parseExtensionConfig<T extends z.ZodType>(schema: T, rawConfig: unknown): z.infer<T>;
+//# sourceMappingURL=parse-extension-config.d.ts.map

package/dist/extension/parse-extension-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-extension-config.d.ts","sourceRoot":"","sources":["../../src/extension/parse-extension-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAEnG"}

package/dist/extension-CfIRUup2.mjs

@@ -0,0 +1 @@
+import{n as e}from"./definition-7C4TvfXk.mjs";import{n as t,t as n}from"./version-u2rO7guD.mjs";import{z as r}from"zod";const i=r.object({entrypoint:r.string().startsWith(`/`,{message:`Entrypoint must be a URL path starting with "/"`})}),a=r.object({endpoint:r.string().url().optional()}),o=r.union([e,r.object({anthropic:a.optional(),openai:a.optional()}).refine(e=>Object.keys(e).length>0,{message:`ProtocolRef config object must specify at least one protocol`})]),s=r.object({id:r.string().min(1),version:t,binaryVersion:t.optional()}),c=r.object({name:r.string().min(1),displayName:r.string().min(1).optional(),description:r.string().optional(),clients:r.array(s).readonly().optional(),protocols:r.array(o).min(1).readonly(),defaultProvider:r.string().min(1).optional()}),l=r.object({id:r.string().min(1),name:r.string().min(1),description:r.string().optional(),binary:r.object({name:r.string().min(1),managed:r.boolean().optional(),version:n.optional()}).strict().refine(e=>e.managed!==!0||e.version!==void 0,{message:`binary.version is required when binary.managed is true`,path:[`version`]}).refine(e=>e.version===void 0||e.managed===!0,{message:`binary.managed must be true when binary.version is provided`,path:[`managed`]}).optional()}).strict(),u=r.object({id:r.string().min(1),name:r.string().min(1),description:r.string().optional()}),d=r.object({prefix:r.string().min(1),description:r.string().optional(),stage:r.enum([`gather`,`transform`,`action`]).optional()}),f=r.object({adapterName:r.string().min(1),displayName:r.string().min(1),logFilePattern:r.string().min(1).optional()}),p=r.object({id:r.string().min(1),label:r.string().min(1),description:r.string().optional(),icon:r.string().min(1).optional(),selectionMode:r.enum([`single`,`multi`]),messageRoles:r.array(r.enum([`user`,`assistant`])).readonly().optional()}),m=r.object({tiles:r.boolean().optional(),widgets:r.boolean().optional(),pages:r.boolean().optional(),routes:r.boolean().optional()}),h={adapters:`adapter`,clients:`client`,providers:`provider`,triggers:`trigger`,logImporters:`log importer`,sessionEventActions:`session event action`};function g(e,t,n){e.addIssue({code:r.ZodIssueCode.custom,path:[t],message:`Duplicate ${h[t]} contribution identifier "${n}"`})}function _(e,t){let n=new Set,r=new Set,i=[];for(let a of e??[]){let e=t(a);if(n.has(e)){r.has(e)||(r.add(e),i.push(e));continue}n.add(e)}return i}const v=r.object({adapters:r.array(c).readonly().optional(),clients:r.array(l).readonly().optional(),providers:r.array(u).readonly().optional(),triggers:r.array(d).readonly().optional(),logImporters:r.array(f).readonly().optional(),sessionEventActions:r.array(p).readonly().optional(),create:r.boolean().optional(),tools:r.boolean().optional(),bootstrap:r.boolean().optional(),namespace:r.boolean().optional(),configSchema:r.boolean().optional(),uiConfig:r.boolean().optional(),ui:m.optional()}).superRefine((e,t)=>{for(let n of _(e.adapters,e=>e.name))g(t,`adapters`,n);for(let n of _(e.clients,e=>e.id))g(t,`clients`,n);for(let n of _(e.providers,e=>e.id))g(t,`providers`,n);for(let n of _(e.triggers,e=>e.prefix))g(t,`triggers`,n);for(let n of _(e.logImporters,e=>e.adapterName))g(t,`logImporters`,n);for(let n of _(e.sessionEventActions,e=>e.id))g(t,`sessionEventActions`,n)}),y=r.string().trim().min(1).transform(e=>e),b=r.object({name:r.string().min(1),required:r.boolean().optional()}),x=r.object({id:r.string(),style:r.enum([`tray-popover`,`utility`,`panel`]),width:r.number().optional(),height:r.number().optional(),singleton:r.boolean().optional(),params:r.array(b).readonly().optional()}).superRefine((e,t)=>{let n=new Set;for(let[i,a]of e.params?.entries()??[]){if(!n.has(a.name)){n.add(a.name);continue}t.addIssue({code:r.ZodIssueCode.custom,message:`Duplicate window param "${a.name}"`,path:[`params`,i,`name`]})}}),S=r.object({label:r.string(),section:r.enum([`utilities`,`tools`,`views`]).optional(),opensWindow:r.string().optional(),action:r.string().optional()}),C=r.object({name:r.string().min(1),description:r.string(),required:r.boolean().optional(),positional:r.boolean().optional(),short:r.string().regex(/^-[A-Za-z0-9]$/,`Expected a short flag like -p`).optional(),type:r.enum([`string`,`boolean`,`number`]).optional()}),w=r.object({name:r.string().min(1),description:r.string(),args:r.array(C).readonly().optional()}),T=r.object({name:r.string().min(1),description:r.string(),subcommands:r.array(w).readonly().optional(),hasInteractive:r.boolean().optional()}),E=r.string().min(1).refine(e=>!/^(?:[\\/]|[A-Za-z]:)/.test(e),`Expected a relative path`).refine(e=>!e.split(/[\\/]/).some(e=>e===``||e===`.`||e===`..`),`Path must not contain empty or dot segments`),D=r.object({migrations:E.optional(),migrationSourceId:r.string().min(1).optional()}),O=r.object({type:r.literal(`extension`),name:r.string().min(1),version:t,optional:r.boolean().optional()});function k(e,t=`>=0.1.0`,n){return n===void 0?{type:`extension`,name:e,version:t}:{type:`extension`,name:e,version:t,optional:n}}const A=r.discriminatedUnion(`type`,[r.object({type:r.literal(`host`),id:r.string().min(1)}),r.object({type:r.literal(`capability`),id:r.string().min(1),version:t.optional()})]),j=r.object({name:r.string().min(1).regex(/^(@[^/\\]+\/)?[^/\\]+$/,`Extension name must be a plain identifier or an npm-scoped name (@scope/pkg)`).refine(e=>(e.startsWith(`@`)?e.split(`/`):[e]).every(e=>e!==`.`&&e!==`..`),`Extension name must not be a dot-segment`),displayName:r.string().min(1),version:n,surface:r.enum([`interactive`,`headless`,`any`]).optional(),dependencies:r.array(O).readonly().optional(),requires:r.array(A).readonly().optional(),provides:r.array(y).readonly().optional(),windows:r.array(x).readonly().optional(),tray:S.optional(),cli:T.optional(),storage:D.optional(),browser:i.optional(),contributions:v.optional()});function M(e){return Object.freeze({name:e})}const N=r.object({command:r.string().min(1),args:r.array(r.string()).optional(),env:r.record(r.string(),r.string()).optional(),healthTimeoutMs:r.number().int().positive().optional(),shutdownTimeoutMs:r.number().int().positive().optional()}),P=r.enum([`none`,`on-crash`,`always`]),F=N.extend({restartPolicy:P.optional()}),I=r.discriminatedUnion(`type`,[F.extend({type:r.literal(`bus-stdio`)}),F.extend({type:r.literal(`bus-websocket`)}),N.extend({type:r.literal(`mcp-stdio`)})]);function L(e){if(e.includes(`\\`)||e.startsWith(`./`)||e.startsWith(`../`)||e.startsWith(`/`))return!1;let t=e.split(`/`),n=t.at(-1);return!n||n.includes(`.`)?!1:t.every(e=>e!==``&&e!==`.`&&e!==`..`&&e!==`src`&&e!==`dist`)}const R=r.union([r.literal(!0),r.string().min(1).refine(L,{message:`entrypoint stem must use forward-slash path stems, must not contain empty, . or .. segments, must not include a dotted final segment, and must not contain src or dist segments`})]),z=r.object({server:R.optional(),browser:R.optional(),cli:R.optional()}).refine(e=>e.server!==void 0||e.browser!==void 0||e.cli!==void 0,{message:`at least one entrypoint must be declared`});function B(e){return e.execution===`detached`}const V=j.extend({version:n,makaio:r.object({framework:t}).strict().readonly(),entrypoints:z.optional(),execution:r.enum([`embedded`,`detached`]).optional(),transport:I.optional(),config:r.object({defaults:r.record(r.string(),r.unknown()).optional()}).optional()}).superRefine((e,t)=>{e.execution===`detached`?(e.transport===void 0&&t.addIssue({code:r.ZodIssueCode.custom,message:`detached extensions must declare a 'transport' config`,path:[`transport`]}),e.entrypoints!==void 0&&t.addIssue({code:r.ZodIssueCode.custom,message:`detached extensions must not declare entrypoints`,path:[`entrypoints`]})):(e.entrypoints===void 0&&t.addIssue({code:r.ZodIssueCode.custom,message:`embedded extensions must declare at least one entrypoint`,path:[`entrypoints`]}),e.transport!==void 0&&t.addIssue({code:r.ZodIssueCode.custom,message:`embedded extensions must not declare a transport config`,path:[`transport`]}))});function H(e){return e}function U(e){return H(V.parse(e))}function W(e){let t=V.safeParse(e);return t.success?{success:!0,data:H(t.data)}:t}const G=r.discriminatedUnion(`kind`,[r.object({kind:r.literal(`configure-integration`),clientId:r.string().min(1),bundle:r.string().min(1)}),r.object({kind:r.literal(`install-extension`),extensionName:r.string().min(1)}),r.object({kind:r.literal(`open-url`),url:r.string().url()}),r.object({kind:r.literal(`run-command`),command:r.string().min(1)})]),K=r.enum([`info`,`recommended`,`degraded`]),q=r.object({severity:K,title:r.string().min(1),message:r.string().min(1),action:G.optional()});function J(e){switch(e.kind){case`configure-integration`:return`Configure`;case`install-extension`:return`Install`;case`open-url`:return`Open`;case`run-command`:return`Run`}}const Y=r.object({extensionName:r.string().min(1),warnings:r.array(q)});function X(e,t){return e.parse(t??{})}function Z(e){return JSON.stringify([e.extensionId,e.type,e.name,e.filename])}export{v as A,x as C,s as D,y as E,p as F,d as I,m as L,a as M,o as N,c as O,u as P,i as R,S,k as T,w as _,q as a,A as b,I as c,B as d,U as f,T as g,C as h,Y as i,f as j,l as k,V as l,M as m,X as n,K as o,W as p,G as r,J as s,Z as t,z as u,O as v,b as w,D as x,j as y};