@framers/agentos-extensions-registry 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# @framers/agentos-extensions-registry
+
+Curated extension registry bundle for AgentOS. Single import to register channels, tools, and integrations.
+
+## Installation
+
+```bash
+pnpm add @framers/agentos-extensions-registry
+```
+
+Channel extensions are **optional dependencies** — only installed channels are loaded. Missing packages are silently skipped.
+
+## Usage
+
+```typescript
+import { createCuratedManifest } from '@framers/agentos-extensions-registry';
+
+// Load all available extensions
+const manifest = await createCuratedManifest({ channels: 'all', tools: 'all' });
+
+// Or selectively enable specific channels
+const manifest = await createCuratedManifest({
+  channels: ['telegram', 'discord', 'slack'],
+  tools: 'all',
+  secrets: {
+    'telegram.botToken': process.env.TELEGRAM_BOT_TOKEN,
+    'discord.botToken': process.env.DISCORD_BOT_TOKEN,
+    'slack.botToken': process.env.SLACK_BOT_TOKEN,
+    'slack.signingSecret': process.env.SLACK_SIGNING_SECRET,
+  },
+});
+
+// Use with AgentOS
+const agent = new AgentOS();
+await agent.initialize({ extensionManifest: manifest });
+```
+
+## API
+
+### `createCuratedManifest(options?)`
+
+Creates a pre-configured `ExtensionManifest` with all available curated extensions.
+
+**Options:**
+
+| Parameter      | Type                          | Default  | Description                          |
+| -------------- | ----------------------------- | -------- | ------------------------------------ |
+| `channels`     | `string[] \| 'all' \| 'none'` | `'none'` | Which channel platforms to enable    |
+| `tools`        | `string[] \| 'all' \| 'none'` | `'all'`  | Which tool extensions to enable      |
+| `secrets`      | `Record<string, string>`      | `{}`     | Secrets map (falls back to env vars) |
+| `basePriority` | `number`                      | `50`     | Base priority for all extensions     |
+| `overrides`    | `Record<string, Override>`    | `{}`     | Per-extension overrides              |
+
+**Override shape:**
+
+```typescript
+{ enabled?: boolean; priority?: number; options?: any }
+```
+
+### `getAvailableExtensions()`
+
+Returns a list of extensions whose optional dependencies are installed.
+
+### `getAvailableChannels()`
+
+Returns a list of available channel adapters.
+
+## Available Channel Extensions
+
+| Channel  | Package                                 | SDK         | Secret                                   |
+| -------- | --------------------------------------- | ----------- | ---------------------------------------- |
+| Telegram | `@framers/agentos-ext-channel-telegram` | grammY      | `telegram.botToken`                      |
+| WhatsApp | `@framers/agentos-ext-channel-whatsapp` | Baileys     | `whatsapp.sessionData`                   |
+| Discord  | `@framers/agentos-ext-channel-discord`  | discord.js  | `discord.botToken`                       |
+| Slack    | `@framers/agentos-ext-channel-slack`    | @slack/bolt | `slack.botToken` + `slack.signingSecret` |
+| WebChat  | `@framers/agentos-ext-channel-webchat`  | (built-in)  | none                                     |
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@framers/agentos-extensions-registry",
+  "version": "0.1.0",
+  "description": "Curated extension registry bundle for AgentOS — single import to register channels, tools, and integrations",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/framersai/agentos-extensions-registry.git"
+  },
+  "keywords": [
+    "agentos",
+    "extensions",
+    "registry",
+    "channels",
+    "tools"
+  ],
+  "author": {
+    "name": "Framers AI",
+    "email": "team@frame.dev",
+    "url": "https://frame.dev"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@framers/agentos": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@framers/agentos": {
+      "optional": false
+    }
+  },
+  "optionalDependencies": {
+    "@framers/agentos-ext-auth": "^1.0.0",
+    "@framers/agentos-ext-web-search": "^1.0.0",
+    "@framers/agentos-ext-web-browser": "^1.0.0",
+    "@framers/agentos-ext-telegram": "^1.0.0",
+    "@framers/agentos-ext-cli-executor": "^1.0.0",
+    "@framers/agentos-ext-giphy": "^1.0.0",
+    "@framers/agentos-ext-image-search": "^1.0.0",
+    "@framers/agentos-ext-voice-synthesis": "^1.0.0",
+    "@framers/agentos-ext-news-search": "^1.0.0"
+  },
+  "devDependencies": {
+    "@framers/agentos": "^0.1.0",
+    "typescript": "^5.4.5",
+    "vitest": "^1.0.0"
+  }
+}

package/src/channel-registry.ts

@@ -0,0 +1,197 @@
+/**
+ * @fileoverview Channel registry — metadata catalog for all supported
+ * messaging channel extensions.
+ *
+ * Each entry defines the channel's metadata, secret requirements, and
+ * default priority. The actual adapter implementations live in
+ * `@framers/agentos-extensions/registry/curated/channels/<platform>/`.
+ *
+ * @module @framers/agentos-extensions-registry/channel-registry
+ */
+
+import type { ChannelRegistryEntry } from './types.js';
+
+/**
+ * Full catalog of messaging channel extensions.
+ * Ordered by priority tier (P0 first, then P1, P2).
+ */
+export const CHANNEL_CATALOG: ChannelRegistryEntry[] = [
+  // ── P0: Core Channels ──
+  {
+    packageName: '@framers/agentos-ext-channel-telegram',
+    name: 'channel-telegram',
+    category: 'channel',
+    platform: 'telegram',
+    displayName: 'Telegram',
+    description: 'Telegram Bot API via grammY — supports text, images, inline keyboards, groups.',
+    sdkPackage: 'grammy',
+    requiredSecrets: ['telegram.botToken'],
+    defaultPriority: 50,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-whatsapp',
+    name: 'channel-whatsapp',
+    category: 'channel',
+    platform: 'whatsapp',
+    displayName: 'WhatsApp',
+    description: 'WhatsApp Web bridge via Baileys — supports text, images, documents, voice notes.',
+    sdkPackage: '@whiskeysockets/baileys',
+    requiredSecrets: ['whatsapp.sessionData'],
+    defaultPriority: 50,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-discord',
+    name: 'channel-discord',
+    category: 'channel',
+    platform: 'discord',
+    displayName: 'Discord',
+    description: 'Discord bot via discord.js — supports text, embeds, threads, reactions, buttons.',
+    sdkPackage: 'discord.js',
+    requiredSecrets: ['discord.botToken'],
+    defaultPriority: 50,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-slack',
+    name: 'channel-slack',
+    category: 'channel',
+    platform: 'slack',
+    displayName: 'Slack',
+    description:
+      'Slack workspace integration via Bolt — supports text, blocks, threads, reactions.',
+    sdkPackage: '@slack/bolt',
+    requiredSecrets: ['slack.botToken', 'slack.appToken'],
+    defaultPriority: 50,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-webchat',
+    name: 'channel-webchat',
+    category: 'channel',
+    platform: 'webchat',
+    displayName: 'WebChat',
+    description: 'Browser-based chat widget via Socket.IO — embeds in any website.',
+    sdkPackage: 'socket.io',
+    requiredSecrets: [],
+    defaultPriority: 50,
+    available: false,
+  },
+
+  // ── P1: Extended Channels ──
+  {
+    packageName: '@framers/agentos-ext-channel-signal',
+    name: 'channel-signal',
+    category: 'channel',
+    platform: 'signal',
+    displayName: 'Signal',
+    description: 'Signal messenger via signal-cli — end-to-end encrypted messaging.',
+    sdkPackage: 'signal-cli',
+    requiredSecrets: ['signal.phoneNumber'],
+    defaultPriority: 40,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-imessage',
+    name: 'channel-imessage',
+    category: 'channel',
+    platform: 'imessage',
+    displayName: 'iMessage',
+    description: 'iMessage bridge via BlueBubbles — macOS server required.',
+    sdkPackage: 'bluebubbles-node',
+    requiredSecrets: ['imessage.serverUrl', 'imessage.password'],
+    defaultPriority: 40,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-google-chat',
+    name: 'channel-google-chat',
+    category: 'channel',
+    platform: 'google-chat',
+    displayName: 'Google Chat',
+    description: 'Google Workspace Chat via Cloud API — supports cards and threads.',
+    sdkPackage: '@google-cloud/chat',
+    requiredSecrets: ['googlechat.serviceAccount'],
+    defaultPriority: 40,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-teams',
+    name: 'channel-teams',
+    category: 'channel',
+    platform: 'teams',
+    displayName: 'Microsoft Teams',
+    description: 'Microsoft Teams bot via Teams AI library — supports adaptive cards.',
+    sdkPackage: '@microsoft/teams-ai',
+    requiredSecrets: ['teams.appId', 'teams.appPassword'],
+    defaultPriority: 40,
+    available: false,
+  },
+
+  // ── P2: Community Channels ──
+  {
+    packageName: '@framers/agentos-ext-channel-matrix',
+    name: 'channel-matrix',
+    category: 'channel',
+    platform: 'matrix',
+    displayName: 'Matrix',
+    description: 'Matrix/Element via matrix-js-sdk — decentralized, federated messaging.',
+    sdkPackage: 'matrix-js-sdk',
+    requiredSecrets: ['matrix.homeserverUrl', 'matrix.accessToken'],
+    defaultPriority: 30,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-zalo',
+    name: 'channel-zalo',
+    category: 'channel',
+    platform: 'zalo',
+    displayName: 'Zalo',
+    description: 'Zalo Official Account API — popular in Vietnam.',
+    sdkPackage: 'zalo-api',
+    requiredSecrets: ['zalo.appId', 'zalo.secretKey'],
+    defaultPriority: 30,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-email',
+    name: 'channel-email',
+    category: 'channel',
+    platform: 'email',
+    displayName: 'Email',
+    description: 'Email messaging via nodemailer (SMTP) + imap-simple (IMAP).',
+    sdkPackage: 'nodemailer',
+    requiredSecrets: ['email.smtpHost', 'email.smtpUser', 'email.smtpPassword'],
+    defaultPriority: 30,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-channel-sms',
+    name: 'channel-sms',
+    category: 'channel',
+    platform: 'sms',
+    displayName: 'SMS',
+    description: 'SMS messaging via Twilio — text-only, worldwide reach.',
+    sdkPackage: 'twilio',
+    requiredSecrets: ['twilio.accountSid', 'twilio.authToken', 'twilio.phoneNumber'],
+    defaultPriority: 30,
+    available: false,
+  },
+];
+
+/**
+ * Get channel entries filtered by platform names.
+ */
+export function getChannelEntries(platforms?: string[] | 'all' | 'none'): ChannelRegistryEntry[] {
+  if (platforms === 'none') return [];
+  if (!platforms || platforms === 'all') return [...CHANNEL_CATALOG];
+  return CHANNEL_CATALOG.filter((entry) => platforms.includes(entry.platform));
+}
+
+/**
+ * Get a single channel entry by platform.
+ */
+export function getChannelEntry(platform: string): ChannelRegistryEntry | undefined {
+  return CHANNEL_CATALOG.find((entry) => entry.platform === platform);
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview AgentOS Extensions Registry Bundle.
+ *
+ * Single-import package that discovers, configures, and registers all
+ * curated AgentOS extensions (channels, tools, integrations).
+ *
+ * @example
+ * ```typescript
+ * import { createCuratedManifest } from '@framers/agentos-extensions-registry';
+ *
+ * const manifest = await createCuratedManifest({
+ *   channels: ['telegram', 'whatsapp', 'discord'],
+ *   tools: 'all',
+ *   secrets: resolvedSecrets,
+ * });
+ *
+ * const agentOS = new AgentOS({ extensionManifest: manifest });
+ * ```
+ *
+ * @module @framers/agentos-extensions-registry
+ */
+
+export {
+  createCuratedManifest,
+  getAvailableExtensions,
+  getAvailableChannels,
+} from './manifest-builder.js';
+
+export { CHANNEL_CATALOG, getChannelEntries, getChannelEntry } from './channel-registry.js';
+
+export type {
+  RegistryOptions,
+  ExtensionOverrideConfig,
+  ExtensionInfo,
+  ChannelRegistryEntry,
+} from './types.js';

package/src/manifest-builder.ts

@@ -0,0 +1,263 @@
+/**
+ * @fileoverview Manifest builder — creates pre-configured ExtensionManifest
+ * instances from the curated extension catalog.
+ *
+ * This is the primary API of the registry package. Instead of manually wiring
+ * each extension pack in the backend, consumers call `createCuratedManifest()`
+ * with their desired configuration.
+ *
+ * @module @framers/agentos-extensions-registry/manifest-builder
+ */
+
+import type { ExtensionManifest, ExtensionPackManifestEntry } from '@framers/agentos';
+import type { RegistryOptions, ExtensionInfo, RegistryLogger } from './types.js';
+import { CHANNEL_CATALOG, getChannelEntries } from './channel-registry.js';
+
+/**
+ * Known tool extension packages and their metadata.
+ * Matches existing extensions in `agentos-extensions/registry/curated/`.
+ */
+const TOOL_CATALOG: ExtensionInfo[] = [
+  {
+    packageName: '@framers/agentos-ext-auth',
+    name: 'auth',
+    category: 'tool',
+    displayName: 'Authentication',
+    description: 'User authentication and session management tools.',
+    requiredSecrets: [],
+    defaultPriority: 10,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-web-search',
+    name: 'web-search',
+    category: 'tool',
+    displayName: 'Web Search',
+    description: 'Web search via Serper.dev or similar providers.',
+    requiredSecrets: ['serper.apiKey'],
+    defaultPriority: 20,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-web-browser',
+    name: 'web-browser',
+    category: 'tool',
+    displayName: 'Web Browser',
+    description: 'Headless browser for page fetching and scraping.',
+    requiredSecrets: [],
+    defaultPriority: 20,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-telegram',
+    name: 'telegram',
+    category: 'integration',
+    displayName: 'Telegram (Legacy)',
+    description: 'Legacy Telegram bot integration (tool-based, pre-channel system).',
+    requiredSecrets: ['telegram.botToken'],
+    defaultPriority: 50,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-cli-executor',
+    name: 'cli-executor',
+    category: 'tool',
+    displayName: 'CLI Executor',
+    description: 'Execute shell commands in a sandboxed environment.',
+    requiredSecrets: [],
+    defaultPriority: 20,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-giphy',
+    name: 'giphy',
+    category: 'tool',
+    displayName: 'Giphy',
+    description: 'Search and share GIFs via the Giphy API.',
+    requiredSecrets: [],
+    defaultPriority: 30,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-image-search',
+    name: 'image-search',
+    category: 'tool',
+    displayName: 'Image Search',
+    description: 'Search for images via web APIs.',
+    requiredSecrets: [],
+    defaultPriority: 30,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-voice-synthesis',
+    name: 'voice-synthesis',
+    category: 'tool',
+    displayName: 'Voice Synthesis',
+    description: 'Text-to-speech synthesis via ElevenLabs or similar.',
+    requiredSecrets: [],
+    defaultPriority: 30,
+    available: false,
+  },
+  {
+    packageName: '@framers/agentos-ext-news-search',
+    name: 'news-search',
+    category: 'tool',
+    displayName: 'News Search',
+    description: 'Search recent news articles.',
+    requiredSecrets: [],
+    defaultPriority: 30,
+    available: false,
+  },
+];
+
+/**
+ * Attempt to dynamically import a package. Returns the module if available,
+ * or `null` if the package is not installed.
+ */
+async function tryImport(packageName: string): Promise<any | null> {
+  try {
+    return await import(packageName);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check which extensions from the catalog are actually installed
+ * and mark them as available.
+ */
+export async function getAvailableExtensions(): Promise<ExtensionInfo[]> {
+  const allEntries: ExtensionInfo[] = [...TOOL_CATALOG, ...CHANNEL_CATALOG];
+  const results: ExtensionInfo[] = [];
+
+  for (const entry of allEntries) {
+    const mod = await tryImport(entry.packageName);
+    results.push({ ...entry, available: mod !== null });
+  }
+
+  return results;
+}
+
+/**
+ * Get available channel extensions.
+ */
+export async function getAvailableChannels(): Promise<ExtensionInfo[]> {
+  const results: ExtensionInfo[] = [];
+  for (const entry of CHANNEL_CATALOG) {
+    const mod = await tryImport(entry.packageName);
+    results.push({ ...entry, available: mod !== null });
+  }
+  return results;
+}
+
+/**
+ * Creates a pre-configured `ExtensionManifest` with all available curated
+ * extensions. Missing optional dependencies are silently skipped.
+ *
+ * @example
+ * ```typescript
+ * import { createCuratedManifest } from '@framers/agentos-extensions-registry';
+ *
+ * // Enable all available extensions
+ * const manifest = await createCuratedManifest();
+ *
+ * // Selective: only Telegram + Discord channels, all tools
+ * const manifest = await createCuratedManifest({
+ *   channels: ['telegram', 'discord'],
+ *   tools: 'all',
+ *   secrets: {
+ *     'telegram.botToken': process.env.TELEGRAM_BOT_TOKEN!,
+ *     'discord.botToken': process.env.DISCORD_BOT_TOKEN!,
+ *   },
+ * });
+ *
+ * // Pass to AgentOS config
+ * const agentOS = new AgentOS({ extensionManifest: manifest });
+ * ```
+ */
+export async function createCuratedManifest(options?: RegistryOptions): Promise<ExtensionManifest> {
+  const basePriority = options?.basePriority ?? 0;
+  const secrets = options?.secrets;
+  const logger: RegistryLogger | undefined = options?.logger ?? console;
+  const packs: ExtensionPackManifestEntry[] = [];
+
+  // ── Tool Extensions ──
+  const toolFilter = options?.tools ?? 'all';
+  const toolEntries =
+    toolFilter === 'none'
+      ? []
+      : toolFilter === 'all'
+        ? TOOL_CATALOG
+        : TOOL_CATALOG.filter((t) => toolFilter.includes(t.name));
+
+  for (const entry of toolEntries) {
+    const override = options?.overrides?.[entry.name];
+    if (override?.enabled === false) continue;
+
+    const mod = await tryImport(entry.packageName);
+    if (!mod) continue;
+
+    const factory = mod.createExtensionPack ?? mod.default?.createExtensionPack ?? mod.default;
+    if (typeof factory !== 'function') continue;
+
+    packs.push({
+      factory: () =>
+        factory({
+          options: {
+            ...override?.options,
+            secrets,
+          },
+          getSecret: (secretId: string) => secrets?.[secretId],
+          logger,
+        }),
+      priority: override?.priority ?? basePriority + entry.defaultPriority,
+      enabled: true,
+      identifier: `registry:${entry.name}`,
+    });
+  }
+
+  // ── Channel Extensions ──
+  const channelEntries = getChannelEntries(options?.channels);
+
+  for (const entry of channelEntries) {
+    const override = options?.overrides?.[entry.name];
+    if (override?.enabled === false) continue;
+
+    const mod = await tryImport(entry.packageName);
+    if (!mod) continue;
+
+    const factory = mod.createExtensionPack ?? mod.default?.createExtensionPack ?? mod.default;
+    if (typeof factory !== 'function') continue;
+
+    packs.push({
+      factory: () =>
+        factory({
+          options: {
+            ...override?.options,
+            secrets,
+          },
+          getSecret: (secretId: string) => secrets?.[secretId],
+          logger,
+        }),
+      priority: override?.priority ?? basePriority + entry.defaultPriority,
+      enabled: true,
+      identifier: `registry:${entry.name}`,
+    });
+  }
+
+  // ── Build Overrides ──
+  const manifestOverrides = options?.overrides
+    ? {
+        tools: Object.fromEntries(
+          Object.entries(options.overrides)
+            .filter(([, v]) => v.enabled !== undefined || v.priority !== undefined)
+            .map(([k, v]) => [k, { enabled: v.enabled, priority: v.priority }])
+        ),
+      }
+    : undefined;
+
+  return {
+    packs,
+    overrides: manifestOverrides,
+  };
+}

package/src/types.ts

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview Configuration types for the extensions registry bundle.
+ * @module @framers/agentos-extensions-registry/types
+ */
+
+import type { ChannelPlatform } from '@framers/agentos';
+
+export interface RegistryLogger {
+  info?: (...args: any[]) => void;
+  warn?: (...args: any[]) => void;
+  error?: (...args: any[]) => void;
+  debug?: (...args: any[]) => void;
+}
+
+/**
+ * Options for building a curated extension manifest.
+ */
+export interface RegistryOptions {
+  /**
+   * Which messaging channels to enable.
+   * - Array of platform names: selectively enable specific channels.
+   * - `'all'`: enable all available channels (default).
+   * - `'none'`: disable all channels.
+   */
+  channels?: ChannelPlatform[] | 'all' | 'none';
+
+  /**
+   * Which tool extensions to enable.
+   * - Array of tool pack names (e.g., 'web-search', 'giphy').
+   * - `'all'`: enable all available tools (default).
+   * - `'none'`: disable all tools.
+   */
+  tools?: string[] | 'all' | 'none';
+
+  /**
+   * Secrets map (API keys, tokens, credentials).
+   * Keys match secret IDs from `extension-secrets.json` (e.g., 'telegram.botToken').
+   * Falls back to environment variables if not provided here.
+   */
+  secrets?: Record<string, string>;
+
+  /**
+   * Optional logger passed to extension-pack factories. Defaults to `console`.
+   */
+  logger?: RegistryLogger;
+
+  /**
+   * Base priority for all extensions. Individual packs add their own
+   * offset on top of this. Default: 0.
+   */
+  basePriority?: number;
+
+  /**
+   * Per-extension overrides. Keys are pack names or descriptor IDs.
+   */
+  overrides?: Record<string, ExtensionOverrideConfig>;
+}
+
+/**
+ * Override configuration for a specific extension pack or descriptor.
+ */
+export interface ExtensionOverrideConfig {
+  /** Force enable/disable. */
+  enabled?: boolean;
+  /** Override priority. */
+  priority?: number;
+  /** Additional options passed to the pack factory. */
+  options?: Record<string, unknown>;
+}
+
+/**
+ * Metadata about an extension available in the registry.
+ */
+export interface ExtensionInfo {
+  /** Package name (e.g., '@framers/agentos-ext-telegram'). */
+  packageName: string;
+  /** Short name (e.g., 'telegram'). */
+  name: string;
+  /** Category (e.g., 'channel', 'tool', 'integration'). */
+  category: 'channel' | 'tool' | 'integration' | 'provenance';
+  /** Whether the package's dependencies are installed and importable. */
+  available: boolean;
+  /** Human-readable display name. */
+  displayName: string;
+  /** Description. */
+  description: string;
+  /** Required secret IDs. */
+  requiredSecrets: string[];
+  /** Default priority. */
+  defaultPriority: number;
+}
+
+/**
+ * Registry entry for a channel extension.
+ */
+export interface ChannelRegistryEntry extends ExtensionInfo {
+  category: 'channel';
+  /** Platform identifier. */
+  platform: ChannelPlatform;
+  /** SDK package name (e.g., 'grammy', 'discord.js'). */
+  sdkPackage: string;
+}

package/test/manifest-builder.spec.ts

@@ -0,0 +1,96 @@
+/**
+ * Unit tests for createCuratedManifest and registry helpers.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createCuratedManifest, getAvailableExtensions, getAvailableChannels } from '../src/index';
+
+describe('createCuratedManifest', () => {
+  it('should return a manifest object with packs array', async () => {
+    const manifest = await createCuratedManifest({ channels: 'none', tools: 'none' });
+    expect(manifest).toHaveProperty('packs');
+    expect(Array.isArray(manifest.packs)).toBe(true);
+  });
+
+  it('should return empty packs when channels and tools are "none"', async () => {
+    const manifest = await createCuratedManifest({ channels: 'none', tools: 'none' });
+    expect(manifest.packs).toHaveLength(0);
+  });
+
+  it('should attempt to load all channels when channels="all"', async () => {
+    // In test environment, no optional deps are installed, so packs will be empty
+    const manifest = await createCuratedManifest({ channels: 'all', tools: 'none' });
+    // tryImport fails for all → packs = []
+    expect(manifest.packs).toEqual([]);
+  });
+
+  it('should attempt to load all tools when tools="all"', async () => {
+    const manifest = await createCuratedManifest({ channels: 'none', tools: 'all' });
+    // tryImport fails for all → packs = []
+    expect(manifest.packs).toEqual([]);
+  });
+
+  it('should filter channels by platform name', async () => {
+    const manifest = await createCuratedManifest({
+      channels: ['telegram', 'discord'],
+      tools: 'none',
+    });
+    // Even though packages aren't installed, the filter should work
+    expect(manifest.packs).toEqual([]);
+  });
+
+  it('should apply priority overrides', async () => {
+    const manifest = await createCuratedManifest({
+      channels: ['telegram'],
+      tools: 'none',
+      overrides: { 'channel-telegram': { priority: 999 } },
+    });
+    // Package not available, but override would be applied if it were
+    expect(manifest.packs).toEqual([]);
+  });
+
+  it('should skip disabled extensions via overrides', async () => {
+    const manifest = await createCuratedManifest({
+      channels: 'all',
+      tools: 'all',
+      overrides: {
+        'channel-telegram': { enabled: false },
+        auth: { enabled: false },
+      },
+    });
+    expect(manifest.packs).toEqual([]);
+  });
+
+  it('should pass secrets to extension factories', async () => {
+    const manifest = await createCuratedManifest({
+      channels: ['telegram'],
+      tools: 'none',
+      secrets: { 'telegram.botToken': 'test-token-123' },
+    });
+    // Can't test factory call since package not installed, but structure is correct
+    expect(manifest).toHaveProperty('packs');
+  });
+
+  it('should handle basePriority offset', async () => {
+    const manifest = await createCuratedManifest({
+      channels: 'none',
+      tools: 'none',
+      basePriority: 100,
+    });
+    expect(manifest.packs).toEqual([]);
+  });
+});
+
+describe('getAvailableExtensions', () => {
+  it('should return an array', async () => {
+    const extensions = await getAvailableExtensions();
+    expect(Array.isArray(extensions)).toBe(true);
+  });
+});
+
+describe('getAvailableChannels', () => {
+  it('should return an array', async () => {
+    const channels = await getAvailableChannels();
+    expect(Array.isArray(channels)).toBe(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}