@klhapp/skillmux 1.9.2 → 1.10.0

package/src/clients.ts

@@ -1,5 +1,6 @@
 import type { Clients, Config, RemoteRerankerConfig } from "./types";
 import { expandHome } from "./config";
+import { assertHostAllowed } from "./install";
 import type { pipeline as createPipeline } from "@huggingface/transformers";
 
 export type RemoteErrorKind = "configuration" | "availability" | "protocol";
@@ -34,6 +35,17 @@ function authorizationHeaders(
   return { authorization: `Bearer ${apiKey}` };
 }
 
+function assertInferenceHostAllowed(url: string, allowedHosts: string[] | undefined): void {
+  try {
+    assertHostAllowed(url, allowedHosts);
+  } catch (error) {
+    throw new RemoteInferenceError(
+      "configuration",
+      error instanceof Error ? error.message : String(error),
+    );
+  }
+}
+
 function httpFailure(surface: string, status: number): RemoteInferenceError {
   const kind: RemoteErrorKind =
     status === 401 || status === 403
@@ -196,9 +208,12 @@ async function fetchRerankerScores(
   timeoutMs: number,
   query: string,
   docs: { skill_id: string; text: string }[],
+  allowedHosts: string[] | undefined,
 ): Promise<number[]> {
   if (docs.length === 0) return [];
 
+  assertInferenceHostAllowed(reranker.endpoint, allowedHosts);
+
   let response: Response;
   try {
     response = await fetch(reranker.endpoint, {
@@ -300,6 +315,7 @@ export function createClients(config: Config): Clients {
       }
 
       const embedding = config.inference.embedding;
+      assertInferenceHostAllowed(embedding.endpoint, config.egress?.allowed_hosts);
       let response: Response;
       try {
         response = await fetch(embedding.endpoint, {
@@ -344,6 +360,7 @@ export function createClients(config: Config): Clients {
         inference.timeout_ms,
         query,
         docs,
+        config.egress?.allowed_hosts,
       );
     };
   }

package/src/commands/audit.ts

@@ -1,13 +1,13 @@
-import { expandHome, loadConfig } from "../config";
-import { countPrunable, openAudit, pruneAuditBefore } from "../db";
-import { parseSince } from "../stats";
 import { emitSuccess } from "../output";
 import { confirmIfNeeded } from "./shared";
+import type { TargetAdapter } from "../adapters";
+import type { ResolvedContext } from "../context";
+import { isGlobalFlag, isGlobalFlagWithValue } from "../global-flags";
 
 export async function runAudit(
   subCommand: string,
   args: string[],
-  options: { isJson: boolean; dryRun: boolean },
+  options: { isJson: boolean; dryRun: boolean; target: ResolvedContext; adapter: TargetAdapter },
 ): Promise<void> {
   if (subCommand !== "prune") {
     throw new Error("usage: skillmux audit prune [--older-than <window>] [--dry-run] [--yes] [--json]");
@@ -21,62 +21,65 @@ export async function runAudit(
     if (arg === "--older-than") olderThan = args[++i];
     else if (arg === "--dry-run") dryRun = true;
     else if (arg === "--yes") yes = true;
-    else if (arg === "--json") {
-      // handled globally by main()'s isJson flag; recognized here so it isn't rejected
+    else if (isGlobalFlag(arg, "--json", "--allow-insecure", "--verbose")) {
+      // handled globally by main()'s flags; recognized here so it isn't rejected
+    } else if (isGlobalFlagWithValue(arg)) {
+      i++; // skip flag value
     } else if (arg?.startsWith("--")) {
       throw new Error(`unknown audit prune option: ${arg}`);
     }
   }
 
-  const config = await loadConfig();
-  const stateDir = expandHome(config.state_dir);
-
-  let cutoff: Date;
-  if (olderThan) {
-    cutoff = parseSince(olderThan);
-  } else {
-    const retentionDays = config.audit?.retention_days ?? 90;
-    if (retentionDays <= 0) {
-      emitSuccess(
-        { isJson: options.isJson },
-        { audit_deleted: 0, fetch_deleted: 0, dry_run: dryRun, cutoff: null },
-        () => console.log("prune: audit.retention_days is 0 (pruning disabled); nothing to do"),
-      );
-      return;
-    }
-    cutoff = new Date(Date.now() - retentionDays * 86_400_000);
+  if (dryRun) {
+    const counts = await options.adapter.auditCount(olderThan);
+    emitSuccess(
+      { isJson: options.isJson },
+      counts,
+      () =>
+        console.log(
+          counts.cutoff === null
+            ? "prune: audit.retention_days is 0 (pruning disabled); nothing to do"
+            : `prune: audit=${counts.audit_deleted} fetch=${counts.fetch_deleted} admin_audit=${counts.admin_audit_deleted} (dry-run)`,
+        ),
+    );
+    return;
   }
-  const cutoffIso = cutoff.toISOString();
 
-  const db = openAudit(stateDir);
-  try {
-    if (dryRun) {
-      const counts = countPrunable(db, cutoffIso);
-      emitSuccess(
-        { isJson: options.isJson },
-        { ...counts, dry_run: true, cutoff: cutoffIso },
-        () => console.log(`prune: audit=${counts.audit_deleted} fetch=${counts.fetch_deleted} (dry-run)`),
-      );
-      return;
-    }
-
-    if (
-      !(await confirmIfNeeded({
-        confirmed: yes,
-        isJson: options.isJson,
-        prompt: `prune audit rows older than ${cutoffIso}?`,
-        nonInteractiveError: "skillmux audit prune requires --yes when run non-interactively",
-      }))
-    )
-      return;
-
-    const counts = pruneAuditBefore(db, cutoffIso);
+  // Pre-fetch count / cutoff info for confirmation prompt if local or remote
+  const countResult = await options.adapter.auditCount(olderThan);
+  if (countResult.cutoff === null) {
     emitSuccess(
       { isJson: options.isJson },
-      { ...counts, dry_run: false, cutoff: cutoffIso },
-      () => console.log(`prune: audit=${counts.audit_deleted} fetch=${counts.fetch_deleted}`),
+      { audit_deleted: 0, fetch_deleted: 0, admin_audit_deleted: 0, dry_run: false, cutoff: null },
+      () => console.log("prune: audit.retention_days is 0 (pruning disabled); nothing to do"),
     );
-  } finally {
-    db.close();
+    return;
   }
+
+  if (
+    !(await confirmIfNeeded({
+      confirmed: yes,
+      isJson: options.isJson,
+      prompt: `prune audit rows older than ${countResult.cutoff}?`,
+      nonInteractiveError: "skillmux audit prune requires --yes when run non-interactively",
+    }))
+  )
+    return;
+
+  // Reuse the exact cutoff already shown in the confirmation prompt — recomputing
+  // it here (if olderThan was left unset) could drift from what was confirmed,
+  // e.g. if audit.retention_days changed between the two calls on a remote target.
+  const counts = await options.adapter.auditPrune({
+    older_than: countResult.cutoff,
+    dry_run: false,
+    confirm: true,
+  });
+  emitSuccess(
+    { isJson: options.isJson },
+    counts,
+    () =>
+      console.log(
+        `prune: audit=${counts.audit_deleted} fetch=${counts.fetch_deleted} admin_audit=${counts.admin_audit_deleted}`,
+      ),
+  );
 }

package/src/commands/config.ts

@@ -1,9 +1,10 @@
 import { expandHome, migrateLegacyPaths, resolveConfigPath } from "../config";
 import { type TargetAdapter } from "../adapters";
-import { type ResolvedTarget } from "../context";
+import { type ResolvedContext } from "../context";
 import { applyConfigInit, planConfigInit, type ConfigInitPlan } from "../setup";
 import { emitSuccess, isInteractive, renderTargetBanner } from "../output";
 import { confirmAction } from "./shared";
+import { isGlobalFlag } from "../global-flags";
 function emitConfigInitOutcome(
   ctx: { isJson: boolean },
   opts: {
@@ -40,7 +41,7 @@ export async function handleConfigCommand(
   adapter: TargetAdapter,
   sub: string,
   args: string[],
-  ctx: { target: ResolvedTarget; isJson: boolean; dryRun: boolean },
+  ctx: { target: ResolvedContext; isJson: boolean; dryRun: boolean },
 ) {
   if (sub === "init") {
     let vaultPath: string | undefined;
@@ -53,7 +54,7 @@ export async function handleConfigCommand(
           throw new Error("usage: skillmux config init --vault <path> --yes");
       } else if (option === "--yes") {
         yes = true;
-      } else if (option === "--dry-run" || option === "--json") {
+      } else if (isGlobalFlag(option, "--dry-run", "--json")) {
         continue;
       } else {
         throw new Error(`unknown config init option: ${option}`);
@@ -95,7 +96,7 @@ export async function handleConfigCommand(
       if (!ctx.isJson && isInteractive()) {
         if (
           !(await confirmAction(
-            `Create ${plan.configPath} with vault_path ${plan.vaultPath}?`,
+            `create ${plan.configPath} with vault_path ${plan.vaultPath}?`,
           ))
         ) {
           console.log("config init cancelled; nothing written");
@@ -164,9 +165,7 @@ export async function handleConfigCommand(
   if (sub === "validate") {
     const res = await adapter.configValidate();
     emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      console.log(
-        res.valid ? "Configuration is valid." : "Configuration is invalid.",
-      );
+      console.log(res.valid ? "configuration is valid" : "configuration is invalid");
     });
     return;
   }
@@ -204,11 +203,11 @@ export async function handleConfigCommand(
     const res = await adapter.configStatus();
     emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
       renderTargetBanner(ctx.target);
-      console.log(`Runtime: ${res.runtime}`);
-      console.log(`Deployment runtime: ${res.deployment_runtime}`);
-      console.log(`Image variant: ${res.image_variant ?? "none"}`);
-      console.log(`Active revision: ${res.active_revision}`);
-      console.log(`Readiness: ${res.readiness.status}`);
+      console.log(`runtime: ${res.runtime}`);
+      console.log(`deployment runtime: ${res.deployment_runtime}`);
+      console.log(`image variant: ${res.image_variant ?? "none"}`);
+      console.log(`active revision: ${res.active_revision}`);
+      console.log(`readiness: ${res.readiness.status}`);
     });
     return;
   }

package/src/commands/context.ts

@@ -0,0 +1,103 @@
+import {
+  addContext,
+  getCurrentContext,
+  listContexts,
+  removeContext,
+  useContext,
+  type ResolvedContext,
+} from "../context";
+import {
+  emitSuccess,
+  renderTable,
+  renderTargetBanner,
+} from "../output";
+
+export async function handleContextCommand(
+  sub: string,
+  args: string[],
+  ctx: { target: ResolvedContext; isJson: boolean },
+) {
+  if (sub === "list") {
+    const contexts = await listContexts();
+    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, contexts, () => {
+      renderTargetBanner(ctx.target);
+      renderTable(
+        [
+          { key: "name", header: "NAME" },
+          { key: "server", header: "SERVER" },
+          { key: "token_env", header: "TOKEN_ENV" },
+          { key: "isDefault", header: "DEFAULT" },
+        ],
+        contexts.map((c) => ({
+          ...c,
+          token_env: c.token_env ?? "-",
+          isDefault: c.isDefault ? "*" : "",
+        })),
+      );
+    });
+    return;
+  }
+
+  if (sub === "current") {
+    const current = await getCurrentContext();
+    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, current, () => {
+      renderTargetBanner(ctx.target);
+      console.log(`Current context: ${current.name} (${current.server})`);
+    });
+    return;
+  }
+
+  if (sub === "add") {
+    const name = args[0];
+    let server: string | undefined;
+    let tokenEnv: string | undefined;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--server") server = args[++i];
+      else if (args[i] === "--token-env") tokenEnv = args[++i];
+    }
+    if (!name || !server) {
+      throw new Error(
+        "usage: skillmux context add <name> --server <url> [--token-env <env_name>]",
+      );
+    }
+    await addContext(name, { server, token_env: tokenEnv });
+    emitSuccess(
+      { isJson: ctx.isJson, target: ctx.target },
+      { name, server, token_env: tokenEnv },
+      () => {
+        console.log(`Added context "${name}" -> ${server}`);
+      },
+    );
+    return;
+  }
+
+  if (sub === "use") {
+    const name = args[0];
+    if (!name) throw new Error("usage: skillmux context use <name>");
+    await useContext(name);
+    emitSuccess(
+      { isJson: ctx.isJson, target: ctx.target },
+      { default_context: name },
+      () => {
+        console.log(`Switched default context to "${name}"`);
+      },
+    );
+    return;
+  }
+
+  if (sub === "remove") {
+    const name = args[0];
+    if (!name) throw new Error("usage: skillmux context remove <name>");
+    await removeContext(name);
+    emitSuccess(
+      { isJson: ctx.isJson, target: ctx.target },
+      { removed: name },
+      () => {
+        console.log(`Removed context "${name}"`);
+      },
+    );
+    return;
+  }
+
+  throw new Error("usage: skillmux context <add|list|current|use|remove>");
+}

package/src/commands/core.ts

@@ -48,5 +48,9 @@ export async function runCore(
   )
     return;
   writeManifestAtomic(manifestPath, updated);
-  console.log(`${subCommand}: [core] ${skillIds.join(", ")}`);
+  emitSuccess(
+    { isJson: options.isJson },
+    { subcommand: subCommand, skill_ids: skillIds },
+    () => console.log(`${subCommand}: [core] ${skillIds.join(", ")}`),
+  );
 }

package/src/commands/doctor.ts

@@ -0,0 +1,76 @@
+import { resolveConfigPath } from "../config";
+import { diagnose } from "../doctor";
+import { getEffectiveConfig } from "../config-service";
+import type { TargetAdapter } from "../adapters";
+import type { ResolvedContext } from "../context";
+import {
+  emitSuccess,
+  green,
+  red,
+  renderTargetBanner,
+} from "../output";
+
+export async function runDoctor(options: {
+  isJson: boolean;
+  target: ResolvedContext;
+  adapter: TargetAdapter;
+}): Promise<void> {
+  if (options.target.type === "remote") {
+    const target = options.target;
+    const [status, caps] = await Promise.all([
+      options.adapter.configStatus(),
+      options.adapter.getCapabilities(),
+    ]);
+    const remoteReport = {
+      target: target.name || target.server,
+      server: target.server,
+      version: status.version,
+      deployment_runtime: status.deployment_runtime,
+      image_variant: status.image_variant ?? null,
+      runtime: status.runtime,
+      readiness: status.readiness,
+      active_revision: status.active_revision,
+      capabilities: caps,
+      restart_required_keys: status.restart_required_keys,
+      last_reload_error: status.last_reload_error,
+    };
+    emitSuccess({ isJson: options.isJson, target: options.target }, remoteReport, () => {
+      renderTargetBanner(options.target);
+      console.log(`server: ${remoteReport.server}`);
+      console.log(`version: ${remoteReport.version}`);
+      console.log(`deployment runtime: ${remoteReport.deployment_runtime}`);
+      console.log(`image variant: ${remoteReport.image_variant ?? "none"}`);
+      console.log(`runtime: ${remoteReport.runtime}`);
+      console.log(`readiness: ${remoteReport.readiness.status} (${remoteReport.readiness.capability})`);
+      console.log(`active revision: ${remoteReport.active_revision}`);
+      console.log(`persistence: ${caps.persistence}`);
+      console.log(`config read: ${caps.config_read}`);
+      console.log(`config write: ${caps.config_write}`);
+      if (status.last_reload_error) {
+        console.log(`last reload error: ${status.last_reload_error}`);
+      }
+      if (status.restart_required_keys.length > 0) {
+        console.log(`restart required for: ${status.restart_required_keys.join(", ")}`);
+      }
+    });
+    return;
+  }
+
+  const effective = await getEffectiveConfig(resolveConfigPath());
+  const report = await diagnose(effective.effective, process.env, effective.sources);
+  emitSuccess({ isJson: options.isJson }, report, () => {
+    console.log(`version: ${report.version}`);
+    console.log(`runtime: ${report.runtime}`);
+    console.log(`image variant: ${report.image_variant ?? "none"}`);
+    console.log(`vault path: ${report.vault_path}`);
+    console.log(`state directory: ${report.state_dir}`);
+    console.log(`inference mode: ${report.mode}`);
+    console.log(`routing capability: ${report.capability}`);
+    console.log(`retrieval capability: ${report.retrieval_capability}`);
+    for (const check of report.checks)
+      console.log(
+        `${check.ok ? green("ok") : red("fail")}: ${check.name} - ${check.detail}`,
+      );
+  });
+  if (report.checks.some((check) => !check.ok)) process.exitCode = 1;
+}

package/src/commands/eval.ts

@@ -1,15 +1,16 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { expandHome, loadConfig } from "../config";
-import { openAudit } from "../db";
-import { buildPromotedCases, excludeExistingCases, parseEvalCases, queryPromotableFetches } from "../eval";
-import { emitSuccess } from "../output";
+import { excludeExistingCases, parseEvalCases } from "../eval";
+import { emitSuccess, warn } from "../output";
 import { parseSince } from "../stats";
 import { confirmIfNeeded } from "./shared";
+import type { TargetAdapter } from "../adapters";
+import { isGlobalFlag, isGlobalFlagWithValue } from "../global-flags";
 
 export async function runEvalPromote(
   args: string[],
-  options: { isJson: boolean; dryRun: boolean },
+  options: { isJson: boolean; dryRun: boolean; adapter: TargetAdapter },
 ): Promise<void> {
   let since: string | undefined;
   let target: string | undefined;
@@ -21,8 +22,10 @@ export async function runEvalPromote(
     else if (arg === "--target") target = args[++i];
     else if (arg === "--dry-run") dryRun = true;
     else if (arg === "--yes") yes = true;
-    else if (arg === "--json") {
+    else if (isGlobalFlag(arg, "--json", "--allow-insecure", "--verbose")) {
       // handled globally by main()'s isJson flag; recognized here so it isn't rejected
+    } else if (isGlobalFlagWithValue(arg)) {
+      i++; // skip flag value
     } else if (arg?.startsWith("--")) {
       throw new Error(`unknown eval promote option: ${arg}`);
     }
@@ -37,18 +40,12 @@ export async function runEvalPromote(
   const sinceDate = parseSince(since);
   const sinceIso = sinceDate.toISOString();
 
-  const db = openAudit(stateDir);
-  let candidates: ReturnType<typeof buildPromotedCases>;
-  try {
-    candidates = buildPromotedCases(queryPromotableFetches(db, sinceIso));
-  } finally {
-    db.close();
-  }
+  const candidates = await options.adapter.evalPromote(since);
 
   const existing = existsSync(targetPath) ? parseEvalCases(JSON.parse(readFileSync(targetPath, "utf-8"))) : [];
   const { cases: newCases, skipped } = excludeExistingCases(candidates, existing);
 
-  console.error("warning: promoted eval cases contain raw user queries");
+  warn("promoted eval cases contain raw user queries");
 
   if (dryRun) {
     emitSuccess(