natureco-cli 5.7.0 → 5.7.1

package/src/utils/api.js

@@ -9,26 +9,17 @@ const { getConfig } = require('./config');
 const { getToolDefinitions, executeToolCalls } = require('./tool-runner');
 const { MCPClient } = require('./mcp-client');
 const TB = require('./token-budget');
+const { accumulateToolCallDeltas } = require('./streaming-tools');
 
 /**
  * v5.5.0: Provider-specific format detection
  * Groq, OpenAI, Anthropic, Mistral, DeepSeek, OpenRouter, Ollama, MiniMax
+ *
+ * Canonical implementation lives in src/utils/provider-detect.js;
+ * re-exported here so the historical `detectProvider` reference inside
+ * api.js continues to work without touching every call site.
  */
-function detectProvider(providerUrl, model) {
-  const url = (providerUrl || '').toLowerCase();
-  const m = (model || '').toLowerCase();
-  if (url.includes('anthropic.com') || m.includes('claude')) return 'anthropic';
-  if (url.includes('groq.com') || m.includes('groq') || m.includes('llama-3') || m.includes('mixtral')) return 'groq';
-  if (url.includes('openrouter.ai')) return 'openrouter';
-  if (url.includes('api.deepseek.com') || m.includes('deepseek')) return 'deepseek';
-  if (url.includes('mistral.ai') || m.includes('mistral') || m.includes('codestral')) return 'mistral';
-  if (url.includes('together.xyz') || m.includes('together')) return 'together';
-  if (url.includes('fireworks.ai') || m.includes('fireworks')) return 'fireworks';
-  if (url.includes('perplexity.ai') || m.includes('pplx') || m.includes('sonar')) return 'perplexity';
-  if (url.includes('localhost') || url.includes('127.0.0.1') || url.includes('ollama')) return 'ollama';
-  if (url.includes('minimax.io') || url.includes('minimax')) return 'minimax';
-  return 'openai'; // default
-}
+const { detectProvider, isMiniMax } = require('./provider-detect');
 
 /**
  * v5.5.0: Tool definitions'ı provider'a göre normalize et
@@ -81,6 +72,29 @@ function parseToolCallsFromResponse(message, provider) {
   return message.tool_calls || [];
 }
 
+/**
+ * Anthropic Messages API requires `system` to be either a non-empty string
+ * or omitted entirely. Sending `undefined` (which JSON.stringify drops to
+ * silent absence) leaves the model unanchored; sending `''` returns 400
+ * "system: cannot be empty" on recent API revisions. Always pass a
+ * meaningful default when no system message is present.
+ */
+const DEFAULT_ANTHROPIC_SYSTEM =
+  'You are a helpful AI assistant running inside the natureco CLI.';
+
+function extractSystemForAnthropic(messages) {
+  const systemMsg = messages.find(m => m.role === 'system');
+  if (!systemMsg) return DEFAULT_ANTHROPIC_SYSTEM;
+  // content may be a string or an array of content blocks; both round-trip.
+  if (typeof systemMsg.content === 'string') {
+    return systemMsg.content.trim() || DEFAULT_ANTHROPIC_SYSTEM;
+  }
+  if (Array.isArray(systemMsg.content) && systemMsg.content.length > 0) {
+    return systemMsg.content;
+  }
+  return DEFAULT_ANTHROPIC_SYSTEM;
+}
+
 /**
  * v5.5.0: System mesajı provider'a göre ayarla
  * - OpenAI: messages[].role=system
@@ -88,8 +102,6 @@ function parseToolCallsFromResponse(message, provider) {
  */
 function buildRequestBody(messages, model, options, provider) {
   if (provider === 'anthropic') {
-    // System mesajını ayır
-    const systemMsg = messages.find(m => m.role === 'system');
     const userMsgs = messages.filter(m => m.role !== 'system');
     return {
       model,
@@ -97,7 +109,7 @@ function buildRequestBody(messages, model, options, provider) {
         role: m.role,
         content: m.content
       })),
-      system: systemMsg ? systemMsg.content : undefined,
+      system: extractSystemForAnthropic(messages),
       max_tokens: options.max_tokens || 4096,
       temperature: options.temperature || 0.7,
       ...(options.tools && options.tools.length > 0 ? { tools: options.tools } : {})
@@ -534,9 +546,8 @@ function formatToolsForAnthropic() {
  */
 async function sendMessageOpenAICompatible(providerConfig, messages, tools) {
   const baseUrl = providerConfig.url.replace(/\/+$/, '');
-  // MiniMax özel endpoint tespiti
-  const isMiniMax = baseUrl.includes('minimax.io') || baseUrl.includes('minimaxi.com') || baseUrl.includes('minimax.cn');
-  const endpoint = isMiniMax
+  // MiniMax özel endpoint tespiti — provider-detect.js'deki kanonik tanım.
+  const endpoint = isMiniMax(baseUrl)
     ? `${baseUrl}/v1/text/chatcompletion_v2`
     : `${baseUrl}/chat/completions`;
   const requestBody = {
@@ -587,11 +598,10 @@ async function sendMessageOpenAICompatible(providerConfig, messages, tools) {
  */
 async function sendMessageAnthropic(providerConfig, messages, tools) {
   const endpoint = `${providerConfig.url}/v1/messages`;
-  
-  // Anthropic requires system message separate
-  const systemMessage = messages.find(m => m.role === 'system');
+
+  // Anthropic requires system message separate; never send empty string.
   const userMessages = messages.filter(m => m.role !== 'system');
-  
+
   const response = await fetch(endpoint, {
     method: 'POST',
     headers: {
@@ -602,7 +612,7 @@ async function sendMessageAnthropic(providerConfig, messages, tools) {
     body: JSON.stringify({
       model: providerConfig.model,
       max_tokens: 2000,
-      system: systemMessage?.content || '',
+      system: extractSystemForAnthropic(messages),
       messages: userMessages,
       tools: tools,
     }),
@@ -992,9 +1002,8 @@ async function streamProviderCompletion(providerConfig, messages, tools) {
 
 async function streamOpenAICompletion(providerConfig, messages, tools) {
   const baseUrl = providerConfig.url.replace(/\/+$/, '');
-  // MiniMax özel endpoint tespiti (streaming için de aynı)
-  const isMiniMax = baseUrl.includes('minimax.io') || baseUrl.includes('minimaxi.com') || baseUrl.includes('minimax.cn');
-  const endpoint = isMiniMax
+  // MiniMax özel endpoint tespiti (streaming için de aynı) — provider-detect.js.
+  const endpoint = isMiniMax(baseUrl)
     ? `${baseUrl}/v1/text/chatcompletion_v2`
     : `${baseUrl}/chat/completions`;
 
@@ -1046,15 +1055,7 @@ async function streamOpenAICompletion(providerConfig, messages, tools) {
 
         if (delta.tool_calls) {
           hasToolCalls = true;
-          for (const tc of delta.tool_calls) {
-            const idx = tc.index;
-            if (!toolCalls[idx]) {
-              toolCalls[idx] = { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } };
-            }
-            if (tc.id) toolCalls[idx].id = tc.id;
-            if (tc.function?.name) toolCalls[idx].function.name += tc.function.name;
-            if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
-          }
+          accumulateToolCallDeltas(toolCalls, delta.tool_calls);
         }
 
         const token = delta.content || '';
@@ -1089,7 +1090,6 @@ async function streamOpenAICompletion(providerConfig, messages, tools) {
 async function streamAnthropicCompletion(providerConfig, messages) {
   const endpoint = `${providerConfig.url}/v1/messages`;
 
-  const systemMessage = messages.find(m => m.role === 'system');
   const userMessages = messages.filter(m => m.role !== 'system');
 
   const response = await fetch(endpoint, {
@@ -1102,7 +1102,7 @@ async function streamAnthropicCompletion(providerConfig, messages) {
     body: JSON.stringify({
       model: providerConfig.model,
       max_tokens: 2000,
-      system: systemMessage?.content || '',
+      system: extractSystemForAnthropic(messages),
       messages: userMessages,
       stream: true,
     }),
@@ -1154,5 +1154,12 @@ module.exports = {
   streamProviderCompletion,
   streamOpenAICompletion,
   streamAnthropicCompletion,
+  // Exposed for tests + advanced consumers (does not appear in the
+  // public API surface of natureco's user-facing docs).
+  _internals: {
+    extractSystemForAnthropic,
+    DEFAULT_ANTHROPIC_SYSTEM,
+    buildRequestBody,
+  },
   _sendMessage: sendMessage,
 };

package/src/utils/approvals.js

@@ -1,15 +1,25 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const net = require('net');
 const chalk = require('chalk');
 const inquirer = require('./inquirer-wrapper');
 const { NatureCoError } = require('./errors');
+const { writeJsonAtomicSync, readJsonSafeSync } = require('./atomic-file');
 
 const APPROVALS_FILE = path.join(os.homedir(), '.natureco', 'exec-approvals.json');
-const APPROVALS_SOCKET_PATH = path.join(os.homedir(), '.natureco', 'exec-approvals.sock');
 const DEFAULT_TIMEOUT_MS = 1800000; // 30 min
 
+// 0o600 = owner read/write only. The allowlist controls which commands
+// auto-execute without prompting; on a shared machine, world-read leaks
+// the user's automation surface and world-write lets another local
+// account inject auto-approved commands. Treat it like ssh keys.
+const APPROVALS_FILE_MODE = 0o600;
+const APPROVALS_DIR_MODE = 0o700;
+
+function _emptyApprovals() {
+  return { version: 1, defaults: { security: 'full', ask: 'off' }, agents: {} };
+}
+
 class ExecApprovalError extends NatureCoError {
   constructor(message, options = {}) {
     super(message, options);
@@ -33,20 +43,22 @@ function getApprovalsPath() {
 }
 
 function loadApprovals() {
-  if (!fs.existsSync(APPROVALS_FILE)) {
-    return { version: 1, defaults: { security: 'full', ask: 'off' }, agents: {} };
-  }
-  try {
-    return JSON.parse(fs.readFileSync(APPROVALS_FILE, 'utf8'));
-  } catch {
-    return { version: 1, defaults: { security: 'full', ask: 'off' }, agents: {} };
-  }
+  return readJsonSafeSync(APPROVALS_FILE, _emptyApprovals());
 }
 
 function saveApprovals(data) {
   const dir = path.dirname(APPROVALS_FILE);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(APPROVALS_FILE, JSON.stringify(data, null, 2), 'utf8');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: APPROVALS_DIR_MODE });
+  } else {
+    // Tighten the dir even if it pre-existed with looser bits.
+    try { fs.chmodSync(dir, APPROVALS_DIR_MODE); } catch { /* best-effort */ }
+  }
+  writeJsonAtomicSync(APPROVALS_FILE, data, { mode: APPROVALS_FILE_MODE });
+  // Tighten the file even if it pre-existed with looser bits (the rename
+  // in writeJsonAtomicSync preserves the temp's mode, but only when we
+  // pass it through — defensively chmod again in case of older installs).
+  try { fs.chmodSync(APPROVALS_FILE, APPROVALS_FILE_MODE); } catch { /* best-effort */ }
 }
 
 function resolveEffectivePolicy(agentId) {
@@ -294,4 +306,7 @@ module.exports = {
   getApprovalsPath,
   DANGEROUS_PATTERNS,
   SAFE_COMMANDS,
+  APPROVALS_FILE,
+  APPROVALS_FILE_MODE,
+  APPROVALS_DIR_MODE,
 };

package/src/utils/atomic-file.js

@@ -0,0 +1,91 @@
+/**
+ * Crash-safe file write + safe read.
+ *
+ * Why this exists: `fs.writeFileSync(path, data)` is NOT atomic. If the
+ * process is killed mid-write (SIGTERM, OOM, power loss) the file is
+ * left truncated, which becomes a "corrupted session" on next load
+ * (JSON.parse throws and session history is lost).
+ *
+ * `writeFileAtomicSync(path, data)` writes to a temp sibling first, then
+ * `rename(2)`s it into place — atomic on POSIX when both paths are on
+ * the same filesystem (always true here, since the temp is in the same
+ * directory).
+ *
+ * `readFileSafeSync(path, fallback)` returns the parsed JSON or falls
+ * back gracefully on missing/corrupted files instead of throwing.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+function _tempName(target) {
+  // Same directory so rename(2) is atomic. Include pid+rand to avoid
+  // collisions if two processes write the same file.
+  const dir = path.dirname(target);
+  const base = path.basename(target);
+  const suffix = `${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+  return path.join(dir, `.${base}.${suffix}`);
+}
+
+/**
+ * Atomically write a string/Buffer to `filePath`.
+ * On error the temp file is cleaned up and the original is untouched.
+ *
+ * @param {string} filePath
+ * @param {string|Buffer} data
+ * @param {{encoding?: BufferEncoding, mode?: number}} [opts]
+ */
+function writeFileAtomicSync(filePath, data, opts = {}) {
+  const encoding = opts.encoding ?? 'utf-8';
+  const mode = opts.mode; // undefined → fs default
+  const tmp = _tempName(filePath);
+  try {
+    if (mode !== undefined) {
+      fs.writeFileSync(tmp, data, { encoding, mode });
+    } else {
+      fs.writeFileSync(tmp, data, encoding);
+    }
+    fs.renameSync(tmp, filePath);
+  } catch (err) {
+    // Best-effort cleanup; if the temp already vanished, ignore.
+    try { fs.unlinkSync(tmp); } catch { /* ignore */ }
+    throw err;
+  }
+}
+
+/**
+ * Read `filePath` as JSON; return `fallback` on missing or corrupt.
+ *
+ * @template T
+ * @param {string} filePath
+ * @param {T} fallback
+ * @returns {T | object | Array<any>}
+ */
+function readJsonSafeSync(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    if (!raw.trim()) return fallback;
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Convenience: stringify + atomic write. Pretty-printed for human-edit
+ * friendliness (matches the existing JSON.stringify(..., null, 2) calls).
+ *
+ * @param {string} filePath
+ * @param {any} value
+ * @param {{mode?: number}} [opts]  e.g. {mode: 0o600} for secrets/PII
+ */
+function writeJsonAtomicSync(filePath, value, opts = {}) {
+  writeFileAtomicSync(filePath, JSON.stringify(value, null, 2), opts);
+}
+
+module.exports = {
+  writeFileAtomicSync,
+  writeJsonAtomicSync,
+  readJsonSafeSync,
+};

package/src/utils/dashboard-server.js

@@ -18,9 +18,10 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const url = require('url');
+const { getDashboardPort, getDashboardHost } = require('./ports');
 
-const PORT = 7421;
-const HOST = '127.0.0.1';
+const PORT = getDashboardPort();
+const HOST = getDashboardHost();
 
 const NATURECO_DIR = path.join(os.homedir(), '.natureco');
 

package/src/utils/error.js

@@ -9,6 +9,10 @@
  *   - Error codes
  */
 
+// checkMacPermission below uses os.platform() — was relying on a global
+// `os` from another module's load order.
+const os = require('os');
+
 class ToolError extends Error {
   constructor(message, code = "TOOL_ERROR", details = {}) {
     super(message);

package/src/utils/history.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { CONFIG_DIR } = require('./config');
+const { writeJsonAtomicSync, readJsonSafeSync } = require('./atomic-file');
 
 const HISTORY_DIR = path.join(CONFIG_DIR, 'history');
 
@@ -20,26 +21,17 @@ function getHistoryFilePath(botId) {
 // Load conversation history for a bot
 function loadHistory(botId) {
   const filePath = getHistoryFilePath(botId);
-  
-  if (!fs.existsSync(filePath)) {
-    return [];
-  }
-
-  try {
-    const content = fs.readFileSync(filePath, 'utf8');
-    return JSON.parse(content);
-  } catch {
-    return [];
-  }
+  const data = readJsonSafeSync(filePath, []);
+  // Normalize: older versions may have saved non-array; defensive cast.
+  return Array.isArray(data) ? data : [];
 }
 
 // Save conversation history for a bot
 function saveHistory(botId, history) {
   const filePath = getHistoryFilePath(botId);
-  
   try {
-    fs.writeFileSync(filePath, JSON.stringify(history, null, 2), 'utf8');
-  } catch (err) {
+    writeJsonAtomicSync(filePath, history);
+  } catch {
     // Silently fail - history is not critical
   }
 }

package/src/utils/ports.js

@@ -0,0 +1,44 @@
+/**
+ * Centralized port + host defaults with env-var overrides.
+ *
+ * Hardcoding `7421` across multiple modules invited "port already in use"
+ * crashes in environments where the user runs natureco alongside other
+ * services on that port, or wants to run multiple natureco dashboards
+ * (e.g. one per project worktree). This module is the single source of
+ * truth — set NATURECO_DASHBOARD_PORT / NATURECO_DASHBOARD_HOST once and
+ * all callers pick it up.
+ */
+
+const DEFAULT_DASHBOARD_PORT = 7421;
+const DEFAULT_DASHBOARD_HOST = '127.0.0.1';
+
+function _parsePort(raw, fallback) {
+  if (raw === undefined || raw === null || raw === '') return fallback;
+  const n = parseInt(String(raw).trim(), 10);
+  // Bind to a reserved port (≤1024) usually fails and is almost never
+  // what the user meant; clamp out-of-range values to the default.
+  if (!Number.isFinite(n) || n < 1 || n > 65535) return fallback;
+  return n;
+}
+
+function getDashboardPort() {
+  return _parsePort(process.env.NATURECO_DASHBOARD_PORT, DEFAULT_DASHBOARD_PORT);
+}
+
+function getDashboardHost() {
+  const raw = process.env.NATURECO_DASHBOARD_HOST;
+  return (raw && String(raw).trim()) || DEFAULT_DASHBOARD_HOST;
+}
+
+function getDashboardUrl() {
+  return `http://${getDashboardHost()}:${getDashboardPort()}`;
+}
+
+module.exports = {
+  DEFAULT_DASHBOARD_PORT,
+  DEFAULT_DASHBOARD_HOST,
+  getDashboardPort,
+  getDashboardHost,
+  getDashboardUrl,
+  _internals: { _parsePort },
+};

package/src/utils/process-errors.js

@@ -0,0 +1,115 @@
+/**
+ * Top-level process error handlers.
+ *
+ * Node's default behavior for unhandled rejections is to print a deprecated
+ * warning and (since Node 15) exit with code 1. The default for uncaught
+ * exceptions is to print the stack and exit 1. Both bypass natureco's audit
+ * trail and dump raw Node output that's useless to a CLI user.
+ *
+ * `install({ audit, exit, stderr })` registers handlers that:
+ *   1. Append a structured entry to the audit log (synchronous — the
+ *      process is about to die, async fire-and-forget would race),
+ *   2. Print a single friendly Turkish line + log path to stderr,
+ *   3. Exit with code 1 (configurable via `exit` for tests).
+ *
+ * Idempotent: a second call replaces the previous handlers (so the test
+ * suite can re-install with fresh spies).
+ */
+const path = require('path');
+const os = require('os');
+
+const ERROR_LOG_PATH = path.join(os.homedir(), '.natureco', 'logs', 'crash.log');
+
+let _installed = false;
+let _registered = { rejection: null, exception: null, warning: null };
+
+function _defaultAudit() {
+  try {
+    return require('./audit');
+  } catch {
+    return null;
+  }
+}
+
+function _serializeError(err) {
+  if (!err) return { type: 'unknown', message: 'null' };
+  if (err instanceof Error) {
+    return {
+      type: err.constructor.name,
+      message: err.message,
+      stack: err.stack ? err.stack.split('\n').slice(0, 20).join('\n') : null,
+      code: err.code,
+    };
+  }
+  if (typeof err === 'object') {
+    try { return { type: 'object', message: JSON.stringify(err).slice(0, 1000) }; }
+    catch { return { type: 'object', message: String(err) }; }
+  }
+  return { type: typeof err, message: String(err) };
+}
+
+/**
+ * Install global handlers. Returns an `uninstall()` function.
+ *
+ * @param {{
+ *   audit?: { logSync: Function, ACTIONS?: Record<string,string> } | null,
+ *   exit?: (code: number) => void,
+ *   stderr?: (msg: string) => void,
+ * }} [opts]
+ */
+function install(opts = {}) {
+  const audit = opts.audit === undefined ? _defaultAudit() : opts.audit;
+  const exit = opts.exit || ((code) => process.exit(code));
+  const stderr = opts.stderr || ((msg) => process.stderr.write(msg));
+
+  // Replace any previous handlers (idempotency for tests).
+  if (_registered.rejection) process.off('unhandledRejection', _registered.rejection);
+  if (_registered.exception) process.off('uncaughtException', _registered.exception);
+
+  const onRejection = (reason) => {
+    const payload = { kind: 'unhandledRejection', error: _serializeError(reason) };
+    try { audit?.logSync('error', payload); } catch { /* ignore */ }
+    stderr(
+      `\n  ✗ Beklenmedik bir hata oluştu (unhandled promise rejection).\n` +
+      `    Detay: ${payload.error.message}\n` +
+      `    Log: ${ERROR_LOG_PATH}\n` +
+      `    Hata raporu için: github.com/natureco-official/natureco-cli/issues\n\n`,
+    );
+    exit(1);
+  };
+
+  const onException = (err) => {
+    const payload = { kind: 'uncaughtException', error: _serializeError(err) };
+    try { audit?.logSync('error', payload); } catch { /* ignore */ }
+    stderr(
+      `\n  ✗ Beklenmedik bir hata oluştu (uncaught exception).\n` +
+      `    Detay: ${payload.error.message}\n` +
+      `    Log: ${ERROR_LOG_PATH}\n` +
+      `    Hata raporu için: github.com/natureco-official/natureco-cli/issues\n\n`,
+    );
+    exit(1);
+  };
+
+  process.on('unhandledRejection', onRejection);
+  process.on('uncaughtException', onException);
+  _registered = { rejection: onRejection, exception: onException, warning: null };
+  _installed = true;
+
+  return function uninstall() {
+    if (_registered.rejection) process.off('unhandledRejection', _registered.rejection);
+    if (_registered.exception) process.off('uncaughtException', _registered.exception);
+    _registered = { rejection: null, exception: null, warning: null };
+    _installed = false;
+  };
+}
+
+function isInstalled() {
+  return _installed;
+}
+
+module.exports = {
+  install,
+  isInstalled,
+  ERROR_LOG_PATH,
+  _internals: { _serializeError },
+};

package/src/utils/provider-detect.js

@@ -0,0 +1,78 @@
+/**
+ * Provider detection — single source of truth for "given a base URL
+ * (and optionally a model name) which provider family is this?"
+ *
+ * Previously this logic lived inline in three places:
+ *   - src/utils/api.js  (the canonical detectProvider, exported only
+ *     informally via its module surface)
+ *   - src/commands/setup.js  (string contains checks against minimax /
+ *     anthropic / groq, scattered through the OAuth + test flows)
+ *   - src/utils/api.js  again, with `const isMiniMax = baseUrl.includes(
+ *     'minimax.io') || baseUrl.includes('minimaxi.com') || baseUrl.includes(
+ *     'minimax.cn')` repeated twice (lines 560 + 1017)
+ *
+ * Refactoring opportunity from the v5.7 audit. This module preserves
+ * EXACTLY the same detection rules as the original detectProvider so
+ * the migration is a behavioral no-op verifiable by tests.
+ */
+
+/**
+ * Family of an inference provider.
+ *
+ * @typedef {'openai'|'anthropic'|'groq'|'openrouter'|'deepseek'|'mistral'
+ *           |'together'|'fireworks'|'perplexity'|'ollama'|'minimax'} ProviderName
+ */
+
+/**
+ * @param {string} providerUrl
+ * @param {string} [model]
+ * @returns {ProviderName}
+ */
+function detectProvider(providerUrl, model) {
+  const url = (providerUrl || '').toLowerCase();
+  const m = (model || '').toLowerCase();
+  if (url.includes('anthropic.com') || m.includes('claude')) return 'anthropic';
+  if (url.includes('groq.com') || m.includes('groq') || m.includes('llama-3') || m.includes('mixtral')) return 'groq';
+  if (url.includes('openrouter.ai')) return 'openrouter';
+  if (url.includes('api.deepseek.com') || m.includes('deepseek')) return 'deepseek';
+  if (url.includes('mistral.ai') || m.includes('mistral') || m.includes('codestral')) return 'mistral';
+  if (url.includes('together.xyz') || m.includes('together')) return 'together';
+  if (url.includes('fireworks.ai') || m.includes('fireworks')) return 'fireworks';
+  if (url.includes('perplexity.ai') || m.includes('pplx') || m.includes('sonar')) return 'perplexity';
+  if (url.includes('localhost') || url.includes('127.0.0.1') || url.includes('ollama')) return 'ollama';
+  if (url.includes('minimax.io') || url.includes('minimax')) return 'minimax';
+  return 'openai';
+}
+
+/** Convenience predicates — each one short-circuits on hostname only. */
+function isAnthropic(url) {
+  return (url || '').toLowerCase().includes('anthropic.com');
+}
+
+function isGroq(url) {
+  return (url || '').toLowerCase().includes('groq.com');
+}
+
+/**
+ * MiniMax has three known production hosts:
+ *   api.minimax.io    — global English-facing
+ *   api.minimaxi.com  — China-facing
+ *   api.minimax.cn    — legacy CN domain seen in some auth tokens
+ */
+function isMiniMax(url) {
+  const u = (url || '').toLowerCase();
+  return u.includes('minimax.io') || u.includes('minimaxi.com') || u.includes('minimax.cn');
+}
+
+function isOllama(url) {
+  const u = (url || '').toLowerCase();
+  return u.includes('localhost') || u.includes('127.0.0.1') || u.includes('ollama');
+}
+
+module.exports = {
+  detectProvider,
+  isAnthropic,
+  isGroq,
+  isMiniMax,
+  isOllama,
+};

package/src/utils/sessions.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { writeJsonAtomicSync, readJsonSafeSync } = require('./atomic-file');
 
 // ── Legacy botId-based sessions ─────────────────────────────────────────────────
 
@@ -36,20 +37,12 @@ function createSession(botId, botName) {
 function _saveBotSession(botId, session) {
   ensureSessionsDir(botId);
   const sessionFile = path.join(getSessionsDir(botId), `${session.id}.json`);
-  fs.writeFileSync(sessionFile, JSON.stringify(session, null, 2), 'utf-8');
+  writeJsonAtomicSync(sessionFile, session);
 }
 
 function loadSession(botId, sessionId) {
   const sessionFile = path.join(getSessionsDir(botId), `${sessionId}.json`);
-  if (!fs.existsSync(sessionFile)) {
-    return null;
-  }
-  try {
-    const data = fs.readFileSync(sessionFile, 'utf-8');
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
+  return readJsonSafeSync(sessionFile, null);
 }
 
 function getLatestSession(botId) {
@@ -110,10 +103,10 @@ function saveSession(commandName, messages, metadata = {}) {
   }
   const id = Date.now().toString(36);
   const filename = path.join(SESSIONS_DIR, `${commandName}-${id}.json`);
-  fs.writeFileSync(filename, JSON.stringify({
+  writeJsonAtomicSync(filename, {
     id, commandName, messages, metadata,
-    savedAt: new Date().toISOString()
-  }, null, 2));
+    savedAt: new Date().toISOString(),
+  });
   return filename;
 }