@nexrall/code-core 1.4.67 → 1.4.68

package/dist/api/client.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_BASE = void 0;
+exports.SCHEDULE_MAX_MINUTES = exports.SCHEDULE_MIN_MINUTES = exports.API_BASE = void 0;
 exports.chooseFinalContent = chooseFinalContent;
 exports.earlyToolResolveEnabled = earlyToolResolveEnabled;
 exports.gzipRequestsEnabled = gzipRequestsEnabled;
@@ -20,6 +20,12 @@ exports.getUsageDaily = getUsageDaily;
 exports.exchangeVscodeCode = exchangeVscodeCode;
 exports.login = login;
 exports.getUserProfile = getUserProfile;
+exports.clampScheduleMinutes = clampScheduleMinutes;
+exports.listCloudSchedules = listCloudSchedules;
+exports.createCloudSchedule = createCloudSchedule;
+exports.updateCloudSchedule = updateCloudSchedule;
+exports.deleteCloudSchedule = deleteCloudSchedule;
+exports.getCloudScheduleRuns = getCloudScheduleRuns;
 const eventsource_parser_1 = require("eventsource-parser");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const crypto_1 = require("crypto");
@@ -1982,4 +1988,153 @@ async function getUserProfile() {
     }
     return (await response.json());
 }
+// ─── Cloud schedules ────────────────────────────────────────────────────────
+//
+// Recurring agent tasks that run on NEXRALL'S servers (routes/browserAgent.js
+// `/api/browser-agent/schedules`, picked up every 60s by services/agentTaskCron),
+// so the user can close the laptop and the schedule still fires — NOT the same
+// thing as the local `/loop` + cron tools, which live and die with the session.
+//
+// Wire-format notes that decide the code below:
+//  • ids are sharded BIGINTs (migrations 048/080) that exceed
+//    Number.MAX_SAFE_INTEGER. pg returns them as strings, the server's own
+//    routes validate /^\d+$/ and pass the string straight back to pg — so an
+//    id is a digit STRING from end to end here. A Number()/parseInt anywhere on
+//    this path would round to the wrong row (the exact bug class the server
+//    route comments about).
+//  • the server clamps intervals to 15 minutes – 7 days (clampInterval in
+//    routes/browserAgent.js); we validate client-side too, so callers can show
+//    the real rule instead of relaying a 400.
+//  • rows come back snake_case (raw pg). We expose camelCase, one stable shape
+//    for every caller, so no caller has to know column names.
+exports.SCHEDULE_MIN_MINUTES = 15;
+exports.SCHEDULE_MAX_MINUTES = 7 * 24 * 60;
+/** Enforce the server's own bounds with a message that names them. */
+function clampScheduleMinutes(v) {
+    const n = Math.round(Number(v));
+    if (!Number.isFinite(n) || n < exports.SCHEDULE_MIN_MINUTES || n > exports.SCHEDULE_MAX_MINUTES) {
+        throw new Error(`Interval must be between ${exports.SCHEDULE_MIN_MINUTES} minutes and ${exports.SCHEDULE_MAX_MINUTES / (24 * 60)} days.`);
+    }
+    return n;
+}
+/**
+ * A schedule id, still a digit string. Validated here because a malformed id
+ * would otherwise be interpolated into the request path.
+ */
+function scheduleId(id) {
+    const s = String(id ?? '').trim();
+    if (!/^\d+$/.test(s)) {
+        throw new Error(`Invalid schedule id "${id}" — expected the digit string shown in the schedule list.`);
+    }
+    return s;
+}
+function isoOrNull(v) {
+    return typeof v === 'string' && v ? v : null;
+}
+/** One shape for a list row, a create response or a partial patch response. */
+function scheduleRow(row) {
+    return {
+        // String(), never Number() — see the header note on sharded ids.
+        id: row.id == null ? '' : String(row.id),
+        task: typeof row.task === 'string' ? row.task : '',
+        startUrl: isoOrNull(row.start_url ?? row.startUrl),
+        domains: Array.isArray(row.domains) ? row.domains.map((d) => String(d)) : null,
+        intervalMinutes: Number(row.interval_minutes ?? row.intervalMinutes ?? 0) || 0,
+        enabled: row.enabled === true,
+        nextRunAt: isoOrNull(row.next_run_at ?? row.nextRunAt),
+        lastRunAt: isoOrNull(row.last_run_at ?? row.lastRunAt),
+        lastStatus: isoOrNull(row.last_status ?? row.lastStatus),
+    };
+}
+function scheduleRunRow(row) {
+    return {
+        id: row.id == null ? '' : String(row.id),
+        status: typeof row.status === 'string' ? row.status : '',
+        summary: typeof row.summary === 'string' && row.summary ? row.summary : null,
+        steps: Number(row.steps ?? 0) || 0,
+        createdAt: isoOrNull(row.created_at ?? row.createdAt),
+    };
+}
+/** The server answers errors as {error: '<sentence>'}; prefer that sentence. */
+function apiErrorMessage(status, text) {
+    try {
+        const j = JSON.parse(text);
+        if (typeof j.error === 'string' && j.error)
+            return j.error;
+    }
+    catch { /* not JSON — fall through to the raw text */ }
+    return `API error ${status}${text ? `: ${text}` : ''}`;
+}
+async function scheduleRequest(method, path, body) {
+    const fetchOnce = () => (0, node_fetch_1.default)(`${exports.API_BASE}/api/browser-agent${path}`, {
+        method,
+        headers: authHeaders(),
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    let response = await fetchOnce();
+    // Same silent-refresh pattern as getBalance/getOrgs — an expired token on the
+    // first call of a session is the common case, not an error to surface.
+    if (response.status === 401 || response.status === 403) {
+        const text = await response.text().catch(() => '');
+        if (isExpiredTokenResponse(response.status, text) && await refreshAccessToken()) {
+            response = await fetchOnce();
+        }
+        else {
+            throw new Error(apiErrorMessage(response.status, text));
+        }
+    }
+    if (!response.ok) {
+        throw new Error(apiErrorMessage(response.status, await response.text().catch(() => '')));
+    }
+    return response.json().catch(() => null);
+}
+async function listCloudSchedules() {
+    const json = (await scheduleRequest('GET', '/schedules'));
+    return Array.isArray(json?.schedules)
+        ? json.schedules.map((r) => scheduleRow(r))
+        : [];
+}
+async function createCloudSchedule(input) {
+    const task = String(input.task ?? '').trim();
+    if (!task)
+        throw new Error('A schedule needs a task.');
+    const json = (await scheduleRequest('POST', '/schedules', {
+        task,
+        intervalMinutes: clampScheduleMinutes(input.intervalMinutes),
+        ...(input.startUrl != null && input.startUrl !== '' ? { startUrl: input.startUrl } : {}),
+        ...(Array.isArray(input.domains) && input.domains.length ? { domains: input.domains } : {}),
+        ...(input.enabled === false ? { enabled: false } : {}),
+    }));
+    if (!json?.schedule)
+        throw new Error('The server accepted the schedule but returned no record.');
+    return scheduleRow(json.schedule);
+}
+async function updateCloudSchedule(id, patch) {
+    const body = {};
+    if (typeof patch.task === 'string' && patch.task.trim())
+        body.task = patch.task.trim();
+    if (patch.intervalMinutes != null)
+        body.intervalMinutes = clampScheduleMinutes(patch.intervalMinutes);
+    if (typeof patch.enabled === 'boolean')
+        body.enabled = patch.enabled;
+    if (typeof patch.startUrl === 'string')
+        body.startUrl = patch.startUrl;
+    if (Array.isArray(patch.domains))
+        body.domains = patch.domains;
+    if (!Object.keys(body).length)
+        throw new Error('Nothing to update.');
+    const json = (await scheduleRequest('PATCH', `/schedules/${scheduleId(id)}`, body));
+    if (!json?.schedule)
+        throw new Error('The server accepted the update but returned no record.');
+    return scheduleRow(json.schedule);
+}
+async function deleteCloudSchedule(id) {
+    await scheduleRequest('DELETE', `/schedules/${scheduleId(id)}`);
+}
+async function getCloudScheduleRuns(id) {
+    const json = (await scheduleRequest('GET', `/schedules/${scheduleId(id)}/runs`));
+    return Array.isArray(json?.runs)
+        ? json.runs.map((r) => scheduleRunRow(r))
+        : [];
+}
 //# sourceMappingURL=client.js.map

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export * from './agent/skills';
 export * from './mcp/client';
 export * from './mcp/httpClient';
 export * from './mcp/manager';
+export * from './mcp/server';
 export * from './mcp/stats';
 export * from './checkpoint/manager';
 export * from './commands/loader';
@@ -32,6 +33,7 @@ export * from './permissions/destructive';
 export * from './plugins/index';
 export * from './plugins/installer';
 export * from './plugins/sources';
+export * from './plugins/data';
 export * from './agent/trust';
 export * from './agent/crossProcessLock';
 export * from './agent/worktree';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -34,6 +34,7 @@ __exportStar(require("./agent/skills"), exports);
 __exportStar(require("./mcp/client"), exports);
 __exportStar(require("./mcp/httpClient"), exports);
 __exportStar(require("./mcp/manager"), exports);
+__exportStar(require("./mcp/server"), exports);
 __exportStar(require("./mcp/stats"), exports);
 __exportStar(require("./checkpoint/manager"), exports);
 __exportStar(require("./commands/loader"), exports);
@@ -48,6 +49,7 @@ __exportStar(require("./permissions/destructive"), exports);
 __exportStar(require("./plugins/index"), exports);
 __exportStar(require("./plugins/installer"), exports);
 __exportStar(require("./plugins/sources"), exports);
+__exportStar(require("./plugins/data"), exports);
 __exportStar(require("./agent/trust"), exports);
 __exportStar(require("./agent/crossProcessLock"), exports);
 __exportStar(require("./agent/worktree"), exports);

package/dist/mcp/server.d.ts

@@ -0,0 +1,39 @@
+import type { Readable, Writable } from 'stream';
+import type { ToolResult } from '../types';
+export interface McpServerTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+    run(input: Record<string, unknown>, ctx: {
+        workDir: string;
+    }): Promise<ToolResult>;
+}
+export interface ServeOptions {
+    /** Workspace root relative paths resolve against (the client's project). */
+    workDir: string;
+    /** Reported in `serverInfo` during initialize. */
+    version?: string;
+    /** Defaults to `readOnlyMcpTools()`. */
+    tools?: McpServerTool[];
+    /** Injectable for tests; default process.stdin/stdout. */
+    input?: Readable;
+    output?: Writable;
+    /** Diagnostics — stderr by convention. NEVER stdout. */
+    log?: (message: string) => void;
+}
+/**
+ * The read-only surface `nex mcp serve` offers. Kept small on purpose: every tool here is one
+ * an outside agent can call with no human in the loop, so nothing that writes, deletes or
+ * executes may join without a permission story first.
+ */
+export declare function readOnlyMcpTools(): McpServerTool[];
+/**
+ * Serve MCP on stdio until the client closes the pipe. Resolves (never rejects) at EOF — the
+ * standard way an MCP client says "stop" is to close stdin, and the exit code is then 0.
+ */
+export declare function serveMcp(opts: ServeOptions): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAI3C,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;IACF,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACpF;AAED,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,KAAK,CAAC,EAAE,aAAa,EAAE,CAAC;IACxB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,wDAAwD;IACxD,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAaD;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,EAAE,CA+BlD;AASD;;;GAGG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAuHhE"}

package/dist/mcp/server.js

@@ -0,0 +1,189 @@
+"use strict";
+// MCP server — the other direction of `mcp/client.ts`.
+//
+// Point any MCP client at `nex mcp serve` and it can read this machine's files with the same
+// tools the CLI uses. Deliberately READ-ONLY for now: the client is usually another agent with
+// its own permission model, and a server that silently edits files has no one to ask — a write
+// toolset only belongs here once there is a person (or a policy file) behind the approval.
+//
+// Framing is the same newline-delimited JSON-RPC 2.0 the client parses, so our own client is
+// the natural test driver. Two hard rules, both enforced by tests:
+//   * stdout carries protocol frames and NOTHING else — one stray console.log corrupts the
+//     channel; every diagnostic goes to stderr;
+//   * a bad line, an unknown method or a throwing tool must never end the loop.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOnlyMcpTools = readOnlyMcpTools;
+exports.serveMcp = serveMcp;
+const executor_1 = require("../tools/executor");
+// ─── The toolset ──────────────────────────────────────────────────────────────
+/** Wrap one executor tool. The executor is the single source of behaviour — same caps, same
+ *  error messages, same path resolution as the CLI's own turns. */
+const fromExecutor = (name, description, inputSchema) => ({
+    name,
+    description,
+    inputSchema,
+    run: (input, ctx) => (0, executor_1.executeTool)(name, input, undefined, undefined, ctx.workDir),
+});
+/**
+ * The read-only surface `nex mcp serve` offers. Kept small on purpose: every tool here is one
+ * an outside agent can call with no human in the loop, so nothing that writes, deletes or
+ * executes may join without a permission story first.
+ */
+function readOnlyMcpTools() {
+    return [
+        fromExecutor('read_file', 'Read a text file. Returns numbered lines so later edits can cite them. Binary files are refused.', { type: 'object', properties: {
+                path: { type: 'string', description: 'File path, absolute or relative to the workspace root' },
+                offset: { type: 'number', description: '0-based line to start from (default 0)' },
+                limit: { type: 'number', description: 'How many lines to return' },
+            }, required: ['path'] }),
+        fromExecutor('list_directory', 'List the entries of a directory, each marked as file or directory.', { type: 'object', properties: {
+                path: { type: 'string', description: 'Directory path (default: the workspace root)' },
+            } }),
+        fromExecutor('glob', 'Find files by glob pattern, e.g. "**/*.ts" or "src/**/*.test.js".', { type: 'object', properties: {
+                pattern: { type: 'string', description: 'Glob pattern' },
+                path: { type: 'string', description: 'Directory to search from (default: the workspace root)' },
+            }, required: ['pattern'] }),
+        fromExecutor('search_files', 'Search file contents with a regular expression. Returns matching file paths by default; ask for context lines to get the matches themselves.', { type: 'object', properties: {
+                pattern: { type: 'string', description: 'Regular expression' },
+                path: { type: 'string', description: 'Directory to search (default: the workspace root)' },
+                type: { type: 'string', description: '"files" (paths only) or "content" (matching lines)' },
+                include: { type: 'string', description: 'Only files matching this glob, e.g. "*.ts"' },
+                case_insensitive: { type: 'boolean', description: 'Case-insensitive match' },
+                context_lines: { type: 'number', description: 'Lines of context around each match (implies type "content")' },
+            }, required: ['pattern'] }),
+    ];
+}
+// ─── Protocol ─────────────────────────────────────────────────────────────────
+/** Versions whose framing we actually implement (they are all the same for our surface). */
+const SUPPORTED_PROTOCOLS = ['2024-11-05', '2025-03-26', '2025-06-18'];
+const DEFAULT_PROTOCOL = '2024-11-05';
+const SERVER_NAME = 'nexrall';
+/**
+ * Serve MCP on stdio until the client closes the pipe. Resolves (never rejects) at EOF — the
+ * standard way an MCP client says "stop" is to close stdin, and the exit code is then 0.
+ */
+async function serveMcp(opts) {
+    const input = opts.input ?? process.stdin;
+    const output = opts.output ?? process.stdout;
+    const log = opts.log ?? ((m) => process.stderr.write(`[nexrall mcp] ${m}\n`));
+    const tools = opts.tools ?? readOnlyMcpTools();
+    const version = opts.version ?? '0.0.0';
+    const byName = new Map(tools.map((t) => [t.name, t]));
+    const send = (msg) => { output.write(JSON.stringify(msg) + '\n'); };
+    const reply = (id, result) => send({ jsonrpc: '2.0', id, result });
+    const replyError = (id, code, message) => send({ jsonrpc: '2.0', id, error: { code, message } });
+    async function handle(message) {
+        const id = message.id;
+        const isRequest = id !== undefined && id !== null;
+        const method = message.method;
+        const params = (message.params ?? {});
+        switch (method) {
+            case 'initialize': {
+                // Echo the client's version when we implement it, else our default — that is the
+                // spec's instruction and the number is inert for this surface either way.
+                const asked = typeof params.protocolVersion === 'string' ? params.protocolVersion : '';
+                reply(id, {
+                    protocolVersion: SUPPORTED_PROTOCOLS.includes(asked) ? asked : DEFAULT_PROTOCOL,
+                    capabilities: { tools: {} },
+                    serverInfo: { name: SERVER_NAME, version },
+                    instructions: `Read-only file access to ${opts.workDir}. ` +
+                        `Tools: ${tools.map((t) => t.name).join(', ')}. Nothing here writes, deletes or runs commands.`,
+                });
+                log(`initialize from ${typeof params.clientInfo === 'object' && params.clientInfo ? JSON.stringify(params.clientInfo.name ?? 'client') : 'client'}`);
+                return;
+            }
+            case 'notifications/initialized':
+            case 'notifications/cancelled':
+                return; // notifications take no reply
+            case 'ping':
+                reply(id, {});
+                return;
+            case 'tools/list':
+                reply(id, { tools: tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) });
+                return;
+            case 'tools/call': {
+                const name = typeof params.name === 'string' ? params.name : '';
+                const args = (params.arguments ?? {});
+                if (!name)
+                    return replyError(id, -32602, 'Invalid params: name is required');
+                const tool = byName.get(name);
+                if (!tool) {
+                    // A RESULT, not a protocol error: the calling model should read "not offered" as tool
+                    // output and pick another route, not see the whole call fail.
+                    reply(id, { content: [{ type: 'text', text: `Tool "${name}" is not offered by this server (read-only). Available: ${[...byName.keys()].join(', ')}.` }], isError: true });
+                    return;
+                }
+                try {
+                    const res = await tool.run(args, { workDir: opts.workDir });
+                    if (res.error)
+                        reply(id, { content: [{ type: 'text', text: res.error }], isError: true });
+                    else
+                        reply(id, { content: [{ type: 'text', text: res.output ?? '' }] });
+                }
+                catch (err) {
+                    // A throwing tool is the tool's problem, not the session's — answer and keep serving.
+                    reply(id, { content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }], isError: true });
+                }
+                return;
+            }
+            default:
+                if (isRequest)
+                    replyError(id, -32601, `Method not found: ${method}`);
+                return;
+        }
+    }
+    input.setEncoding('utf8');
+    let buffer = '';
+    let queue = Promise.resolve();
+    const feed = (line) => {
+        // Chain instead of racing: responses stay in request order and writes never interleave.
+        queue = queue.then(async () => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let message;
+            try {
+                message = JSON.parse(trimmed);
+            }
+            catch {
+                log(`ignoring a line that is not JSON (${trimmed.slice(0, 80)})`);
+                return;
+            }
+            if (!message || message.jsonrpc !== '2.0' || typeof message.method !== 'string') {
+                log('ignoring a message without jsonrpc 2.0 + method');
+                return;
+            }
+            try {
+                await handle(message);
+            }
+            catch (err) {
+                // handle() is written not to throw, so reaching here is a bug in the server — report
+                // it as a JSON-RPC error rather than dropping the connection.
+                if (message.id !== undefined)
+                    replyError(message.id, -32603, err instanceof Error ? err.message : String(err));
+            }
+        });
+    };
+    await new Promise((resolve) => {
+        input.on('data', (chunk) => {
+            buffer += chunk.toString();
+            let nl;
+            while ((nl = buffer.indexOf('\n')) >= 0) {
+                feed(buffer.slice(0, nl));
+                buffer = buffer.slice(nl + 1);
+            }
+        });
+        const done = () => {
+            if (buffer.trim()) {
+                feed(buffer);
+                buffer = '';
+            }
+            resolve();
+        };
+        input.on('end', done);
+        input.on('close', done);
+    });
+    await queue; // let in-flight calls finish before the process exits
+    log('client closed stdin — server exiting');
+}
+//# sourceMappingURL=server.js.map

package/dist/plugins/data.d.ts

@@ -0,0 +1,23 @@
+/** Claude Code's rule: letters, digits, `_`, `-` survive; everything else becomes `-`. */
+export declare function sanitizePluginId(name: string): string;
+/** Where this plugin's persistent data lives. Pure — does not touch the disk. */
+export declare function pluginDataDir(name: string): string;
+/**
+ * `pluginDataDir`, created if missing. Returns the path either way.
+ *
+ * Called right before a plugin's process is spawned with NEXRALL_PLUGIN_DATA in
+ * its environment, so the promise "the variable points at a directory you may
+ * write to" holds the moment the plugin can read it.
+ */
+export declare function ensurePluginDataDir(name: string): string;
+/** True when the plugin has data on disk from earlier runs. */
+export declare function pluginHasData(name: string): boolean;
+/**
+ * Raw bytes under a plugin's data directory (0 when missing). Bounded walk: a
+ * plugin can park a large tree here, and reporting the size must not be the
+ * thing that makes `nex plugin prune` slow, so entries are counted up to a cap.
+ */
+export declare function pluginDataSize(name: string, maxEntries?: number): number;
+/** Remove a plugin's data directory. Returns true when something was removed. */
+export declare function removePluginData(name: string): boolean;
+//# sourceMappingURL=data.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../src/plugins/data.ts"],"names":[],"mappings":"AAwBA,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMxD;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMnD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,SAAO,GAAG,MAAM,CAiBtE;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAStD"}

package/dist/plugins/data.js

@@ -0,0 +1,141 @@
+"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.sanitizePluginId = sanitizePluginId;
+exports.pluginDataDir = pluginDataDir;
+exports.ensurePluginDataDir = ensurePluginDataDir;
+exports.pluginHasData = pluginHasData;
+exports.pluginDataSize = pluginDataSize;
+exports.removePluginData = removePluginData;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// ─── Plugin data directories ──────────────────────────────────────────────────
+//
+// A plugin's own files are replaced on every update, so state a plugin wants to
+// keep — caches, node_modules, a downloaded model, a database — cannot live
+// inside its install directory. It gets a per-plugin data directory instead:
+//
+//     ~/.nexrall/plugin-data/<id>/
+//
+// which survives updates and is exposed to the plugin's own processes (its hook
+// commands and its MCP servers) as NEXRALL_PLUGIN_DATA. Same idea as Claude
+// Code's ${CLAUDE_PLUGIN_DATA}, same id rule: everything outside [A-Za-z0-9_-]
+// becomes "-", so a name can never escape the parent directory or collide with
+// path syntax ("my.plugin" → "my-plugin"). Two names that differ only in those
+// characters share a directory — which is why the id is derived, never taken
+// verbatim.
+//
+// The directory is created on FIRST REFERENCE, not at install: a plugin that
+// never touches its data dir leaves nothing behind, and `nex plugin remove`
+// does not have to guess whether a directory it finds is in use.
+/** Claude Code's rule: letters, digits, `_`, `-` survive; everything else becomes `-`. */
+function sanitizePluginId(name) {
+    return name.replace(/[^\w-]/g, '-');
+}
+/** Where this plugin's persistent data lives. Pure — does not touch the disk. */
+function pluginDataDir(name) {
+    return path.join(os.homedir(), '.nexrall', 'plugin-data', sanitizePluginId(name));
+}
+/**
+ * `pluginDataDir`, created if missing. Returns the path either way.
+ *
+ * Called right before a plugin's process is spawned with NEXRALL_PLUGIN_DATA in
+ * its environment, so the promise "the variable points at a directory you may
+ * write to" holds the moment the plugin can read it.
+ */
+function ensurePluginDataDir(name) {
+    const dir = pluginDataDir(name);
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { /* unwritable home: the plugin will see the path and fail its own write */ }
+    return dir;
+}
+/** True when the plugin has data on disk from earlier runs. */
+function pluginHasData(name) {
+    try {
+        return fs.readdirSync(pluginDataDir(name)).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Raw bytes under a plugin's data directory (0 when missing). Bounded walk: a
+ * plugin can park a large tree here, and reporting the size must not be the
+ * thing that makes `nex plugin prune` slow, so entries are counted up to a cap.
+ */
+function pluginDataSize(name, maxEntries = 5000) {
+    let total = 0;
+    let seen = 0;
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (seen++ >= maxEntries)
+                return;
+            const full = path.join(dir, e.name);
+            try {
+                if (e.isDirectory())
+                    walk(full);
+                else
+                    total += fs.statSync(full).size;
+            }
+            catch { /* unreadable entry — skip it, size is an estimate */ }
+        }
+    };
+    walk(pluginDataDir(name));
+    return total;
+}
+/** Remove a plugin's data directory. Returns true when something was removed. */
+function removePluginData(name) {
+    const dir = pluginDataDir(name);
+    try {
+        if (!fs.existsSync(dir))
+            return false;
+        fs.rmSync(dir, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data.js.map

package/dist/plugins/index.d.ts

@@ -58,8 +58,20 @@ export declare function loadPlugins(workDir: string): PluginInfo[];
 export declare function findPlugin(workDir: string, name: string, scope: 'project' | 'global'): PluginInfo | undefined;
 /** Subdirectories of every ENABLED installed plugin that hold `kind` assets (existing only). */
 export declare function pluginAssetDirs(workDir: string, kind: 'commands' | 'agents' | 'skills'): string[];
-/** Merge hooks.json from every ENABLED plugin into a single hooks config (arrays concatenated). */
+/** Merge hooks.json from every ENABLED plugin into a single hooks config (arrays concatenated).
+ *
+ * Every handler is stamped with `plugin: <name>`. Provenance is the one thing the merge
+ * would otherwise destroy — and it is what lets the hook runner hand the plugin's own
+ * processes their NEXRALL_PLUGIN_DATA (see runHookHandler). Both entry forms are stamped:
+ * the flat one (the entry IS the handler) and the nested one (each item under `hooks`).
+ */
 export declare function pluginHooks(workDir: string): Record<string, unknown[]>;
-/** MCP server maps declared by ENABLED plugins: { serverName → config } (first plugin wins on clash). */
+/** MCP server maps declared by ENABLED plugins: { serverName → config } (first plugin wins on clash).
+ *
+ * A stdio server from a plugin gets NEXRALL_PLUGIN_DATA in its environment, pointing at the
+ * plugin's persistent data directory — the install directory is replaced on every update, so
+ * this is the only place a server can keep state. A plugin that set the variable itself keeps
+ * its own value: an explicit config value is never overridden here.
+ */
 export declare function pluginMcpServers(workDir: string): Record<string, unknown>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugins/index.ts"],"names":[],"mappings":"AAsCA,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;IAC5B,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,CAAC;CACnB;AAYD,oEAAoE;AACpE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAMrD;AAED,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAWtE;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,eAAe,GAAG,MAAM,GAAG,IAAI,CAQhG;AAwCD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CAKzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAK7G;AAED,gGAAgG;AAChG,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,EAAE,CAOjG;AAED,mGAAmG;AACnG,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAkBtE;AAED,yGAAyG;AACzG,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgBzE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugins/index.ts"],"names":[],"mappings":"AAuCA,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;IAC5B,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,CAAC;CACnB;AAYD,oEAAoE;AACpE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAMrD;AAED,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAWtE;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,eAAe,GAAG,MAAM,GAAG,IAAI,CAQhG;AAwCD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CAKzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAK7G;AAED,gGAAgG;AAChG,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,EAAE,CAOjG;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAkBtE;AAeD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgBzE"}