open-multi-agent-kit 0.95.0 → 0.95.2

package/dist/core/extensions/loader.js.bak-sharedjiti-20260812-111246

@@ -0,0 +1,553 @@
+/**
+ * Extension loader - loads TypeScript extension modules using jiti.
+ *
+ */
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createJiti } from "jiti/static";
+import * as _bundledOmkAgentCore from "omk-agent-core";
+import * as _bundledOmkAgentCoreNode from "omk-agent-core/node";
+import * as _bundledOmkAi from "omk-ai";
+import * as _bundledOmkAiOauth from "omk-ai/oauth";
+import * as _bundledOmkTui from "omk-tui";
+// Static imports of packages that extensions may use.
+// These MUST be static so Bun bundles them into the compiled binary.
+// The virtualModules option then makes them available to extensions.
+import * as _bundledTypebox from "typebox";
+import * as _bundledTypeboxCompile from "typebox/compile";
+import * as _bundledTypeboxValue from "typebox/value";
+import { CONFIG_DIR_NAME, getAgentDir, isBunBinary } from "../../config.js";
+// NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
+// avoiding a circular dependency. Extensions can import from open-multi-agent-kit.
+import * as _bundledOmkCodingAgent from "../../index.js";
+import { resolvePath } from "../../utils/paths.js";
+import { createEventBus } from "../event-bus.js";
+import { execCommand } from "../exec.js";
+import { readPackageManifest } from "../package-manifest.js";
+import { LEGACY_PI_RUNTIME_ALIASES } from "../pi-compat.js";
+import { createSyntheticSourceInfo } from "../source-info.js";
+const LEGACY_PI_VIRTUAL_TARGETS = {
+    "coding-agent": _bundledOmkCodingAgent,
+    "agent-core": _bundledOmkAgentCore,
+    "agent-core-node": _bundledOmkAgentCoreNode,
+    ai: _bundledOmkAi,
+    "ai-oauth": _bundledOmkAiOauth,
+    tui: _bundledOmkTui,
+};
+/** Modules available to extensions via virtualModules (for compiled Bun binary) */
+const VIRTUAL_MODULES = {
+    ...Object.fromEntries(Object.entries(LEGACY_PI_RUNTIME_ALIASES).map(([specifier, target]) => [
+        specifier,
+        LEGACY_PI_VIRTUAL_TARGETS[target],
+    ])),
+    typebox: _bundledTypebox,
+    "typebox/compile": _bundledTypeboxCompile,
+    "typebox/value": _bundledTypeboxValue,
+    "@sinclair/typebox": _bundledTypebox,
+    "@sinclair/typebox/compile": _bundledTypeboxCompile,
+    "@sinclair/typebox/value": _bundledTypeboxValue,
+    "omk-agent-core": _bundledOmkAgentCore,
+    "omk-agent-core/node": _bundledOmkAgentCoreNode,
+    "omk-tui": _bundledOmkTui,
+    "omk-ai": _bundledOmkAi,
+    "omk-ai/oauth": _bundledOmkAiOauth,
+    "open-multi-agent-kit": _bundledOmkCodingAgent,
+};
+const require = createRequire(import.meta.url);
+let _aliases = null;
+function findPackageJsonPath(specifier, startDir, resolvePackageJson = require.resolve, existsSync = fs.existsSync) {
+    try {
+        return resolvePackageJson(`${specifier}/package.json`);
+    }
+    catch {
+        let current = startDir;
+        while (true) {
+            const candidate = path.join(current, "node_modules", ...specifier.split("/"), "package.json");
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                throw new Error(`Unable to resolve package.json for ${specifier}. Install ${specifier} or run OMK from a workspace containing its built package.`);
+            }
+            current = parent;
+        }
+    }
+}
+function resolveWorkspaceOrPackageFile(workspaceRelativePath, specifier, packageRelativePath, packagesRoot, resolvePackageJson, existsSync, startDir) {
+    const workspacePath = path.join(packagesRoot, workspaceRelativePath);
+    if (existsSync(workspacePath)) {
+        return workspacePath;
+    }
+    const packageJsonPath = findPackageJsonPath(specifier, startDir, resolvePackageJson, existsSync);
+    return path.join(path.dirname(packageJsonPath), packageRelativePath);
+}
+/** Internal test seam for omk-agent-core/node resolution branches. */
+export function resolveOmkAgentCoreNodeEntryForTests(options) {
+    return resolveWorkspaceOrPackageFile("agent/dist/node.js", "omk-agent-core", "dist/node.js", options.packagesRoot, options.resolvePackageJson, options.existsSync, options.startDir);
+}
+/**
+ * Get aliases for jiti (used in Node.js/development mode).
+ * In Bun binary mode, virtualModules is used instead.
+ */
+function getAliases() {
+    if (_aliases)
+        return _aliases;
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const packageIndex = path.resolve(__dirname, "../..", "index.js");
+    const typeboxEntry = require.resolve("typebox");
+    const typeboxCompileEntry = require.resolve("typebox/compile");
+    const typeboxValueEntry = require.resolve("typebox/value");
+    const packagesRoot = path.resolve(__dirname, "../../../../");
+    const omkCodingAgentEntry = packageIndex;
+    const omkAgentCoreEntry = resolveWorkspaceOrPackageFile("agent/dist/index.js", "omk-agent-core", "dist/index.js", packagesRoot, require.resolve, fs.existsSync, __dirname);
+    const omkAgentCoreNodeEntry = resolveWorkspaceOrPackageFile("agent/dist/node.js", "omk-agent-core", "dist/node.js", packagesRoot, require.resolve, fs.existsSync, __dirname);
+    const omkTuiEntry = resolveWorkspaceOrPackageFile("tui/dist/index.js", "omk-tui", "dist/index.js", packagesRoot, require.resolve, fs.existsSync, __dirname);
+    const omkAiEntry = resolveWorkspaceOrPackageFile("ai/dist/index.js", "omk-ai", "dist/index.js", packagesRoot, require.resolve, fs.existsSync, __dirname);
+    const omkAiOauthEntry = resolveWorkspaceOrPackageFile("ai/dist/oauth.js", "omk-ai", "dist/oauth.js", packagesRoot, require.resolve, fs.existsSync, __dirname);
+    const legacyPiAliasTargets = {
+        "coding-agent": omkCodingAgentEntry,
+        "agent-core": omkAgentCoreEntry,
+        "agent-core-node": omkAgentCoreNodeEntry,
+        ai: omkAiEntry,
+        "ai-oauth": omkAiOauthEntry,
+        tui: omkTuiEntry,
+    };
+    _aliases = {
+        ...Object.fromEntries(Object.entries(LEGACY_PI_RUNTIME_ALIASES).map(([specifier, target]) => [
+            specifier,
+            legacyPiAliasTargets[target],
+        ])),
+        "open-multi-agent-kit": omkCodingAgentEntry,
+        "omk-agent-core": omkAgentCoreEntry,
+        "omk-agent-core/node": omkAgentCoreNodeEntry,
+        "omk-tui": omkTuiEntry,
+        "omk-ai": omkAiEntry,
+        "omk-ai/oauth": omkAiOauthEntry,
+        typebox: typeboxEntry,
+        "typebox/compile": typeboxCompileEntry,
+        "typebox/value": typeboxValueEntry,
+        "@sinclair/typebox": typeboxEntry,
+        "@sinclair/typebox/compile": typeboxCompileEntry,
+        "@sinclair/typebox/value": typeboxValueEntry,
+    };
+    return _aliases;
+}
+/**
+ * Create a runtime with throwing stubs for action methods.
+ * Runner.bindCore() replaces these with real implementations.
+ */
+export function createExtensionRuntime() {
+    const notInitialized = () => {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+    };
+    const state = {};
+    const assertActive = () => {
+        if (state.staleMessage) {
+            throw new Error(state.staleMessage);
+        }
+    };
+    const runtime = {
+        sendMessage: notInitialized,
+        sendUserMessage: notInitialized,
+        appendEntry: notInitialized,
+        setSessionName: notInitialized,
+        getSessionName: notInitialized,
+        setLabel: notInitialized,
+        getActiveTools: notInitialized,
+        getAllTools: notInitialized,
+        setActiveTools: notInitialized,
+        // registerTool() is valid during extension load; refresh is only needed post-bind.
+        refreshTools: () => { },
+        getCommands: notInitialized,
+        setModel: () => Promise.reject(new Error("Extension runtime not initialized")),
+        getThinkingLevel: notInitialized,
+        setThinkingLevel: notInitialized,
+        // Optional; replaced by bindCore when the session provides a handler.
+        callMcpTool: undefined,
+        flagValues: new Map(),
+        pendingProviderRegistrations: [],
+        assertActive,
+        invalidate: (message) => {
+            state.staleMessage ??=
+                message ??
+                    "This extension ctx is stale after session replacement or reload. Do not use a captured extension API or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
+        },
+        // Pre-bind: queue registrations so bindCore() can flush them once the
+        // model registry is available. bindCore() replaces both with direct calls.
+        registerProvider: (name, config, extensionPath = "<unknown>") => {
+            runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
+        },
+        unregisterProvider: (name) => {
+            runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter((r) => r.name !== name);
+        },
+    };
+    return runtime;
+}
+/**
+ * Create the ExtensionAPI for an extension.
+ * Registration methods write to the extension object.
+ * Action methods delegate to the shared runtime.
+ */
+function createExtensionAPI(extension, runtime, cwd, eventBus) {
+    const api = {
+        // Registration methods - write to extension
+        on(event, handler) {
+            runtime.assertActive();
+            const list = extension.handlers.get(event) ?? [];
+            list.push(handler);
+            extension.handlers.set(event, list);
+        },
+        registerTool(tool) {
+            runtime.assertActive();
+            extension.tools.set(tool.name, {
+                definition: tool,
+                sourceInfo: extension.sourceInfo,
+            });
+            runtime.refreshTools();
+        },
+        registerCommand(name, options) {
+            runtime.assertActive();
+            extension.commands.set(name, {
+                name,
+                sourceInfo: extension.sourceInfo,
+                ...options,
+            });
+        },
+        registerShortcut(shortcut, options) {
+            runtime.assertActive();
+            extension.shortcuts.set(shortcut, { shortcut, extensionPath: extension.path, ...options });
+        },
+        registerFlag(name, options) {
+            runtime.assertActive();
+            extension.flags.set(name, { name, extensionPath: extension.path, ...options });
+            if (options.default !== undefined && !runtime.flagValues.has(name)) {
+                runtime.flagValues.set(name, options.default);
+            }
+        },
+        registerMessageRenderer(customType, renderer) {
+            runtime.assertActive();
+            extension.messageRenderers.set(customType, renderer);
+        },
+        // Flag access - checks extension registered it, reads from runtime
+        getFlag(name) {
+            runtime.assertActive();
+            if (!extension.flags.has(name))
+                return undefined;
+            return runtime.flagValues.get(name);
+        },
+        // Action methods - delegate to shared runtime
+        sendMessage(message, options) {
+            runtime.assertActive();
+            runtime.sendMessage(message, options);
+        },
+        sendUserMessage(content, options) {
+            runtime.assertActive();
+            runtime.sendUserMessage(content, options);
+        },
+        appendEntry(customType, data) {
+            runtime.assertActive();
+            runtime.appendEntry(customType, data);
+        },
+        setSessionName(name) {
+            runtime.assertActive();
+            runtime.setSessionName(name);
+        },
+        getSessionName() {
+            runtime.assertActive();
+            return runtime.getSessionName();
+        },
+        setLabel(entryId, label) {
+            runtime.assertActive();
+            runtime.setLabel(entryId, label);
+        },
+        exec(command, args, options) {
+            runtime.assertActive();
+            return execCommand(command, args, options?.cwd ?? cwd, options);
+        },
+        // Always expose the method so load-time factories can capture it (typeof === "function").
+        // The bound handler is resolved at call time after bindCore; until then callers get a clear error.
+        async callMcpTool(server, name, args) {
+            runtime.assertActive();
+            const handler = runtime.callMcpTool;
+            if (typeof handler !== "function") {
+                throw new Error("Extension callMcpTool is not bound. The session must provide a callMcpTool handler via bindCore.");
+            }
+            return handler(server, name, args);
+        },
+        isMcpToolBound() {
+            runtime.assertActive();
+            return typeof runtime.callMcpTool === "function";
+        },
+        getActiveTools() {
+            runtime.assertActive();
+            return runtime.getActiveTools();
+        },
+        getAllTools() {
+            runtime.assertActive();
+            return runtime.getAllTools();
+        },
+        setActiveTools(toolNames) {
+            runtime.assertActive();
+            runtime.setActiveTools(toolNames);
+        },
+        getCommands() {
+            runtime.assertActive();
+            return runtime.getCommands();
+        },
+        setModel(model) {
+            runtime.assertActive();
+            return runtime.setModel(model);
+        },
+        getThinkingLevel() {
+            runtime.assertActive();
+            return runtime.getThinkingLevel();
+        },
+        setThinkingLevel(level) {
+            runtime.assertActive();
+            runtime.setThinkingLevel(level);
+        },
+        registerProvider(name, config) {
+            runtime.assertActive();
+            runtime.registerProvider(name, config, extension.path);
+        },
+        unregisterProvider(name) {
+            runtime.assertActive();
+            runtime.unregisterProvider(name, extension.path);
+        },
+        // Track extension event subscriptions so they can be
+        // unsubscribed on reload instead of stacking duplicate listeners
+        // on the shared event bus.
+        events: {
+            emit: (channel, data) => {
+                eventBus.emit(channel, data);
+            },
+            on: (channel, handler) => {
+                const unsubscribe = eventBus.on(channel, handler);
+                extension.eventBusSubscriptions?.push(unsubscribe);
+                return unsubscribe;
+            },
+        },
+    };
+    return api;
+}
+async function loadExtensionModule(extensionPath, binaryMode = isBunBinary) {
+    const jiti = createJiti(import.meta.url, {
+        moduleCache: false,
+        // In Bun binary: use virtualModules for bundled packages (no filesystem resolution)
+        // Also disable tryNative so jiti handles ALL imports (not just the entry point)
+        // In Node.js/dev: use aliases to resolve to node_modules paths
+        ...(binaryMode ? { virtualModules: VIRTUAL_MODULES, tryNative: false } : { alias: getAliases() }),
+    });
+    const module = await jiti.import(extensionPath, { default: true });
+    const factory = module;
+    return typeof factory !== "function" ? undefined : factory;
+}
+/** Internal test seam for loading extensions through Bun binary virtual modules. */
+export async function loadExtensionModuleWithVirtualModulesForTests(extensionPath) {
+    return loadExtensionModule(extensionPath, true);
+}
+/**
+ * Create an Extension object with empty collections.
+ */
+function createExtension(extensionPath, resolvedPath) {
+    const source = extensionPath.startsWith("<") && extensionPath.endsWith(">")
+        ? extensionPath.slice(1, -1).split(":")[0] || "temporary"
+        : "local";
+    const baseDir = extensionPath.startsWith("<") ? undefined : path.dirname(resolvedPath);
+    return {
+        path: extensionPath,
+        resolvedPath,
+        sourceInfo: createSyntheticSourceInfo(extensionPath, { source, baseDir }),
+        handlers: new Map(),
+        tools: new Map(),
+        messageRenderers: new Map(),
+        commands: new Map(),
+        flags: new Map(),
+        shortcuts: new Map(),
+        eventBusSubscriptions: [],
+    };
+}
+async function loadExtension(extensionPath, cwd, eventBus, runtime) {
+    const resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: true });
+    try {
+        const factory = await loadExtensionModule(resolvedPath);
+        if (!factory) {
+            return { extension: null, error: `Extension does not export a valid factory function: ${extensionPath}` };
+        }
+        const extension = createExtension(extensionPath, resolvedPath);
+        const api = createExtensionAPI(extension, runtime, cwd, eventBus);
+        await factory(api);
+        return { extension, error: null };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { extension: null, error: `Failed to load extension: ${message}` };
+    }
+}
+/**
+ * Create an Extension from an inline factory function.
+ */
+export async function loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath = "<inline>") {
+    const extension = createExtension(extensionPath, extensionPath);
+    const resolvedCwd = resolvePath(cwd);
+    const api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
+    await factory(api);
+    return extension;
+}
+/**
+ * Load extensions from paths.
+ */
+export async function loadExtensions(paths, cwd, eventBus) {
+    const extensions = [];
+    const errors = [];
+    const resolvedCwd = resolvePath(cwd);
+    const resolvedEventBus = eventBus ?? createEventBus();
+    const runtime = createExtensionRuntime();
+    for (const extPath of paths) {
+        const { extension, error } = await loadExtension(extPath, resolvedCwd, resolvedEventBus, runtime);
+        if (error) {
+            errors.push({ path: extPath, error });
+            continue;
+        }
+        if (extension) {
+            extensions.push(extension);
+        }
+    }
+    return {
+        extensions,
+        errors,
+        runtime,
+    };
+}
+function isExtensionFile(name) {
+    return name.endsWith(".ts") || name.endsWith(".js");
+}
+/**
+ * Resolve extension entry points from a directory.
+ *
+ * Checks for:
+ * 1. package.json with "omk.extensions" or "pi.extensions" (omk wins)
+ * 2. index.ts or index.js -> returns the index file
+ *
+ * Returns resolved paths or null if no entry points found.
+ */
+function resolveExtensionEntries(dir) {
+    const packageJsonPath = path.join(dir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        const resolvedManifest = readPackageManifest(packageJsonPath);
+        if (resolvedManifest && (resolvedManifest.key !== null || resolvedManifest.diagnostics.length > 0)) {
+            const entries = [];
+            for (const extPath of resolvedManifest.manifest?.extensions ?? []) {
+                const candidate = path.resolve(dir, extPath);
+                if (!fs.existsSync(candidate))
+                    continue;
+                if (fs.statSync(candidate).isDirectory()) {
+                    for (const indexName of ["index.ts", "index.js", "index.mjs", "index.cjs"]) {
+                        const indexPath = path.join(candidate, indexName);
+                        if (fs.existsSync(indexPath)) {
+                            entries.push(indexPath);
+                            break;
+                        }
+                    }
+                }
+                else {
+                    entries.push(candidate);
+                }
+            }
+            return entries;
+        }
+    }
+    // Check for index.ts or index.js
+    const indexTs = path.join(dir, "index.ts");
+    const indexJs = path.join(dir, "index.js");
+    if (fs.existsSync(indexTs)) {
+        return [indexTs];
+    }
+    if (fs.existsSync(indexJs)) {
+        return [indexJs];
+    }
+    return null;
+}
+/**
+ * Discover extensions in a directory.
+ *
+ * Discovery rules:
+ * 1. Direct files: `extensions/*.ts` or `*.js` → load
+ * 2. Subdirectory with index: `extensions/* /index.ts` or `index.js` → load
+ * 3. Subdirectory with package.json: `extensions/* /package.json` with OMK manifest → load what it declares
+ *
+ * No recursion beyond one level. Complex packages must use package.json manifest.
+ */
+function discoverExtensionsInDir(dir) {
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    const discovered = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(dir, entry.name);
+            // 1. Direct files: *.ts or *.js
+            if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
+                discovered.push(entryPath);
+                continue;
+            }
+            // 2 & 3. Subdirectories
+            if (entry.isDirectory() || entry.isSymbolicLink()) {
+                const entries = resolveExtensionEntries(entryPath);
+                if (entries) {
+                    discovered.push(...entries);
+                }
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return discovered;
+}
+/**
+ * Discover and load extensions from standard locations.
+ */
+export async function discoverAndLoadExtensions(configuredPaths, cwd, agentDir = getAgentDir(), eventBus) {
+    const resolvedCwd = resolvePath(cwd);
+    const resolvedAgentDir = resolvePath(agentDir);
+    const allPaths = [];
+    const seen = new Set();
+    const addPaths = (paths) => {
+        for (const p of paths) {
+            const resolved = path.resolve(p);
+            if (!seen.has(resolved)) {
+                seen.add(resolved);
+                allPaths.push(p);
+            }
+        }
+    };
+    // 1. Project-local extensions: cwd/${CONFIG_DIR_NAME}/extensions/
+    const localExtDir = path.join(resolvedCwd, CONFIG_DIR_NAME, "extensions");
+    addPaths(discoverExtensionsInDir(localExtDir));
+    // 2. Global extensions: agentDir/extensions/
+    const globalExtDir = path.join(resolvedAgentDir, "extensions");
+    addPaths(discoverExtensionsInDir(globalExtDir));
+    // 3. Explicitly configured paths
+    for (const p of configuredPaths) {
+        const resolved = resolvePath(p, resolvedCwd, { normalizeUnicodeSpaces: true });
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+            // Check for package.json with omk manifest or index.ts
+            const entries = resolveExtensionEntries(resolved);
+            if (entries) {
+                addPaths(entries);
+                continue;
+            }
+            // No explicit entries - discover individual files in directory
+            addPaths(discoverExtensionsInDir(resolved));
+            continue;
+        }
+        addPaths([resolved]);
+    }
+    return loadExtensions(allPaths, resolvedCwd, eventBus);
+}
+//# sourceMappingURL=loader.js.map