@mearl/client 2.21.0 → 3.0.0-beta.0

package/dist/pluginModelSessionWorker.js

@@ -1,13 +1,13 @@
-import { readFileSync } from 'node:fs';
-import { serializePluginExecutionError } from './pluginExecutorProtocol.js';
-import { supervisePluginExecutor } from './pluginExecutorSupervisor.js';
+import { CLIENT_VERSION } from './runtimePaths.js';
+import { serializePluginExecutionError } from './plugins/runtime/pluginExecutorProtocol.js';
+import { supervisePluginExecutor } from './plugins/runtime/pluginExecutorSupervisor.js';
 if (process.argv[2] !== '--command') {
     supervisePluginExecutor(import.meta.url);
 }
 else {
     const ready = import('@mearl/agent-runtime/codex').then(runtime => ({
         runtime,
-        provider: new runtime.CodexAgentProvider(() => { }, JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version),
+        provider: new runtime.CodexAgentProvider(() => { }, CLIENT_VERSION),
     }));
     const conversation = {};
     let busy = false;

package/dist/{pluginHostConnection.d.ts → plugins/clients/pluginHostConnection.d.ts}

@@ -1,5 +1,5 @@
-import type { PluginInvocationSource, PluginExecutionHost } from './generated-plugin-execution.js';
-import type { PluginExecutionContext } from './plugin.js';
+import type { PluginInvocationSource, PluginExecutionHost } from '@mearl/browser-core';
+import type { PluginExecutionContext } from '../sdk/plugin.js';
 export interface PluginHostConnectionOptions {
     source?: PluginInvocationSource;
     plugin?: string;

package/dist/{pluginHostConnection.js → plugins/clients/pluginHostConnection.js}

@@ -1,12 +1,12 @@
 import { spawn } from 'node:child_process';
 import { closeSync, mkdirSync, openSync } from 'node:fs';
 import { createConnection } from 'node:net';
-import { fileURLToPath } from 'node:url';
+import { PLUGIN_TASK_HOST_PATH } from '../../runtimePaths.js';
 import { claimRecord, isProcessOwnerAlive, processIdentity, readRecord, removeInvalidRecord, removeRecordIfPid, rotateLogIfNeeded, } from '@mearl/daemon-core';
-import { pluginHostPaths } from './pluginHostPaths.js';
-import { PLUGIN_TASK_PROTOCOL_VERSION } from './generated-plugin-tasks.js';
-import { readPluginTaskMessages, writePluginTaskMessage } from './pluginTaskWire.js';
-import { pluginExecutionError, serializePluginExecutionError } from './pluginExecutorProtocol.js';
+import { pluginHostPaths } from '../runtime/pluginHostPaths.js';
+import { PLUGIN_TASK_PROTOCOL_VERSION } from '@mearl/browser-core';
+import { readPluginTaskMessages, writePluginTaskMessage } from '../pluginTaskWire.js';
+import { pluginExecutionError, serializePluginExecutionError, } from '../runtime/pluginExecutorProtocol.js';
 const starting = new Map();
 async function ensureHost(runtimePath) {
     const paths = pluginHostPaths();
@@ -112,8 +112,7 @@ export class PluginHostConnection {
             if (!['ENOENT', 'ECONNREFUSED', 'PLUGIN_TASK_CONNECTION_LOST'].includes(code ?? ''))
                 throw error;
         }
-        await ensureHost(this.configuration.runtimePath ??
-            fileURLToPath(new URL('./plugin-task-host.js', import.meta.url)));
+        await ensureHost(this.configuration.runtimePath ?? PLUGIN_TASK_HOST_PATH);
         const deadline = Date.now() + 10000;
         let failure;
         do {

package/dist/{pluginModels.d.ts → plugins/clients/pluginModels.d.ts}

@@ -1,9 +1,9 @@
 import type { PluginHostClientOptions } from './pluginHostConnection.js';
 import { PluginTaskClient } from './pluginTasks.js';
 import type { PluginTaskStartOptions, PluginTaskWaitOptions } from './pluginTasks.js';
-import type { PluginModelRequest, PluginModelResult, PluginModelCapability, PluginModelList } from './generated-plugin-models.js';
-import type { PluginTaskStartResult } from './generated-plugin-tasks.js';
-export type * from './generated-plugin-models.js';
+import type { PluginModelRequest, PluginModelResult, PluginModelCapability, PluginModelList } from '@mearl/browser-core';
+import type { PluginTaskStartResult } from '@mearl/browser-core';
+export type * from '@mearl/browser-core';
 export declare class PluginModelClient {
     readonly tasks: PluginTaskClient;
     constructor(options?: PluginHostClientOptions);

package/dist/{pluginPages.d.ts → plugins/clients/pluginPages.d.ts}

@@ -1,7 +1,7 @@
 import type { PluginHostConnection } from './pluginHostConnection.js';
-import type { UnifiedClientOptions, UnifiedInvokeOptions } from './unified.js';
-import type { PluginPageInstance, PluginPageEvents, PluginPageOperation } from './generated-plugin-pages.js';
-export type { PluginPageInstance, PluginPageEvents, PluginPageRuntime, PluginPageActivation, PluginPageTarget, PluginPageOperation, } from './generated-plugin-pages.js';
+import type { UnifiedClientOptions, UnifiedInvokeOptions } from '../../unified.js';
+import type { PluginPageInstance, PluginPageEvents, PluginPageOperation } from '@mearl/browser-core';
+export type { PluginPageInstance, PluginPageEvents, PluginPageRuntime, PluginPageActivation, PluginPageTarget, PluginPageOperation, } from '@mearl/browser-core';
 export declare class PluginPageClient {
     private readonly connection?;
     private readonly client?;

package/dist/{pluginPages.js → plugins/clients/pluginPages.js}

@@ -1,4 +1,4 @@
-import { UnifiedClient } from './unified.js';
+import { UnifiedClient } from '../../unified.js';
 export class PluginPageClient {
     connection;
     client;

package/dist/{pluginState.d.ts → plugins/clients/pluginState.d.ts}

@@ -1,8 +1,8 @@
 import { PluginHostConnection } from './pluginHostConnection.js';
 import type { PluginHostClientOptions } from './pluginHostConnection.js';
-import type { PluginOptions } from './plugin.js';
-import type { PluginStateOperation, PluginStateSnapshot, PluginStateList, PluginStateTransaction } from './generated-plugin-state.js';
-export type * from './generated-plugin-state.js';
+import type { PluginOptions } from '../sdk/plugin.js';
+import type { PluginStateOperation, PluginStateSnapshot, PluginStateList, PluginStateTransaction } from '@mearl/browser-core';
+export type * from '@mearl/browser-core';
 export declare class PluginStateClient {
     private readonly options;
     readonly connection: PluginHostConnection;

package/dist/{pluginTasks.d.ts → plugins/clients/pluginTasks.d.ts}

@@ -1,9 +1,9 @@
 import { PluginHostConnection } from './pluginHostConnection.js';
 import type { PluginHostClientOptions, HostStatus as PluginHostStatus } from './pluginHostConnection.js';
-import type { PluginTaskCheckpoint } from './generated-plugin-recovery.js';
-import type { PluginDiagnosticOptions, PluginDiagnosticReport } from './generated-plugin-diagnostics.js';
-import type { PluginTask, PluginTaskEvents, PluginTaskListResult, PluginTaskResultChunk, PluginTaskStartResult } from './generated-plugin-tasks.js';
-import type { PluginInvocation, PluginOptions } from './plugin.js';
+import type { PluginTaskCheckpoint } from '@mearl/browser-core';
+import type { PluginDiagnosticOptions, PluginDiagnosticReport } from '@mearl/browser-core';
+import type { PluginTask, PluginTaskEvents, PluginTaskListResult, PluginTaskResultChunk, PluginTaskStartResult } from '@mearl/browser-core';
+import type { PluginInvocation, PluginOptions } from '../sdk/plugin.js';
 export type { PluginTask, PluginTaskEvents, PluginTaskListResult, PluginTaskStartResult };
 export interface PluginTaskStartOptions extends PluginOptions {
     cwd?: string;

package/dist/{pluginTasks.js → plugins/clients/pluginTasks.js}

@@ -1,10 +1,10 @@
 import { PluginHostConnection } from './pluginHostConnection.js';
 import { createHash } from 'node:crypto';
 import { isProcessOwnerAlive, readRecord } from '@mearl/daemon-core';
-import { pluginHostPaths } from './pluginHostPaths.js';
-import { UnifiedClient, decodeBrowserTarget } from './unified.js';
-import { isPluginTaskActive } from './generated-plugin-tasks.js';
-import { pluginExecutionError } from './pluginExecutorProtocol.js';
+import { pluginHostPaths } from '../runtime/pluginHostPaths.js';
+import { UnifiedClient, decodeBrowserTarget } from '../../unified.js';
+import { isPluginTaskActive } from '@mearl/browser-core';
+import { pluginExecutionError } from '../runtime/pluginExecutorProtocol.js';
 function localWait(promise, signal, timeoutMs = Infinity) {
     return new Promise((resolve, reject) => {
         const abort = () => {

package/dist/plugins/officialPluginCatalog.d.ts

@@ -0,0 +1,25 @@
+export declare const OFFICIAL_PLUGIN_MANAGER = "@mearl/setup:official";
+export interface OfficialPluginDefinition {
+    description: string;
+    installArgs: readonly string[];
+    setup?: string;
+    skill: string;
+}
+export type OfficialPluginName = string;
+export declare const OFFICIAL_PLUGINS: Record<string, OfficialPluginDefinition>;
+export interface PluginCatalogSelection {
+    path: string;
+    sha256: string;
+}
+export interface PluginCatalog {
+    schemaVersion: 1;
+    revision: string;
+    plugins: Record<string, OfficialPluginDefinition>;
+    selection?: PluginCatalogSelection;
+}
+export declare function validateOfficialPluginCatalog(value: unknown): PluginCatalog;
+export declare function readOfficialPluginCatalog(): PluginCatalog | undefined;
+/** Installation hosts persist only the catalog selected by an approved preset. */
+export declare function replaceOfficialPluginCatalog(revision: string, plugins: Record<string, OfficialPluginDefinition>, selection?: PluginCatalogSelection): void;
+export declare function findOfficialPlugin(name: string): OfficialPluginDefinition | undefined;
+export declare function listOfficialPluginNames(setup?: string): string[];

package/dist/plugins/officialPluginCatalog.js

@@ -0,0 +1,125 @@
+import { constants, closeSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { isAbsolute, join } from 'node:path';
+import { assertPluginName, pluginDirectory } from './pluginRegistry.js';
+export const OFFICIAL_PLUGIN_MANAGER = '@mearl/setup:official';
+export const OFFICIAL_PLUGINS = {};
+const MAX_CATALOG_BYTES = 256 * 1024;
+const catalogPath = () => join(pluginDirectory(), '.official-catalog.json');
+export function validateOfficialPluginCatalog(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid managed plugin catalog');
+    const input = value;
+    if (input.schemaVersion !== 1 || typeof input.revision !== 'string' || !/^[a-f0-9]{64}$/.test(input.revision) ||
+        !input.plugins || typeof input.plugins !== 'object' || Array.isArray(input.plugins) ||
+        Object.keys(input).some(key => !['schemaVersion', 'revision', 'plugins', 'selection'].includes(key)) || Object.keys(input.plugins).length > 200)
+        throw new Error('Invalid managed plugin catalog');
+    const selection = input.selection;
+    if (selection !== undefined && (!selection || typeof selection !== 'object' || Array.isArray(selection) || Object.keys(selection).some(key => !['path', 'sha256'].includes(key)) || typeof selection.path !== 'string' || !isAbsolute(selection.path) || selection.path.length > 4096 || /[\0\r\n]/.test(selection.path) || typeof selection.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(selection.sha256)))
+        throw new Error('Invalid plugin catalog selection');
+    const plugins = {};
+    for (const [name, value] of Object.entries(input.plugins)) {
+        assertPluginName(name);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('Invalid managed plugin declaration');
+        const item = value;
+        if (Object.keys(item).some(key => !['description', 'installArgs', 'setup', 'skill'].includes(key)) ||
+            typeof item.description !== 'string' || item.description.length > 1000 ||
+            typeof item.skill !== 'string' || !/^[a-z][a-z0-9-]*$/.test(item.skill) ||
+            !Array.isArray(item.installArgs) || item.installArgs.length === 0 || item.installArgs.length > 32 ||
+            item.installArgs.some(arg => typeof arg !== 'string' || arg.length > 2048 || /[\0\r\n]/.test(arg)) ||
+            (item.setup !== undefined && (typeof item.setup !== 'string' || !/^[a-z][a-z0-9-]*$/.test(item.setup))))
+            throw new Error('Invalid managed plugin declaration');
+        plugins[name] = { description: item.description, skill: item.skill, installArgs: [...item.installArgs], ...(item.setup !== undefined && { setup: item.setup }) };
+    }
+    const catalog = { schemaVersion: 1, revision: input.revision, plugins, ...(selection ? { selection: { path: selection.path, sha256: selection.sha256 } } : {}) };
+    if (Buffer.byteLength(JSON.stringify(catalog)) > MAX_CATALOG_BYTES)
+        throw new Error('Managed plugin catalog exceeds 256 KiB');
+    return catalog;
+}
+function selectionMatches(selection) {
+    try {
+        const before = lstatSync(selection.path);
+        if (!before.isFile() || before.isSymbolicLink() || before.size > 1024 * 1024)
+            return false;
+        const fd = openSync(selection.path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const stat = fstatSync(fd);
+            if (!stat.isFile() || stat.size > 1024 * 1024)
+                return false;
+            const bytes = Buffer.alloc(stat.size + 1);
+            let size = 0;
+            while (size < bytes.length) {
+                const count = readSync(fd, bytes, size, bytes.length - size, null);
+                if (!count)
+                    break;
+                size += count;
+            }
+            return size === stat.size && createHash('sha256').update(bytes.subarray(0, size)).digest('hex') === selection.sha256;
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+export function readOfficialPluginCatalog() {
+    let source;
+    try {
+        source = readFileSync(catalogPath(), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    if (Buffer.byteLength(source) > MAX_CATALOG_BYTES)
+        throw new Error('Managed plugin catalog exceeds 256 KiB');
+    const catalog = validateOfficialPluginCatalog(JSON.parse(source));
+    return catalog.selection && !selectionMatches(catalog.selection) ? undefined : catalog;
+}
+/** Installation hosts persist only the catalog selected by an approved preset. */
+export function replaceOfficialPluginCatalog(revision, plugins, selection) {
+    const catalog = validateOfficialPluginCatalog({ schemaVersion: 1, revision, plugins, ...(selection ? { selection } : {}) });
+    const content = JSON.stringify(catalog);
+    if (Buffer.byteLength(content) > MAX_CATALOG_BYTES)
+        throw new Error('Managed plugin catalog exceeds 256 KiB');
+    if (catalog.selection && !selectionMatches(catalog.selection))
+        throw new Error('PLUGIN_CATALOG_SELECTION_CHANGED');
+    mkdirSync(pluginDirectory(), { recursive: true, mode: 0o700 });
+    const file = catalogPath();
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, content, { mode: 0o600, flag: 'wx' });
+        if (catalog.selection && !selectionMatches(catalog.selection))
+            throw new Error('PLUGIN_CATALOG_SELECTION_CHANGED');
+        renameSync(temporary, file);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+    refreshOfficialPlugins();
+}
+function refreshOfficialPlugins() {
+    let plugins = {};
+    try {
+        plugins = readOfficialPluginCatalog()?.plugins ?? {};
+    }
+    catch { /* An invalid optional catalog cannot disable registered plugin or browser commands. */ }
+    for (const name of Object.keys(OFFICIAL_PLUGINS))
+        delete OFFICIAL_PLUGINS[name];
+    Object.assign(OFFICIAL_PLUGINS, plugins);
+    return OFFICIAL_PLUGINS;
+}
+refreshOfficialPlugins();
+export function findOfficialPlugin(name) {
+    const plugins = refreshOfficialPlugins();
+    return Object.hasOwn(plugins, name) ? plugins[name] : undefined;
+}
+export function listOfficialPluginNames(setup) {
+    return Object.entries(refreshOfficialPlugins()).filter(([, item]) => setup === undefined || item.setup === setup).map(([name]) => name);
+}

package/dist/{officialPluginInstaller.js → plugins/officialPluginInstaller.js}

@@ -1,11 +1,9 @@
 import { closeSync, mkdirSync, openSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
+import { CLIENT_VERSION } from '../runtimePaths.js';
 import { join } from 'node:path';
 import { spawn } from 'node:child_process';
-import { findOfficialPlugin } from './officialPluginCatalog.js';
+import { findOfficialPlugin, readOfficialPluginCatalog } from './officialPluginCatalog.js';
 import { findPluginRegistration, pluginDirectory } from './pluginRegistry.js';
-const require = createRequire(import.meta.url);
-const CLIENT_VERSION = require('../package.json').version;
 const INSTALL_TIMEOUT_MS = 180_000;
 const INSTALL_LOCK_STALE_MS = 5 * 60_000;
 const MAX_INSTALL_OUTPUT = 1024 * 1024;
@@ -107,8 +105,13 @@ async function installOfficialPlugin(name, progress) {
     try {
         if (findPluginRegistration(name))
             return;
+        const accepted = JSON.stringify(readOfficialPluginCatalog());
+        if (!findOfficialPlugin(name))
+            throw new Error('PLUGIN_CATALOG_SELECTION_CHANGED');
         progress?.(`正在安装官方插件 ${name}...`);
         await installWithSetup(name);
+        if (JSON.stringify(readOfficialPluginCatalog()) !== accepted)
+            throw new Error('PLUGIN_CATALOG_SELECTION_CHANGED');
         if (!findPluginRegistration(name)) {
             throw new Error(`官方插件 ${name} 安装完成后仍未注册`);
         }

package/dist/{pluginRegistry.d.ts → plugins/pluginRegistry.d.ts}

@@ -1,4 +1,4 @@
-import { type AppProfileContribution } from './generated-app-profile-definition.js';
+import { type AppProfileContribution } from '@mearl/browser-core';
 export declare class PluginError extends Error {
     readonly code: string;
     constructor(code: string, message: string);

package/dist/{pluginRegistry.js → plugins/pluginRegistry.js}

@@ -1,10 +1,10 @@
-import { validateAppProfileContribution, } from './generated-app-profile-definition.js';
+import { validateAppProfileContribution, } from '@mearl/browser-core';
 import { randomUUID } from 'node:crypto';
-import { parseToolboxIcon } from './generated-toolbox-icon.js';
+import { parseToolboxIcon } from '@mearl/browser-core';
 import { closeSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
-import { COMMAND_MAP } from './commands.js';
+import { COMMAND_MAP } from '../commands.js';
 import { buildPluginPageBundle, PLUGIN_PAGE_CHUNK_BYTES, PLUGIN_PAGE_RUNTIME_HASH, } from './pluginPageBundle.js';
 import { pluginFileVersion } from './pluginSource.js';
 const RESERVED_NAMES = new Set([

package/dist/{pluginTaskProtocol.d.ts → plugins/pluginTaskProtocol.d.ts}

@@ -1,5 +1,5 @@
-import type { PluginExecutionError, PluginInvocationSource } from './generated-plugin-execution.js';
-import type { PluginOptions } from './plugin.js';
+import type { PluginExecutionError, PluginInvocationSource } from '@mearl/browser-core';
+import type { PluginOptions } from './sdk/plugin.js';
 export interface PluginTaskScope {
     access: 'public' | 'toolbox' | 'runtime';
     plugin?: string;

package/dist/{pluginCommandWorker.js → plugins/runtime/pluginCommandWorker.js}

@@ -1,6 +1,6 @@
-import { pluginRecoverySignature } from './pluginRecoveryDefinition.js';
-import { loadPlugin, findPluginRegistration, invokeRegisteredPlugin, invokeRegisteredToolboxPlugin, invokeRegisteredRuntimePlugin, invokeRegisteredRecoveryPlugin, } from './plugin.js';
-import { pluginFileVersion } from './pluginSource.js';
+import { pluginRecoverySignature } from '../sdk/pluginRecoveryDefinition.js';
+import { loadPlugin, findPluginRegistration, invokeRegisteredPlugin, invokeRegisteredToolboxPlugin, invokeRegisteredRuntimePlugin, invokeRegisteredRecoveryPlugin, } from '../sdk/plugin.js';
+import { pluginFileVersion } from '../pluginSource.js';
 import { MAX_PLUGIN_RESULT_BYTES, pluginExecutionError, serializePluginExecutionError, } from './pluginExecutorProtocol.js';
 const controller = new AbortController();
 const pending = new Map();

package/dist/{pluginDiagnostics.d.ts → plugins/runtime/pluginDiagnostics.d.ts}

@@ -1,8 +1,8 @@
-import type { PluginModelDiagnostic } from './generated-plugin-models.js';
-import type { PluginDiagnosticFailure, PluginDiagnosticOptions, PluginDiagnosticPage, PluginDiagnosticPageBinding, PluginDiagnosticReport } from './generated-plugin-diagnostics.js';
+import type { PluginModelDiagnostic } from '@mearl/browser-core';
+import type { PluginDiagnosticFailure, PluginDiagnosticOptions, PluginDiagnosticPage, PluginDiagnosticPageBinding, PluginDiagnosticReport } from '@mearl/browser-core';
 import type { PluginTaskRecord } from './pluginTaskStore.js';
-import type { PluginTaskScope } from './pluginTaskProtocol.js';
-import type { PluginExecutionHost } from './generated-plugin-execution.js';
+import type { PluginTaskScope } from '../pluginTaskProtocol.js';
+import type { PluginExecutionHost } from '@mearl/browser-core';
 export declare const MAX_PLUGIN_DIAGNOSTIC_BYTES: number;
 export declare function normalizeDiagnosticOptions(value: unknown): PluginDiagnosticOptions;
 export declare function diagnosticFailure(value: {

package/dist/{pluginDiagnostics.js → plugins/runtime/pluginDiagnostics.js}

@@ -1,7 +1,7 @@
 import { isProcessOwnerAlive } from '@mearl/daemon-core';
 import { basename } from 'node:path';
-import { isPluginTaskId, PLUGIN_TASK_PROTOCOL_VERSION } from './generated-plugin-tasks.js';
-import { isPluginPageInstanceId } from './generated-plugin-pages.js';
+import { isPluginTaskId, PLUGIN_TASK_PROTOCOL_VERSION } from '@mearl/browser-core';
+import { isPluginPageInstanceId } from '@mearl/browser-core';
 export const MAX_PLUGIN_DIAGNOSTIC_BYTES = 256 * 1024;
 function text(value, maximum = 256) {
     if (typeof value !== 'string')

package/dist/{pluginExecution.d.ts → plugins/runtime/pluginExecution.d.ts}

@@ -1,6 +1,6 @@
-import type { PluginExecutionHost, PluginInvocationIdentity, PluginInvocationSource } from './generated-plugin-execution.js';
-import type { PluginApp } from './plugin.js';
-import type { PluginTaskRecoveryContext } from './generated-plugin-recovery.js';
+import type { PluginExecutionHost, PluginInvocationIdentity, PluginInvocationSource } from '@mearl/browser-core';
+import type { PluginApp } from '../sdk/plugin.js';
+import type { PluginTaskRecoveryContext } from '@mearl/browser-core';
 export type { PluginExecutionHost, PluginInvocationIdentity, PluginInvocationSource };
 export interface PluginCommandContext extends Pick<PluginApp, 'invoke' | 'progress'> {
     readonly identity: Readonly<PluginInvocationIdentity>;

package/dist/{pluginExecution.js → plugins/runtime/pluginExecution.js}

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { linkSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { pluginDirectory } from './pluginRegistry.js';
+import { pluginDirectory } from '../pluginRegistry.js';
 const epoch = randomUUID();
 const hostIds = new Map();
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

package/dist/{pluginExecutor.d.ts → plugins/runtime/pluginExecutor.d.ts}

@@ -1,6 +1,6 @@
-import type { PluginModelDiagnostic, PluginModelRequest } from './generated-plugin-models.js';
-import { type PluginRegistration } from './pluginRegistry.js';
-import type { PluginExecutionContext, PluginInvocation, PluginInvokeOptions } from './plugin.js';
+import type { PluginModelDiagnostic, PluginModelRequest } from '@mearl/browser-core';
+import { type PluginRegistration } from '../pluginRegistry.js';
+import type { PluginExecutionContext, PluginInvocation, PluginInvokeOptions } from '../sdk/plugin.js';
 export interface PluginExecutorDependencies {
     stopProcessTree?: (pid: number) => Promise<void>;
     registration?: PluginRegistration;

package/dist/{pluginExecutor.js → plugins/runtime/pluginExecutor.js}

@@ -1,7 +1,7 @@
 import { fork } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { findPluginRegistration, PluginError } from './pluginRegistry.js';
-import { pluginFileVersion } from './pluginSource.js';
+import { PLUGIN_WORKER_PATH } from '../../runtimePaths.js';
+import { findPluginRegistration, PluginError } from '../pluginRegistry.js';
+import { pluginFileVersion } from '../pluginSource.js';
 import { createPluginInvocationIdentity } from './pluginExecution.js';
 import { pluginExecutionError, serializePluginExecutionError } from './pluginExecutorProtocol.js';
 import { stopPluginProcessTree } from './pluginProcessTree.js';
@@ -24,7 +24,7 @@ export async function executeRegisteredPlugin(plugin, invocation, context, optio
         createPluginInvocationIdentity(plugin, source ?? context.source ?? 'sdk', context.parentInvocation);
     const entryVersion = pluginFileVersion(registration.entry);
     return new Promise((resolve, reject) => {
-        const child = fork(workerPath ?? fileURLToPath(new URL('./plugin-worker.js', import.meta.url)), [], {
+        const child = fork(workerPath ?? PLUGIN_WORKER_PATH, [], {
             stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
             serialization: 'advanced',
             execArgv: [],

package/dist/{pluginExecutorProtocol.d.ts → plugins/runtime/pluginExecutorProtocol.d.ts}

@@ -1,7 +1,7 @@
-import type { PluginModelDiagnostic, PluginModelRequest } from './generated-plugin-models.js';
-import type { PluginInvocationIdentity, PluginExecutionError } from './generated-plugin-execution.js';
-import type { PluginInvocation, PluginOptions, PluginProgress } from './plugin.js';
-import type { PluginRegistration } from './pluginRegistry.js';
+import type { PluginModelDiagnostic, PluginModelRequest } from '@mearl/browser-core';
+import type { PluginInvocationIdentity, PluginExecutionError } from '@mearl/browser-core';
+import type { PluginInvocation, PluginOptions, PluginProgress } from '../sdk/plugin.js';
+import type { PluginRegistration } from '../pluginRegistry.js';
 export type PluginWorkerRequest = {
     type: 'start';
     plugin: string;

package/dist/{pluginHost.d.ts → plugins/runtime/pluginHost.d.ts}

@@ -4,8 +4,8 @@ import { PluginStateManager } from './pluginStateManager.js';
 import { PluginPageManager } from './pluginPageManager.js';
 import { PluginModelCatalog } from './pluginModelCatalog.js';
 import { PluginModelSessions } from './pluginModelSessions.js';
-import type { PluginDiagnosticOptions } from './generated-plugin-diagnostics.js';
-import type { PluginTaskScope } from './pluginTaskProtocol.js';
+import type { PluginDiagnosticOptions } from '@mearl/browser-core';
+import type { PluginTaskScope } from '../pluginTaskProtocol.js';
 /** The host owns service composition; task execution receives explicit service dependencies. */
 export declare class PluginHost {
     readonly tasks: PluginTaskManager;
@@ -15,6 +15,6 @@ export declare class PluginHost {
     readonly modelSessions: PluginModelSessions;
     private closing?;
     constructor(configuration?: PluginTaskManagerOptions);
-    diagnose(value: PluginDiagnosticOptions, scope: PluginTaskScope): import("./generated-plugin-diagnostics.js").PluginDiagnosticReport;
+    diagnose(value: PluginDiagnosticOptions, scope: PluginTaskScope): import("@mearl/browser-core").PluginDiagnosticReport;
     close(): Promise<void>;
 }

package/dist/{pluginHostPaths.js → plugins/runtime/pluginHostPaths.js}

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { pluginDirectory } from './pluginRegistry.js';
+import { pluginDirectory } from '../pluginRegistry.js';
 export function pluginHostPaths() {
     const registry = pluginDirectory();
     const key = createHash('sha256').update(registry).digest('hex').slice(0, 16);

package/dist/{pluginHostServer.js → plugins/runtime/pluginHostServer.js}

@@ -2,10 +2,10 @@ import { randomUUID } from 'node:crypto';
 import { createServer } from 'node:net';
 import { chmodSync, rmSync } from 'node:fs';
 import { claimRecord, isProcessOwnerAlive, processIdentity, readRecord, removeInvalidRecord, removeRecordIfPid, writeRecordIfPid, } from '@mearl/daemon-core';
-import { PLUGIN_TASK_PROTOCOL_VERSION } from './generated-plugin-tasks.js';
+import { PLUGIN_TASK_PROTOCOL_VERSION } from '@mearl/browser-core';
 import { pluginHostPaths } from './pluginHostPaths.js';
 import { PluginHost } from './pluginHost.js';
-import { readPluginTaskMessages, writePluginTaskMessage } from './pluginTaskWire.js';
+import { readPluginTaskMessages, writePluginTaskMessage } from '../pluginTaskWire.js';
 import { pluginExecutionError, serializePluginExecutionError } from './pluginExecutorProtocol.js';
 export async function startPluginHostServer(configuration = {}) {
     const paths = pluginHostPaths();
@@ -122,7 +122,7 @@ export async function startPluginHostServer(configuration = {}) {
             if (method === 'model.list')
                 return models.list(input.provider);
             if (method === 'model.capabilities')
-                return (await import('./pluginModelDefinition.js')).pluginModelCapabilities();
+                return (await import('../sdk/pluginModelDefinition.js')).pluginModelCapabilities();
             if (method === 'page.call') {
                 const execution = input.execution;
                 return pages.call(String(input.plugin), input.input, bridge, input.options, execution

package/dist/{pluginModelCatalog.d.ts → plugins/runtime/pluginModelCatalog.d.ts}

@@ -1,4 +1,4 @@
-import type { PluginModelList, PluginModelOption } from './generated-plugin-models.js';
+import type { PluginModelList, PluginModelOption } from '@mearl/browser-core';
 /** A bounded shared lookup avoids starting a discovery process for each open tool. */
 export declare class PluginModelCatalog {
     private readonly discover;

package/dist/{pluginModelSessions.js → plugins/runtime/pluginModelSessions.js}

@@ -1,10 +1,10 @@
 import { fork } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
+import { PLUGIN_MODEL_SESSION_WORKER_PATH } from '../../runtimePaths.js';
 import { processIdentity } from '@mearl/daemon-core';
 import { pluginExecutionError } from './pluginExecutorProtocol.js';
 import { stopPluginProcessTree } from './pluginProcessTree.js';
-import { validatePluginModelResult } from './pluginModelDefinition.js';
+import { validatePluginModelResult } from '../sdk/pluginModelDefinition.js';
 /** Opt-in conversations retain a supervised process and thread within one execution owner. */
 export class PluginModelSessions {
     idleMs;
@@ -13,7 +13,7 @@ export class PluginModelSessions {
     sessions = new Map();
     closing = new Set();
     closed = false;
-    constructor(idleMs = 5 * 60_000, limit = 2, workerPath = fileURLToPath(new URL('./pluginModelSessionWorker.js', import.meta.url))) {
+    constructor(idleMs = 5 * 60_000, limit = 2, workerPath = PLUGIN_MODEL_SESSION_WORKER_PATH) {
         this.idleMs = idleMs;
         this.limit = limit;
         this.workerPath = workerPath;

package/dist/{pluginPageManager.d.ts → plugins/runtime/pluginPageManager.d.ts}

@@ -1,9 +1,9 @@
-import type { PluginDiagnosticPage } from './generated-plugin-diagnostics.js';
+import type { PluginDiagnosticPage } from '@mearl/browser-core';
 import type { PluginStateManager } from './pluginStateManager.js';
-import type { PluginInvocationIdentity } from './generated-plugin-execution.js';
+import type { PluginInvocationIdentity } from '@mearl/browser-core';
 import type { PluginRevision } from './pluginRevision.js';
-import type { PluginOptions } from './plugin.js';
-import type { PluginPageTarget } from './generated-plugin-pages.js';
+import type { PluginOptions } from '../sdk/plugin.js';
+import type { PluginPageTarget } from '@mearl/browser-core';
 import type { PluginTaskBridge, PluginTaskManager } from './pluginTaskManager.js';
 interface Execution {
     cwd: string;

package/dist/{pluginPageManager.js → plugins/runtime/pluginPageManager.js}

@@ -4,13 +4,13 @@ import { EventEmitter } from 'node:events';
 import { readFileSync, statSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
 import { capturePluginRevision } from './pluginRevision.js';
-import { findPluginRegistration } from './plugin.js';
-import { compilePluginPageSchema } from './pluginPageDefinition.js';
-import { UnifiedClient, decodeBrowserTarget } from './unified.js';
+import { findPluginRegistration } from '../sdk/plugin.js';
+import { compilePluginPageSchema } from '../sdk/pluginPageDefinition.js';
+import { UnifiedClient, decodeBrowserTarget } from '../../unified.js';
 import { pluginHostPaths } from './pluginHostPaths.js';
 import { serializePluginExecutionError, pluginExecutionError } from './pluginExecutorProtocol.js';
-import { isPluginTaskActive } from './generated-plugin-tasks.js';
-import { isPluginPageInstanceId, matchesPluginPageURL, isPluginPageInvalidation, isPluginPageUnavailable, pluginPageUnavailable, PLUGIN_PAGE_LEASE_MS, } from './generated-plugin-pages.js';
+import { isPluginTaskActive } from '@mearl/browser-core';
+import { isPluginPageInstanceId, matchesPluginPageURL, isPluginPageInvalidation, isPluginPageUnavailable, pluginPageUnavailable, PLUGIN_PAGE_LEASE_MS, } from '@mearl/browser-core';
 function failure(code, message) {
     return Object.assign(new Error(message), { code });
 }

package/dist/{pluginRevision.d.ts → plugins/runtime/pluginRevision.d.ts}

@@ -1,4 +1,4 @@
-import type { PluginRegistration } from './pluginRegistry.js';
+import type { PluginRegistration } from '../pluginRegistry.js';
 export interface PluginRevision {
     plugin: string;
     installationId: string;

package/dist/{pluginRevision.js → plugins/runtime/pluginRevision.js}

@@ -5,7 +5,8 @@ import { claimRecord, readRecord, writeRecord } from '@mearl/daemon-core';
 import { isBuiltin } from 'node:module';
 import { parse } from 'acorn';
 import { pluginHostPaths } from './pluginHostPaths.js';
-import { findPluginRegistration, PluginError } from './pluginRegistry.js';
+import { skillManifestPath } from '../skillManifest.js';
+import { findPluginRegistration, PluginError } from '../pluginRegistry.js';
 const MAX_REVISION_BYTES = 64 * 1024 * 1024;
 const validatedSources = new Set();
 function within(root, file) {
@@ -15,7 +16,7 @@ function within(root, file) {
 function sourceRoot(entry) {
     let candidate = dirname(entry);
     for (let depth = 0; depth < 6; depth++) {
-        if (existsSync(join(candidate, 'SKILL.md')))
+        if (skillManifestPath(candidate))
             return candidate;
         const parent = dirname(candidate);
         if (parent === candidate)

package/dist/{pluginRuntimeCleanup.js → plugins/runtime/pluginRuntimeCleanup.js}

@@ -2,8 +2,8 @@ import { rmSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { claimRecord, isProcessOwnerAlive, processIdentity, readRecord, removeInvalidRecord, removeRecordIfPid, } from '@mearl/daemon-core';
 import { pluginHostPaths } from './pluginHostPaths.js';
-import { listPluginNames } from './pluginRegistry.js';
-import { PluginTaskClient } from './pluginTasks.js';
+import { listPluginNames } from '../pluginRegistry.js';
+import { PluginTaskClient } from '../clients/pluginTasks.js';
 import { PluginTaskStore, pluginTaskExecutionUnconfirmed } from './pluginTaskStore.js';
 /** Complete uninstall discards execution caches after every plugin has been removed. */
 export async function cleanupPluginRuntime() {