nemoris 0.1.0

package/src/onboarding/wizard.js

@@ -0,0 +1,499 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { parseToml } from "../config/toml-lite.js";
+import { detect } from "./phases/detect.js";
+import { scaffold } from "./phases/scaffold.js";
+import { resolveDefaultAgentName, writeIdentity } from "./phases/identity.js";
+import { runAuthPhase } from "./phases/auth.js";
+import { runTelegramPhase } from "./phases/telegram.js";
+import { runOllamaPhase } from "./phases/ollama.js";
+import { validateScaffold } from "./phases/validate.js";
+import { choose } from "./phases/choose.js";
+import { buildFresh, buildShadow } from "./phases/build.js";
+import { verify } from "./phases/verify.js";
+import { createClackPrompter, SetupCancelledError } from "./clack-prompter.js";
+import { detectPreferredProvider, detectProviderOptions, summarizeSelectedModels } from "./model-catalog.js";
+import { isDaemonRunning, loadDaemon, writeDaemonUnit } from "./platform.js";
+
+const MIN_NODE_MAJOR = 22;
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_ENTRY = path.join(__dirname, "..", "cli.js");
+export const SETUP_RETRY_MESSAGE = "Fix: re-run `nemoris setup` to retry.";
+
+function checkNodeVersion() {
+  const [major] = process.versions.node.split(".").map(Number);
+  return major >= MIN_NODE_MAJOR;
+}
+
+function stripAnsi(value) {
+  return String(value || "").replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function createLegacyPromptAdapter(prompter) {
+  return {
+    promptSecret: async (message) => prompter.password({ message }),
+    prompt: async (message, initialValue = "") => prompter.text({ message, initialValue }),
+    select: async (message, options) => prompter.select({
+      message,
+      options: options.map((option) => ({
+        value: option.value,
+        label: stripAnsi(option.label),
+        hint: option.description ? stripAnsi(option.description) : undefined,
+      })),
+    }),
+    confirm: async (message, initialValue = false) => prompter.confirm({ message, initialValue }),
+    bold: (value) => value,
+    dim: (value) => value,
+    cyan: (value) => value,
+    green: (value) => value,
+    red: (value) => value,
+    yellow: (value) => value,
+  };
+}
+
+function readRuntimeConfig(installDir) {
+  const runtimePath = path.join(installDir, "config", "runtime.toml");
+  try {
+    return parseToml(fs.readFileSync(runtimePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function summarizeExistingConfig(installDir) {
+  const runtime = readRuntimeConfig(installDir);
+  const providersDir = path.join(installDir, "config", "providers");
+  const providers = fs.existsSync(providersDir)
+    ? fs.readdirSync(providersDir).filter((file) => file.endsWith(".toml")).map((file) => path.basename(file, ".toml"))
+    : [];
+  const lines = [
+    `Install dir: ${installDir}`,
+    `Providers: ${providers.length > 0 ? providers.join(", ") : "none"}`,
+  ];
+  if (runtime?.telegram?.default_agent) {
+    lines.push(`Telegram: ${runtime.telegram.default_agent}${runtime.telegram.operator_chat_id ? ` · chat ${runtime.telegram.operator_chat_id}` : ""}`);
+  }
+  if (runtime?.telegram?.polling_mode !== undefined) {
+    lines.push(`Transport: ${runtime.telegram.polling_mode ? "long-poll" : "webhook"}`);
+  }
+  return lines.join("\n");
+}
+
+function resetInstallArtifacts(installDir, scope) {
+  const targets = scope === "config"
+    ? ["config"]
+    : scope === "config+state"
+      ? ["config", "state", ".env", "nemoris.lock"]
+      : ["config", "state", ".env", "nemoris.lock", "workspace"];
+
+  for (const target of targets) {
+    fs.rmSync(path.join(installDir, target), { recursive: true, force: true });
+  }
+}
+
+async function waitForDaemonHealthy({ timeoutMs = 15000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (isDaemonRunning()) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  return isDaemonRunning();
+}
+
+function installShellCompletion() {
+  const shell = path.basename(process.env.SHELL || "");
+  const home = process.env.HOME || os.homedir();
+  const commands = [
+    "setup", "start", "stop", "restart", "status", "logs", "chat", "models",
+    "doctor", "migrate", "mcp", "init", "telegram", "tools", "skills",
+    "improvements", "uninstall", "run", "runs", "internal",
+  ];
+
+  if (shell === "zsh") {
+    const zshrc = path.join(home, ".zshrc");
+    const marker = "# nemoris completion";
+    const snippet = `${marker}
+autoload -U compinit
+compinit
+compctl -k "(${commands.join(" ")})" nemoris
+`;
+    const content = fs.existsSync(zshrc) ? fs.readFileSync(zshrc, "utf8") : "";
+    if (!content.includes(marker)) {
+      fs.appendFileSync(zshrc, `\n${snippet}`);
+    }
+    return true;
+  }
+
+  if (shell === "bash") {
+    const bashrc = path.join(home, ".bashrc");
+    const marker = "# nemoris completion";
+    const snippet = `${marker}
+_nemoris_complete() {
+  COMPREPLY=( $(compgen -W "${commands.join(" ")}" -- "\${COMP_WORDS[1]}") )
+}
+complete -F _nemoris_complete nemoris
+`;
+    const content = fs.existsSync(bashrc) ? fs.readFileSync(bashrc, "utf8") : "";
+    if (!content.includes(marker)) {
+      fs.appendFileSync(bashrc, `\n${snippet}`);
+    }
+    return true;
+  }
+
+  return false;
+}
+
+async function launchChat() {
+  await new Promise((resolve) => {
+    const child = spawn(process.execPath, [CLI_ENTRY, "chat"], {
+      stdio: "inherit",
+      env: process.env,
+    });
+    child.once("exit", () => resolve());
+    child.once("error", () => resolve());
+  });
+}
+
+async function runInteractiveWizard({
+  installDir,
+  flowOverride = null,
+}) {
+  const prompter = createClackPrompter();
+  await prompter.intro("Nemoris setup");
+
+  await prompter.note([
+    "Security warning — please read.",
+    "",
+    "Nemoris runs as a background daemon on your machine.",
+    "It can execute shell commands, read files, and make network requests — always acting on your instructions, never autonomously.",
+    "",
+    "This is open-source software. Review the code at:",
+    "https://github.com/amzer24/nemoris",
+    "",
+    "Run as a personal agent — one trusted operator boundary.",
+    "Do not expose to the internet without hardening first.",
+  ].join("\n"), "Security");
+
+  const proceed = await prompter.confirm({
+    message: "I understand. Continue?",
+    initialValue: false,
+  });
+  if (!proceed) {
+    await prompter.cancel("Cancelled.");
+    return 0;
+  }
+
+  if (fs.existsSync(path.join(installDir, "config", "runtime.toml"))) {
+    await prompter.note(summarizeExistingConfig(installDir), "Existing config detected");
+    const action = await prompter.select({
+      message: "Config handling",
+      options: [
+        { value: "keep", label: "Use existing values" },
+        { value: "update", label: "Update values" },
+        { value: "reset", label: "Reset everything" },
+      ],
+    });
+
+    if (action === "keep") {
+      await prompter.outro("Config unchanged. Run nemoris status to check what's running.");
+      return 0;
+    }
+
+    if (action === "reset") {
+      const scope = await prompter.select({
+        message: "Reset scope",
+        options: [
+          { value: "config", label: "Config only" },
+          { value: "config+state", label: "Config + state (memory, runs, scheduler)" },
+          { value: "full", label: "Full reset (everything)" },
+        ],
+      });
+      resetInstallArtifacts(installDir, scope);
+    }
+  }
+
+  const flow = flowOverride || await prompter.select({
+    message: "Setup mode",
+    options: [
+      { value: "quickstart", label: "QuickStart", hint: "Running in 2 minutes, configure details later with: nemoris setup" },
+      { value: "manual", label: "Manual", hint: "Full configuration now" },
+    ],
+    initialValue: "quickstart",
+  });
+
+  if (flow === "quickstart") {
+    await prompter.note([
+      "QuickStart defaults:",
+      `State directory: ${installDir}`,
+      "Polling: long-poll (no tunnel needed)",
+      "Daemon: auto-installed",
+    ].join("\n"), "QuickStart");
+  }
+
+  if (process.platform === "win32") {
+    await prompter.note([
+      "Windows detected — Nemoris runs best on WSL2.",
+      "Native Windows support is experimental.",
+      "Quick setup: wsl --install (one command, one reboot)",
+      "Guide: https://github.com/amzer24/nemoris#windows",
+    ].join("\n"), "Windows");
+  }
+
+  const detection = await detect(installDir);
+  await scaffold({ installDir });
+
+  const userName = await prompter.text({
+    message: "Your name",
+    initialValue: process.env.NEMORIS_USER_NAME || process.env.USER || "",
+    placeholder: os.userInfo().username || "",
+  });
+  const defaultAgentName = process.env.NEMORIS_AGENT_NAME || resolveDefaultAgentName();
+  const agentName = await prompter.text({
+    message: "What should your agent be called?",
+    initialValue: defaultAgentName,
+    validate: (value) => String(value || "").trim() ? undefined : "Agent name is required.",
+  });
+  const agentId = String(agentName).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  writeIdentity({
+    installDir,
+    userName: userName || process.env.USER || "operator",
+    agentName,
+    agentId,
+    userGoal: "build software",
+  });
+
+  const provider = await prompter.select({
+    message: "Choose your AI provider",
+    options: detectProviderOptions({
+      env: process.env,
+      ollamaResult: detection.ollama ? { ok: true, models: detection.ollama.models } : { ok: false, models: [] },
+    }).map((option) => ({
+      value: option.value,
+      label: option.label,
+      hint: option.hint,
+    })),
+    initialValue: detectPreferredProvider({
+      env: process.env,
+      ollamaResult: detection.ollama ? { ok: true } : { ok: false },
+    }),
+  });
+
+  let authResult = { providers: [], providerFlags: {}, selectedModels: {} };
+  let telegramResult = { configured: false, verified: false };
+  let ollamaResult = { configured: false, verified: false, models: [] };
+
+  if (provider !== "skip" && provider !== "ollama") {
+    const authSpin = prompter.spinner();
+    authSpin.start("Configuring provider auth...");
+    authResult = await runAuthPhase(installDir, {
+      tui: createLegacyPromptAdapter(prompter),
+      detectionCache: {
+        rawKeys: detection.apiKeys,
+        ollamaResult: detection.ollama ? { ok: true, models: detection.ollama.models } : { ok: false, models: [] },
+      },
+      providerOrder: [provider],
+      enableOpenAIOAuthChoice: provider === "openai",
+    });
+    authSpin.stop("Provider configured");
+  }
+
+  const connectTelegram = await prompter.confirm({
+    message: "Connect via Telegram?",
+    initialValue: true,
+  });
+  if (connectTelegram) {
+    telegramResult = await runTelegramPhase({ installDir, agentId, nonInteractive: false, skipGate: true });
+  }
+
+  const useOllama = provider === "ollama" || await prompter.confirm({
+    message: "Add Ollama local models too?",
+    initialValue: flow === "quickstart",
+  });
+  if (useOllama) {
+    ollamaResult = await runOllamaPhase({ installDir, nonInteractive: false });
+  }
+
+  const installDaemon = flow === "quickstart" || await prompter.confirm({
+    message: "Install background service (recommended)",
+    initialValue: true,
+  });
+  let daemonHealthy = false;
+
+  if (installDaemon) {
+    const spin = prompter.spinner();
+    spin.start("Installing daemon...");
+    await writeDaemonUnit(installDir);
+    const loaded = await loadDaemon(installDir);
+    spin.stop(loaded.ok ? "Daemon installed" : `Daemon install failed: ${loaded.message || "check logs with nemoris logs"}`);
+    daemonHealthy = loaded.ok ? await waitForDaemonHealthy({ timeoutMs: 15000 }) : false;
+  }
+
+  if (!daemonHealthy) {
+    await prompter.note("Run `nemoris start` to start it manually.\nDocs: https://github.com/amzer24/nemoris#troubleshooting", "Daemon");
+  }
+
+  if (daemonHealthy) {
+    const hatch = await prompter.select({
+      message: "How do you want to start?",
+      options: [
+        { value: "chat", label: "Open TUI chat (recommended)" },
+        { value: "later", label: "Do this later" },
+      ],
+      initialValue: "chat",
+    });
+    if (hatch === "chat") {
+      await launchChat();
+    }
+  }
+
+  const installCompletion = flow === "quickstart" || await prompter.confirm({
+    message: "Enable shell completion?",
+    initialValue: true,
+  });
+  if (installCompletion) {
+    installShellCompletion();
+  }
+
+  const modelSummary = summarizeSelectedModels([
+    ...(authResult.selectedModels?.[provider] || []),
+    ...(ollamaResult.models || []).map((model) => `ollama/${model}`),
+  ]);
+  const authMethod = provider === "ollama"
+    ? "local"
+    : authResult.providers.length > 0
+      ? "api_key"
+      : "skipped";
+
+  await prompter.note([
+    "Auth overview:",
+    `  ${provider}  ${provider === "skip" ? "skip" : "✓"}  ${authMethod}`,
+    "",
+    "Models:",
+    `  Default  : ${modelSummary.defaultModel || "not configured"}`,
+    `  Fallback : ${modelSummary.fallbackModel || "not configured"}`,
+    "",
+    "Docs: https://github.com/amzer24/nemoris",
+    "Issues: https://github.com/amzer24/nemoris/issues",
+  ].join("\n"), "Ready");
+
+  await prompter.outro(
+    telegramResult.verified
+      ? "Nemoris is running. Message your bot to get started."
+      : "Nemoris is running. Start with: nemoris chat"
+  );
+  return 0;
+}
+
+async function runNonInteractiveWizard({
+  installDir,
+  acceptRisk = false,
+  flow = "quickstart",
+  anthropicKey = null,
+  openaiKey = null,
+  openrouterKey = null,
+}) {
+  if (!acceptRisk) {
+    console.error("Non-interactive setup requires --accept-risk.");
+    return 1;
+  }
+
+  const detectionCache = await detect(installDir);
+  detectionCache.apiKeys = {
+    ...detectionCache.apiKeys,
+    anthropic: anthropicKey || detectionCache.apiKeys?.anthropic || null,
+    openai: openaiKey || detectionCache.apiKeys?.openai || null,
+    openrouter: openrouterKey || detectionCache.apiKeys?.openrouter || null,
+  };
+
+  const { mode } = await choose({ detectionCache, nonInteractive: true });
+  const userName = process.env.NEMORIS_USER_NAME || process.env.USER || "operator";
+
+  let buildResult;
+  if (mode === "shadow") {
+    buildResult = await buildShadow({
+      installDir,
+      userName,
+      detectionCache,
+      nonInteractive: true,
+    });
+  } else {
+    const requestedAgentName = String(process.env.NEMORIS_AGENT_NAME || "").trim() || "Nemo";
+    buildResult = await buildFresh({
+      installDir,
+      agentName: requestedAgentName,
+      userName,
+      userGoal: "build software",
+      detectionCache,
+      nonInteractive: true,
+    });
+  }
+
+  const result = await verify({
+    installDir,
+    agentName: buildResult.agentName,
+    userName: buildResult.userName,
+    agentId: buildResult.agentId,
+    mode,
+    providers: buildResult.providers || [],
+    providerFlags: buildResult.providerFlags || {},
+    nonInteractive: true,
+    skipHealthcheck: process.env.NEMORIS_SKIP_HEALTHCHECK === "true",
+    telegramConfigured: buildResult.telegramConfigured,
+    telegramVerified: buildResult.telegramVerified,
+    telegramBotUsername: buildResult.telegramBotUsername,
+    telegramBotToken: buildResult.botToken,
+    telegramOperatorChatId: buildResult.operatorChatId,
+    userGoal: buildResult.userGoal,
+  });
+
+  if (result.status === "warning") {
+    return 1;
+  }
+  if (flow !== "quickstart" && buildResult.ollamaConfigured) {
+    // Keep manual mode deterministic in CI while preserving quickstart defaults.
+    return 0;
+  }
+  return 0;
+}
+
+export async function runWizard({
+  installDir,
+  nonInteractive = false,
+  acceptRisk = false,
+  flow = null,
+  anthropicKey = null,
+  openaiKey = null,
+  openrouterKey = null,
+}) {
+  if (!checkNodeVersion()) {
+    console.error(`Node.js v${MIN_NODE_MAJOR}+ is required.`);
+    return 1;
+  }
+
+  try {
+    return nonInteractive
+      ? await runNonInteractiveWizard({
+          installDir,
+          acceptRisk,
+          flow: flow || "quickstart",
+          anthropicKey,
+          openaiKey,
+          openrouterKey,
+        })
+      : await runInteractiveWizard({
+          installDir,
+          flowOverride: flow,
+        });
+  } catch (error) {
+    if (error instanceof SetupCancelledError) {
+      return 0;
+    }
+    console.error(`Setup failed: ${error.message}`);
+    return 1;
+  }
+}

package/src/providers/anthropic.js

@@ -0,0 +1,168 @@
+import { ProviderAdapter } from "./base.js";
+
+/**
+ * Build correct auth headers for Anthropic API.
+ * OAuth/setup-tokens (sk-ant-oat-*) use Authorization: Bearer.
+ * API keys (sk-ant-api-* or sk-ant-*) use x-api-key.
+ */
+export function buildAnthropicAuthHeaders(token) {
+  if (token && token.startsWith("sk-ant-oat")) {
+    return { "Authorization": `Bearer ${token}`, "anthropic-version": "2023-06-01" };
+  }
+  return { "x-api-key": token, "anthropic-version": "2023-06-01" };
+}
+
+export class AnthropicAdapter extends ProviderAdapter {
+  static providerId = "anthropic";
+
+  normalizeModelId(model) {
+    return typeof model === "string" && model.startsWith("anthropic/")
+      ? model.slice("anthropic/".length)
+      : model;
+  }
+
+  getCapabilities() {
+    return {
+      supportsToolDefinitions: true,
+      supportsToolCalls: true,
+      structuredOutputMode: "forced_tool",
+      supportsReasoningSchema: true,
+      tokenCountingMode: "exact",
+      toolReliabilityTier: "high",
+      supportsVision: true
+    };
+  }
+
+  buildStructuredOutputTool(input) {
+    if (!input?.responseSchema?.schema) return null;
+    return {
+      name: input.responseSchema.name || "record_structured_output",
+      description: "Return the final structured job result using the required schema.",
+      input_schema: input.responseSchema.schema
+    };
+  }
+
+  buildInvokePayload(input) {
+    const { model: rawModel, system, messages, maxTokens = 2048, tools } = input;
+    const model = this.normalizeModelId(rawModel);
+    const structuredOutputTool = this.buildStructuredOutputTool(input);
+    const combinedTools = [...(tools || [])];
+    if (structuredOutputTool) {
+      combinedTools.push(structuredOutputTool);
+    }
+
+    const payload = {
+      model,
+      max_tokens: maxTokens,
+      messages
+    };
+    if (system) {
+      payload.system = [{
+        type: "text",
+        text: typeof system === "string" ? system : JSON.stringify(system),
+        cache_control: { type: "ephemeral" }
+      }];
+    }
+    if (combinedTools.length) payload.tools = combinedTools;
+    if (structuredOutputTool) {
+      payload.tool_choice = {
+        type: "tool",
+        name: structuredOutputTool.name
+      };
+      payload.disable_parallel_tool_use = true;
+    }
+    return payload;
+  }
+
+  async invoke(input) {
+    const token = this.ensureAuthToken();
+    return this.postJson(
+      "v1/messages",
+      this.buildInvokePayload(input),
+      buildAnthropicAuthHeaders(token),
+      {
+        timeoutMs: input.timeoutMs
+      }
+    );
+  }
+
+  normalizeResponse(raw) {
+    const toolUseBlock =
+      raw?.content?.find((item) => item?.type === "tool_use" && item.input && typeof item.input === "object") || null;
+    if (toolUseBlock?.input) {
+      return {
+        summary: toolUseBlock.input.summary || "Provider returned structured tool output.",
+        output: toolUseBlock.input.output ?? toolUseBlock.input,
+        nextActions: Array.isArray(toolUseBlock.input.nextActions) ? toolUseBlock.input.nextActions : [],
+        reasoning: toolUseBlock.input.analysis || null,
+        raw
+      };
+    }
+
+    return super.normalizeResponse(raw);
+  }
+
+  buildCountTokensPayload(input) {
+    const { model: rawModel, system, messages, tools } = input;
+    const model = this.normalizeModelId(rawModel);
+    const structuredOutputTool = this.buildStructuredOutputTool(input);
+    const combinedTools = [...(tools || [])];
+    if (structuredOutputTool) {
+      combinedTools.push(structuredOutputTool);
+    }
+
+    const payload = {
+      model,
+      messages
+    };
+    if (system) {
+      payload.system = [{
+        type: "text",
+        text: typeof system === "string" ? system : JSON.stringify(system),
+        cache_control: { type: "ephemeral" }
+      }];
+    }
+    if (combinedTools.length) payload.tools = combinedTools;
+    if (structuredOutputTool) {
+      payload.tool_choice = {
+        type: "tool",
+        name: structuredOutputTool.name
+      };
+      payload.disable_parallel_tool_use = true;
+    }
+    return payload;
+  }
+
+  async countTokens(input) {
+    const token = this.ensureAuthToken();
+    const result = await this.postJson(
+      "v1/messages/count_tokens",
+      this.buildCountTokensPayload(input),
+      buildAnthropicAuthHeaders(token),
+      {
+        timeoutMs: input.timeoutMs
+      }
+    );
+    return Number(result?.input_tokens ?? result?.inputTokens ?? 0);
+  }
+
+  async healthCheck() {
+    const token = this.ensureAuthToken();
+    // OAuth tokens (sk-ant-oat*) don't have access to GET /v1/models.
+    // Use a minimal messages.count_tokens probe instead — works with all token types.
+    // The configured baseUrl still goes through the shared SSRF policy.
+    try {
+      const response = await this.fetchResponse("v1/messages/count_tokens", {
+        method: "POST",
+        headers: { "content-type": "application/json", ...buildAnthropicAuthHeaders(token) },
+        body: JSON.stringify({
+          model: "claude-haiku-4-5",
+          messages: [{ role: "user", content: "ping" }]
+        })
+      });
+      return { ok: response.ok, status: response.status };
+    } catch {
+      return { ok: false, status: 0 };
+    }
+  }
+}