nexus-ai-pro 2.3.0 → 2.5.0

package/dist/mcp/client.js

@@ -131,6 +131,64 @@ export class McpClient {
             this.settle(id, undefined, error);
     }
 }
+const INHERITED_ENV = new Set([
+    'PATH',
+    'PATHEXT',
+    'HOME',
+    'USER',
+    'USERNAME',
+    'LOGNAME',
+    'SHELL',
+    'TERM',
+    'LANG',
+    'LANGUAGE',
+    'TZ',
+    'TMPDIR',
+    'TEMP',
+    'TMP',
+    'XDG_CONFIG_HOME',
+    'XDG_CACHE_HOME',
+    'XDG_DATA_HOME',
+    'XDG_RUNTIME_DIR',
+    'SYSTEMROOT',
+    'SYSTEMDRIVE',
+    'WINDIR',
+    'COMSPEC',
+    'APPDATA',
+    'LOCALAPPDATA',
+    'USERPROFILE',
+    'HOMEDRIVE',
+    'HOMEPATH',
+    'PROGRAMDATA',
+    'PROGRAMFILES',
+    'PROGRAMFILES(X86)',
+    'COMMONPROGRAMFILES',
+    'PROCESSOR_ARCHITECTURE',
+    'NUMBER_OF_PROCESSORS',
+    'OS',
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'NO_PROXY',
+    'ALL_PROXY',
+    'NODE_EXTRA_CA_CERTS',
+    'SSL_CERT_FILE',
+    'SSL_CERT_DIR',
+]);
+export function serverEnvironment(source, options = {}) {
+    if (options.inheritEnv === false)
+        return { ...options.env };
+    const named = new Set((Array.isArray(options.inheritEnv) ? options.inheritEnv : []).map((name) => name.toUpperCase()));
+    const inherited = {};
+    for (const [name, value] of Object.entries(source)) {
+        if (value === undefined)
+            continue;
+        const upper = name.toUpperCase();
+        if (options.inheritEnv === true || INHERITED_ENV.has(upper) || upper.startsWith('LC_') || named.has(upper)) {
+            inherited[name] = value;
+        }
+    }
+    return { ...inherited, ...options.env };
+}
 export function createStdioTransport(options) {
     let child;
     const decoder = new LineDecoder();
@@ -141,7 +199,7 @@ export function createStdioTransport(options) {
             const { spawn } = await import('node:child_process');
             const spawned = spawn(options.command, options.args ?? [], {
                 cwd: options.cwd,
-                env: { ...process.env, ...options.env },
+                env: serverEnvironment(process.env, options),
                 stdio: ['pipe', 'pipe', 'inherit'],
             });
             spawned.stdout.setEncoding('utf8');

package/dist/mcp/registry.d.ts

@@ -15,6 +15,12 @@ export interface McpServerConfig {
     env?: Record<string, string>;
     /** Working directory for the process. */
     cwd?: string;
+    /**
+     * Which of this process's own environment variables a local server inherits, besides `env`. By
+     * default, only what a process needs to start, never an API key; a list adds variables by name,
+     * `true` passes the whole environment, and `false` nothing but `env`.
+     */
+    inheritEnv?: boolean | string[];
     /** The endpoint of a remote server, reached over HTTP. */
     url?: string;
     /** Headers sent to a remote server, such as authorization. */

package/dist/mcp/registry.js

@@ -59,6 +59,7 @@ export class McpRegistry {
                         ...(resolved.args ? { args: resolved.args } : {}),
                         ...(resolved.env ? { env: resolved.env } : {}),
                         ...(resolved.cwd ? { cwd: resolved.cwd } : {}),
+                        ...(resolved.inheritEnv !== undefined ? { inheritEnv: resolved.inheritEnv } : {}),
                     })
                     : createHttpTransport({
                         url: resolved.url,
@@ -163,6 +164,12 @@ export function validateMcpConfig(value) {
                 throw new McpRegistryError(`Server "${name}": "${field}" is a list of strings`, name);
             }
         }
+        const inherit = server.inheritEnv;
+        if (inherit !== undefined &&
+            typeof inherit !== 'boolean' &&
+            !(Array.isArray(inherit) && inherit.every((item) => typeof item === 'string'))) {
+            throw new McpRegistryError(`Server "${name}": "inheritEnv" is true, false, or a list of names`, name);
+        }
         for (const field of ['env', 'headers']) {
             const map = server[field];
             if (map !== undefined &&

package/dist/operations/adapters.d.ts

@@ -58,7 +58,8 @@ export declare class RedisOperationStore<TResult = unknown> implements Operation
     private readonly client;
     private readonly prefix;
     private readonly useEval;
-    private readonly indexed;
+    /** Whether queued and leased work is kept in sorted sets, as `index: true` asks. */
+    readonly indexed: boolean;
     constructor(client: RedisOperationLikeClient, options?: RedisOperationStoreOptions);
     /**
      * Stores a new record and indexes its idempotency key. Throws `OperationDuplicateError` when another

package/dist/operations/runner.js

@@ -51,6 +51,8 @@ export class OperationRunner {
         for (const record of candidates) {
             if (claimed.length >= limit)
                 break;
+            if (!matchesFilter(record, filter))
+                continue;
             if (record.expiresAt && record.expiresAt <= nowIso) {
                 await this.settleExpired(record);
                 continue;

package/dist/operations/stats.js

@@ -5,29 +5,36 @@ export function isUnheldQueued(record, now) {
 export function matchesFilter(record, filter) {
     if (filter?.tenantId !== undefined && record.tenantId !== filter.tenantId)
         return false;
+    if (filter?.kinds && !filter.kinds.includes(record.kind ?? ''))
+        return false;
     return !filter?.kindPrefix || (record.kind ?? '').startsWith(filter.kindPrefix);
 }
 export function countRecords(records, now, filter) {
     const byStatus = {};
     let oldestQueuedAt;
     let lapsedLeases = 0;
+    const queuedByKind = {};
     for (const record of records) {
         if (isTerminalOperationStatus(record.status) || !matchesFilter(record, filter))
             continue;
         byStatus[record.status] = (byStatus[record.status] ?? 0) + 1;
-        if (record.status === 'queued' && (!oldestQueuedAt || record.createdAt < oldestQueuedAt)) {
-            oldestQueuedAt = record.createdAt;
+        if (record.status === 'queued') {
+            if (!oldestQueuedAt || record.createdAt < oldestQueuedAt)
+                oldestQueuedAt = record.createdAt;
+            const kind = record.kind ?? '';
+            queuedByKind[kind] = (queuedByKind[kind] ?? 0) + 1;
         }
         if (record.status === 'running' && (!record.lease || record.lease.expiresAt <= now))
             lapsedLeases += 1;
     }
-    return { byStatus, ...(oldestQueuedAt ? { oldestQueuedAt } : {}), lapsedLeases };
+    return { byStatus, ...(oldestQueuedAt ? { oldestQueuedAt } : {}), lapsedLeases, queuedByKind };
 }
 export async function operationStats(store, options = {}) {
     const now = (options.now ?? new Date()).toISOString();
-    const filter = options.kindPrefix || options.tenantId !== undefined
+    const filter = options.kindPrefix || options.kinds || options.tenantId !== undefined
         ? {
             ...(options.kindPrefix ? { kindPrefix: options.kindPrefix } : {}),
+            ...(options.kinds ? { kinds: options.kinds } : {}),
             ...(options.tenantId !== undefined ? { tenantId: options.tenantId } : {}),
         }
         : undefined;

package/dist/postgres/index.d.ts

@@ -9,9 +9,10 @@ export { PostgresPromptStore, type PostgresPromptStoreOptions, promptStoreMigrat
 export { PostgresRollupStore, type PostgresRollupStoreOptions, rollupStoreMigration, rollupStoreMigrations, } from './rollups.js';
 export { PostgresStore, type PostgresStoreOptions, storeMigration, storeMigrations } from './store.js';
 export { PostgresTraceStore, type PostgresTraceStoreOptions, traceStoreMigration, traceStoreMigrations, } from './traces.js';
+export { PostgresTenantUsage, type PostgresTenantUsageOptions, tenantUsageMigration, tenantUsageMigrations, } from './tenancy.js';
 export { PostgresVectorStore, type PostgresVectorStoreOptions, vectorStoreMigration, vectorStoreMigrations, } from './vectors.js';
 /** The Postgres adapters a migration can include. */
-export type PostgresAdapter = 'operations' | 'store' | 'traces' | 'evaluation' | 'circuits' | 'prompts' | 'rollups' | 'vectors';
+export type PostgresAdapter = 'operations' | 'store' | 'traces' | 'evaluation' | 'circuits' | 'tenancy' | 'prompts' | 'rollups' | 'vectors';
 /** Options for `postgresMigrations()` and `postgresMigration()`. */
 export interface PostgresMigrationOptions {
     /**

package/dist/postgres/index.js

@@ -7,6 +7,7 @@ import { operationStoreMigrations } from './operations.js';
 import { promptStoreMigrations } from './prompts.js';
 import { rollupStoreMigrations } from './rollups.js';
 import { storeMigrations } from './store.js';
+import { tenantUsageMigrations } from './tenancy.js';
 import { traceStoreMigrations } from './traces.js';
 import { vectorStoreMigrations } from './vectors.js';
 export { migrationChecksum, SchemaMigrationError, } from '../utils/schema-migrations.js';
@@ -19,6 +20,7 @@ export { PostgresPromptStore, promptStoreMigration, promptStoreMigrations, } fro
 export { PostgresRollupStore, rollupStoreMigration, rollupStoreMigrations, } from './rollups.js';
 export { PostgresStore, storeMigration, storeMigrations } from './store.js';
 export { PostgresTraceStore, traceStoreMigration, traceStoreMigrations, } from './traces.js';
+export { PostgresTenantUsage, tenantUsageMigration, tenantUsageMigrations, } from './tenancy.js';
 export { PostgresVectorStore, vectorStoreMigration, vectorStoreMigrations, } from './vectors.js';
 export const POSTGRES_ADAPTERS = [
     'operations',
@@ -26,6 +28,7 @@ export const POSTGRES_ADAPTERS = [
     'traces',
     'evaluation',
     'circuits',
+    'tenancy',
     'prompts',
     'rollups',
     'vectors',
@@ -39,6 +42,7 @@ export function postgresMigrations(options = {}) {
         traces: () => traceStoreMigrations(),
         evaluation: () => evaluationStoreMigrations(),
         circuits: () => circuitStoreMigrations(),
+        tenancy: () => tenantUsageMigrations(),
         prompts: () => promptStoreMigrations(),
         rollups: () => rollupStoreMigrations(),
         vectors: () => {

package/dist/postgres/operations.js

@@ -131,12 +131,12 @@ export class PostgresOperationStore {
     async stats(now, filter) {
         const params = [now];
         const narrowed = filterSql(filter, params);
-        const { rows } = await this.client.query(`SELECT status, count(*)::int AS count,
+        const { rows } = await this.client.query(`SELECT status, kind, count(*)::int AS count,
          min(created_at) FILTER (WHERE status = 'queued') AS oldest,
          count(*) FILTER (WHERE status = 'running' AND (lease_expires_at IS NULL OR lease_expires_at <= $1))::int AS lapsed
        FROM ${this.table}
        WHERE status NOT IN (${TERMINAL})${narrowed}
-       GROUP BY status`, params);
+       GROUP BY status, kind`, params);
         return statsFromRows(rows);
     }
     async prune(before) {
@@ -163,6 +163,10 @@ function filterSql(filter, params) {
         params.push(filter.kindPrefix);
         sql += ` AND substr(kind, 1, char_length($${params.length})) = $${params.length}`;
     }
+    if (filter?.kinds) {
+        params.push([...filter.kinds]);
+        sql += ` AND kind = ANY($${params.length}::text[])`;
+    }
     if (filter?.tenantId !== undefined) {
         params.push(filter.tenantId);
         sql += ` AND doc ->> 'tenantId' = $${params.length}`;
@@ -173,11 +177,14 @@ function statsFromRows(rows) {
     const byStatus = {};
     let oldestQueuedAt;
     let lapsedLeases = 0;
+    const queuedByKind = {};
     for (const row of rows) {
-        byStatus[row.status] = Number(row.count);
+        byStatus[row.status] = (byStatus[row.status] ?? 0) + Number(row.count);
+        if (row.status === 'queued')
+            queuedByKind[row.kind ?? ''] = (queuedByKind[row.kind ?? ''] ?? 0) + Number(row.count);
         if (row.oldest && (!oldestQueuedAt || row.oldest < oldestQueuedAt))
             oldestQueuedAt = row.oldest;
         lapsedLeases += Number(row.lapsed);
     }
-    return { byStatus, ...(oldestQueuedAt ? { oldestQueuedAt } : {}), lapsedLeases };
+    return { byStatus, ...(oldestQueuedAt ? { oldestQueuedAt } : {}), lapsedLeases, queuedByKind };
 }

package/dist/postgres/store.d.ts

@@ -44,6 +44,13 @@ export declare class PostgresStore implements Store {
     migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
     /** Stores an item, keeping its original `createdAt` when it replaces one. */
     put<V>(namespace: StoreNamespace, key: string, value: V, options?: StorePutOptions): Promise<void>;
+    /**
+     * Stores an item only when the stored one's `version` is `expected`, or, with `expected` `null`,
+     * only when none is stored. One statement, so two writers deciding on one version cannot both win.
+     */
+    putIfVersion<V extends {
+        version: number;
+    }>(namespace: StoreNamespace, key: string, value: V, expected: number | null): Promise<boolean>;
     /** Reads an item, or `undefined` when it does not exist or has expired. */
     get<V>(namespace: StoreNamespace, key: string): Promise<StoreItem<V> | undefined>;
     /** Deletes an item. */

package/dist/postgres/store.js

@@ -71,6 +71,27 @@ export class PostgresStore {
             vector ? JSON.stringify(vector) : null,
         ]);
     }
+    async putIfVersion(namespace, key, value, expected) {
+        if (!key.trim())
+            throw new RangeError('A store key must not be empty');
+        const timestamp = this.now().toISOString();
+        const vector = await this.embed(value, undefined);
+        const embedding = vector ? JSON.stringify(vector) : null;
+        const cast = this.options.vectorDimensions ? '::vector' : '::jsonb';
+        const { rows } = expected === null
+            ?
+                await this.client.query(`INSERT INTO ${this.table} (ns_key, key, namespace, value, created_at, updated_at, expires_at, embedding)
+             VALUES ($1, $2, $3::jsonb, $4::jsonb, $5, $5, NULL, $6${cast})
+             ON CONFLICT (ns_key, key) DO UPDATE SET value = EXCLUDED.value, created_at = EXCLUDED.created_at,
+               updated_at = EXCLUDED.updated_at, expires_at = NULL, embedding = EXCLUDED.embedding
+             WHERE ${this.table}.expires_at IS NOT NULL AND ${this.table}.expires_at <= $5
+             RETURNING key`, [namespaceKey(namespace), key, JSON.stringify([...namespace]), JSON.stringify(value), timestamp, embedding])
+            : await this.client.query(`UPDATE ${this.table} SET value = $3::jsonb, updated_at = $4, expires_at = NULL, embedding = $5${cast}
+             WHERE ns_key = $1 AND key = $2 AND (expires_at IS NULL OR expires_at > $4)
+               AND jsonb_typeof(value -> 'version') = 'number' AND (value ->> 'version')::numeric = $6
+             RETURNING key`, [namespaceKey(namespace), key, JSON.stringify(value), timestamp, embedding, expected]);
+        return rows.length > 0;
+    }
     async get(namespace, key) {
         const { rows } = await this.client.query(`SELECT namespace::text AS namespace, key, value::text AS value, created_at, updated_at, expires_at FROM ${this.table}
        WHERE ns_key = $1 AND key = $2 AND (expires_at IS NULL OR expires_at > $3)`, [namespaceKey(namespace), key, this.now().toISOString()]);

package/dist/postgres/tenancy.d.ts

@@ -0,0 +1,43 @@
+import type { TenantUsageStore } from '../server/tenancy.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
+import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
+/** Options for `PostgresTenantUsage`. */
+export interface PostgresTenantUsageOptions {
+    /** Table name, optionally schema-qualified. Defaults to `nexus_tenant_usage`. */
+    table?: string;
+    /** Clock for slot leases and spending periods, in epoch milliseconds. Defaults to `Date.now`. */
+    now?: () => number;
+}
+/** The schema, as statements: every migration's, in order. */
+export declare function tenantUsageMigration(options?: Pick<PostgresTenantUsageOptions, 'table'>): string[];
+/** The versioned schema, which `migrate()` and `nexus db migrate` apply. */
+export declare function tenantUsageMigrations(options?: Pick<PostgresTenantUsageOptions, 'table'>): SchemaMigration[];
+/**
+ * Tenant usage in Postgres, shared by every replica, for a deployment that already runs Postgres
+ * and not Redis. Pass it to `tenantLimits({ usage })`.
+ *
+ * Each key is one row: a tenant's active slots as a JSON map from run to lease expiry, or its spending
+ * in the current period. Every step is a single statement on that row, and Postgres applies
+ * concurrent updates of one row one at a time, re-checking each against the newest version. Two
+ * replicas admitting runs for one tenant at the same moment therefore cannot both take its last slot.
+ */
+export declare class PostgresTenantUsage implements TenantUsageStore {
+    private readonly client;
+    private readonly options;
+    private readonly table;
+    private readonly now;
+    constructor(client: PostgresLikeClient, options?: PostgresTenantUsageOptions);
+    /** Creates the table, or brings it up to date. */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
+    /** Takes a slot for `member` unless `max` live slots are held. Holding one already counts as taken. */
+    acquire(key: string, member: string, max: number, ttlMs: number): Promise<boolean>;
+    /** Frees a slot. Freeing one that is not held does nothing. */
+    release(key: string, member: string): Promise<void>;
+    /** Live slots held under a key. */
+    count(key: string): Promise<number>;
+    /** Adds to a total that resets at `resetAt`, and resolves to the new total. */
+    add(key: string, amount: number, resetAt: number): Promise<number>;
+    /** A total, or 0 once its period has reset. */
+    total(key: string): Promise<number>;
+}

package/dist/postgres/tenancy.js

@@ -0,0 +1,71 @@
+import { quoteTable } from './client.js';
+export function tenantUsageMigration(options = {}) {
+    return tenantUsageMigrations(options).flatMap((migration) => [...migration.statements]);
+}
+export function tenantUsageMigrations(options = {}) {
+    const name = options.table ?? 'nexus_tenant_usage';
+    return [
+        {
+            component: `tenancy:${name}`,
+            version: 1,
+            name: 'create the tenant usage table',
+            statements: [
+                `CREATE TABLE IF NOT EXISTS ${quoteTable(name)} (
+  key text PRIMARY KEY,
+  slots jsonb NOT NULL DEFAULT '{}'::jsonb,
+  total double precision NOT NULL DEFAULT 0,
+  reset_at double precision
+)`,
+            ],
+        },
+    ];
+}
+export class PostgresTenantUsage {
+    client;
+    options;
+    table;
+    now;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+        this.table = quoteTable(options.table ?? 'nexus_tenant_usage');
+        this.now = options.now ?? Date.now;
+    }
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await import('./migrations.js');
+        return applyPostgresMigrations(this.client, tenantUsageMigrations(this.options), options);
+    }
+    async acquire(key, member, max, ttlMs) {
+        const now = this.now();
+        await this.client.query(`INSERT INTO ${this.table} (key) VALUES ($1) ON CONFLICT (key) DO NOTHING`, [key]);
+        const live = `(SELECT COALESCE(jsonb_object_agg(slot.member, slot.expires), '{}'::jsonb)
+      FROM jsonb_each(${this.table}.slots) AS slot(member, expires)
+      WHERE (slot.expires #>> '{}')::double precision > $3)`;
+        const { rows } = await this.client.query(`UPDATE ${this.table}
+       SET slots = CASE WHEN ${live} ? $2 THEN ${live} ELSE ${live} || jsonb_build_object($2::text, $4::double precision) END
+       WHERE key = $1 AND (${live} ? $2 OR (SELECT count(*) FROM jsonb_object_keys(${live})) < $5)
+       RETURNING key`, [key, member, now, now + ttlMs, max]);
+        return rows.length > 0;
+    }
+    async release(key, member) {
+        await this.client.query(`UPDATE ${this.table} SET slots = slots - $2::text WHERE key = $1`, [key, member]);
+    }
+    async count(key) {
+        const { rows } = await this.client.query(`SELECT count(*)::int AS held FROM ${this.table}, jsonb_each(${this.table}.slots) AS slot(member, expires)
+       WHERE key = $1 AND (slot.expires #>> '{}')::double precision > $2`, [key, this.now()]);
+        return Number(rows[0]?.held ?? 0);
+    }
+    async add(key, amount, resetAt) {
+        const { rows } = await this.client.query(`INSERT INTO ${this.table} (key, total, reset_at) VALUES ($1, $2, $3)
+       ON CONFLICT (key) DO UPDATE SET
+         total = CASE WHEN ${this.table}.reset_at IS NOT NULL AND ${this.table}.reset_at <= $4
+           THEN EXCLUDED.total ELSE ${this.table}.total + EXCLUDED.total END,
+         reset_at = EXCLUDED.reset_at
+       RETURNING total`, [key, amount, resetAt, this.now()]);
+        return Number(rows[0]?.total ?? 0);
+    }
+    async total(key) {
+        const { rows } = await this.client.query(`SELECT CASE WHEN reset_at IS NULL OR reset_at > $2 THEN total ELSE 0 END AS total FROM ${this.table} WHERE key = $1`, [key, this.now()]);
+        return Number(rows[0]?.total ?? 0);
+    }
+}

package/dist/prompts/file.js

@@ -38,20 +38,24 @@ export class FilePromptStore {
     }
     async setLabel(label, expected) {
         const file = this.labelFile(label.name, label.label);
-        if (expected !== undefined) {
-            const current = await readJson(file);
-            if (expected === null ? current !== undefined : current?.version !== expected)
-                return false;
-        }
-        await writeJson(file, label);
-        return true;
+        return serialized(file, async () => {
+            if (expected !== undefined) {
+                const current = await readJson(file);
+                if (expected === null ? current !== undefined : current?.version !== expected)
+                    return false;
+            }
+            await writeJson(file, label);
+            return true;
+        });
     }
     async deleteLabel(name, label) {
         const file = this.labelFile(name, label);
-        if ((await readJson(file)) === undefined)
-            return false;
-        await rm(file, { force: true });
-        return true;
+        return serialized(file, async () => {
+            if ((await readJson(file)) === undefined)
+                return false;
+            await rm(file, { force: true });
+            return true;
+        });
     }
     async appendHistory(entry) {
         await mkdir(this.promptDir(entry.name), { recursive: true });
@@ -109,6 +113,19 @@ async function readJson(file) {
         return undefined;
     }
 }
+const labelWrites = new Map();
+async function serialized(file, work) {
+    const key = path.resolve(file);
+    const next = (labelWrites.get(key) ?? Promise.resolve()).catch(() => undefined).then(work);
+    labelWrites.set(key, next);
+    try {
+        return await next;
+    }
+    finally {
+        if (labelWrites.get(key) === next)
+            labelWrites.delete(key);
+    }
+}
 async function writeJson(file, value) {
     await mkdir(path.dirname(file), { recursive: true });
     const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;