natureco-cli 5.7.0 → 5.7.2

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/paste-safe-input.js

@@ -0,0 +1,173 @@
+/**
+ * paste-safe-input — Terminal'e uzun/çok satırlı metin yapıştırılınca
+ * her satırın ayrı bir "Enter" gibi gönderilip anında submit edilmesini önler.
+ *
+ * Sorun: Node'un düz `readline` arayüzü, terminalden gelen her "\n" karakterini
+ * bir 'line' event'i olarak görür. Terminal "bracketed paste mode" açık değilse
+ * (veya açık olsa da bu karakterler ayıklanmazsa), kullanıcı 10 satırlık bir metni
+ * yapıştırdığında readline bunu 10 ayrı mesaj gibi okur ve her birini hemen
+ * gönderir — kullanıcı paste'i bitirmeden cevaplar gelmeye başlar.
+ *
+ * Çözüm: Terminalin "bracketed paste" (ESC[200~ ... ESC[201~) işaretleyicilerini
+ * dinleyip, bu işaretler arasındaki tüm veriyi tek parça olarak topluyoruz.
+ * İçindeki gerçek satır sonlarını geçici bir placeholder ile değiştirip
+ * readline'a TEK satır gibi besliyoruz. Kullanıcı gerçekten Enter'a basana kadar
+ * hiçbir 'line' event'i tetiklenmez. Enter'a basıldığında, alınan satırdaki
+ * placeholder'lar gerçek "\n" karakterine geri çevrilip mesaj olarak kullanılır.
+ */
+
+'use strict';
+
+const { PassThrough } = require('stream');
+
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+
+// Yapıştırılan içindeki satır sonlarını gizlemek için kullanılan placeholder.
+// Gerçek kullanıcı girdisinde pratikte hiç geçmeyecek bir dizi.
+const NEWLINE_PLACEHOLDER = '\u2424\u2424LINEBREAK\u2424\u2424';
+
+/**
+ * Bracketed paste'i destekleyen bir PassThrough stream döner.
+ * `source` (genellikle process.stdin) üzerinden gelen veriyi işler.
+ *
+ * readline.createInterface({ input: createPasteSafeInput(process.stdin), ... })
+ * şeklinde process.stdin yerine kullanılmalı.
+ */
+// str'nin sonunda PASTE_START veya PASTE_END marker'ının bir ön-eki (prefix)
+// olarak duran kısmın uzunluğunu döner (0 = eşleşme yok). Sadece gerçekten
+// marker olabilecek bir kuyruk varsa bekletiyoruz; aksi halde tek tuş
+// yazımında karakterler bir sonraki tuşa kadar ekranda gecikir.
+function trailingMarkerPrefixLen(str, marker) {
+  const maxLen = Math.min(str.length, marker.length - 1);
+  for (let len = maxLen; len > 0; len--) {
+    if (str.slice(str.length - len) === marker.slice(0, len)) return len;
+  }
+  return 0;
+}
+
+// TERMINAL-AGNOSTIK PASTE TESPİTİ
+// ---------------------------------
+// Birçok terminal (örn. macOS'un yerleşik Terminal.app'i) bracketed-paste
+// (ESC[200~/[201~) modunu desteklemez/etkinleştirmez. Bu yüzden bracket
+// marker'larına güvenmek yetersiz kalıyor. Daha güvenilir, terminalden
+// bağımsız bir sinyal var: bir gerçek Enter tuşuna basış, işletim sisteminden
+// tek başına ve tek bir karakter ('\r' veya '\n') olarak gelir — başka hiçbir
+// karakterle birlikte değil. Ama bir yapıştırma (paste), terminal emülatörü
+// tarafından TEK SEFERDE (çok karakterli, içinde satır sonları barındıran bir
+// "data" event'i olarak) pty'ye yazılır. Yani: içinde satır sonu BARINDIRAN
+// ama SADECE tek bir satır sonu karakterinden İBARET OLMAYAN bir chunk,
+// hemen hemen kesin olarak bir paste'tir — bracket marker olsun olmasın.
+function isLoneEnterKeystroke(str) {
+  return str === '\r' || str === '\n' || str === '\r\n';
+}
+
+function escapeEmbeddedNewlines(str) {
+  if (!str || isLoneEnterKeystroke(str)) return str;
+  const newlineCount = (str.match(/\r\n|\r|\n/g) || []).length;
+  // Terminal-agnostik paste tespiti: sadece içinde birden çok satır
+  // barındıran chunk'lar paste kabul edilir. Tek satır + \n normal
+  // yazım olabilir (test/paste-safe-input.test.js "normal yazılan
+  // satırlar ayrı ayrı submit edilir" senaryosu).
+  if (newlineCount === 0) return str;
+  if (newlineCount === 1 && str.length < 100) return str;
+  return str.replace(/\r\n|\r|\n/g, NEWLINE_PLACEHOLDER);
+}
+
+function createPasteSafeInput(source = process.stdin) {
+  const proxy = new PassThrough();
+
+  let inPaste = false;
+  let carry = ''; // marker'ın chunk sınırında bölünmesine karşı tampon
+
+  const onData = (chunk) => {
+    let str = carry + chunk.toString('utf8');
+    carry = '';
+    let out = '';
+
+    while (str.length) {
+      if (inPaste) {
+        const endIdx = str.indexOf(PASTE_END);
+        if (endIdx === -1) {
+          const keepLen = trailingMarkerPrefixLen(str, PASTE_END);
+          const flushLen = str.length - keepLen;
+          out += str.slice(0, flushLen).replace(/\r\n|\r|\n/g, NEWLINE_PLACEHOLDER);
+          carry = str.slice(flushLen);
+          str = '';
+          break;
+        }
+        const pasted = str.slice(0, endIdx);
+        out += pasted.replace(/\r\n|\r|\n/g, NEWLINE_PLACEHOLDER);
+        inPaste = false;
+        str = str.slice(endIdx + PASTE_END.length);
+        continue;
+      }
+
+      const startIdx = str.indexOf(PASTE_START);
+      if (startIdx === -1) {
+        const keepLen = trailingMarkerPrefixLen(str, PASTE_START);
+        const flushLen = str.length - keepLen;
+        // Bracket marker'ı olmayan terminallerde de paste'i yakala: bu segment
+        // tek başına bir Enter tuşu değilse ve içinde satır sonu varsa, o
+        // satır sonlarını gizle (terminal-agnostik heuristik).
+        out += escapeEmbeddedNewlines(str.slice(0, flushLen));
+        carry = str.slice(flushLen);
+        str = '';
+        break;
+      }
+      out += escapeEmbeddedNewlines(str.slice(0, startIdx));
+      str = str.slice(startIdx + PASTE_START.length);
+      inPaste = true;
+    }
+
+    if (out) proxy.write(out);
+  };
+
+  source.on('data', onData);
+  source.on('end', () => {
+    if (carry) {
+      proxy.write(inPaste ? carry.replace(/\r\n|\r|\n/g, NEWLINE_PLACEHOLDER) : carry);
+      carry = '';
+    }
+    proxy.end();
+  });
+  source.on('error', (e) => proxy.emit('error', e));
+
+  // process.stdin'in raw-mode/pause-resume API'lerini proxy üzerinden de eriştir,
+  // readline bunları çağırabiliyor.
+  proxy.isTTY = source.isTTY;
+  proxy.setRawMode = source.setRawMode ? source.setRawMode.bind(source) : undefined;
+  proxy.ref = source.ref ? source.ref.bind(source) : undefined;
+  proxy.unref = source.unref ? source.unref.bind(source) : undefined;
+
+  return proxy;
+}
+
+/**
+ * Terminalde bracketed paste mode'u açar. Çoğu modern terminal (iTerm2, Terminal.app,
+ * Windows Terminal, VS Code, gnome-terminal vb.) bunu destekler. Desteklemeyen
+ * terminallerde bu escape kodu sessizce yok sayılır, davranış eskisi gibi kalır.
+ */
+function enableBracketedPaste(out = process.stdout) {
+  if (out.isTTY) out.write('\x1b[?2004h');
+}
+
+function disableBracketedPaste(out = process.stdout) {
+  if (out.isTTY) out.write('\x1b[?2004l');
+}
+
+/**
+ * readline'dan gelen satırı, paste placeholder'larını gerçek "\n" karakterine
+ * geri çevirerek normalize eder. Gönderilecek mesaj olarak bunu kullan.
+ */
+function restoreNewlines(line) {
+  return line.split(NEWLINE_PLACEHOLDER).join('\n');
+}
+
+module.exports = {
+  createPasteSafeInput,
+  enableBracketedPaste,
+  disableBracketedPaste,
+  restoreNewlines,
+  NEWLINE_PLACEHOLDER,
+};

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 },
+};