dr-claw 1.1.2 → 1.1.4

package/server/gemini-cli.js

@@ -12,6 +12,8 @@ import { buildTempAttachmentFilename, toPortableAtPath } from './utils/imageAtta
 import { splitLegacyGeminiThoughtContent } from '../shared/geminiThoughtParser.js';
 import { classifyError } from '../shared/errorClassifier.js';
 import { buildGeminiThinkingConfig } from '../shared/geminiThinkingSupport.js';
+import { buildMemoryBlock } from './utils/memoryPrompt.js';
+import { expandSkillCommand } from './utils/skillExpander.js';
 
 // Use cross-spawn on Windows for better command execution
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
@@ -606,13 +608,22 @@ export async function spawnGemini(command, options = {}, ws) {
     }
 
     if (command && command.trim()) {
+      // Expand /skill-name slash commands into full SKILL.md instructions
+      // so the Gemini model receives actionable procedures.
+      const expandedCommand = await expandSkillCommand(command.trim(), workingDir);
+
       const effectiveAttachments = attachments || images;
-      const attachmentResult = await handleGeminiAttachments(command, effectiveAttachments, workingDir);
+      const attachmentResult = await handleGeminiAttachments(expandedCommand, effectiveAttachments, workingDir);
       tempFilePaths = attachmentResult.tempFilePaths;
       if (attachmentResult.tempDir) {
         tempDirs.push(attachmentResult.tempDir);
       }
-      const effectivePrompt = `${attachmentResult.modifiedCommand}`;
+      // Memory is prepended to the user prompt because Gemini CLI uses --prompt flag
+      // and does not expose a separate system instruction API.
+      const memoryBlock = options.userId ? buildMemoryBlock(options.userId) : '';
+      const effectivePrompt = memoryBlock
+        ? `${memoryBlock}\n\n${attachmentResult.modifiedCommand}`
+        : `${attachmentResult.modifiedCommand}`;
       args.push('--prompt', effectivePrompt);
 
       // Keep Gemini CLI in yolo mode internally and enforce policy in our own approval hook.

package/server/index.js

@@ -31,8 +31,6 @@ const c = {
     dim: (text) => `${colors.dim}${text}${colors.reset}`,
 };
 
-console.log('Requested PORT from env:', process.env.PORT);
-
 import express from 'express';
 import { WebSocketServer, WebSocket } from 'ws';
 import os from 'os';
@@ -52,6 +50,7 @@ import { queryCodex, abortCodexSession, isCodexSessionActive, getCodexSessionSta
 import { spawnGemini, abortGeminiSession, isGeminiSessionActive, getGeminiSessionStartTime, getActiveGeminiSessions } from './gemini-cli.js';
 import { queryOpenRouter, abortOpenRouterSession, isOpenRouterSessionActive, getOpenRouterSessionStartTime, getActiveOpenRouterSessions } from './openrouter.js';
 import { queryLocalGPU, abortLocalGPUSession, isLocalGPUSessionActive, getLocalGPUSessionStartTime, getActiveLocalGPUSessions } from './local-gpu.js';
+import { spawnNanoClaudeCode, abortNanoClaudeCodeSession, isNanoClaudeCodeSessionActive, getNanoClaudeCodeSessionStartTime, getActiveNanoClaudeCodeSessions } from './nano-claude-code.js';
 import gitRoutes from './routes/git.js';
 import authRoutes from './routes/auth.js';
 import mcpRoutes from './routes/mcp.js';
@@ -59,6 +58,7 @@ import cursorRoutes from './routes/cursor.js';
 import taskmasterRoutes from './routes/taskmaster.js';
 import mcpUtilsRoutes from './routes/mcp-utils.js';
 import commandsRoutes from './routes/commands.js';
+import claudeBtwRoutes from './routes/claude-btw.js';
 import settingsRoutes from './routes/settings.js';
 import agentRoutes from './routes/agent.js';
 import projectsRoutes, { WORKSPACES_ROOT, getWorkspacesRoot, validateWorkspacePath } from './routes/projects.js';
@@ -86,13 +86,15 @@ import {
     setRuntimePortSync,
 } from './utils/runtimePorts.js';
 import { buildCodexTokenUsageFromJsonl } from './utils/sessionTokenUsage.js';
+import { getNanoDrClawSessionsRoot } from './nanoSessionPaths.js';
 
 // File system watchers for provider project/session folders
 const PROVIDER_WATCH_PATHS = [
     { provider: 'claude', rootPath: path.join(os.homedir(), '.claude', 'projects') },
     { provider: 'cursor', rootPath: path.join(os.homedir(), '.cursor', 'chats') },
     { provider: 'codex', rootPath: path.join(os.homedir(), '.codex', 'sessions') },
-    { provider: 'gemini', rootPath: path.join(os.homedir(), '.gemini', 'sessions') }
+    { provider: 'gemini', rootPath: path.join(os.homedir(), '.gemini', 'sessions') },
+    { provider: 'nano', rootPath: getNanoDrClawSessionsRoot() },
 ];
 const WATCHER_IGNORED_PATTERNS = [
     '**/node_modules/**',
@@ -132,6 +134,11 @@ function shouldProcessProjectsWatcherEvent(eventType, filePath, provider) {
         );
     }
 
+    if (provider === 'nano') {
+        const base = path.basename(String(filePath || '').replace(/\\/g, '/')).toLowerCase();
+        return base.endsWith('.json') && base.startsWith('drclaw-nano-');
+    }
+
     return true;
 }
 
@@ -298,6 +305,15 @@ const SHELL_EMBEDDED_ENV_KEYS_TO_REMOVE = [
     'WT_SESSION',
 ];
 
+function safePtyKill(session, sessionKey) {
+    if (!session?.pty?.kill) return;
+    try {
+        session.pty.kill();
+    } catch (err) {
+        console.warn(`⚠️ Failed to kill PTY process (${sessionKey}):`, err);
+    }
+}
+
 function stripAnsiSequences(value = '') {
     return value.replace(ANSI_ESCAPE_SEQUENCE_REGEX, '');
 }
@@ -412,7 +428,14 @@ const wss = new WebSocketServer({
 // Make WebSocket server available to routes
 app.locals.wss = wss;
 
-app.use(cors());
+// Parse VITE_PORT early so CORS reflects the actual frontend port.
+const CORS_VITE_PORT = parsePortNumber(process.env.VITE_PORT, DEFAULT_FRONTEND_PORT);
+app.use(cors({
+  origin: process.env.DR_CLAW_CORS_ORIGINS
+    ? process.env.DR_CLAW_CORS_ORIGINS.split(',').map((o) => o.trim()).filter(Boolean)
+    : [`http://localhost:${getFrontendPortSync(CORS_VITE_PORT)}`, `http://127.0.0.1:${getFrontendPortSync(CORS_VITE_PORT)}`],
+  credentials: true,
+}));
 app.use(express.json({
   limit: '50mb',
   type: (req) => {
@@ -428,11 +451,21 @@ app.use(express.urlencoded({ limit: '50mb', extended: true }));
 
 // Public health check endpoint (no authentication required)
 app.get('/health', (req, res) => {
-  res.json({
+  const isDesktop = process.env.DR_CLAW_DESKTOP === '1';
+  const response = {
     status: 'ok',
     timestamp: new Date().toISOString(),
-    installMode
-  });
+    installMode: isDesktop ? 'desktop' : installMode,
+  };
+
+  if (isDesktop) {
+    response.desktop = {
+      platform: process.platform,
+      arch: process.arch,
+    };
+  }
+
+  res.json(response);
 });
 
 // Optional API key validation (if configured)
@@ -462,6 +495,9 @@ app.use('/api/mcp-utils', authenticateToken, mcpUtilsRoutes);
 // Commands API Routes (protected)
 app.use('/api/commands', authenticateToken, commandsRoutes);
 
+// Claude ephemeral side question (/btw)
+app.use('/api/claude', authenticateToken, claudeBtwRoutes);
+
 // Settings API Routes (protected)
 app.use('/api/settings', authenticateToken, settingsRoutes);
 
@@ -655,6 +691,13 @@ app.use(express.static(path.join(__dirname, '../dist'), {
 // System update endpoint
 app.post('/api/system/update', authenticateToken, async (req, res) => {
     try {
+        if (process.env.DR_CLAW_DESKTOP === '1') {
+            return res.status(400).json({
+                success: false,
+                error: 'Desktop builds do not support in-app self-update yet. Install a newer desktop package instead.'
+            });
+        }
+
         // Get the project root directory (parent of server directory)
         const projectRoot = path.join(__dirname, '..');
 
@@ -662,7 +705,7 @@ app.post('/api/system/update', authenticateToken, async (req, res) => {
 
         // Run the update command based on installation mode
         const updateCommand = installMode === 'git'
-            ? 'git checkout main && git pull && npm install'
+            ? 'git stash && git checkout main && git pull && npm install'
             : `npm install -g ${npmPackageName}@latest`;
 
         const child = spawn('sh', ['-c', updateCommand], {
@@ -1662,6 +1705,35 @@ function handleChatConnection(ws, request) {
                 queryLocalGPU(data.command, { ...data.options, env: sessionEnv }, writer).catch(error => {
                     console.error('[ERROR] Local GPU query error:', error);
                 });
+            } else if (data.type === 'nano-command') {
+                console.log('[DEBUG] Nano Claude Code message:', data.command || '[Continue/Resume]');
+                console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
+                console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
+                console.log('🤖 Model:', data.options?.model || 'default');
+                const commandTelemetryEnabled = data.options?.telemetryEnabled !== false;
+                const sessionId = data.options?.sessionId || data.sessionId;
+
+                if (sessionId && isNanoClaudeCodeSessionActive(sessionId)) {
+                    console.log(`[WARN] Nano Claude Code session ${sessionId} is already active. Ignoring concurrent request.`);
+                    return;
+                }
+
+                enqueueConversationTelemetry(
+                    {
+                        name: 'agent_dialogue_meta',
+                        direction: 'user_to_agent',
+                        provider: 'nano',
+                        sessionId: sessionId || null,
+                        projectPath: data.options?.projectPath || data.options?.cwd || null,
+                        transportType: data.type,
+                    },
+                    { ...telemetryContext, telemetryEnabled: commandTelemetryEnabled },
+                );
+                writer.telemetryContext = { ...telemetryContext, provider: 'nano', telemetryEnabled: commandTelemetryEnabled };
+                writer.setProjectPath(data.options?.projectPath || data.options?.cwd || null);
+                spawnNanoClaudeCode(data.command, { ...data.options, env: sessionEnv }, writer).catch(error => {
+                    console.error('[ERROR] Nano Claude Code error:', error);
+                });
             } else if (data.type === 'cursor-resume') {
                 // Backward compatibility: treat as cursor-command with resume and no prompt
                 console.log('[DEBUG] Cursor resume session (compat):', data.sessionId);
@@ -1695,6 +1767,8 @@ function handleChatConnection(ws, request) {
                     success = abortOpenRouterSession(data.sessionId);
                 } else if (provider === 'local') {
                     success = abortLocalGPUSession(data.sessionId);
+                } else if (provider === 'nano') {
+                    success = abortNanoClaudeCodeSession(data.sessionId);
                 } else {
                     // Use Claude Agents SDK
                     success = await abortClaudeSDKSession(data.sessionId);
@@ -1749,6 +1823,9 @@ function handleChatConnection(ws, request) {
                 } else if (provider === 'local') {
                     isActive = isLocalGPUSessionActive(sessionId);
                     startTime = getLocalGPUSessionStartTime(sessionId);
+                } else if (provider === 'nano') {
+                    isActive = isNanoClaudeCodeSessionActive(sessionId);
+                    startTime = getNanoClaudeCodeSessionStartTime(sessionId);
                 } else {
                     // Use Claude Agents SDK
                     isActive = isClaudeSDKSessionActive(sessionId);
@@ -1769,7 +1846,8 @@ function handleChatConnection(ws, request) {
                     cursor: getActiveCursorSessions(),
                     codex: getActiveCodexSessions(),
                     gemini: getActiveGeminiSessions(),
-                    local: getActiveLocalGPUSessions()
+                    local: getActiveLocalGPUSessions(),
+                    nano: getActiveNanoClaudeCodeSessions()
                 };
 
                 writer.send({
@@ -1840,7 +1918,7 @@ function handleShellConnection(ws) {
                     if (oldSession) {
                         console.log('🧹 Cleaning up existing login session:', ptySessionKey);
                         if (oldSession.timeoutId) clearTimeout(oldSession.timeoutId);
-                        if (oldSession.pty && oldSession.pty.kill) oldSession.pty.kill();
+                        safePtyKill(oldSession, ptySessionKey);
                         ptySessionsMap.delete(ptySessionKey);
                     }
                 }
@@ -2172,9 +2250,7 @@ function handleShellConnection(ws) {
 
                 session.timeoutId = setTimeout(() => {
                     console.log('⏰ PTY session timeout, killing process:', ptySessionKey);
-                    if (session.pty && session.pty.kill) {
-                        session.pty.kill();
-                    }
+                    safePtyKill(session, ptySessionKey);
                     ptySessionsMap.delete(ptySessionKey);
                 }, PTY_SESSION_TIMEOUT);
             }
@@ -2390,9 +2466,7 @@ function handleComputeShellConnection(ws, urlNodeId) {
                 session.ws = null;
                 session.timeoutId = setTimeout(() => {
                     console.log('⏰ Compute PTY session timeout, killing:', ptySessionKey);
-                    if (session.pty && session.pty.kill) {
-                        session.pty.kill();
-                    }
+                    safePtyKill(session, ptySessionKey);
                     ptySessionsMap.delete(ptySessionKey);
                 }, PTY_SESSION_TIMEOUT);
             }
@@ -3088,6 +3162,7 @@ async function getFileTree(dirPath, maxDepth = 3, currentDepth = 0, showHidden =
 const REQUESTED_PORT = parsePortNumber(process.env.PORT, DEFAULT_BACKEND_PORT);
 const REQUESTED_VITE_PORT = parsePortNumber(process.env.VITE_PORT, DEFAULT_FRONTEND_PORT);
 const HOST = process.env.HOST || '0.0.0.0';
+const IS_DESKTOP = process.env.DR_CLAW_DESKTOP === '1';
 // Show localhost when binding to all interfaces; 0.0.0.0 is not directly connectable.
 const DISPLAY_HOST = HOST === '0.0.0.0' ? 'localhost' : HOST;
 
@@ -3103,6 +3178,9 @@ async function startServer() {
 
         // Log Claude implementation mode
         console.log(`${c.info('[INFO]')} Using Claude Agents SDK for Claude integration`);
+        if (IS_DESKTOP) {
+            console.log(`${c.info('[INFO]')} Running inside Electron desktop shell`);
+        }
         console.log(`${c.info('[INFO]')} Running in ${c.bright(isProduction ? 'PRODUCTION' : 'DEVELOPMENT')} mode`);
 
         if (!isProduction) {

package/server/load-env.js

@@ -42,6 +42,18 @@ function resolveDefaultDatabasePath() {
   }
 }
 
+function stripOptionalEnvQuotes(raw) {
+  const v = String(raw).trim();
+  if (v.length >= 2) {
+    const open = v[0];
+    const close = v[v.length - 1];
+    if ((open === '"' && close === '"') || (open === "'" && close === "'")) {
+      return v.slice(1, -1);
+    }
+  }
+  return v;
+}
+
 try {
   const envPath = path.join(__dirname, '../.env');
   const envFile = fs.readFileSync(envPath, 'utf8');
@@ -50,7 +62,7 @@ try {
     if (trimmedLine && !trimmedLine.startsWith('#')) {
       const [key, ...valueParts] = trimmedLine.split('=');
       if (key && valueParts.length > 0 && !process.env[key]) {
-        process.env[key] = valueParts.join('=').trim();
+        process.env[key] = stripOptionalEnvQuotes(valueParts.join('='));
       }
     }
   });

package/server/local-gpu.js

@@ -11,20 +11,26 @@ import crypto from 'crypto';
 import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
-import { exec } from 'child_process';
+import { exec, execFile } from 'child_process';
 import { promisify } from 'util';
+import { glob } from 'glob';
 import { encodeProjectPath, ensureProjectSkillLinks, reconcileLocalGPUSessionIndex } from './projects.js';
 import { writeProjectTemplates } from './templates/index.js';
 import { classifyError } from '../shared/errorClassifier.js';
 import { applyStageTagsToSession, recordIndexedSession } from './utils/sessionIndex.js';
 import { createRequestId, waitForToolApproval, matchesToolPermission } from './utils/permissions.js';
+import { buildMemoryBlock } from './utils/memoryPrompt.js';
 
 const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
-const DEFAULT_OLLAMA_URL = 'http://localhost:11434';
+export const DEFAULT_OLLAMA_URL = 'http://localhost:11434';
 const MAX_AGENT_TURNS = 30;
 const BASH_TIMEOUT_MS = 120_000;
 const MAX_OUTPUT_CHARS = 100_000;
+/** Match maxBuffer to capped output so large command output is not buffered in full. */
+const MAX_TOOL_BUFFER_BYTES = Math.min(MAX_OUTPUT_CHARS * 4, 512 * 1024);
+const GLOB_MAX_MATCHES = 200;
 const SESSIONS_DIR_NAME = 'localgpu-sessions';
 
 const activeLocalGPUSessions = new Map();
@@ -93,12 +99,58 @@ export async function detectGPUs() {
 // Ollama helpers
 // ---------------------------------------------------------------------------
 
+function isLoopbackHostname(hostname) {
+  if (!hostname) return false;
+  const h = hostname.toLowerCase();
+  if (h === 'localhost' || h === '::1' || h === '[::1]') return true;
+  if (h === '127.0.0.1') return true;
+  const m = /^127\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(h);
+  if (!m) return false;
+  return [m[1], m[2], m[3]].every((oct) => {
+    const n = parseInt(oct, 10);
+    return n >= 0 && n <= 255;
+  });
+}
+
+/**
+ * Normalize and validate Ollama base URL. Only http(s) loopback hosts are allowed (SSRF hardening).
+ */
+export function normalizeLocalOllamaBaseUrl(input) {
+  let raw = String(input ?? '').trim().replace(/\/+$/, '');
+  if (!raw) raw = DEFAULT_OLLAMA_URL;
+  if (!/^https?:\/\//i.test(raw)) {
+    raw = `http://${raw}`;
+  }
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    throw new Error('Invalid Ollama server URL');
+  }
+  if (u.protocol !== 'http:' && u.protocol !== 'https:') {
+    throw new Error('Ollama URL must use http or https');
+  }
+  if (u.username || u.password) {
+    throw new Error('Ollama URL must not include credentials');
+  }
+  if (!isLoopbackHostname(u.hostname)) {
+    throw new Error('Ollama URL must use localhost or 127.0.0.1 (loopback only)');
+  }
+  return u.origin;
+}
+
 function getOllamaUrl(options) {
-  return (options?.serverUrl || process.env.LOCAL_GPU_SERVER_URL || DEFAULT_OLLAMA_URL).replace(/\/+$/, '');
+  const raw = options?.serverUrl || process.env.LOCAL_GPU_SERVER_URL || DEFAULT_OLLAMA_URL;
+  return normalizeLocalOllamaBaseUrl(raw);
 }
 
 export async function checkOllamaStatus(serverUrl) {
-  const url = (serverUrl || DEFAULT_OLLAMA_URL).replace(/\/+$/, '');
+  let url;
+  try {
+    url = normalizeLocalOllamaBaseUrl(serverUrl || DEFAULT_OLLAMA_URL);
+  } catch (e) {
+    return { running: false, error: e.message };
+  }
   try {
     const res = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(5000) });
     if (!res.ok) return { running: false, error: `Server returned ${res.status}` };
@@ -129,7 +181,7 @@ function formatOllamaModel(m) {
 }
 
 export async function pullOllamaModel(serverUrl, modelName) {
-  const url = (serverUrl || DEFAULT_OLLAMA_URL).replace(/\/+$/, '');
+  const url = normalizeLocalOllamaBaseUrl(serverUrl || DEFAULT_OLLAMA_URL);
   const res = await fetch(`${url}/api/pull`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -279,6 +331,78 @@ function sendMessage(ws, data) {
 // Tool execution (same as OpenRouter)
 // ---------------------------------------------------------------------------
 
+async function runBashToolCommand(command, execCwd) {
+  if (typeof command !== 'string') {
+    return 'Error: command must be a string';
+  }
+  if (command.includes('\0')) {
+    return 'Error: command contains invalid characters';
+  }
+  const opts = {
+    cwd: execCwd,
+    timeout: BASH_TIMEOUT_MS,
+    maxBuffer: MAX_TOOL_BUFFER_BYTES,
+    windowsHide: true,
+  };
+  try {
+    if (process.platform === 'win32') {
+      const comspec = process.env.ComSpec || 'cmd.exe';
+      const { stdout, stderr } = await execFileAsync(comspec, ['/d', '/s', '/c', command], opts);
+      return (stdout + (stderr ? `\n[stderr]\n${stderr}` : '')).slice(0, MAX_OUTPUT_CHARS);
+    }
+    const { stdout, stderr } = await execFileAsync('/bin/sh', ['-c', command], opts);
+    return (stdout + (stderr ? `\n[stderr]\n${stderr}` : '')).slice(0, MAX_OUTPUT_CHARS);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+
+function isPathUnderSearchRoot(absPath, rootAbs) {
+  const rootNorm = path.resolve(rootAbs);
+  const fileNorm = path.resolve(absPath);
+  const prefix = rootNorm.endsWith(path.sep) ? rootNorm : `${rootNorm}${path.sep}`;
+  return fileNorm === rootNorm || fileNorm.startsWith(prefix);
+}
+
+async function runRipgrepSearch(pattern, dirAbs, includeGlob) {
+  if (typeof pattern !== 'string' || pattern.includes('\0')) {
+    return 'Error: invalid search pattern';
+  }
+  const rgArgs = [
+    '--max-count', '50',
+    '--line-number',
+    '--color', 'never',
+    '--no-heading',
+  ];
+  if (includeGlob && typeof includeGlob === 'string' && !includeGlob.includes('\0')) {
+    rgArgs.push('--glob', includeGlob);
+  }
+  rgArgs.push('--', pattern, dirAbs);
+  const opts = {
+    cwd: dirAbs,
+    timeout: 15_000,
+    maxBuffer: MAX_TOOL_BUFFER_BYTES,
+    windowsHide: true,
+  };
+  try {
+    const { stdout, stderr } = await execFileAsync('rg', rgArgs, opts);
+    const combined = (stdout || '') + (stderr ? `\n[stderr]\n${stderr}` : '');
+    const trimmed = combined.trim().slice(0, MAX_OUTPUT_CHARS);
+    return trimmed || 'No results.';
+  } catch (err) {
+    if (err?.code === 'ENOENT') {
+      return 'Error: ripgrep (rg) is not installed or not in PATH. Install from https://github.com/BurntSushi/ripgrep';
+    }
+    // ripgrep exits 1 when there are zero matches (not an error).
+    if (err?.code === 1 && typeof err.stdout === 'string') {
+      const combined = (err.stdout || '') + (err.stderr ? `\n[stderr]\n${err.stderr}` : '');
+      const trimmed = combined.trim().slice(0, MAX_OUTPUT_CHARS);
+      return trimmed || 'No results.';
+    }
+    return `Error: ${err.message}`;
+  }
+}
+
 async function executeTool(name, args, cwd) {
   try {
     if (name === 'Read') {
@@ -313,35 +437,40 @@ async function executeTool(name, args, cwd) {
 
     if (name === 'Bash') {
       const execCwd = args.cwd ? (path.isAbsolute(args.cwd) ? args.cwd : path.resolve(cwd, args.cwd)) : cwd;
-      const { stdout, stderr } = await execAsync(args.command, {
-        cwd: execCwd,
-        timeout: BASH_TIMEOUT_MS,
-        maxBuffer: 10 * 1024 * 1024,
-      });
-      return (stdout + (stderr ? `\n[stderr]\n${stderr}` : '')).slice(0, MAX_OUTPUT_CHARS);
+      return await runBashToolCommand(args.command, execCwd);
     }
 
     if (name === 'Glob') {
       const dir = args.directory
         ? (path.isAbsolute(args.directory) ? args.directory : path.resolve(cwd, args.directory))
         : cwd;
-      const { stdout } = await execAsync(
-        `find ${JSON.stringify(dir)} -path ${JSON.stringify(args.pattern)} -type f 2>/dev/null | head -200`,
-        { cwd: dir, timeout: 15000 },
-      );
-      return stdout.trim() || 'No files matched.';
+      const dirResolved = path.resolve(dir);
+      if (typeof args.pattern !== 'string' || args.pattern.includes('\0')) {
+        return 'Error: invalid glob pattern';
+      }
+      const matches = await glob(args.pattern, {
+        cwd: dirResolved,
+        nodir: true,
+        absolute: true,
+        followSymbolicLinks: false,
+        maxDepth: 40,
+      });
+      const safe = [];
+      for (const p of matches) {
+        if (isPathUnderSearchRoot(p, dirResolved)) {
+          safe.push(p);
+        }
+        if (safe.length >= GLOB_MAX_MATCHES) break;
+      }
+      return safe.join('\n') || 'No files matched.';
     }
 
     if (name === 'Search') {
       const dir = args.directory
         ? (path.isAbsolute(args.directory) ? args.directory : path.resolve(cwd, args.directory))
         : cwd;
-      const includeFlag = args.include ? `--glob ${JSON.stringify(args.include)}` : '';
-      const { stdout } = await execAsync(
-        `rg --max-count 50 --line-number ${includeFlag} ${JSON.stringify(args.pattern)} ${JSON.stringify(dir)} 2>/dev/null | head -200`,
-        { cwd: dir, timeout: 15000 },
-      );
-      return stdout.trim() || 'No results.';
+      const dirResolved = path.resolve(dir);
+      return await runRipgrepSearch(args.pattern, dirResolved, args.include);
     }
 
     if (name === 'LS') {
@@ -556,7 +685,19 @@ export async function queryLocalGPU(command, options = {}, ws) {
   } = options;
 
   const workingDirectory = cwd || projectPath || process.cwd();
-  const ollamaUrl = getOllamaUrl(options);
+  let ollamaUrl;
+  try {
+    ollamaUrl = getOllamaUrl(options);
+  } catch (err) {
+    sendMessage(ws, {
+      type: 'localgpu-error',
+      error: err.message,
+      errorType: 'auth',
+      isRetryable: false,
+      sessionId,
+    });
+    return;
+  }
 
   // Verify Ollama is reachable
   try {
@@ -623,7 +764,8 @@ export async function queryLocalGPU(command, options = {}, ws) {
       projectName: workingDirectory ? encodeProjectPath(workingDirectory) : undefined,
     });
 
-    const systemContent = customSystemPrompt || await buildSystemPrompt(workingDirectory);
+    const memoryBlock = options.userId ? buildMemoryBlock(options.userId) : '';
+    const systemContent = (customSystemPrompt || await buildSystemPrompt(workingDirectory)) + memoryBlock;
     const messages = [{ role: 'system', content: systemContent }];
 
     if (sessionId) {