@klhapp/skillmux 1.9.3 → 1.10.0

package/src/router-core.ts

@@ -4,6 +4,8 @@ import { join } from "node:path";
 import { buildAuditRow } from "./audit";
 import { embeddingDimension, embeddingFingerprint, expandHome, loadConfig } from "./config";
 import { RemoteInferenceError } from "./clients";
+import { log } from "./logger";
+import { warn } from "./output";
 import {
   deleteSkill,
   findExactMatch,
@@ -274,7 +276,7 @@ export async function syncVaultIfNeeded(): Promise<void> {
     const invalidIds: string[] = [];
     const skills = await scanVaults(vaultPath, localVaultPaths, (skillId, error) => {
       invalidIds.push(skillId);
-      console.error(`warning: keeping previous index entry for ${skillId}: ${error}`);
+      warn(`keeping previous index entry for ${skillId}: ${error}`);
     });
     const rows = skills.map(toSkillRow);
     // See rebuildIndex: a skill_id invalid in one root can still be valid in
@@ -361,7 +363,7 @@ async function reindexOneSkill(db: Database, vaultPath: string, skillId: string)
     upsertSkill(db, await readSkill(vaultPath, skillId));
     backfillEmbeddings().catch(() => {});
   } catch (error) {
-    console.error(`warning: keeping previous index entry for ${skillId}: ${error}`);
+    warn(`keeping previous index entry for ${skillId}: ${error}`);
   }
 }
 
@@ -395,7 +397,7 @@ export async function startVaultWatcher(): Promise<() => void> {
   // A watcher error (e.g. the vault root disappearing) must degrade the index,
   // not crash the server — an unhandled 'error' event would throw.
   watcher.on("error", (error) => {
-    console.error(`warning: vault watcher error, live updates paused: ${error}`);
+    warn(`vault watcher error, live updates paused: ${error}`);
   });
 
   return () => {
@@ -554,14 +556,7 @@ export async function retrieveAndRerank(
       retrieval = "lexical";
       degraded_from = clients.rerank ? "reranked" : "hybrid";
       degradation_reason = classifyInferenceError("embedding", embedRes.error);
-      console.error(
-        JSON.stringify({
-          level: "warn",
-          stage: "embedding",
-          degraded_from,
-          reason: degradation_reason,
-        }),
-      );
+      log.warn("embedding", { degraded_from, reason: degradation_reason });
     } else {
       try {
         const queryVec = (embedRes as Float32Array[])[0];
@@ -574,14 +569,7 @@ export async function retrieveAndRerank(
         retrieval = "lexical";
         degraded_from = clients.rerank ? "reranked" : "hybrid";
         degradation_reason = classifyInferenceError("embedding", embedError);
-        console.error(
-          JSON.stringify({
-            level: "warn",
-            stage: "embedding",
-            degraded_from,
-            reason: degradation_reason,
-          }),
-        );
+        log.warn("embedding", { degraded_from, reason: degradation_reason });
       }
     }
   }
@@ -601,14 +589,7 @@ export async function retrieveAndRerank(
       scores = null;
       degraded_from = "reranked";
       degradation_reason = classifyInferenceError("reranker", rerankError);
-      console.error(
-        JSON.stringify({
-          level: "warn",
-          stage: "reranker",
-          degraded_from,
-          reason: degradation_reason,
-        }),
-      );
+      log.warn("reranker", { degraded_from, reason: degradation_reason });
     }
   }
 

package/src/server.ts

@@ -16,13 +16,15 @@ import {
   resolveSkill,
 } from "./router-core";
 import { closeRuntime, getRuntime, startVaultWatcher } from "./router-core";
-import { getStats, SINCE_PATTERN } from "./stats";
+import { getStats, parseSince, SINCE_PATTERN } from "./stats";
+import { countPrunable, insertAdminAuditRow, pruneAuditBefore, type AdminAuditChange } from "./db";
+import { buildPromotedCases, evalVault, queryPromotableFetches } from "./eval";
 import { SKILL_ID_PATTERN } from "./vault";
 import { MetricsRegistry } from "./metrics";
 import { ReadinessState } from "./readiness";
 import { initializeRuntime } from "./lifecycle";
 import { buildRedactor } from "./redact";
-import { insertAdminAuditRow, type AdminAuditChange } from "./db";
+import { redactedErrorLog } from "./logger";
 import type { Clients, Config } from "./types";
 import {
   computeHash,
@@ -41,16 +43,6 @@ export const readinessState = new ReadinessState();
 const DEFAULT_MAX_BODY_BYTES = 1_048_576; // 1 MiB
 const DEFAULT_MAX_CONCURRENT_REQUESTS = 100;
 
-/** Pairs a fixed log prefix with a redacted error message, for console.error. */
-export function redactedErrorLog(
-  prefix: string,
-  err: unknown,
-  redact: (text: string) => string,
-): [string, string] {
-  const msg = err instanceof Error ? err.message : String(err);
-  return [prefix, redact(msg)];
-}
-
 export interface ServerHandle {
   port?: number;
   statsPort?: number;
@@ -409,7 +401,7 @@ export async function startServer(opts?: {
             allowed_origins: [],
           };
           const origin = req.headers.get("origin") || "";
-          const allowedOrigins = serverConfig.allowed_origins;
+          const allowedOrigins = serverConfig.allowed_origins || [];
           const isAllowed =
             allowedOrigins.includes("*") || allowedOrigins.includes(origin);
           const allowOriginHeader = isAllowed
@@ -700,6 +692,161 @@ export async function startServer(opts?: {
               });
             }
 
+            if (
+              req.method === "POST" &&
+              url.pathname === "/admin/v1/audit/prune"
+            ) {
+              let body: {
+                older_than?: string;
+                dry_run?: boolean;
+                confirm?: boolean;
+              } = {};
+              try {
+                const text = await req.text();
+                if (text.trim()) {
+                  body = JSON.parse(text);
+                }
+              } catch {
+                return new Response(
+                  JSON.stringify({
+                    error: "INVALID_JSON",
+                    message: "Request body must be valid JSON",
+                  }),
+                  { status: 400, headers },
+                );
+              }
+
+              const dryRun = body.dry_run ?? false;
+              const confirm = body.confirm ?? false;
+              if (!dryRun && !confirm) {
+                return new Response(
+                  JSON.stringify({
+                    error: "CONFIRMATION_REQUIRED",
+                    message:
+                      "Non-dry-run audit prune requires confirm: true",
+                  }),
+                  { status: 400, headers },
+                );
+              }
+
+              const { effective } = await getEffectiveConfig(configPath);
+              let cutoff: Date;
+              if (body.older_than) {
+                try {
+                  cutoff = parseSince(body.older_than);
+                } catch (err: any) {
+                  return new Response(
+                    JSON.stringify({
+                      error: "INVALID_CUTOFF",
+                      message: err.message,
+                    }),
+                    { status: 400, headers },
+                  );
+                }
+              } else {
+                const retentionDays = effective.audit?.retention_days ?? 90;
+                if (retentionDays <= 0) {
+                  return new Response(
+                    JSON.stringify({
+                      audit_deleted: 0,
+                      fetch_deleted: 0,
+                      admin_audit_deleted: 0,
+                      dry_run: dryRun,
+                      cutoff: null,
+                    }),
+                    { status: 200, headers },
+                  );
+                }
+                cutoff = new Date(Date.now() - retentionDays * 86_400_000);
+              }
+              const cutoffIso = cutoff.toISOString();
+
+              const { auditDb } = await getRuntime();
+              if (dryRun) {
+                const counts = countPrunable(auditDb, cutoffIso);
+                return new Response(
+                  JSON.stringify({
+                    ...counts,
+                    dry_run: true,
+                    cutoff: cutoffIso,
+                  }),
+                  { status: 200, headers },
+                );
+              }
+
+              const counts = pruneAuditBefore(auditDb, cutoffIso);
+              return new Response(
+                JSON.stringify({
+                  ...counts,
+                  dry_run: false,
+                  cutoff: cutoffIso,
+                }),
+                { status: 200, headers },
+              );
+            }
+
+            if (req.method === "POST" && url.pathname === "/admin/v1/eval") {
+              const report = await evalVault();
+              return new Response(JSON.stringify(report), {
+                status: 200,
+                headers,
+              });
+            }
+
+            if (
+              req.method === "POST" &&
+              url.pathname === "/admin/v1/eval/promote"
+            ) {
+              let body: { since?: string } = {};
+              try {
+                const text = await req.text();
+                if (text.trim()) {
+                  body = JSON.parse(text);
+                }
+              } catch {
+                return new Response(
+                  JSON.stringify({
+                    error: "INVALID_JSON",
+                    message: "Request body must be valid JSON",
+                  }),
+                  { status: 400, headers },
+                );
+              }
+
+              if (!body.since || typeof body.since !== "string") {
+                return new Response(
+                  JSON.stringify({
+                    error: "MISSING_SINCE",
+                    message: "Field 'since' is required",
+                  }),
+                  { status: 400, headers },
+                );
+              }
+
+              let sinceDate: Date;
+              try {
+                sinceDate = parseSince(body.since);
+              } catch (err: any) {
+                return new Response(
+                  JSON.stringify({
+                    error: "INVALID_SINCE",
+                    message: err.message,
+                  }),
+                  { status: 400, headers },
+                );
+              }
+              const sinceIso = sinceDate.toISOString();
+
+              const { auditDb } = await getRuntime();
+              const candidates = buildPromotedCases(
+                queryPromotableFetches(auditDb, sinceIso),
+              );
+              return new Response(JSON.stringify({ candidates }), {
+                status: 200,
+                headers,
+              });
+            }
+
             return new Response("Not Found", { status: 404, headers });
           }
 

package/src/toml-writer.ts

@@ -0,0 +1,51 @@
+export function stringifyToml(obj: Record<string, any>): string {
+  let out = "";
+  const topLevel: Record<string, any> = {};
+  const sections: Record<string, any> = {};
+
+  for (const [k, v] of Object.entries(obj)) {
+    if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+      sections[k] = v;
+    } else {
+      topLevel[k] = v;
+    }
+  }
+
+  for (const [k, v] of Object.entries(topLevel)) {
+    out += `${k} = ${formatTomlVal(v)}\n`;
+  }
+  if (Object.keys(topLevel).length > 0) out += "\n";
+
+  for (const [secName, secObj] of Object.entries(sections)) {
+    out += stringifyTomlSection([secName], secObj);
+  }
+
+  return out;
+}
+
+export function stringifyTomlSection(path: string[], obj: Record<string, any>): string {
+  let out = `[${path.join(".")}]\n`;
+  const subSections: Record<string, any> = {};
+
+  for (const [k, v] of Object.entries(obj)) {
+    if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+      subSections[k] = v;
+    } else {
+      out += `${k} = ${formatTomlVal(v)}\n`;
+    }
+  }
+  out += "\n";
+
+  for (const [subName, subObj] of Object.entries(subSections)) {
+    out += stringifyTomlSection([...path, subName], subObj);
+  }
+
+  return out;
+}
+
+export function formatTomlVal(v: unknown): string {
+  if (typeof v === "string") return JSON.stringify(v);
+  if (typeof v === "boolean" || typeof v === "number") return String(v);
+  if (Array.isArray(v)) return JSON.stringify(v);
+  return JSON.stringify(v);
+}