protoagent 0.1.4 → 0.1.6

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;
@@ -504,6 +503,17 @@ export const App = ({ dangerouslyAcceptAll = false, logLevel, sessionId, }) => {
                             }
                         }
                         break;
+                    case 'sub_agent_iteration':
+                        if (event.subAgentTool) {
+                            const { tool, status } = event.subAgentTool;
+                            if (status === 'running') {
+                                setActiveTool(`sub_agent → ${tool}`);
+                            }
+                            else {
+                                setActiveTool(null);
+                            }
+                        }
+                        break;
                     case 'tool_call':
                         if (event.toolCall) {
                             const toolCall = event.toolCall;

package/dist/agentic-loop.js

@@ -126,6 +126,21 @@ function extractFirstCompleteJsonValue(value) {
     }
     return null;
 }
+/**
+ * Repair invalid JSON escape sequences in a string value.
+ *
+ * JSON only allows: \" \\ \/ \b \f \n \r \t \uXXXX
+ * Models sometimes emit \| \! \- etc. (e.g. grep regex args) which make
+ * JSON.parse throw, and Anthropic strict-validates tool_call arguments on
+ * every subsequent request, bricking the session permanently.
+ *
+ * We double the backslash for any \X where X is not a valid JSON escape char.
+ */
+function repairInvalidEscapes(value) {
+    // Match a backslash followed by any character that is NOT a valid JSON escape
+    // Valid escapes: " \ / b f n r t u
+    return value.replace(/\\([^"\\\/bfnrtu])/g, '\\\\$1');
+}
 function normalizeJsonArguments(argumentsText) {
     const trimmed = argumentsText.trim();
     if (!trimmed)
@@ -157,6 +172,25 @@ function normalizeJsonArguments(argumentsText) {
             // Give up and return the original text below.
         }
     }
+    // Heuristic: repair invalid escape sequences (e.g. \| from grep regex args)
+    const repaired = repairInvalidEscapes(trimmed);
+    if (repaired !== trimmed) {
+        try {
+            JSON.parse(repaired);
+            return repaired;
+        }
+        catch {
+            // Try repair + first-value extraction together
+            const repairedFirst = extractFirstCompleteJsonValue(repaired);
+            if (repairedFirst) {
+                try {
+                    JSON.parse(repairedFirst);
+                    return repairedFirst;
+                }
+                catch { /* give up */ }
+            }
+        }
+    }
     return argumentsText;
 }
 function sanitizeToolCall(toolCall, validToolNames) {
@@ -231,6 +265,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
     }
     let iterationCount = 0;
     let repairRetryCount = 0;
+    let contextRetryCount = 0;
     const validToolNames = getValidToolNames();
     while (iterationCount < maxIterations) {
         // Check if abort was requested
@@ -389,10 +424,24 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                     })),
                 });
                 updatedMessages.push(assistantMessage);
+                // Track which tool_call_ids still need a tool result message.
+                // This set is used to inject stub responses on abort, preventing
+                // orphaned tool_call_ids from permanently bricking the session.
+                const pendingToolCallIds = new Set(assistantMessage.tool_calls.map((tc) => tc.id));
+                const injectStubsForPendingToolCalls = () => {
+                    for (const id of pendingToolCallIds) {
+                        updatedMessages.push({
+                            role: 'tool',
+                            tool_call_id: id,
+                            content: 'Aborted by user.',
+                        });
+                    }
+                };
                 for (const toolCall of assistantMessage.tool_calls) {
                     // Check abort between tool calls
                     if (abortSignal?.aborted) {
                         logger.debug('Agentic loop aborted between tool calls');
+                        injectStubsForPendingToolCalls();
                         emitAbortAndFinish(onEvent);
                         return updatedMessages;
                     }
@@ -408,19 +457,14 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                         if (name === 'sub_agent') {
                             const subProgress = (evt) => {
                                 onEvent({
-                                    type: 'tool_call',
-                                    toolCall: {
-                                        id: toolCall.id,
-                                        name: `sub_agent → ${evt.tool}`,
-                                        args: '',
-                                        status: evt.status === 'running' ? 'running' : 'done',
-                                    },
+                                    type: 'sub_agent_iteration',
+                                    subAgentTool: { tool: evt.tool, status: evt.status, iteration: evt.iteration },
                                 });
                             };
-                            result = await runSubAgent(client, model, args.task, args.max_iterations, requestDefaults, subProgress);
+                            result = await runSubAgent(client, model, args.task, args.max_iterations, requestDefaults, subProgress, abortSignal);
                         }
                         else {
-                            result = await handleToolCall(name, args, { sessionId });
+                            result = await handleToolCall(name, args, { sessionId, abortSignal });
                         }
                         logger.debug('Tool result', {
                             tool: name,
@@ -433,6 +477,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                             tool_call_id: toolCall.id,
                             content: result,
                         });
+                        pendingToolCallIds.delete(toolCall.id);
                         onEvent({
                             type: 'tool_result',
                             toolCall: { id: toolCall.id, name, args: argsStr, status: 'done', result },
@@ -445,6 +490,14 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                             tool_call_id: toolCall.id,
                             content: `Error: ${errMsg}`,
                         });
+                        pendingToolCallIds.delete(toolCall.id);
+                        // If the tool was aborted, inject stubs for remaining pending calls and stop
+                        if (abortSignal?.aborted || (err instanceof Error && (err.name === 'AbortError' || err.message === 'Operation aborted'))) {
+                            logger.debug('Agentic loop aborted during tool execution');
+                            injectStubsForPendingToolCalls();
+                            emitAbortAndFinish(onEvent);
+                            return updatedMessages;
+                        }
                         onEvent({
                             type: 'tool_result',
                             toolCall: { id: toolCall.id, name, args: argsStr, status: 'error', result: errMsg },
@@ -520,6 +573,48 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                     continue;
                 }
             }
+            // Handle context-window-exceeded (prompt too long) — attempt forced compaction
+            // This fires when our token estimate was too low (e.g. base64 images from MCP tools)
+            // and the request actually hit the hard provider limit.
+            const isContextTooLong = apiError?.status === 400 &&
+                typeof errMsg === 'string' &&
+                /prompt.{0,30}too long|context.{0,30}length|maximum.{0,30}token|tokens?.{0,10}exceed/i.test(errMsg);
+            if (isContextTooLong && contextRetryCount < 2) {
+                contextRetryCount++;
+                logger.warn(`Prompt too long (attempt ${contextRetryCount}); forcing compaction`, { errMsg });
+                onEvent({
+                    type: 'error',
+                    error: 'Prompt too long. Compacting conversation and retrying...',
+                    transient: true,
+                });
+                if (pricing) {
+                    // Use the normal LLM-based compaction path
+                    try {
+                        const compacted = await compactIfNeeded(client, model, updatedMessages, pricing.contextWindow, 
+                        // Pass the context window itself as currentTokens to force compaction
+                        pricing.contextWindow, requestDefaults, sessionId);
+                        updatedMessages.length = 0;
+                        updatedMessages.push(...compacted);
+                    }
+                    catch (compactErr) {
+                        logger.error(`Forced compaction failed: ${compactErr}`);
+                        // Fall through to truncation fallback below
+                    }
+                }
+                // Fallback: truncate any tool result messages whose content looks like
+                // base64 or is extremely large (e.g. MCP screenshot data)
+                const MAX_TOOL_RESULT_CHARS = 20_000;
+                for (let i = 0; i < updatedMessages.length; i++) {
+                    const m = updatedMessages[i];
+                    if (m.role === 'tool' && typeof m.content === 'string' && m.content.length > MAX_TOOL_RESULT_CHARS) {
+                        updatedMessages[i] = {
+                            ...m,
+                            content: m.content.slice(0, MAX_TOOL_RESULT_CHARS) + '\n... (truncated — content was too large)',
+                        };
+                    }
+                }
+                continue;
+            }
             // Retry on 429 (rate limit) with backoff
             if (apiError?.status === 429) {
                 const retryAfter = parseInt(apiError?.headers?.['retry-after'] || '5', 10);

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/sub-agent.js

@@ -39,7 +39,7 @@ export const subAgentTool = {
  * Run a sub-agent with its own isolated conversation.
  * Returns the sub-agent's final text response.
  */
-export async function runSubAgent(client, model, task, maxIterations = 30, requestDefaults = {}, onProgress) {
+export async function runSubAgent(client, model, task, maxIterations = 30, requestDefaults = {}, onProgress, abortSignal) {
     const op = logger.startOperation('sub-agent');
     const subAgentSessionId = `sub-agent-${crypto.randomUUID()}`;
     const systemPrompt = await generateSystemPrompt();
@@ -56,13 +56,17 @@ Do NOT ask the user questions — work autonomously with the tools available.`;
     ];
     try {
         for (let i = 0; i < maxIterations; i++) {
+            // Check abort at the top of each iteration
+            if (abortSignal?.aborted) {
+                return '(sub-agent aborted)';
+            }
             const response = await client.chat.completions.create({
                 ...requestDefaults,
                 model,
                 messages,
                 tools: getAllTools(),
                 tool_choice: 'auto',
-            });
+            }, { signal: abortSignal });
             const message = response.choices[0]?.message;
             if (!message)
                 break;
@@ -70,12 +74,16 @@ Do NOT ask the user questions — work autonomously with the tools available.`;
             if (message.tool_calls && message.tool_calls.length > 0) {
                 messages.push(message);
                 for (const toolCall of message.tool_calls) {
+                    // Check abort between tool calls
+                    if (abortSignal?.aborted) {
+                        return '(sub-agent aborted)';
+                    }
                     const { name, arguments: argsStr } = toolCall.function;
                     logger.debug(`Sub-agent tool call: ${name}`);
                     onProgress?.({ tool: name, status: 'running', iteration: i });
                     try {
                         const args = JSON.parse(argsStr);
-                        const result = await handleToolCall(name, args, { sessionId: subAgentSessionId });
+                        const result = await handleToolCall(name, args, { sessionId: subAgentSessionId, abortSignal });
                         messages.push({
                             role: 'tool',
                             tool_call_id: toolCall.id,

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.6",
   "type": "module",
   "files": [
     "dist",