@nexrall/code-core 1.0.0

package/dist/mcp/sseClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sseClient.d.ts","sourceRoot":"","sources":["../../src/mcp/sseClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AA6BjF,qBAAa,YAAa,YAAW,YAAY;IAWrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAVjD,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0H;IACnJ,OAAO,CAAC,eAAe,CAAoE;IAC3F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAmB,MAAM,EAAE,eAAe;IAIlE,IAAI,KAAK,IAAI,iBAAiB,EAAE,CAE/B;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAc5E,UAAU,IAAI,IAAI;IAalB,4EAA4E;YAC9D,WAAW;IAoCzB,OAAO,CAAC,eAAe;IAYvB,oFAAoF;IACpF,OAAO,CAAC,KAAK;IAWb,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,cAAc;IAuCtB,OAAO,CAAC,IAAI;YAgBE,OAAO;IAIrB,6EAA6E;YAC/D,YAAY;CAwB3B"}

package/dist/mcp/sseClient.js

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpSseClient = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const httpClient_1 = require("./httpClient");
+const REQUEST_TIMEOUT_MS = 30000;
+const ENDPOINT_TIMEOUT_MS = 15000;
+class McpSseClient {
+    constructor(name, config) {
+        this.config = config;
+        this._nextId = 1;
+        this._tools = [];
+        this._endpointUrl = null;
+        this._abort = null;
+        this._sseBuf = '';
+        this._closed = false;
+        this._pending = new Map();
+        this._endpointWaiter = null;
+        this.name = name;
+    }
+    get tools() {
+        return this._tools;
+    }
+    async connect() {
+        if (!this.config.url)
+            throw new Error(`MCP server "${this.name}" has no url (sse transport requires one).`);
+        await this._openStream();
+        await this._rpc('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'nexrall-code', version: '1.0' },
+        });
+        await this._notify('notifications/initialized');
+        const res = (await this._rpc('tools/list', {}));
+        this._tools = res?.tools ?? [];
+    }
+    async callTool(name, args) {
+        const result = (await this._rpc('tools/call', { name, arguments: args }));
+        if (!result)
+            return '';
+        const text = (result.content ?? [])
+            .filter((c) => c.type === 'text')
+            .map((c) => c.text ?? '')
+            .join('\n');
+        if (result.isError)
+            throw new Error(text || 'MCP tool returned an error');
+        return text;
+    }
+    disconnect() {
+        this._closed = true;
+        this._abort?.abort();
+        this._abort = null;
+        for (const { reject, timer } of this._pending.values()) {
+            clearTimeout(timer);
+            reject(new Error('MCP SSE connection closed'));
+        }
+        this._pending.clear();
+    }
+    // ─── Private ──────────────────────────────────────────────────────────────
+    /** Open the GET event stream and wait for the server's `endpoint` event. */
+    async _openStream() {
+        const controller = new AbortController();
+        this._abort = controller;
+        const headers = {
+            Accept: 'text/event-stream',
+            ...(this.config.headers ?? {}),
+        };
+        const resp = await (0, node_fetch_1.default)(this.config.url, { method: 'GET', headers, signal: controller.signal });
+        if (!resp.ok) {
+            if (resp.status === 401) {
+                throw new httpClient_1.McpOAuthRequiredError(this.name, this.config.url, resp.headers.get('www-authenticate') ?? '');
+            }
+            const body = await resp.text().catch(() => '');
+            throw new Error(`MCP SSE HTTP ${resp.status} ${resp.statusText}${body ? `: ${body.slice(0, 200)}` : ''}`);
+        }
+        if (!resp.body)
+            throw new Error('MCP SSE response has no body stream');
+        const stream = resp.body;
+        stream.on('data', (chunk) => this._feed(chunk.toString('utf-8')));
+        stream.on('end', () => this._onStreamClosed(new Error('MCP SSE stream ended')));
+        stream.on('error', (err) => { if (!this._closed)
+            this._onStreamClosed(err); });
+        // Wait for the `endpoint` event so we know where to POST messages.
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this._endpointWaiter = null;
+                reject(new Error('Timed out waiting for SSE endpoint event'));
+            }, ENDPOINT_TIMEOUT_MS);
+            this._endpointWaiter = {
+                resolve: () => { clearTimeout(timer); resolve(); },
+                reject: (e) => { clearTimeout(timer); reject(e); },
+            };
+        });
+    }
+    _onStreamClosed(err) {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this._endpointWaiter?.reject(err);
+        this._endpointWaiter = null;
+        for (const { reject, timer } of this._pending.values()) {
+            clearTimeout(timer);
+            reject(err);
+        }
+        this._pending.clear();
+    }
+    /** Accumulate raw bytes and dispatch complete SSE events (blank-line delimited). */
+    _feed(text) {
+        this._sseBuf += text;
+        let sep;
+        // Events are separated by a blank line (\n\n or \r\n\r\n).
+        while ((sep = this._firstEventBoundary(this._sseBuf)) !== -1) {
+            const raw = this._sseBuf.slice(0, sep);
+            this._sseBuf = this._sseBuf.slice(sep).replace(/^(\r?\n)+/, '');
+            this._dispatchEvent(raw);
+        }
+    }
+    _firstEventBoundary(buf) {
+        const a = buf.indexOf('\n\n');
+        const b = buf.indexOf('\r\n\r\n');
+        if (a === -1)
+            return b;
+        if (b === -1)
+            return a;
+        return Math.min(a, b);
+    }
+    _dispatchEvent(raw) {
+        let event = 'message';
+        const dataLines = [];
+        for (const line of raw.split(/\r?\n/)) {
+            if (line.startsWith('event:'))
+                event = line.slice(6).trim();
+            else if (line.startsWith('data:'))
+                dataLines.push(line.slice(5).replace(/^ /, ''));
+            // ignore `id:`, `:` comments / pings, etc.
+        }
+        const data = dataLines.join('\n');
+        if (!data && event !== 'endpoint')
+            return;
+        if (event === 'endpoint') {
+            try {
+                this._endpointUrl = new URL(data, this.config.url).toString();
+                this._endpointWaiter?.resolve();
+            }
+            catch {
+                this._endpointWaiter?.reject(new Error(`Invalid SSE endpoint URL: ${data}`));
+            }
+            this._endpointWaiter = null;
+            return;
+        }
+        // event: message — a JSON-RPC response/notification.
+        let msg;
+        try {
+            msg = JSON.parse(data);
+        }
+        catch {
+            return; // non-JSON frame
+        }
+        if (typeof msg.id === 'number' && this._pending.has(msg.id)) {
+            const { resolve, reject, timer } = this._pending.get(msg.id);
+            clearTimeout(timer);
+            this._pending.delete(msg.id);
+            if (msg.error)
+                reject(new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+            else
+                resolve(msg.result ?? null);
+        }
+        // Server-initiated notifications (no matching id) are ignored.
+    }
+    _rpc(method, params) {
+        const id = this._nextId++;
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this._pending.delete(id);
+                reject(new Error(`MCP SSE request "${method}" timed out`));
+            }, REQUEST_TIMEOUT_MS);
+            this._pending.set(id, { resolve, reject, timer });
+        });
+        this._postMessage({ jsonrpc: '2.0', id, method, params }).catch((err) => {
+            const entry = this._pending.get(id);
+            if (entry) {
+                clearTimeout(entry.timer);
+                this._pending.delete(id);
+                entry.reject(err);
+            }
+        });
+        return promise;
+    }
+    async _notify(method, params) {
+        await this._postMessage({ jsonrpc: '2.0', method, params });
+    }
+    /** POST a JSON-RPC message to the endpoint discovered via the SSE stream. */
+    async _postMessage(body) {
+        if (!this._endpointUrl)
+            throw new Error('MCP SSE endpoint not established yet');
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let resp;
+        try {
+            resp = await (0, node_fetch_1.default)(this._endpointUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...(this.config.headers ?? {}) },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!resp.ok) {
+            if (resp.status === 401) {
+                throw new httpClient_1.McpOAuthRequiredError(this.name, this.config.url, resp.headers.get('www-authenticate') ?? '');
+            }
+            const text = await resp.text().catch(() => '');
+            throw new Error(`MCP SSE POST ${resp.status} ${resp.statusText}${text ? `: ${text.slice(0, 200)}` : ''}`);
+        }
+        // Body (if any) is ignored — the JSON-RPC response arrives over the SSE stream.
+    }
+}
+exports.McpSseClient = McpSseClient;
+//# sourceMappingURL=sseClient.js.map

package/dist/permissions/rules.d.ts

@@ -0,0 +1,20 @@
+export type PermissionDecision = 'allow' | 'ask' | 'deny';
+export interface PermissionRules {
+    allow: string[];
+    ask: string[];
+    deny: string[];
+}
+export interface MergedSettings {
+    permissions: PermissionRules;
+    /** Raw merged object (for hooks, allowedTools, etc.). */
+    raw: Record<string, unknown>;
+}
+/** Merge the settings tiers (deny/allow/ask arrays are unioned). */
+export declare function loadSettings(workDir: string): MergedSettings;
+/**
+ * Evaluate a tool call against merged rules. Returns the matching decision, or
+ * null when no rule applies (caller decides the default, usually "ask").
+ * Precedence: deny → allow → ask.
+ */
+export declare function evaluatePermission(rules: PermissionRules, tool: string, input: Record<string, unknown>, workDir: string): PermissionDecision | null;
+//# sourceMappingURL=rules.d.ts.map

package/dist/permissions/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../src/permissions/rules.ts"],"names":[],"mappings":"AAwBA,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAE1D,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,eAAe,CAAC;IAC7B,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B;AAsBD,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAoB5D;AAqHD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,MAAM,GACd,kBAAkB,GAAG,IAAI,CAK3B"}

package/dist/permissions/rules.js

@@ -0,0 +1,218 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSettings = loadSettings;
+exports.evaluatePermission = evaluatePermission;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function managedSettingsPath() {
+    if (process.platform === 'darwin')
+        return '/Library/Application Support/Nexrall/managed-settings.json';
+    if (process.platform === 'win32')
+        return path.join(process.env.PROGRAMDATA ?? 'C:\\ProgramData', 'Nexrall', 'managed-settings.json');
+    return '/etc/nexrall/managed-settings.json';
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function extractRules(obj) {
+    const p = (obj?.permissions ?? {});
+    const arr = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+    return { allow: arr(p.allow), ask: arr(p.ask), deny: arr(p.deny) };
+}
+/** Merge the settings tiers (deny/allow/ask arrays are unioned). */
+function loadSettings(workDir) {
+    const tiers = [
+        managedSettingsPath(),
+        path.join(os.homedir(), '.nexrall', 'settings.json'),
+        path.join(workDir, '.nexrall', 'settings.json'),
+        path.join(workDir, '.nexrall', 'settings.local.json'),
+    ];
+    const merged = { allow: [], ask: [], deny: [] };
+    const raw = {};
+    for (const file of tiers) {
+        const obj = readJson(file);
+        if (!obj)
+            continue;
+        Object.assign(raw, obj);
+        const r = extractRules(obj);
+        merged.allow.push(...r.allow);
+        merged.ask.push(...r.ask);
+        merged.deny.push(...r.deny);
+    }
+    return { permissions: merged, raw };
+}
+// ─── Rule matching ──────────────────────────────────────────────────────────
+function parseRule(rule) {
+    const m = /^([A-Za-z0-9_]+)\((.*)\)$/.exec(rule.trim());
+    if (m)
+        return { tool: m[1], pattern: m[2] };
+    return { tool: rule.trim(), pattern: null };
+}
+function globToRegExp(glob) {
+    // Process token by token so ** and * are handled without a placeholder.
+    // The old approach used a null byte / control-char sentinel which (a) made
+    // the file appear binary to grep/tools, and (b) broke paths containing spaces
+    // (the space placeholder was replaced back even in non-glob contexts).
+    let re = '';
+    for (let i = 0; i < glob.length; i++) {
+        const ch = glob[i];
+        if (ch === '*' && glob[i + 1] === '*') {
+            re += '.*'; // ** → match across path separators
+            i++; // skip second *
+        }
+        else if (ch === '*') {
+            re += '[^/]*'; // * → match within one segment
+        }
+        else if (ch === '?') {
+            re += '[^/]'; // ? → single non-separator char
+        }
+        else {
+            // Escape regex metacharacters literally
+            re += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+function matchPattern(pattern, value) {
+    if (!value)
+        return false;
+    // "name:*" → prefix match (Claude Bash semantics)
+    if (pattern.endsWith(':*')) {
+        const prefix = pattern.slice(0, -2);
+        return value === prefix || value.startsWith(prefix);
+    }
+    if (pattern.includes('*') || pattern.includes('?')) {
+        try {
+            return globToRegExp(pattern).test(value);
+        }
+        catch {
+            return false;
+        }
+    }
+    return value === pattern;
+}
+/** Map a tool's input to the string(s) a rule pattern should match against. */
+function matchValues(tool, input, workDir) {
+    const str = (v) => (typeof v === 'string' ? v : '');
+    const vals = [];
+    const pushPath = (p) => {
+        if (!p)
+            return;
+        vals.push(p);
+        if (path.isAbsolute(p))
+            vals.push(path.relative(workDir, p));
+        else
+            vals.push(path.resolve(workDir, p));
+    };
+    switch (tool) {
+        case 'bash':
+            vals.push(str(input.command));
+            break;
+        case 'move_file':
+            pushPath(str(input.source));
+            pushPath(str(input.dest));
+            break;
+        case 'copy_file':
+            pushPath(str(input.source));
+            pushPath(str(input.destination));
+            break;
+        case 'fetch_url':
+            vals.push(str(input.url));
+            break;
+        case 'generate_image':
+            vals.push(str(input.path));
+            break;
+        case 'stock_photo':
+            vals.push(str(input.path));
+            break;
+        default:
+            pushPath(str(input.path));
+            break;
+    }
+    return vals.filter(Boolean);
+}
+function ruleMatches(rule, tool, input, workDir, opts) {
+    const { tool: ruleTool, pattern } = parseRule(rule);
+    // Allow a few friendly aliases so rules read naturally (Claude-style names).
+    const aliases = {
+        Read: ['read_file', 'list_directory', 'search_files', 'glob', 'notebook_read'],
+        Edit: ['edit_file', 'multi_edit', 'write_file', 'notebook_edit'],
+        Write: ['write_file'],
+        Bash: ['bash'],
+        WebFetch: ['fetch_url'],
+        Image: ['generate_image', 'stock_photo'],
+    };
+    const matchesTool = ruleTool === tool ||
+        ruleTool === '*' ||
+        (aliases[ruleTool]?.includes(tool) ?? false);
+    if (!matchesTool)
+        return false;
+    // Multi-line guard for ALLOW rules on bash: a patterned allow rule
+    // (prefix or glob) must never auto-approve a multi-line command — a newline
+    // acts like `;`, so "npm run test\nrm -rf ~" would otherwise ride an
+    // "Bash(npm run test:*)" allow rule straight past the user prompt.
+    // Deny rules stay aggressive (they SHOULD match multi-line commands), and a
+    // bare "Bash" allow (pattern === null) is an explicit "allow everything".
+    if (opts?.forAllow && tool === 'bash' && pattern !== null && pattern !== '' && pattern !== '*') {
+        const cmd = typeof input.command === 'string' ? input.command : '';
+        if (/[\r\n]/.test(cmd))
+            return false;
+    }
+    if (pattern === null || pattern === '' || pattern === '*')
+        return true;
+    return matchValues(tool, input, workDir).some((v) => matchPattern(pattern, v));
+}
+/**
+ * Evaluate a tool call against merged rules. Returns the matching decision, or
+ * null when no rule applies (caller decides the default, usually "ask").
+ * Precedence: deny → allow → ask.
+ */
+function evaluatePermission(rules, tool, input, workDir) {
+    if (rules.deny.some((r) => ruleMatches(r, tool, input, workDir)))
+        return 'deny';
+    if (rules.allow.some((r) => ruleMatches(r, tool, input, workDir, { forAllow: true })))
+        return 'allow';
+    if (rules.ask.some((r) => ruleMatches(r, tool, input, workDir)))
+        return 'ask';
+    return null;
+}
+//# sourceMappingURL=rules.js.map

package/dist/plugins/index.d.ts

@@ -0,0 +1,18 @@
+export interface PluginInfo {
+    /** Directory name (or plugin.json "name" when present). */
+    name: string;
+    version?: string;
+    description?: string;
+    /** Absolute path to the plugin directory. */
+    dir: string;
+    scope: 'project' | 'global';
+}
+/** Discover installed plugins (project scope shadows global on name clash). */
+export declare function loadPlugins(workDir: string): PluginInfo[];
+/** Subdirectories of every installed plugin that hold `kind` assets (existing only). */
+export declare function pluginAssetDirs(workDir: string, kind: 'commands' | 'agents'): string[];
+/** Merge hooks.json from every plugin into a single hooks config (arrays concatenated). */
+export declare function pluginHooks(workDir: string): Record<string, unknown[]>;
+/** MCP server maps declared by plugins: { serverName → config } (first plugin wins on clash). */
+export declare function pluginMcpServers(workDir: string): Record<string, unknown>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugins/index.ts"],"names":[],"mappings":"AAsBA,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,SAAS,GAAG,QAAQ,CAAC;CAC7B;AAsCD,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CAKzD;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,MAAM,EAAE,CAMtF;AAED,2FAA2F;AAC3F,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAetE;AAED,iGAAiG;AACjG,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAazE"}

package/dist/plugins/index.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlugins = loadPlugins;
+exports.pluginAssetDirs = pluginAssetDirs;
+exports.pluginHooks = pluginHooks;
+exports.pluginMcpServers = pluginMcpServers;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function readMeta(dir) {
+    try {
+        const raw = fs.readFileSync(path.join(dir, 'plugin.json'), 'utf-8');
+        const j = JSON.parse(raw);
+        return {
+            name: typeof j.name === 'string' ? j.name : undefined,
+            version: typeof j.version === 'string' ? j.version : undefined,
+            description: typeof j.description === 'string' ? j.description : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function scanRoot(root, scope, into) {
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink())
+            continue;
+        const dir = path.join(root, entry.name);
+        try {
+            if (!fs.statSync(dir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const meta = readMeta(dir);
+        const name = meta.name || entry.name;
+        if (into.has(name))
+            continue; // project scope scanned first — it wins
+        into.set(name, { name, version: meta.version, description: meta.description, dir, scope });
+    }
+}
+/** Discover installed plugins (project scope shadows global on name clash). */
+function loadPlugins(workDir) {
+    const out = new Map();
+    scanRoot(path.join(workDir, '.nexrall', 'plugins'), 'project', out);
+    scanRoot(path.join(os.homedir(), '.nexrall', 'plugins'), 'global', out);
+    return [...out.values()];
+}
+/** Subdirectories of every installed plugin that hold `kind` assets (existing only). */
+function pluginAssetDirs(workDir, kind) {
+    return loadPlugins(workDir)
+        .map((p) => path.join(p.dir, kind))
+        .filter((d) => {
+        try {
+            return fs.statSync(d).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Merge hooks.json from every plugin into a single hooks config (arrays concatenated). */
+function pluginHooks(workDir) {
+    const merged = {};
+    for (const p of loadPlugins(workDir)) {
+        try {
+            const raw = fs.readFileSync(path.join(p.dir, 'hooks.json'), 'utf-8');
+            const j = JSON.parse(raw);
+            // Accept either { hooks: {...} } or the bare hooks object.
+            const hooks = (j.hooks ?? j);
+            for (const [phase, entries] of Object.entries(hooks)) {
+                if (!Array.isArray(entries))
+                    continue;
+                merged[phase] = [...(merged[phase] ?? []), ...entries];
+            }
+        }
+        catch { /* no hooks.json or malformed — skip */ }
+    }
+    return merged;
+}
+/** MCP server maps declared by plugins: { serverName → config } (first plugin wins on clash). */
+function pluginMcpServers(workDir) {
+    const merged = {};
+    for (const p of loadPlugins(workDir)) {
+        try {
+            const raw = fs.readFileSync(path.join(p.dir, 'mcp.json'), 'utf-8');
+            const j = JSON.parse(raw);
+            const servers = (j.mcpServers ?? j);
+            for (const [name, cfg] of Object.entries(servers)) {
+                if (!(name in merged))
+                    merged[name] = cfg;
+            }
+        }
+        catch { /* no mcp.json — skip */ }
+    }
+    return merged;
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/executor.d.ts

@@ -0,0 +1,6 @@
+import type { ToolResult } from '../types';
+import { type SandboxConfig } from './sandbox';
+export declare function executeTool(name: string, input: Record<string, unknown>, abortSignal?: {
+    aborted: boolean;
+}, sandbox?: SandboxConfig, workDir?: string, agentScope?: string): Promise<ToolResult>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/tools/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AA46CtE,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CAiBrB"}