@ornexus/neocortex 4.0.1 → 4.0.2

package/packages/client/dist/resolvers/remote-resolver.js

@@ -1,282 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- *
- * This file is part of Neocortex CLI, licensed under the
- * Functional Source License, Version 1.1 (FSL-1.1).
- *
- * Change Date: February 20, 2029
- * Change License: MIT
- *
- * See the LICENSE file in the project root for full license text.
- */
-import { ResolverMode, NoOpCache, } from '../types/index.js';
-import { InMemoryAssetCache } from '../cache/in-memory-asset-cache.js';
-// ── Constants ────────────────────────────────────────────────────────────
-const DEFAULT_TIMEOUT_MS = 30_000;
-const DEFAULT_RETRY_COUNT = 3;
-const BACKOFF_BASE_MS = 1_000;
-const BACKOFF_MAX_MS = 10_000;
-// ── Error Types ──────────────────────────────────────────────────────────
-export class RemoteResolverError extends Error {
-    statusCode;
-    endpoint;
-    constructor(message, statusCode, endpoint) {
-        super(message);
-        this.statusCode = statusCode;
-        this.endpoint = endpoint;
-        this.name = 'RemoteResolverError';
-    }
-}
-// ── RemoteResolver Implementation ───────────────────────────────────────
-export class RemoteResolver {
-    mode = ResolverMode.REMOTE;
-    serverUrl;
-    licenseKey;
-    timeout;
-    retryCount;
-    /**
-     * Persistent cache -- used for registry only.
-     * P70.06: NEVER used for step/skill/standard content (those live in
-     * `assetCache` and only in process memory).
-     */
-    cache;
-    /**
-     * In-memory LRU cache for asset content (Epic P70.06).
-     * Volatile: discarded on process exit. Never persisted to disk.
-     */
-    assetCache;
-    licenseClient;
-    constructor(options) {
-        this.serverUrl = options.serverUrl.replace(/\/+$/, '');
-        this.licenseKey = options.licenseKey;
-        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
-        this.retryCount = options.retryCount ?? DEFAULT_RETRY_COUNT;
-        this.cache = options.cacheProvider ?? new NoOpCache();
-        this.licenseClient = options.licenseClient ?? null;
-        // P70.06: asset content always lives in volatile memory cache.
-        this.assetCache = new InMemoryAssetCache();
-    }
-    async resolveStep(stepId, _context) {
-        // P70.06: step content in-memory only
-        const cacheKey = `step:${stepId}`;
-        return this.fetchWithInMemoryCache(cacheKey, {
-            method: 'GET',
-            path: `/api/v1/steps/${encodeURIComponent(stepId)}`,
-        });
-    }
-    async resolveSkill(skillId, _context) {
-        // P70.06: skill content in-memory only
-        const cacheKey = `skill:${skillId}`;
-        return this.fetchWithInMemoryCache(cacheKey, {
-            method: 'GET',
-            path: `/api/v1/skills/${encodeURIComponent(skillId)}`,
-        });
-    }
-    async resolveStandard(standardId) {
-        // P70.06: standard content in-memory only
-        const cacheKey = `standard:${standardId}`;
-        return this.fetchWithInMemoryCache(cacheKey, {
-            method: 'GET',
-            path: `/api/v1/standards/${encodeURIComponent(standardId)}`,
-        });
-    }
-    async resolveRegistry() {
-        // Registry is NOT asset content -- it's tokenized metadata (P70.02).
-        // Persistent cache is acceptable here.
-        const cacheKey = 'registry';
-        return this.fetchWithCacheFallback(cacheKey, {
-            method: 'GET',
-            path: '/api/v1/registry',
-        });
-    }
-    async assemblePrompt(stepId, context) {
-        // assemblePrompt is not cached because it depends on dynamic context
-        return this.fetchWithRetry({
-            method: 'POST',
-            path: '/api/v1/prompts/assemble',
-            body: {
-                stepId,
-                context,
-            },
-        });
-    }
-    async isAvailable() {
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 5_000);
-            const response = await fetch(`${this.serverUrl}/api/v1/health`, {
-                method: 'GET',
-                headers: await this.buildHeaders(),
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    async dispose() {
-        await this.cache.clear();
-        // P70.06: explicit asset cache clear (defense-in-depth; process exit
-        // already releases it).
-        await this.assetCache.clear();
-    }
-    // ── Private Methods ─────────────────────────────────────────────────
-    /**
-     * Build authorization headers for API requests.
-     * When a LicenseClient is available, uses JWT token from it.
-     * Story 31.04: NEVER sends raw license key as Bearer token.
-     * If JWT is unavailable, omits Authorization header entirely.
-     * Server will return 401, which fetchWithRetry handles via forceRefresh.
-     */
-    async buildHeaders() {
-        const headers = {
-            'Content-Type': 'application/json',
-            'X-Client-Version': '0.1.0',
-        };
-        if (this.licenseClient) {
-            const jwt = await this.licenseClient.getToken();
-            if (jwt) {
-                headers['Authorization'] = `Bearer ${jwt}`;
-            }
-            // No JWT available: omit Authorization header entirely
-            // Server will return 401, which fetchWithRetry handles via forceRefresh
-        }
-        return headers;
-    }
-    /**
-     * Execute HTTP request with retry and exponential backoff.
-     * Handles 401 specially: if a licenseClient is available, attempts
-     * forceRefresh() and retries once with the new token.
-     */
-    async fetchWithRetry(options) {
-        let lastError;
-        let authRetried = false;
-        for (let attempt = 0; attempt <= this.retryCount; attempt++) {
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-                const url = `${this.serverUrl}${options.path}`;
-                const fetchOptions = {
-                    method: options.method,
-                    headers: await this.buildHeaders(),
-                    signal: controller.signal,
-                };
-                if (options.body) {
-                    fetchOptions.body = JSON.stringify(options.body);
-                }
-                const response = await fetch(url, fetchOptions);
-                clearTimeout(timeoutId);
-                if (!response.ok) {
-                    const errorBody = await response.text().catch(() => 'Unknown error');
-                    // 401: attempt token refresh once if licenseClient is available
-                    if (response.status === 401 && !authRetried && this.licenseClient) {
-                        authRetried = true;
-                        const newToken = await this.licenseClient.forceRefresh();
-                        if (newToken) {
-                            // Retry immediately with the new token (don't count as a normal retry)
-                            attempt--; // offset the loop increment so this doesn't consume a retry
-                            continue;
-                        }
-                        // forceRefresh failed - throw immediately
-                        throw new RemoteResolverError(`API error: ${response.status} ${response.statusText} - ${errorBody}`, response.status, options.path);
-                    }
-                    // Don't retry on 4xx client errors (except 429 rate limit)
-                    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-                        throw new RemoteResolverError(`API error: ${response.status} ${response.statusText} - ${errorBody}`, response.status, options.path);
-                    }
-                    // Retry on 5xx server errors and 429 rate limit
-                    throw new RemoteResolverError(`Server error: ${response.status} ${response.statusText}`, response.status, options.path);
-                }
-                return (await response.json());
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                // Don't retry on non-retryable errors (4xx except 429)
-                if (error instanceof RemoteResolverError && error.statusCode && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
-                    throw error;
-                }
-                // Apply backoff before next retry (except on last attempt)
-                if (attempt < this.retryCount) {
-                    const backoff = Math.min(BACKOFF_BASE_MS * Math.pow(2, attempt), BACKOFF_MAX_MS);
-                    // Add jitter (0-25% of backoff)
-                    const jitter = Math.random() * backoff * 0.25;
-                    await this.sleep(backoff + jitter);
-                }
-            }
-        }
-        throw lastError ?? new RemoteResolverError('All retry attempts failed', undefined, options.path);
-    }
-    /**
-     * Fetch with persistent cache fallback: try HTTP first, fall back to cache
-     * on failure. On successful HTTP response, update the cache.
-     *
-     * P70.06: ONLY the registry uses this path. Asset content (step/skill/
-     * standard) uses {@link fetchWithInMemoryCache} so it never touches disk.
-     */
-    async fetchWithCacheFallback(cacheKey, options) {
-        try {
-            const result = await this.fetchWithRetry(options);
-            // Update cache with fresh data (fire-and-forget)
-            this.cache.set(cacheKey, JSON.stringify(result)).catch(() => {
-                // Cache write failures are non-critical
-            });
-            return result;
-        }
-        catch (error) {
-            // Try cache fallback
-            const cached = await this.cache.get(cacheKey);
-            if (cached !== null) {
-                try {
-                    return JSON.parse(cached);
-                }
-                catch {
-                    // Invalid cache data, rethrow original error
-                }
-            }
-            throw error;
-        }
-    }
-    /**
-     * P70.06: fetch with VOLATILE in-memory cache fallback.
-     *
-     * Identical structure to {@link fetchWithCacheFallback} but the backing
-     * store is {@link InMemoryAssetCache} -- entries live only in the running
-     * process memory, never written to disk.
-     *
-     * When the server is unreachable and the in-memory cache is empty (e.g.
-     * first invocation of a fresh CLI process), the original error is
-     * re-thrown instead of silently degrading to a stale disk cache.
-     */
-    async fetchWithInMemoryCache(cacheKey, options) {
-        try {
-            const result = await this.fetchWithRetry(options);
-            // Update volatile cache (fire-and-forget)
-            this.assetCache.set(cacheKey, JSON.stringify(result)).catch(() => {
-                // Cache write failures are non-critical
-            });
-            return result;
-        }
-        catch (error) {
-            // Try in-memory fallback -- NEVER fall back to disk cache
-            const cached = await this.assetCache.get(cacheKey);
-            if (cached !== null) {
-                try {
-                    return JSON.parse(cached);
-                }
-                catch {
-                    // Invalid cache data, rethrow original error
-                }
-            }
-            throw error;
-        }
-    }
-    /**
-     * Sleep for the specified duration.
-     */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}
+import{ResolverMode as y,NoOpCache as d}from"../types/index.js";import{InMemoryAssetCache as m}from"../cache/in-memory-asset-cache.js";const C=3e4,f=3,w=1e3,p=1e4;class o extends Error{statusCode;endpoint;constructor(t,e,s){super(t),this.statusCode=e,this.endpoint=s,this.name="RemoteResolverError"}}class ${mode=y.REMOTE;serverUrl;licenseKey;timeout;retryCount;cache;assetCache;licenseClient;constructor(t){this.serverUrl=t.serverUrl.replace(/\/+$/,""),this.licenseKey=t.licenseKey,this.timeout=t.timeout??C,this.retryCount=t.retryCount??f,this.cache=t.cacheProvider??new d,this.licenseClient=t.licenseClient??null,this.assetCache=new m}async resolveStep(t,e){const s=`step:${t}`;return this.fetchWithInMemoryCache(s,{method:"GET",path:`/api/v1/steps/${encodeURIComponent(t)}`})}async resolveSkill(t,e){const s=`skill:${t}`;return this.fetchWithInMemoryCache(s,{method:"GET",path:`/api/v1/skills/${encodeURIComponent(t)}`})}async resolveStandard(t){const e=`standard:${t}`;return this.fetchWithInMemoryCache(e,{method:"GET",path:`/api/v1/standards/${encodeURIComponent(t)}`})}async resolveRegistry(){return this.fetchWithCacheFallback("registry",{method:"GET",path:"/api/v1/registry"})}async assemblePrompt(t,e){return this.fetchWithRetry({method:"POST",path:"/api/v1/prompts/assemble",body:{stepId:t,context:e}})}async isAvailable(){try{const t=new AbortController,e=setTimeout(()=>t.abort(),5e3),s=await fetch(`${this.serverUrl}/api/v1/health`,{method:"GET",headers:await this.buildHeaders(),signal:t.signal});return clearTimeout(e),s.ok}catch{return!1}}async dispose(){await this.cache.clear(),await this.assetCache.clear()}async buildHeaders(){const t={"Content-Type":"application/json","X-Client-Version":"0.1.0"};if(this.licenseClient){const e=await this.licenseClient.getToken();e&&(t.Authorization=`Bearer ${e}`)}return t}async fetchWithRetry(t){let e,s=!1;for(let n=0;n<=this.retryCount;n++)try{const a=new AbortController,c=setTimeout(()=>a.abort(),this.timeout),i=`${this.serverUrl}${t.path}`,h={method:t.method,headers:await this.buildHeaders(),signal:a.signal};t.body&&(h.body=JSON.stringify(t.body));const r=await fetch(i,h);if(clearTimeout(c),!r.ok){const l=await r.text().catch(()=>"Unknown error");if(r.status===401&&!s&&this.licenseClient){if(s=!0,await this.licenseClient.forceRefresh()){n--;continue}throw new o(`API error: ${r.status} ${r.statusText} - ${l}`,r.status,t.path)}throw r.status>=400&&r.status<500&&r.status!==429?new o(`API error: ${r.status} ${r.statusText} - ${l}`,r.status,t.path):new o(`Server error: ${r.status} ${r.statusText}`,r.status,t.path)}return await r.json()}catch(a){if(e=a instanceof Error?a:new Error(String(a)),a instanceof o&&a.statusCode&&a.statusCode>=400&&a.statusCode<500&&a.statusCode!==429)throw a;if(n<this.retryCount){const c=Math.min(w*Math.pow(2,n),p),i=Math.random()*c*.25;await this.sleep(c+i)}}throw e??new o("All retry attempts failed",void 0,t.path)}async fetchWithCacheFallback(t,e){try{const s=await this.fetchWithRetry(e);return this.cache.set(t,JSON.stringify(s)).catch(()=>{}),s}catch(s){const n=await this.cache.get(t);if(n!==null)try{return JSON.parse(n)}catch{}throw s}}async fetchWithInMemoryCache(t,e){try{const s=await this.fetchWithRetry(e);return this.assetCache.set(t,JSON.stringify(s)).catch(()=>{}),s}catch(s){const n=await this.assetCache.get(t);if(n!==null)try{return JSON.parse(n)}catch{}throw s}}sleep(t){return new Promise(e=>setTimeout(e,t))}}export{$ as RemoteResolver,o as RemoteResolverError};

package/packages/client/dist/telemetry/index.js

@@ -1,5 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- */
-export { OfflineTelemetryQueue } from './offline-queue.js';
+import{OfflineTelemetryQueue as r}from"./offline-queue.js";export{r as OfflineTelemetryQueue};

package/packages/client/dist/telemetry/offline-queue.js

@@ -1,131 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- *
- * This file is part of Neocortex CLI, licensed under the
- * Functional Source License, Version 1.1 (FSL-1.1).
- *
- * Change Date: February 20, 2029
- * Change License: MIT
- *
- * See the LICENSE file in the project root for full license text.
- */
-/**
- * @neocortex/client - Offline Telemetry Queue
- *
- * Persistent FIFO queue for telemetry events when the CLI operates offline.
- * Events are stored in a JSON file and flushed when connection is restored.
- * Respects configurable limits on event count (1000) and file size (5MB).
- *
- * Story 42.9
- */
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-// ── Defaults ──────────────────────────────────────────────────────────────
-const DEFAULT_CONFIG = {
-    queueFilePath: join(homedir(), '.neocortex', '.telemetry-queue'),
-    maxEvents: 1_000,
-    maxSizeBytes: 5_242_880, // 5MB
-};
-// ── OfflineTelemetryQueue ────────────────────────────────────────────────
-export class OfflineTelemetryQueue {
-    config;
-    constructor(config) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Add a telemetry event to the queue.
-     * Evicts oldest events if limits are reached.
-     */
-    async enqueue(event) {
-        try {
-            const events = await this.loadQueue();
-            events.push(event);
-            // Evict oldest events if count limit exceeded
-            while (events.length > this.config.maxEvents) {
-                events.shift();
-            }
-            // Evict oldest events if size limit exceeded
-            let serialized = JSON.stringify(events);
-            while (Buffer.byteLength(serialized, 'utf8') > this.config.maxSizeBytes && events.length > 0) {
-                events.shift();
-                serialized = JSON.stringify(events);
-            }
-            await this.saveQueue(events);
-        }
-        catch {
-            // Queue write failures are non-critical
-        }
-    }
-    /**
-     * Flush all queued events using the provided send function.
-     * Returns count of sent and failed events.
-     */
-    async flush(sendFn) {
-        try {
-            const events = await this.loadQueue();
-            if (events.length === 0) {
-                return { sent: 0, failed: 0 };
-            }
-            const success = await sendFn(events);
-            if (success) {
-                await this.saveQueue([]);
-                return { sent: events.length, failed: 0 };
-            }
-            return { sent: 0, failed: events.length };
-        }
-        catch {
-            return { sent: 0, failed: 0 };
-        }
-    }
-    /**
-     * Get queue statistics.
-     */
-    async getStats() {
-        try {
-            const events = await this.loadQueue();
-            const serialized = JSON.stringify(events);
-            return {
-                count: events.length,
-                sizeBytes: Buffer.byteLength(serialized, 'utf8'),
-            };
-        }
-        catch {
-            return { count: 0, sizeBytes: 0 };
-        }
-    }
-    /**
-     * Clear all queued events.
-     */
-    async clear() {
-        try {
-            await this.saveQueue([]);
-        }
-        catch {
-            // Clear failures are non-critical
-        }
-    }
-    // ── Private ─────────────────────────────────────────────────────────
-    async loadQueue() {
-        try {
-            const raw = await readFile(this.config.queueFilePath, 'utf8');
-            const data = JSON.parse(raw);
-            if (!Array.isArray(data))
-                return [];
-            return data;
-        }
-        catch {
-            return [];
-        }
-    }
-    async saveQueue(events) {
-        const dir = dirname(this.config.queueFilePath);
-        await mkdir(dir, { recursive: true });
-        const tmpPath = `${this.config.queueFilePath}.tmp`;
-        await writeFile(tmpPath, JSON.stringify(events), 'utf8');
-        const { rename } = await import('node:fs/promises');
-        await rename(tmpPath, this.config.queueFilePath);
-    }
-}
+import{readFile as a,writeFile as n,mkdir as r}from"node:fs/promises";import{dirname as u}from"node:path";import{join as c}from"node:path";import{homedir as o}from"node:os";const h={queueFilePath:c(o(),".neocortex",".telemetry-queue"),maxEvents:1e3,maxSizeBytes:5242880};class d{config;constructor(t){this.config={...h,...t}}async enqueue(t){try{const e=await this.loadQueue();for(e.push(t);e.length>this.config.maxEvents;)e.shift();let i=JSON.stringify(e);for(;Buffer.byteLength(i,"utf8")>this.config.maxSizeBytes&&e.length>0;)e.shift(),i=JSON.stringify(e);await this.saveQueue(e)}catch{}}async flush(t){try{const e=await this.loadQueue();return e.length===0?{sent:0,failed:0}:await t(e)?(await this.saveQueue([]),{sent:e.length,failed:0}):{sent:0,failed:e.length}}catch{return{sent:0,failed:0}}}async getStats(){try{const t=await this.loadQueue(),e=JSON.stringify(t);return{count:t.length,sizeBytes:Buffer.byteLength(e,"utf8")}}catch{return{count:0,sizeBytes:0}}}async clear(){try{await this.saveQueue([])}catch{}}async loadQueue(){try{const t=await a(this.config.queueFilePath,"utf8"),e=JSON.parse(t);return Array.isArray(e)?e:[]}catch{return[]}}async saveQueue(t){const e=u(this.config.queueFilePath);await r(e,{recursive:!0});const i=`${this.config.queueFilePath}.tmp`;await n(i,JSON.stringify(t),"utf8");const{rename:s}=await import("node:fs/promises");await s(i,this.config.queueFilePath)}}export{d as OfflineTelemetryQueue};

package/packages/client/dist/tier/index.js

@@ -1,5 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- */
-export { TierAwareClient, } from './tier-aware-client.js';
+import{TierAwareClient as i}from"./tier-aware-client.js";export{i as TierAwareClient};