nemoris 0.1.19 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nemoris",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "type": "module",
   "description": "Personal AI agent runtime — persistent memory, delivery guarantees, task contracts, self-healing. Local-first, no cloud.",
   "license": "MIT",
@@ -73,7 +73,9 @@
     "publish:check": "node scripts/check-publish-dry-run.js",
     "status": "node src/cli.js runtime-status",
     "test": "node --test",
-    "test:e2e": "node tests/e2e/run-report.js"
+    "test:e2e": "node tests/e2e/run-report.js",
+    "test:e2e:interactive": "node --test tests/e2e/onboarding-interactive.test.js",
+    "test:e2e:setup-sweep": "node scripts/e2e-setup-sweep.js"
   },
   "engines": {
     "node": ">=22.5.0"

package/src/onboarding/auth/api-key.js

@@ -143,19 +143,59 @@ export async function validateApiKey(provider, key, options = {}) {
   }
 
   const fetch = options.fetchImpl || globalThis.fetch;
-  const providerTargets = {
-    anthropic: {
-      url: "https://api.anthropic.com/v1/messages/count_tokens",
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...buildAnthropicAuthHeaders(key)
+  if (provider === "anthropic") {
+    const probes = [
+      {
+        url: "https://api.anthropic.com/v1/models",
+        method: "GET",
+        headers: {
+          "x-api-key": key,
+          "anthropic-version": "2023-06-01"
+        }
       },
-      body: JSON.stringify({
-        model: "claude-haiku-4-5",
-        messages: [{ role: "user", content: "ping" }]
-      })
-    },
+      {
+        url: "https://api.anthropic.com/v1/models",
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${key}`,
+          "anthropic-version": "2023-06-01"
+        }
+      },
+      {
+        url: "https://api.anthropic.com/v1/messages/count_tokens",
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...buildAnthropicAuthHeaders(key)
+        },
+        body: JSON.stringify({
+          model: "claude-haiku-4-5",
+          messages: [{ role: "user", content: "ping" }]
+        })
+      }
+    ];
+
+    let lastFailure = { ok: false, error: "request failed" };
+    for (const probe of probes) {
+      try {
+        const response = await fetch(probe.url, {
+          method: probe.method,
+          headers: probe.headers,
+          body: probe.body,
+          signal: AbortSignal.timeout(10000)
+        });
+        if (response.ok) {
+          return { ok: true, status: response.status };
+        }
+        lastFailure = { ok: false, status: response.status };
+      } catch (error) {
+        lastFailure = { ok: false, error: error.message };
+      }
+    }
+    return lastFailure;
+  }
+
+  const providerTargets = {
     openai: {
       url: "https://api.openai.com/v1/models",
       method: "GET",

package/src/onboarding/clack-prompter.js

@@ -23,6 +23,27 @@ function normalizeOptions(options = []) {
   }));
 }
 
+function normalizeSearchTokens(search = "") {
+  return String(search)
+    .toLowerCase()
+    .split(/\s+/)
+    .map((token) => token.trim())
+    .filter(Boolean);
+}
+
+function buildOptionSearchText(option = {}) {
+  return `${option.label || ""} ${option.hint || ""} ${option.value || ""}`.toLowerCase();
+}
+
+function tokenizedOptionFilter(search, option) {
+  const tokens = normalizeSearchTokens(search);
+  if (tokens.length === 0) {
+    return true;
+  }
+  const haystack = buildOptionSearchText(option);
+  return tokens.every((token) => haystack.includes(token));
+}
+
 export function createClackPrompter() {
   return {
     intro(message) {
@@ -48,12 +69,20 @@ export function createClackPrompter() {
       }));
     },
     async multiselect({ message, options, initialValues = [], required = false }) {
-      const value = guardCancel(await p.multiselect({
-        message,
-        options: normalizeOptions(options),
-        initialValues,
-        required,
-      }));
+      const normalized = normalizeOptions(options);
+      const value = guardCancel(await (required || !p.autocompleteMultiselect
+        ? p.multiselect({
+            message,
+            options: normalized,
+            initialValues,
+            required,
+          })
+        : p.autocompleteMultiselect({
+            message,
+            options: normalized,
+            initialValues,
+            filter: tokenizedOptionFilter,
+          })));
       return Array.isArray(value) ? value : [];
     },
     async text({ message, placeholder, initialValue, validate }) {

package/src/onboarding/phases/auth.js

@@ -9,6 +9,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { providerTemplate, routerTemplate } from "../templates.js";
+import { parseToml } from "../../config/toml-lite.js";
 import {
   detectExistingKeys,
   validateApiKey,
@@ -57,6 +58,10 @@ const PROVIDER_CONFIGS = {
 };
 
 const MODEL_ROLE_ORDER = ["cheap_interactive", "fallback", "manual_bump"];
+const MODEL_ROLE_INDEX = new Map(MODEL_ROLE_ORDER.map((role, index) => [role, index]));
+const KEEP_VALUE = "__keep__";
+const MANUAL_VALUE = "__manual__";
+const SHOW_ALL_VALUE = "__show_all__";
 const PROVIDER_MODEL_PRESETS = {
   anthropic: [
     {
@@ -209,6 +214,28 @@ function providerDisplayName(provider) {
   return provider;
 }
 
+function readConfiguredProviderModels(installDir, provider) {
+  const providerId = PROVIDER_CONFIGS[provider]?.providerId || provider;
+  const providerPath = path.join(installDir, "config", "providers", `${providerId}.toml`);
+
+  try {
+    const parsed = parseToml(fs.readFileSync(providerPath, "utf8"));
+    return Object.values(parsed?.models || {})
+      .sort((left, right) => {
+        const leftRank = MODEL_ROLE_INDEX.get(left?.role) ?? Number.MAX_SAFE_INTEGER;
+        const rightRank = MODEL_ROLE_INDEX.get(right?.role) ?? Number.MAX_SAFE_INTEGER;
+        if (leftRank !== rightRank) {
+          return leftRank - rightRank;
+        }
+        return String(left?.id || "").localeCompare(String(right?.id || ""));
+      })
+      .map((entry) => String(entry?.id || "").trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 const OPENAI_CONTEXT_WINDOWS = {
   "gpt-4.1": 1000000,
   "gpt-4o": 128000,
@@ -380,15 +407,77 @@ async function buildProviderSelectionOptions(provider, key, { fetchImpl = global
   return { options, fetchedModels, extra };
 }
 
-async function promptForProviderModels(provider, key, tui, { fetchImpl = globalThis.fetch } = {}) {
-  const { select, prompt, dim, cyan } = tui;
-  if (!select) return { chosen: [], fetchedModels: [] };
+function normalizePickerOption(option) {
+  return {
+    value: option.value,
+    label: option.label,
+    description: option.description || option.hint || "",
+  };
+}
+
+function buildExpandedPickerOptions(options, extra = []) {
+  return [
+    ...options.filter((option) => !String(option.value).startsWith("__")).map(normalizePickerOption),
+    ...extra.map(normalizePickerOption),
+  ];
+}
+
+function buildCurrentModelLabel(provider, modelId) {
+  const stripped = stripProviderPrefix(provider, modelId);
+  return stripped || modelId;
+}
+
+function ensureFallbackOption(options, provider, modelId) {
+  if (!modelId || options.some((option) => option.value === modelId)) {
+    return options;
+  }
+  return [
+    ...options,
+    {
+      value: modelId,
+      label: buildCurrentModelLabel(provider, modelId),
+      description: "current (not in catalog)",
+    },
+  ];
+}
+
+async function promptManualProviderModel(provider, key, tui, fetchedModels, {
+  fetchImpl = globalThis.fetch,
+  initialValue = "",
+} = {}) {
+  const { prompt } = tui;
+  if (!prompt) {
+    return null;
+  }
+
+  while (true) {
+    const custom = await prompt("Model id", stripProviderPrefix(provider, initialValue));
+    const modelId = ensureProviderModelPrefix(provider, custom);
+    if (!modelId) {
+      return null;
+    }
+
+    const check = await validateModelId(provider, modelId, key, { fetchImpl, fetchedModels });
+    if (check.ok) {
+      return modelId;
+    }
+
+    console.log(`  \u274c  ${check.error || "Model not found."} Try again or press Enter to cancel.`);
+  }
+}
+
+async function promptForProviderModels(provider, key, tui, {
+  fetchImpl = globalThis.fetch,
+  currentModels = [],
+} = {}) {
+  const { select, multiselect, dim, cyan } = tui;
+  if (!select) return { chosen: currentModels.slice(0, 3), fetchedModels: [] };
 
   const { options, fetchedModels, extra } = await buildProviderSelectionOptions(provider, key, { fetchImpl });
-  let activeOptions = options;
+  let activeOptions = options.map(normalizePickerOption);
   const chosen = [];
-  const manualOptionValue = "__custom__";
-  // Use first curated model as placeholder for custom entry, not a "new" or extra model
+  const currentDefault = currentModels[0] || "";
+  const currentFallbacks = currentModels.slice(1);
   const defaultModelValue = options.find((item) => {
     const v = String(item.value);
     return !v.startsWith("__") && !v.startsWith("\u2605");
@@ -397,81 +486,111 @@ async function promptForProviderModels(provider, key, tui, { fetchImpl = globalT
   console.log(`\n  ${cyan(`Choose ${provider === "openrouter" ? "OpenRouter" : provider === "openai" ? "OpenAI" : "Anthropic"} models`)}`);
   console.log(`  ${dim("Pick up to three models. The first is your default. The others are fallbacks when the default is slow or unavailable.")}`);
 
-  while (chosen.length < 3) {
-    const remaining = activeOptions.filter((item) => !chosen.includes(item.value));
-    const pickerOptions = remaining.map((item) => ({
-      label: item.label,
-      value: item.value,
-      description: item.description,
-    }));
-
-    if (chosen.length > 0) {
-      // Insert "Done" before the custom-entry option at the end
-      const customIndex = pickerOptions.findIndex((item) => item.value === "__custom__");
-      const doneOption = { label: "Done", value: "__done__", description: "Continue setup with the models already selected." };
-      if (customIndex >= 0) {
-        pickerOptions.splice(customIndex, 0, doneOption);
-      } else {
-        pickerOptions.push(doneOption);
-      }
+  let defaultModel = "";
+  while (!defaultModel) {
+    const defaultOptions = [];
+    if (currentDefault) {
+      defaultOptions.push({
+        value: KEEP_VALUE,
+        label: `Keep current (${buildCurrentModelLabel(provider, currentDefault)})`,
+        description: "Use the current configured default model.",
+      });
     }
+    defaultOptions.push({
+      value: MANUAL_VALUE,
+      label: "Enter model manually",
+      description: "Use a specific model id not shown in the list.",
+    });
+    defaultOptions.push(...activeOptions.filter((option) =>
+      option.value !== MANUAL_VALUE && option.value !== "__custom__",
+    ));
 
-    const picked = await select(
-      chosen.length === 0 ? "Default model:" : `Add another model (${chosen.length}/3 selected):`,
-      pickerOptions,
-    );
-
-    if (picked === "__done__") {
+    const picked = await select("Default model:", defaultOptions);
+    if (picked === KEEP_VALUE) {
+      defaultModel = currentDefault;
       break;
     }
-
-    if (picked === "__show_all__") {
-      // Expand to full filtered list + custom entry
-      activeOptions = [
-        ...activeOptions.filter((o) => !o.value.startsWith("__")),
-        ...(extra || []),
-        { value: "__custom__", label: "Enter a different model name...", description: "Use a specific model id not shown in the list." },
-      ];
+    if (picked === SHOW_ALL_VALUE) {
+      activeOptions = buildExpandedPickerOptions(options, extra);
       continue;
     }
+    if (picked === MANUAL_VALUE || picked === "__custom__") {
+      defaultModel = await promptManualProviderModel(provider, key, tui, fetchedModels, {
+        fetchImpl,
+        initialValue: currentDefault || defaultModelValue,
+      });
+      continue;
+    }
+    defaultModel = picked;
+  }
 
-    let modelId = picked;
-    if (picked === manualOptionValue) {
-      let validated = false;
-      while (!validated) {
-        const custom = await prompt("Model id", stripProviderPrefix(provider, defaultModelValue));
-        modelId = ensureProviderModelPrefix(provider, custom);
-        if (!modelId) {
-          break;
-        }
-        const check = await validateModelId(provider, modelId, key, { fetchImpl, fetchedModels });
-        if (check.ok) {
-          validated = true;
-        } else {
-          console.log(`  \u274c  ${check.error || "Model not found."} Try again or press Enter to skip.`);
-          const retry = await prompt("Model id (or empty to cancel)", "");
-          if (!retry) {
-            modelId = null;
-            break;
-          }
-          modelId = ensureProviderModelPrefix(provider, retry);
-          const recheck = await validateModelId(provider, modelId, key, { fetchImpl, fetchedModels });
-          if (recheck.ok) {
-            validated = true;
-          } else {
-            console.log(`  \u274c  ${recheck.error || "Model not found."}`);
-            modelId = null;
-            break;
-          }
-        }
+  if (defaultModel) {
+    chosen.push(defaultModel);
+  }
+
+  const fullCatalogOptions = buildExpandedPickerOptions(options, extra)
+    .filter((option) => option.value !== chosen[0]);
+  let fallbackOptions = fullCatalogOptions;
+  for (const fallback of currentFallbacks) {
+    fallbackOptions = ensureFallbackOption(fallbackOptions, provider, fallback);
+  }
+
+  if (typeof multiselect === "function" && fallbackOptions.length > 0) {
+    const initialValues = currentFallbacks.filter((modelId) =>
+      fallbackOptions.some((option) => option.value === modelId),
+    );
+    const selectedFallbacks = await multiselect(
+      "Backup models (optional)",
+      fallbackOptions,
+      initialValues,
+    );
+    for (const modelId of selectedFallbacks) {
+      if (modelId && !chosen.includes(modelId)) {
+        chosen.push(modelId);
       }
-      if (!modelId) {
-        continue;
+      if (chosen.length === 3) {
+        break;
       }
     }
+    return { chosen, fetchedModels };
+  }
 
-    if (!chosen.includes(modelId)) {
-      chosen.push(modelId);
+  while (chosen.length < 3) {
+    const remaining = fallbackOptions.filter((option) => !chosen.includes(option.value));
+    if (remaining.length === 0) {
+      break;
+    }
+
+    const pickerOptions = [
+      ...remaining,
+      {
+        label: "Done",
+        value: "__done__",
+        description: "Continue setup with the models already selected.",
+      },
+      {
+        label: "Enter model manually",
+        value: MANUAL_VALUE,
+        description: "Use a specific model id not shown in the list.",
+      },
+    ];
+
+    const picked = await select(`Add another model (${chosen.length}/3 selected):`, pickerOptions);
+    if (picked === "__done__") {
+      break;
+    }
+    if (picked === MANUAL_VALUE) {
+      const manualModel = await promptManualProviderModel(provider, key, tui, fetchedModels, {
+        fetchImpl,
+        initialValue: chosen.at(-1) || defaultModelValue,
+      });
+      if (manualModel && !chosen.includes(manualModel)) {
+        chosen.push(manualModel);
+      }
+      continue;
+    }
+    if (picked && !chosen.includes(picked)) {
+      chosen.push(picked);
     }
   }
 
@@ -566,6 +685,16 @@ async function promptForProviderKey(provider, tui, validateApiKeyImpl = validate
   }
 }
 
+function formatProviderValidationFailure(provider, result = {}) {
+  if (result.status === 401 || result.status === 403) {
+    return "authentication failed";
+  }
+  if (result.status) {
+    return `HTTP ${result.status}`;
+  }
+  return result.error || `${providerDisplayName(provider)} key verification failed`;
+}
+
 async function confirmLocalOnlySetup(tui) {
   const { confirm, yellow = (value) => value, dim = (value) => value } = tui;
   if (!confirm) {
@@ -579,6 +708,7 @@ async function confirmLocalOnlySetup(tui) {
 
 async function maybeResolveOpenAIOAuth({
   tui,
+  authMethod = null,
   enableOpenAIOAuthChoice = false,
   openAIOAuthImpl = initiateOpenAICodexOAuthFlow,
 }) {
@@ -597,22 +727,29 @@ async function maybeResolveOpenAIOAuth({
     };
   }
 
-  if (!enableOpenAIOAuthChoice || !tui?.select) {
+  if (authMethod === "api_key") {
     return null;
   }
 
-  const method = await tui.select("OpenAI auth method:", [
-    {
-      label: "API key",
-      value: "api_key",
-      description: "Paste an OpenAI API key from platform.openai.com.",
-    },
-    {
-      label: "ChatGPT OAuth",
-      value: "oauth",
-      description: "Open browser login and store a refreshable local profile.",
-    },
-  ]);
+  let method = authMethod;
+  if (!method) {
+    if (!enableOpenAIOAuthChoice || !tui?.select) {
+      return null;
+    }
+
+    method = await tui.select("OpenAI auth method:", [
+      {
+        label: "API key",
+        value: "api_key",
+        description: "Paste an OpenAI API key from platform.openai.com.",
+      },
+      {
+        label: "ChatGPT OAuth",
+        value: "oauth",
+        description: "Open browser login and store a refreshable local profile.",
+      },
+    ]);
+  }
 
   if (method !== "oauth") {
     return null;
@@ -642,6 +779,7 @@ export async function runAuthPhase(installDir, options = {}) {
   const {
     tui,
     detectionCache,
+    authMethod = null,
     validateApiKeyImpl = validateApiKey,
     fetchImpl = globalThis.fetch,
     providerOrder = ["openrouter", "anthropic", "openai"],
@@ -655,6 +793,7 @@ export async function runAuthPhase(installDir, options = {}) {
   const selectedModels = {};
   const providerAuthRefs = {};
   const providerSecrets = {};
+  const validationFailures = {};
 
   if (tui) {
     let promptingComplete = false;
@@ -664,6 +803,7 @@ export async function runAuthPhase(installDir, options = {}) {
         if (provider === "openai") {
           const oauthResult = await maybeResolveOpenAIOAuth({
             tui,
+            authMethod,
             enableOpenAIOAuthChoice,
             openAIOAuthImpl,
           });
@@ -697,17 +837,51 @@ export async function runAuthPhase(installDir, options = {}) {
   const validatedKeys = {};
   const providerFlags = { anthropic: false, openrouter: false, openai: false, ollama: ollamaResult.ok };
 
-  for (const [provider, key] of Object.entries(keys)) {
+  for (const provider of Object.keys(keys)) {
+    let key = keys[provider];
     if (!key) continue;
-    const format = validateApiKeyFormat(provider, key);
-    if (!format.ok) continue;
-    const result = prevalidatedKeys.has(provider)
+    let format = validateApiKeyFormat(provider, key);
+    if (!format.ok) {
+      validationFailures[provider] = format.error;
+      if (tui && providerOrder.includes(provider)) {
+        console.log(`  ${tui.yellow("!")} Found a ${providerDisplayName(provider)} key, but it looks malformed: ${format.error}`);
+        const replacement = await promptForProviderKey(provider, tui, validateApiKeyImpl);
+        if (!replacement) {
+          continue;
+        }
+        key = replacement;
+        keys[provider] = replacement;
+        prevalidatedKeys.add(provider);
+        format = validateApiKeyFormat(provider, key);
+        if (!format.ok) {
+          validationFailures[provider] = format.error;
+          continue;
+        }
+      } else {
+        continue;
+      }
+    }
+
+    let result = prevalidatedKeys.has(provider)
       ? { ok: true, status: 200 }
       : await validateApiKeyImpl(provider, key);
+    if (!result.ok && tui && providerOrder.includes(provider)) {
+      validationFailures[provider] = formatProviderValidationFailure(provider, result);
+      console.log(`  ${tui.yellow("!")} Found a ${providerDisplayName(provider)} key, but Nemoris could not verify it (${validationFailures[provider]}).`);
+      const replacement = await promptForProviderKey(provider, tui, validateApiKeyImpl);
+      if (!replacement) {
+        continue;
+      }
+      key = replacement;
+      keys[provider] = replacement;
+      prevalidatedKeys.add(provider);
+      result = { ok: true, status: 200 };
+    }
     if (!result.ok) continue;
 
     validatedKeys[provider] = key;
     providerSecrets[provider] = key;
+    delete validationFailures[provider];
     if (provider in providerFlags) {
       providerFlags[provider] = true;
     }
@@ -722,7 +896,10 @@ export async function runAuthPhase(installDir, options = {}) {
     for (const provider of ["openrouter", "anthropic", "openai"]) {
       const providerToken = providerSecrets[provider];
       if (!providerToken) continue;
-      const { chosen, fetchedModels } = await promptForProviderModels(provider, providerToken, tui, { fetchImpl });
+      const { chosen, fetchedModels } = await promptForProviderModels(provider, providerToken, tui, {
+        fetchImpl,
+        currentModels: readConfiguredProviderModels(installDir, provider),
+      });
       selectedModels[provider] = chosen;
       fetchedModelsCache[provider] = fetchedModels;
     }
@@ -777,5 +954,5 @@ export async function runAuthPhase(installDir, options = {}) {
   }])));
   writeRouter(installDir, providerFlags, selectedModels);
 
-  return { providers: providerIds, providerFlags, keys: validatedKeys, selectedModels };
+  return { providers: providerIds, providerFlags, keys: validatedKeys, selectedModels, validationFailures };
 }