@jagilber-org/index-server 1.28.10 → 1.28.19

package/dist/dashboard/server/routes/embeddings.routes.js

@@ -309,13 +309,47 @@ function createEmbeddingsRoutes(embeddingPathOverride, embeddingStore) {
                     error: 'No instructions loaded in index',
                 });
             }
+            // Pre-flight: detect a no-op (full cache hit) so we can return a clearer
+            // signal to the dashboard instead of pretending we just computed N items.
+            const readiness = (0, embeddingService_js_1.checkModelReadiness)(sem.model, sem.cacheDir, sem.localOnly);
+            let preCached = null;
+            try {
+                if (embeddingStore) {
+                    preCached = embeddingStore.load();
+                }
+                else {
+                    const file = embeddingPathOverride ?? sem.embeddingPath;
+                    if (file && node_fs_1.default.existsSync(file)) {
+                        preCached = JSON.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+                    }
+                }
+            }
+            catch { /* tolerate */ }
+            const currentIds = new Set(state.list.map(i => i.id));
+            const cachedIds = preCached?.embeddings ? new Set(Object.keys(preCached.embeddings)) : new Set();
+            const cachedHashes = preCached?.entryHashes ?? {};
+            const sameModel = preCached?.modelName === sem.model;
+            const sameIndex = preCached?.indexHash === state.hash;
+            const toCompute = state.list.filter(inst => {
+                if (!sameModel)
+                    return true;
+                const h = cachedHashes[inst.id];
+                return !h || h !== inst.sourceHash || !cachedIds.has(inst.id);
+            });
+            const fullHit = sameModel && sameIndex && toCompute.length === 0 && cachedIds.size > 0;
             const start = performance.now();
-            const embeddings = await (0, embeddingService_js_1.getInstructionEmbeddings)(state.list, state.hash, sem.embeddingPath, sem.model, sem.cacheDir, sem.device, sem.localOnly);
+            const embeddings = await (0, embeddingService_js_1.getInstructionEmbeddings)(state.list, state.hash, sem.embeddingPath, sem.model, sem.cacheDir, sem.device, sem.localOnly, undefined, embeddingStore);
             const elapsed = (performance.now() - start).toFixed(0);
             const count = Object.keys(embeddings).length;
+            const computed = fullHit ? 0 : toCompute.length;
+            const reused = count - computed;
             return res.json({
                 success: true,
                 count,
+                computed,
+                reused,
+                cacheHit: fullHit,
+                modelDownloaded: !readiness.cached, // best-effort: model wasn't cached before this call
                 model: sem.model,
                 device: sem.device,
                 elapsedMs: Number(elapsed),
@@ -341,5 +375,46 @@ function createEmbeddingsRoutes(embeddingPathOverride, embeddingStore) {
             });
         }
     });
+    // POST /embeddings/reset — clear cached embeddings (forces full recompute on next compute).
+    // Optionally clears the on-disk model cache so the next compute re-downloads the model.
+    router.post('/embeddings/reset', adminAuth_js_1.dashboardAdminAuth, async (req, res) => {
+        try {
+            const sem = (0, runtimeConfig_js_1.getRuntimeConfig)().semantic;
+            const clearModel = req.body && req.body.clearModel === true;
+            let embeddingsCleared = false;
+            let modelCacheCleared = false;
+            // Clear embeddings cache (works for both JSON file and SQLite store).
+            if (embeddingStore) {
+                embeddingStore.save({ indexHash: '', modelName: '', entryHashes: {}, embeddings: {} });
+                embeddingsCleared = true;
+            }
+            else {
+                const file = embeddingPathOverride ?? sem.embeddingPath;
+                if (file && node_fs_1.default.existsSync(file)) {
+                    node_fs_1.default.rmSync(file, { force: true });
+                    embeddingsCleared = true;
+                }
+            }
+            // Optionally clear the model cache directory to force a re-download.
+            if (clearModel && sem.cacheDir && node_fs_1.default.existsSync(sem.cacheDir)) {
+                node_fs_1.default.rmSync(sem.cacheDir, { recursive: true, force: true });
+                modelCacheCleared = true;
+            }
+            return res.json({
+                success: true,
+                embeddingsCleared,
+                modelCacheCleared,
+                embeddingPath: embeddingPathOverride ?? sem.embeddingPath,
+                cacheDir: sem.cacheDir,
+            });
+        }
+        catch (err) {
+            return res.status(500).json({
+                success: false,
+                error: 'Failed to reset embeddings',
+                message: err.message,
+            });
+        }
+    });
     return router;
 }

package/dist/dashboard/server/routes/instructions.routes.js

@@ -16,6 +16,7 @@ const registry_js_1 = require("../../../server/registry.js");
 const indexContext_js_1 = require("../../../services/indexContext.js");
 const adminAuth_js_1 = require("./adminAuth.js");
 const handlers_search_js_1 = require("../../../services/handlers.search.js");
+const instruction_js_1 = require("../../../models/instruction.js");
 const schemaVersion_js_1 = require("../../../versioning/schemaVersion.js");
 const runtimeConfig_js_1 = require("../../../config/runtimeConfig.js");
 const instructionRecordValidation_js_1 = require("../../../services/instructionRecordValidation.js");
@@ -123,17 +124,9 @@ function dashboardRequirement(value) {
     }
 }
 function dashboardContentType(value) {
-    switch (value) {
-        case 'template':
-        case 'workflow':
-        case 'reference':
-        case 'example':
-        case 'agent':
-        case 'instruction':
-            return value;
-        default:
-            return 'instruction';
-    }
+    return typeof value === 'string' && instruction_js_1.CONTENT_TYPES.includes(value)
+        ? value
+        : 'instruction';
 }
 function createInstructionsRoutes() {
     const router = (0, express_1.Router)();

package/dist/dashboard/server/routes/scripts.routes.js

@@ -56,18 +56,48 @@ function createScriptsRoutes() {
             });
             return;
         }
-        try {
-            const scriptsDir = path_1.default.join(process.cwd(), 'scripts', 'dist');
+        // Candidate dirs (first existing wins):
+        //  1. Installed package layout: <pkg-root>/scripts/client (resolved from __dirname = dist/dashboard/server/routes)
+        //  2. Installed package layout (alt): <pkg-root>/scripts/dist (legacy)
+        //  3. Repo dev layout: <cwd>/scripts/client
+        //  4. Repo dev layout (legacy): <cwd>/scripts/dist
+        const pkgRoot = path_1.default.resolve(__dirname, '..', '..', '..', '..');
+        const candidateDirs = [
+            path_1.default.join(pkgRoot, 'scripts', 'client'),
+            path_1.default.join(pkgRoot, 'scripts', 'dist'),
+            path_1.default.join(process.cwd(), 'scripts', 'client'),
+            path_1.default.join(process.cwd(), 'scripts', 'dist'),
+        ];
+        let content;
+        let lastErr;
+        for (const scriptsDir of candidateDirs) {
             const filePath = path_1.default.join(scriptsDir, meta.file); // nosemgrep: javascript.express.security.audit.express-path-join-resolve-traversal.express-path-join-resolve-traversal -- path validated below via startsWith check
             let resolved;
             try {
                 resolved = (0, pathContainment_js_1.validatePathContainment)(path_1.default.resolve(filePath), scriptsDir); // nosemgrep: javascript.express.security.audit.express-path-join-resolve-traversal.express-path-join-resolve-traversal -- containment validated by shared helper
             }
             catch {
-                res.status(400).json({ error: 'Invalid script path' });
+                continue;
+            }
+            try {
+                content = await (0, promises_1.readFile)(resolved, 'utf-8');
+                break;
+            }
+            catch (err) {
+                lastErr = err;
+            }
+        }
+        try {
+            if (content === undefined) {
+                const message = lastErr instanceof Error ? lastErr.message : String(lastErr);
+                if (!lastErr || message.includes('ENOENT')) {
+                    res.status(404).json({ error: `Script file not found on disk: ${name}` });
+                }
+                else {
+                    res.status(500).json({ error: `Failed to read script: ${message}` });
+                }
                 return;
             }
-            const content = await (0, promises_1.readFile)(resolved, 'utf-8');
             res.setHeader('Content-Type', meta.contentType);
             res.setHeader('Content-Disposition', `attachment; filename="${meta.file}"`);
             res.setHeader('X-Content-Type-Options', 'nosniff');
@@ -75,12 +105,7 @@ function createScriptsRoutes() {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            if (message.includes('ENOENT')) {
-                res.status(404).json({ error: `Script file not found on disk: ${name}` });
-            }
-            else {
-                res.status(500).json({ error: `Failed to read script: ${message}` });
-            }
+            res.status(500).json({ error: `Failed to send script: ${message}` });
         }
     });
     return router;

package/dist/dashboard/server/routes/status.routes.js

@@ -11,6 +11,7 @@ exports.createStatusRoutes = createStatusRoutes;
 const express_1 = require("express");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
 const v8_1 = __importDefault(require("v8"));
 const runtimeConfig_js_1 = require("../../../config/runtimeConfig.js");
 const logger_js_1 = require("../../../services/logger.js");
@@ -73,6 +74,7 @@ function createStatusRoutes(metricsCollector) {
             const snapshot = metricsCollector.getCurrentSnapshot();
             const git = getGitCommit();
             const buildTime = getBuildTime();
+            const cfg = (0, runtimeConfig_js_1.getRuntimeConfig)();
             // Prevent stale caching of build/version metadata in browsers / proxies
             res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
             res.setHeader('Pragma', 'no-cache');
@@ -84,6 +86,12 @@ function createStatusRoutes(metricsCollector) {
                 buildTime: buildTime || undefined,
                 uptime: snapshot.server.uptime,
                 startTime: snapshot.server.startTime,
+                paths: {
+                    instructionsDir: cfg.index.baseDir,
+                    storageBackend: cfg.storage.backend,
+                    sqlitePath: cfg.storage.backend === 'sqlite' ? cfg.storage.sqlitePath : undefined,
+                    backupsDir: cfg.dashboard.admin.backupsDir,
+                },
                 timestamp: Date.now(),
             });
         }
@@ -151,6 +159,75 @@ function createStatusRoutes(metricsCollector) {
             });
         }
     });
+    /**
+     * POST /api/system/reveal-path - Open one of the configured paths in the OS
+     * file manager. Accepts only a fixed allowlist key (instructions | sqlite |
+     * backups) — the server resolves the actual path from runtime config so the
+     * client cannot supply an arbitrary filesystem path.
+     *
+     * Loopback-only by virtue of the dashboard binding to 127.0.0.1.
+     */
+    router.post('/system/reveal-path', (req, res) => {
+        try {
+            const key = String((req.body && req.body.key) || '');
+            const cfg = (0, runtimeConfig_js_1.getRuntimeConfig)();
+            let target;
+            switch (key) {
+                case 'instructions':
+                    target = cfg.index.baseDir;
+                    break;
+                case 'sqlite':
+                    target = cfg.storage.backend === 'sqlite' ? cfg.storage.sqlitePath : undefined;
+                    break;
+                case 'backups':
+                    target = cfg.dashboard.admin.backupsDir;
+                    break;
+                default:
+                    return res.status(400).json({ success: false, error: `unknown key: ${key}` });
+            }
+            if (!target) {
+                return res.status(404).json({ success: false, error: `path not configured for key: ${key}` });
+            }
+            // For files (e.g. sqlite db) reveal the parent directory instead of trying
+            // to open the file itself in the file manager.
+            let toOpen = target;
+            try {
+                if (fs_1.default.existsSync(target) && fs_1.default.statSync(target).isFile()) {
+                    toOpen = path_1.default.dirname(target);
+                }
+                else if (!fs_1.default.existsSync(target)) {
+                    // Fall back to the parent if the leaf does not exist yet.
+                    toOpen = path_1.default.dirname(target);
+                }
+            }
+            catch { /* ignore stat errors, attempt original */ }
+            // Platform-appropriate "open folder" command. All args are server-derived
+            // from runtime config; no user input ever reaches the spawned argv.
+            let cmd;
+            let args;
+            if (process.platform === 'win32') {
+                cmd = 'explorer.exe';
+                args = [toOpen];
+            }
+            else if (process.platform === 'darwin') {
+                cmd = 'open';
+                args = [toOpen];
+            }
+            else {
+                cmd = 'xdg-open';
+                args = [toOpen];
+            }
+            // nosemgrep: javascript.lang.security.audit.detect-child-process.detect-child-process -- args resolved from server-side runtimeConfig allowlist; no user input
+            const child = (0, child_process_1.spawn)(cmd, args, { detached: true, stdio: 'ignore' });
+            child.on('error', () => { });
+            child.unref();
+            res.json({ success: true, key, path: toOpen, timestamp: Date.now() });
+        }
+        catch (error) {
+            (0, logger_js_1.logError)('[API] reveal-path error:', error);
+            res.status(500).json({ success: false, error: 'Failed to reveal path' });
+        }
+    });
     /**
      * GET /api/system/health - Advanced system health metrics
      */

package/dist/models/instruction.d.ts

@@ -1,6 +1,7 @@
 export type AudienceScope = 'individual' | 'group' | 'all';
 export type RequirementLevel = 'mandatory' | 'critical' | 'recommended' | 'optional' | 'deprecated';
-export type ContentType = 'instruction' | 'template' | 'workflow' | 'reference' | 'example' | 'agent';
+export declare const CONTENT_TYPES: readonly ["agent", "skill", "instruction", "prompt", "workflow", "knowledge", "template", "integration"];
+export type ContentType = typeof CONTENT_TYPES[number];
 export interface InstructionEntry {
     id: string;
     title: string;

package/dist/models/instruction.js

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTENT_TYPES = void 0;
+exports.CONTENT_TYPES = ['agent', 'skill', 'instruction', 'prompt', 'workflow', 'knowledge', 'template', 'integration'];