protoagent 0.1.4 → 0.1.5

package/README.md

@@ -1,4 +1,7 @@
-# ProtoAgent
+```
+█▀█ █▀█ █▀█ ▀█▀ █▀█ ▄▀█ █▀▀ █▀▀ █▄ █ ▀█▀
+█▀▀ █▀▄ █▄█  █  █▄█ █▀█ █▄█ ██▄ █ ▀█  █
+```
 
 A minimal, educational AI coding agent CLI written in TypeScript. It stays small enough to read in an afternoon, but it still has the core pieces you expect from a real coding agent: a streaming tool-use loop, approvals, sessions, MCP, skills, sub-agents, and cost tracking.
 
@@ -8,7 +11,7 @@ A minimal, educational AI coding agent CLI written in TypeScript. It stays small
 - **Built-in tools** — Read, write, edit, list, search, run shell commands, manage todos, and fetch web pages with `webfetch`
 - **Approval system** — Inline confirmation for file writes, file edits, and non-safe shell commands
 - **Session persistence** — Conversations and TODO state are saved automatically and can be resumed with `--session`
-- **Dynamic extensions** — Load skills on demand and add external tools through MCP servers
+<!-- - **Dynamic extensions** — Load skills on demand and add external tools through MCP servers -->
 - **Sub-agents** — Delegate self-contained tasks to isolated child conversations
 - **Usage tracking** — Live token, context, and estimated cost display in the TUI
 
@@ -19,7 +22,12 @@ npm install -g protoagent
 protoagent
 ```
 
-On first run, ProtoAgent shows an inline setup flow where you pick a provider/model pair and enter an API key. Config is stored in `~/.local/share/protoagent/config.json` on macOS/Linux and `~/AppData/Local/protoagent/config.json` on Windows.
+On first run, ProtoAgent shows an inline setup flow where you pick a provider/model pair and enter an API key. ProtoAgent stores that selection in `protoagent.jsonc`.
+
+Runtime config lookup is simple:
+
+- if `<cwd>/.protoagent/protoagent.jsonc` exists, ProtoAgent uses it
+- otherwise it falls back to the shared user config at `~/.config/protoagent/protoagent.jsonc` on macOS/Linux and `~/AppData/Local/protoagent/protoagent.jsonc` on Windows
 
 You can also run the standalone wizard directly:
 
@@ -27,6 +35,29 @@ You can also run the standalone wizard directly:
 protoagent configure
 ```
 
+Or configure a specific target non-interactively:
+
+```bash
+protoagent configure --project --provider openai --model gpt-5-mini
+protoagent configure --user --provider anthropic --model claude-sonnet-4-6
+```
+
+To create a runtime config file for the current project or your shared user config, run:
+
+```bash
+protoagent init
+```
+
+`protoagent init` creates `protoagent.jsonc` in either `<cwd>/.protoagent/protoagent.jsonc` or your shared user config location and prints the exact path it used.
+
+For scripts or non-interactive setup, use:
+
+```bash
+protoagent init --project
+protoagent init --user
+protoagent init --project --force
+```
+
 ## Interactive Commands
 
 - `/help` — Show available slash commands

package/dist/App.js

@@ -232,7 +232,7 @@ const InlineSetup = ({ onComplete }) => {
                         model: selectedModelId,
                         ...(value.trim().length > 0 ? { apiKey: value.trim() } : {}),
                     };
-                    writeConfig(newConfig);
+                    writeConfig(newConfig, 'project');
                     onComplete(newConfig);
                 } })] }));
 };
@@ -365,8 +365,7 @@ export const App = ({ dangerouslyAcceptAll = false, logLevel, sessionId, }) => {
                 });
             });
             await loadRuntimeConfig();
-            // Load config — if none exists, show inline setup
-            const loadedConfig = readConfig();
+            const loadedConfig = readConfig('active');
             if (!loadedConfig) {
                 setNeedsSetup(true);
                 return;

package/dist/agentic-loop.js

@@ -420,7 +420,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                             result = await runSubAgent(client, model, args.task, args.max_iterations, requestDefaults, subProgress);
                         }
                         else {
-                            result = await handleToolCall(name, args, { sessionId });
+                            result = await handleToolCall(name, args, { sessionId, abortSignal });
                         }
                         logger.debug('Tool result', {
                             tool: name,

package/dist/cli.js

@@ -13,7 +13,7 @@ import { readFileSync } from 'node:fs';
 import { render } from 'ink';
 import { Command } from 'commander';
 import { App } from './App.js';
-import { ConfigureComponent } from './config.js';
+import { ConfigureComponent, InitComponent, readConfig, writeConfig, writeInitConfig } from './config.js';
 // Get package.json version
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -33,7 +33,64 @@ program
 program
     .command('configure')
     .description('Configure AI model and API key settings')
-    .action(() => {
+    .option('--project', 'Write <cwd>/.protoagent/protoagent.jsonc')
+    .option('--user', 'Write the shared user protoagent.jsonc')
+    .option('--provider <id>', 'Provider id to configure')
+    .option('--model <id>', 'Model id to configure')
+    .option('--api-key <key>', 'Explicit API key to store in protoagent.jsonc')
+    .action((options) => {
+    if (options.project || options.user || options.provider || options.model || options.apiKey) {
+        if (options.project && options.user) {
+            console.error('Choose only one of --project or --user.');
+            process.exitCode = 1;
+            return;
+        }
+        if (!options.provider || !options.model) {
+            console.error('Non-interactive configure requires --provider and --model.');
+            process.exitCode = 1;
+            return;
+        }
+        const target = options.project ? 'project' : 'user';
+        const resultPath = writeConfig({
+            provider: options.provider,
+            model: options.model,
+            ...(typeof options.apiKey === 'string' && options.apiKey.trim() ? { apiKey: options.apiKey.trim() } : {}),
+        }, target);
+        console.log('Configured ProtoAgent:');
+        console.log(resultPath);
+        const selected = readConfig(target);
+        if (selected) {
+            console.log(`${selected.provider} / ${selected.model}`);
+        }
+        return;
+    }
     render(_jsx(ConfigureComponent, {}));
 });
+program
+    .command('init')
+    .description('Create a project-local or shared ProtoAgent runtime config')
+    .option('--project', 'Write <cwd>/.protoagent/protoagent.jsonc')
+    .option('--user', 'Write the shared user protoagent.jsonc')
+    .option('--force', 'Overwrite an existing target file')
+    .action((options) => {
+    if (options.project || options.user) {
+        if (options.project && options.user) {
+            console.error('Choose only one of --project or --user.');
+            process.exitCode = 1;
+            return;
+        }
+        const result = writeInitConfig(options.project ? 'project' : 'user', process.cwd(), {
+            overwrite: Boolean(options.force),
+        });
+        const message = result.status === 'created'
+            ? 'Created ProtoAgent config:'
+            : result.status === 'overwritten'
+                ? 'Overwrote ProtoAgent config:'
+                : 'ProtoAgent config already exists:';
+        console.log(message);
+        console.log(result.path);
+        return;
+    }
+    render(_jsx(InitComponent, {}));
+});
 program.parse(process.argv);

package/dist/config.js

@@ -2,10 +2,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, chmodSync } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { useState, useEffect } from 'react';
+import { useState } from 'react';
 import { Box, Text } from 'ink';
 import { Select, TextInput, PasswordInput } from '@inkjs/ui';
-import { loadRuntimeConfig } from './runtime-config.js';
+import { parse } from 'jsonc-parser';
+import { getActiveRuntimeConfigPath } from './runtime-config.js';
 import { getAllProviders, getProvider } from './providers.js';
 const CONFIG_DIR_MODE = 0o700;
 const CONFIG_FILE_MODE = 0o600;
@@ -56,80 +57,150 @@ export const getConfigDirectory = () => {
     }
     return path.join(homeDir, '.local', 'share', 'protoagent');
 };
-export const getConfigPath = () => {
-    return path.join(getConfigDirectory(), 'config.json');
-};
-export const ensureConfigDirectory = () => {
-    const dir = getConfigDirectory();
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true, mode: CONFIG_DIR_MODE });
+export const getUserRuntimeConfigDirectory = () => {
+    const homeDir = os.homedir();
+    if (process.platform === 'win32') {
+        return path.join(homeDir, 'AppData', 'Local', 'protoagent');
     }
-    hardenPermissions(dir, CONFIG_DIR_MODE);
+    return path.join(homeDir, '.config', 'protoagent');
 };
-export const readConfig = () => {
-    const configPath = getConfigPath();
-    if (existsSync(configPath)) {
-        try {
-            const content = readFileSync(configPath, 'utf8');
-            const raw = JSON.parse(content);
-            // Handle legacy format: { provider, model, credentials: { KEY: "..." } }
-            let apiKey = raw.apiKey;
-            if (!apiKey && raw.credentials && typeof raw.credentials === 'object') {
-                const provider = getAllProviders().find((p) => p.id === raw.provider);
-                if (provider?.apiKeyEnvVar) {
-                    apiKey = raw.credentials[provider.apiKeyEnvVar];
-                }
-                // Fallback: grab the first non-empty value
-                if (!apiKey) {
-                    apiKey = Object.values(raw.credentials).find((v) => typeof v === 'string' && v.length > 0);
-                }
-            }
-            if (!raw.provider || !raw.model) {
-                return null;
-            }
-            return {
-                provider: raw.provider,
-                model: raw.model,
-                apiKey: typeof apiKey === 'string' && apiKey.trim().length > 0 ? apiKey.trim() : undefined,
-            };
-        }
-        catch (error) {
-            console.error('Error reading config file:', error);
+export const getUserRuntimeConfigPath = () => {
+    return path.join(getUserRuntimeConfigDirectory(), 'protoagent.jsonc');
+};
+export const getProjectRuntimeConfigDirectory = (cwd = process.cwd()) => {
+    return path.join(cwd, '.protoagent');
+};
+export const getProjectRuntimeConfigPath = (cwd = process.cwd()) => {
+    return path.join(getProjectRuntimeConfigDirectory(cwd), 'protoagent.jsonc');
+};
+export const getInitConfigPath = (target, cwd = process.cwd()) => {
+    return target === 'project' ? getProjectRuntimeConfigPath(cwd) : getUserRuntimeConfigPath();
+};
+const RUNTIME_CONFIG_TEMPLATE = `{
+  // Add project or user-wide ProtoAgent runtime config here.
+  // Example uses:
+  // - choose the active provider/model by making it the first provider
+  //   and the first model under that provider
+  // - custom providers/models
+  // - MCP server definitions
+  // - request default parameters
+  "providers": {},
+  "mcp": {
+    "servers": {}
+  }
+}
+`;
+function ensureDirectory(targetDir) {
+    if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true, mode: CONFIG_DIR_MODE });
+    }
+    hardenPermissions(targetDir, CONFIG_DIR_MODE);
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function readRuntimeConfigFileSync(configPath) {
+    if (!existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(configPath, 'utf8');
+        const errors = [];
+        const parsed = parse(content, errors, { allowTrailingComma: true, disallowComments: false });
+        if (errors.length > 0 || !isPlainObject(parsed)) {
             return null;
         }
+        return parsed;
+    }
+    catch (error) {
+        console.error('Error reading runtime config file:', error);
+        return null;
+    }
+}
+function getConfiguredProviderAndModel(runtimeConfig) {
+    for (const [providerId, providerConfig] of Object.entries(runtimeConfig.providers || {})) {
+        const modelId = Object.keys(providerConfig.models || {})[0];
+        if (!modelId)
+            continue;
+        const apiKey = typeof providerConfig.apiKey === 'string' && providerConfig.apiKey.trim().length > 0
+            ? providerConfig.apiKey.trim()
+            : undefined;
+        return {
+            provider: providerId,
+            model: modelId,
+            ...(apiKey ? { apiKey } : {}),
+        };
     }
     return null;
-};
-export const writeConfig = (config) => {
-    ensureConfigDirectory();
-    const configPath = getConfigPath();
-    const normalizedConfig = {
-        provider: config.provider,
-        model: config.model,
+}
+function writeRuntimeConfigFile(configPath, runtimeConfig) {
+    ensureDirectory(path.dirname(configPath));
+    writeFileSync(configPath, `${JSON.stringify(runtimeConfig, null, 2)}\n`, { encoding: 'utf8', mode: CONFIG_FILE_MODE });
+    hardenPermissions(configPath, CONFIG_FILE_MODE);
+}
+function upsertSelectedConfig(runtimeConfig, config) {
+    const existingProviders = runtimeConfig.providers || {};
+    const currentProvider = existingProviders[config.provider] || {};
+    const currentModels = currentProvider.models || {};
+    const selectedModelConfig = currentModels[config.model] || {};
+    const nextProvider = {
+        ...currentProvider,
         ...(config.apiKey?.trim() ? { apiKey: config.apiKey.trim() } : {}),
+        models: Object.fromEntries([
+            [config.model, selectedModelConfig],
+            ...Object.entries(currentModels).filter(([modelId]) => modelId !== config.model),
+        ]),
+    };
+    if (!config.apiKey?.trim()) {
+        delete nextProvider.apiKey;
+    }
+    return {
+        ...runtimeConfig,
+        providers: Object.fromEntries([
+            [config.provider, nextProvider],
+            ...Object.entries(existingProviders).filter(([providerId]) => providerId !== config.provider),
+        ]),
     };
-    writeFileSync(configPath, JSON.stringify(normalizedConfig, null, 2), { encoding: 'utf8', mode: CONFIG_FILE_MODE });
+}
+export function writeInitConfig(target, cwd = process.cwd(), options = {}) {
+    const configPath = getInitConfigPath(target, cwd);
+    const alreadyExists = existsSync(configPath);
+    if (alreadyExists) {
+        if (!options.overwrite) {
+            return { path: configPath, status: 'exists' };
+        }
+    }
+    else {
+        ensureDirectory(path.dirname(configPath));
+    }
+    writeFileSync(configPath, RUNTIME_CONFIG_TEMPLATE, { encoding: 'utf8', mode: CONFIG_FILE_MODE });
     hardenPermissions(configPath, CONFIG_FILE_MODE);
+    return { path: configPath, status: alreadyExists ? 'overwritten' : 'created' };
+}
+export const readConfig = (target = 'active', cwd = process.cwd()) => {
+    const configPath = target === 'active' ? getActiveRuntimeConfigPath() : getInitConfigPath(target, cwd);
+    if (!configPath) {
+        return null;
+    }
+    const runtimeConfig = readRuntimeConfigFileSync(configPath);
+    if (!runtimeConfig) {
+        return null;
+    }
+    return getConfiguredProviderAndModel(runtimeConfig);
 };
-export const InitialLoading = ({ setExistingConfig, setStep }) => {
-    useEffect(() => {
-        loadRuntimeConfig()
-            .then(() => {
-            const config = readConfig();
-            if (config) {
-                setExistingConfig(config);
-                setStep(1);
-            }
-            else {
-                setStep(2);
-            }
-        })
-            .catch((error) => {
-            console.error('Error loading runtime config:', error);
-            setStep(2);
-        });
-    }, []);
-    return _jsx(Text, { children: "Loading configuration..." });
+export function getDefaultConfigTarget(cwd = process.cwd()) {
+    const activeConfigPath = getActiveRuntimeConfigPath();
+    if (activeConfigPath === getProjectRuntimeConfigPath(cwd)) {
+        return 'project';
+    }
+    return 'user';
+}
+export const writeConfig = (config, target = 'user', cwd = process.cwd()) => {
+    const configPath = getInitConfigPath(target, cwd);
+    const runtimeConfig = readRuntimeConfigFileSync(configPath) || { providers: {}, mcp: { servers: {} } };
+    const nextRuntimeConfig = upsertSelectedConfig(runtimeConfig, config);
+    writeRuntimeConfigFile(configPath, nextRuntimeConfig);
+    return configPath;
 };
 export const ResetPrompt = ({ existingConfig, setStep, setConfigWritten }) => {
     const [resetInput, setResetInput] = useState('');
@@ -157,7 +228,7 @@ export const ModelSelection = ({ setSelectedProviderId, setSelectedModelId, setS
     };
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Select an AI Model:" }), _jsx(Select, { options: items, onChange: handleSelect })] }));
 };
-export const ApiKeyInput = ({ selectedProviderId, selectedModelId, setStep, setConfigWritten, }) => {
+export const ApiKeyInput = ({ selectedProviderId, selectedModelId, target, setStep, setConfigWritten, }) => {
     const [errorMessage, setErrorMessage] = useState('');
     const provider = getProvider(selectedProviderId);
     const canUseResolvedAuth = Boolean(resolveApiKey({ provider: selectedProviderId, apiKey: undefined }));
@@ -171,7 +242,7 @@ export const ApiKeyInput = ({ selectedProviderId, selectedModelId, setStep, setC
             model: selectedModelId,
             ...(value.trim().length > 0 ? { apiKey: value.trim() } : {}),
         };
-        writeConfig(newConfig);
+        writeConfig(newConfig, target);
         setConfigWritten(true);
         setStep(4);
     };
@@ -182,22 +253,79 @@ export const ConfigResult = ({ configWritten }) => {
 };
 export const ConfigureComponent = () => {
     const [step, setStep] = useState(0);
+    const [target, setTarget] = useState(getDefaultConfigTarget());
     const [existingConfig, setExistingConfig] = useState(null);
     const [selectedProviderId, setSelectedProviderId] = useState('');
     const [selectedModelId, setSelectedModelId] = useState('');
     const [configWritten, setConfigWritten] = useState(false);
+    if (step === 0) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Choose where to configure ProtoAgent:" }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: [
+                            { label: `Project config — ${getProjectRuntimeConfigPath()}`, value: 'project' },
+                            { label: `Shared user config — ${getUserRuntimeConfigPath()}`, value: 'user' },
+                        ], onChange: (value) => {
+                            setTarget(value);
+                            const existing = readConfig(value);
+                            setExistingConfig(existing);
+                            setStep(existing ? 1 : 2);
+                        } }) })] }));
+    }
     switch (step) {
-        case 0:
-            return _jsx(InitialLoading, { setExistingConfig: setExistingConfig, setStep: setStep });
         case 1:
             return _jsx(ResetPrompt, { existingConfig: existingConfig, setStep: setStep, setConfigWritten: setConfigWritten });
         case 2:
             return (_jsx(ModelSelection, { setSelectedProviderId: setSelectedProviderId, setSelectedModelId: setSelectedModelId, setStep: setStep }));
         case 3:
-            return (_jsx(ApiKeyInput, { selectedProviderId: selectedProviderId, selectedModelId: selectedModelId, setStep: setStep, setConfigWritten: setConfigWritten }));
+            return (_jsx(ApiKeyInput, { selectedProviderId: selectedProviderId, selectedModelId: selectedModelId, target: target, setStep: setStep, setConfigWritten: setConfigWritten }));
         case 4:
             return _jsx(ConfigResult, { configWritten: configWritten });
         default:
             return _jsx(Text, { children: "Unknown step." });
     }
 };
+export const InitComponent = () => {
+    const [selectedTarget, setSelectedTarget] = useState(null);
+    const [result, setResult] = useState(null);
+    const options = [
+        {
+            label: 'Project config',
+            value: 'project',
+            description: getProjectRuntimeConfigPath(),
+        },
+        {
+            label: 'Shared user config',
+            value: 'user',
+            description: getUserRuntimeConfigPath(),
+        },
+    ];
+    const activeTarget = selectedTarget ?? 'project';
+    const activeOption = options.find((option) => option.value === activeTarget) ?? options[0];
+    if (selectedTarget && !result) {
+        const selectedPath = getInitConfigPath(selectedTarget);
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Config already exists:" }), _jsx(Text, { children: selectedPath }), _jsx(Text, { children: "Overwrite it? (y/n)" }), _jsx(TextInput, { onSubmit: (answer) => {
+                        if (answer.trim().toLowerCase() === 'y') {
+                            setResult(writeInitConfig(selectedTarget, process.cwd(), { overwrite: true }));
+                        }
+                        else {
+                            setResult({ path: selectedPath, status: 'exists' });
+                        }
+                    } })] }));
+    }
+    if (result) {
+        const color = result.status === 'exists' ? 'yellow' : 'green';
+        const message = result.status === 'created'
+            ? 'Created ProtoAgent config:'
+            : result.status === 'overwritten'
+                ? 'Overwrote ProtoAgent config:'
+                : 'ProtoAgent config already exists:';
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: color, children: message }), _jsx(Text, { children: result.path })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Create a ProtoAgent runtime config:" }), _jsx(Text, { dimColor: true, children: "Select where to write `protoagent.jsonc`." }), _jsx(Text, { dimColor: true, children: activeOption.description }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: options.map((option) => ({ label: option.label, value: option.value })), onChange: (value) => {
+                        const target = value;
+                        const configPath = getInitConfigPath(target);
+                        if (existsSync(configPath)) {
+                            setSelectedTarget(target);
+                            return;
+                        }
+                        setResult(writeInitConfig(target));
+                    } }) })] }));
+};

package/dist/runtime-config.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { parse, printParseErrorCode } from 'jsonc-parser';
@@ -16,13 +17,26 @@ const DEFAULT_RUNTIME_CONFIG = {
     mcp: { servers: {} },
 };
 let runtimeConfigCache = null;
-function getRuntimeConfigPaths() {
+function getProjectRuntimeConfigPath() {
+    return path.join(process.cwd(), '.protoagent', 'protoagent.jsonc');
+}
+function getUserRuntimeConfigPath() {
     const homeDir = os.homedir();
-    return [
-        path.join(homeDir, '.config', 'protoagent', 'protoagent.jsonc'),
-        path.join(homeDir, '.protoagent', 'protoagent.jsonc'),
-        path.join(process.cwd(), '.protoagent', 'protoagent.jsonc'),
-    ];
+    if (process.platform === 'win32') {
+        return path.join(homeDir, 'AppData', 'Local', 'protoagent', 'protoagent.jsonc');
+    }
+    return path.join(homeDir, '.config', 'protoagent', 'protoagent.jsonc');
+}
+export function getActiveRuntimeConfigPath() {
+    const projectPath = getProjectRuntimeConfigPath();
+    if (existsSync(projectPath)) {
+        return projectPath;
+    }
+    const userPath = getUserRuntimeConfigPath();
+    if (existsSync(userPath)) {
+        return userPath;
+    }
+    return null;
 }
 function isPlainObject(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
@@ -156,16 +170,17 @@ export async function loadRuntimeConfig(forceReload = false) {
     if (!forceReload && runtimeConfigCache) {
         return runtimeConfigCache;
     }
-    let merged = DEFAULT_RUNTIME_CONFIG;
-    for (const configPath of getRuntimeConfigPaths()) {
+    const configPath = getActiveRuntimeConfigPath();
+    let loaded = DEFAULT_RUNTIME_CONFIG;
+    if (configPath) {
         const fileConfig = await readRuntimeConfigFile(configPath);
-        if (!fileConfig)
-            continue;
-        logger.debug(`Loaded runtime config`, { path: configPath });
-        merged = mergeRuntimeConfig(merged, fileConfig);
+        if (fileConfig) {
+            logger.debug('Loaded runtime config', { path: configPath });
+            loaded = mergeRuntimeConfig(DEFAULT_RUNTIME_CONFIG, fileConfig);
+        }
     }
-    runtimeConfigCache = merged;
-    return merged;
+    runtimeConfigCache = loaded;
+    return loaded;
 }
 export function getRuntimeConfig() {
     return runtimeConfigCache || DEFAULT_RUNTIME_CONFIG;

package/dist/tools/bash.js

@@ -114,7 +114,7 @@ async function isSafe(command) {
     }
     return validateCommandPaths(tokens);
 }
-export async function runBash(command, timeoutMs = 30_000, sessionId) {
+export async function runBash(command, timeoutMs = 30_000, sessionId, abortSignal) {
     // Layer 1: hard block
     if (isDangerous(command)) {
         return `Error: Command blocked for safety. "${command}" contains a dangerous pattern that cannot be executed.`;
@@ -139,6 +139,7 @@ export async function runBash(command, timeoutMs = 30_000, sessionId) {
         let stdout = '';
         let stderr = '';
         let timedOut = false;
+        let aborted = false;
         const child = spawn(command, [], {
             shell: true,
             cwd: process.cwd(),
@@ -147,13 +148,31 @@ export async function runBash(command, timeoutMs = 30_000, sessionId) {
         });
         child.stdout?.on('data', (data) => { stdout += data.toString(); });
         child.stderr?.on('data', (data) => { stderr += data.toString(); });
-        const timer = setTimeout(() => {
-            timedOut = true;
+        const terminateChild = () => {
             child.kill('SIGTERM');
             setTimeout(() => child.kill('SIGKILL'), 2000);
+        };
+        const onAbort = () => {
+            aborted = true;
+            terminateChild();
+        };
+        if (abortSignal?.aborted) {
+            onAbort();
+        }
+        else {
+            abortSignal?.addEventListener('abort', onAbort, { once: true });
+        }
+        const timer = setTimeout(() => {
+            timedOut = true;
+            terminateChild();
         }, timeoutMs);
         child.on('close', (code) => {
             clearTimeout(timer);
+            abortSignal?.removeEventListener('abort', onAbort);
+            if (aborted) {
+                resolve(`Command aborted by user.\nPartial stdout:\n${stdout.slice(0, 5000)}\nPartial stderr:\n${stderr.slice(0, 2000)}`);
+                return;
+            }
             if (timedOut) {
                 resolve(`Command timed out after ${timeoutMs / 1000}s.\nPartial stdout:\n${stdout.slice(0, 5000)}\nPartial stderr:\n${stderr.slice(0, 2000)}`);
                 return;
@@ -172,6 +191,7 @@ export async function runBash(command, timeoutMs = 30_000, sessionId) {
         });
         child.on('error', (err) => {
             clearTimeout(timer);
+            abortSignal?.removeEventListener('abort', onAbort);
             resolve(`Error executing command: ${err.message}`);
         });
     });

package/dist/tools/index.js

@@ -71,7 +71,7 @@ export async function handleToolCall(toolName, args, context = {}) {
             case 'search_files':
                 return await searchFiles(args.search_term, args.directory_path, args.case_sensitive, args.file_extensions);
             case 'bash':
-                return await runBash(args.command, args.timeout_ms, context.sessionId);
+                return await runBash(args.command, args.timeout_ms, context.sessionId, context.abortSignal);
             case 'todo_read':
                 return readTodos(context.sessionId);
             case 'todo_write':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protoagent",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "files": [
     "dist",