@ruvnet/open-claude-code 2.0.1 → 2.1.1-nightly.20261011.202

package/src/tools/send-message.mjs

@@ -5,6 +5,8 @@
  * Messages are stored in a shared message queue.
  */
 
+import { randomBytes } from 'crypto';
+
 const messageQueue = new Map(); // agentId -> messages[]
 
 export const SendMessageTool = {
@@ -38,8 +40,10 @@ export const SendMessageTool = {
     },
 
     async call(input) {
+        // Use cryptographically secure random bytes for message IDs to
+        // prevent guessing/enumeration of message identifiers.
         const msg = {
-            id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            id: `msg_${Date.now()}_${randomBytes(6).toString('hex')}`,
             from: process.env.AGENT_ID || 'main',
             to: input.to,
             type: input.type || 'notification',

package/src/tools/web-fetch.mjs

@@ -1,7 +1,13 @@
 /**
  * Web Fetch Tool — fetch URL content using built-in Node.js fetch.
+ *
+ * Security: validates the URL before fetching to prevent SSRF attacks.
+ * Private/link-local/loopback addresses and cloud metadata endpoints are
+ * blocked so the tool cannot be used to probe internal network services.
  */
 
+import { isPrivateHost } from '../permissions/ssrf-check.mjs';
+
 export const WebFetchTool = {
     name: 'WebFetch',
     description: 'Fetch content from a URL. Returns the response body as text.',
@@ -25,7 +31,15 @@ export const WebFetchTool = {
         const errors = [];
         if (!input.url) errors.push('url is required');
         try {
-            new URL(input.url);
+            const parsed = new URL(input.url);
+            // Only allow http and https protocols
+            if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+                errors.push('url must use http or https protocol');
+            }
+            // Block SSRF: reject private/internal/loopback hosts
+            if (isPrivateHost(parsed.hostname)) {
+                errors.push('url must not target private or internal network addresses');
+            }
         } catch {
             errors.push('url must be a valid URL');
         }

package/src/tools/web-search.mjs

@@ -5,7 +5,11 @@
  * - Brave Search API (BRAVE_API_KEY)
  * - SearXNG (self-hosted, SEARXNG_URL)
  * - Fallback: returns instructions to use web-fetch instead
+ *
+ * Security: validates that SEARXNG_URL does not target private/internal
+ * addresses (SSRF guard) before making requests.
  */
+import { isPrivateHost } from '../permissions/ssrf-check.mjs';
 
 export const WebSearchTool = {
     name: 'WebSearch',
@@ -32,9 +36,17 @@ export const WebSearchTool = {
             return searchBrave(input.query, limit, braveKey);
         }
 
-        // Try SearXNG
+        // Try SearXNG — validate the configured URL is not an internal host
         const searxUrl = process.env.SEARXNG_URL;
         if (searxUrl) {
+            try {
+                const parsed = new URL(searxUrl);
+                if (isPrivateHost(parsed.hostname)) {
+                    return 'SEARXNG_URL points to a private/internal address. Configure a public SearXNG instance.';
+                }
+            } catch {
+                return 'SEARXNG_URL is not a valid URL.';
+            }
             return searchSearxng(input.query, limit, searxUrl);
         }
 

package/src/ui/app.mjs

@@ -0,0 +1,286 @@
+/**
+ * Main Ink App — full React terminal UI matching Claude Code's interface.
+ *
+ * Uses React.createElement (no JSX transpiler needed).
+ *
+ * Features:
+ * - Scrolling messages area with assistant, user, tool, thinking messages
+ * - Persistent status bar (model, context%, cost, time, permission mode)
+ * - Text input with prompt indicator
+ * - Loading spinner during API calls
+ * - Tool execution display with spinners
+ * - Keyboard shortcuts (Escape, Ctrl+C, Ctrl+L)
+ * - Slash command support (39 commands)
+ * - Skill invocation via /skill-name
+ */
+
+import React, { useState, useCallback, useRef } from 'react';
+import { render, Box, Text, useInput, useApp } from 'ink';
+import TextInput from 'ink-text-input';
+import {
+    StatusBar,
+    Message,
+    LoadingIndicator,
+    WelcomeBanner,
+} from './components.mjs';
+import { executeCommand, COMMANDS } from './commands.mjs';
+
+const h = React.createElement;
+
+/**
+ * Main application component.
+ */
+export function App({ agentLoop, settings }) {
+    const [input, setInput] = useState('');
+    const [messages, setMessages] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [model, setModel] = useState(agentLoop.state.model || 'claude-sonnet-4-6');
+    const [tokenCount, setTokenCount] = useState({ input: 0, output: 0 });
+    const [cost, setCost] = useState(0);
+    const [mode] = useState(settings.permissions?.defaultMode || 'default');
+    const [toolStatus, setToolStatus] = useState(null);
+    const [startTime] = useState(Date.now());
+    const loadingRef = useRef(false);
+    const { exit } = useApp();
+
+    // Calculate cost from token counts
+    const updateCost = useCallback((tokens) => {
+        const m = agentLoop.state.model || '';
+        let priceIn = 3, priceOut = 15;
+        if (m.includes('haiku')) { priceIn = 0.25; priceOut = 1.25; }
+        if (m.includes('opus')) { priceIn = 15; priceOut = 75; }
+        const costIn = (tokens.input / 1_000_000) * priceIn;
+        const costOut = (tokens.output / 1_000_000) * priceOut;
+        setCost(costIn + costOut);
+    }, [agentLoop.state.model]);
+
+    // Add a message to the display
+    const addMessage = useCallback((msg) => {
+        setMessages(prev => {
+            const next = [...prev, msg];
+            return next.length > 200 ? next.slice(-150) : next;
+        });
+    }, []);
+
+    // Handle slash commands
+    const handleCommand = useCallback((text) => {
+        const cmdName = text.split(/\s+/)[0].toLowerCase();
+
+        // Check for skill invocation
+        if (!COMMANDS[cmdName] && agentLoop.state._skillsLoader) {
+            const skill = agentLoop.state._skillsLoader.get(cmdName.slice(1));
+            if (skill) {
+                const args = text.slice(cmdName.length).trim();
+                addMessage({ role: 'user', content: text });
+                runPrompt(
+                    `[Skill: ${skill.name}]\n${skill.prompt}${args ? `\nArguments: ${args}` : ''}`
+                );
+                return;
+            }
+        }
+
+        const { response, exit: shouldExit } = executeCommand(text, agentLoop.state);
+        if (shouldExit) {
+            exit();
+            return;
+        }
+        addMessage({ role: 'system', content: response });
+
+        // Sync model if it changed
+        if (agentLoop.state.model !== model) {
+            setModel(agentLoop.state.model);
+        }
+    }, [agentLoop, model, addMessage, exit]);
+
+    // Run a prompt through the agent loop
+    const runPrompt = useCallback(async (text) => {
+        setIsLoading(true);
+        loadingRef.current = true;
+        setToolStatus(null);
+
+        try {
+            for await (const event of agentLoop.run(text)) {
+                switch (event.type) {
+                    case 'stream_event':
+                        setMessages(prev => {
+                            const last = prev[prev.length - 1];
+                            if (last && last.role === 'assistant' && last._streaming) {
+                                return [
+                                    ...prev.slice(0, -1),
+                                    { ...last, content: (last.content || '') + (event.text || '') },
+                                ];
+                            }
+                            return [
+                                ...prev,
+                                { role: 'assistant', content: event.text || '', _streaming: true },
+                            ];
+                        });
+                        break;
+
+                    case 'assistant':
+                        setMessages(prev => {
+                            const last = prev[prev.length - 1];
+                            if (last && last.role === 'assistant' && last._streaming) {
+                                return [
+                                    ...prev.slice(0, -1),
+                                    { ...last, _streaming: false },
+                                ];
+                            }
+                            if (event.content) {
+                                return [...prev, { role: 'assistant', content: event.content }];
+                            }
+                            return prev;
+                        });
+                        break;
+
+                    case 'thinking':
+                        addMessage({ role: 'thinking', thinking: event.text });
+                        break;
+
+                    case 'tool_progress':
+                        setToolStatus(event.tool);
+                        addMessage({
+                            role: 'tool',
+                            toolName: event.tool,
+                            toolStatus: 'running',
+                        });
+                        break;
+
+                    case 'result':
+                        setToolStatus(null);
+                        setMessages(prev => {
+                            const idx = prev.findLastIndex(
+                                m => m.role === 'tool' &&
+                                     m.toolName === event.tool &&
+                                     m.toolStatus === 'running'
+                            );
+                            if (idx >= 0) {
+                                const updated = [...prev];
+                                updated[idx] = {
+                                    ...updated[idx],
+                                    toolResult: typeof event.result === 'string'
+                                        ? event.result
+                                        : JSON.stringify(event.result),
+                                    toolStatus: 'done',
+                                };
+                                return updated;
+                            }
+                            return prev;
+                        });
+                        break;
+
+                    case 'compaction':
+                        addMessage({ role: 'system', content: `[compaction #${event.count}]` });
+                        break;
+
+                    case 'hookPermissionResult':
+                        if (!event.allowed) {
+                            addMessage({ role: 'system', content: `[blocked: ${event.tool}]` });
+                        }
+                        break;
+
+                    case 'error':
+                        addMessage({ role: 'error', content: event.message });
+                        break;
+
+                    case 'stop':
+                        break;
+                }
+
+                // Update token counts
+                const usage = agentLoop.state.tokenUsage;
+                setTokenCount({ input: usage.input, output: usage.output });
+                updateCost(usage);
+            }
+        } catch (err) {
+            addMessage({ role: 'error', content: err.message });
+        } finally {
+            setIsLoading(false);
+            loadingRef.current = false;
+            setToolStatus(null);
+        }
+    }, [agentLoop, addMessage, updateCost]);
+
+    // Handle submit
+    const handleSubmit = useCallback((value) => {
+        const trimmed = value.trim();
+        if (!trimmed) return;
+
+        setInput('');
+
+        if (trimmed.startsWith('/')) {
+            handleCommand(trimmed);
+            return;
+        }
+
+        addMessage({ role: 'user', content: trimmed });
+        runPrompt(trimmed);
+    }, [handleCommand, addMessage, runPrompt]);
+
+    // Keyboard shortcuts
+    useInput((ch, key) => {
+        if (key.escape && loadingRef.current) {
+            setIsLoading(false);
+            setToolStatus(null);
+            addMessage({ role: 'system', content: '[cancelled]' });
+        }
+        if (key.ctrl && ch === 'c') {
+            exit();
+        }
+        if (key.ctrl && ch === 'l') {
+            setMessages([]);
+        }
+    });
+
+    const toolCount = agentLoop.state.tools?.list?.()?.length || 0;
+
+    // Build the message list
+    const messageElements = messages.map((msg, i) =>
+        h(Message, { key: i, ...msg })
+    );
+
+    return h(Box, { flexDirection: 'column' },
+        // Welcome banner
+        h(WelcomeBanner, { model, toolCount }),
+
+        // Messages area
+        h(Box, { flexDirection: 'column', flexGrow: 1 },
+            ...messageElements,
+            isLoading ? h(LoadingIndicator, { tool: toolStatus }) : null,
+        ),
+
+        // Input area
+        h(Box, { borderStyle: 'round', borderColor: 'cyan', paddingX: 1, marginTop: 1 },
+            h(Text, { color: 'cyan' }, '> '),
+            h(TextInput, {
+                value: input,
+                onChange: setInput,
+                onSubmit: handleSubmit,
+                placeholder: 'Type a message...',
+            }),
+        ),
+
+        // Status bar
+        h(StatusBar, {
+            model,
+            tokens: tokenCount,
+            cost,
+            mode,
+            startTime,
+            contextMax: settings.maxContextTokens || 200000,
+        }),
+    );
+}
+
+/**
+ * Start the Ink application.
+ * @param {object} agentLoop - agent loop instance
+ * @param {object} settings - loaded settings
+ * @returns {object} Ink instance
+ */
+export function startInkApp(agentLoop, settings) {
+    const instance = render(
+        h(App, { agentLoop, settings })
+    );
+    return instance;
+}