protoagent 0.0.5 → 0.1.0

package/dist/config.js

@@ -0,0 +1,171 @@
+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 { Box, Text } from 'ink';
+import { Select, TextInput, PasswordInput } from '@inkjs/ui';
+import { SUPPORTED_MODELS, getProvider } from './providers.js';
+const CONFIG_DIR_MODE = 0o700;
+const CONFIG_FILE_MODE = 0o600;
+function hardenPermissions(targetPath, mode) {
+    if (process.platform === 'win32')
+        return;
+    chmodSync(targetPath, mode);
+}
+export function resolveApiKey(config) {
+    const directApiKey = config.apiKey?.trim();
+    if (directApiKey) {
+        return directApiKey;
+    }
+    const provider = getProvider(config.provider);
+    if (!provider?.apiKeyEnvVar) {
+        return null;
+    }
+    const envApiKey = process.env[provider.apiKeyEnvVar]?.trim();
+    return envApiKey || null;
+}
+export const getConfigDirectory = () => {
+    const homeDir = os.homedir();
+    if (process.platform === 'win32') {
+        return path.join(homeDir, 'AppData', 'Local', 'protoagent');
+    }
+    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 });
+    }
+    hardenPermissions(dir, CONFIG_DIR_MODE);
+};
+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 = SUPPORTED_MODELS.find((p) => p.id === raw.provider);
+                if (provider) {
+                    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);
+            return null;
+        }
+    }
+    return null;
+};
+export const writeConfig = (config) => {
+    ensureConfigDirectory();
+    const configPath = getConfigPath();
+    const normalizedConfig = {
+        provider: config.provider,
+        model: config.model,
+        ...(config.apiKey?.trim() ? { apiKey: config.apiKey.trim() } : {}),
+    };
+    writeFileSync(configPath, JSON.stringify(normalizedConfig, null, 2), { encoding: 'utf8', mode: CONFIG_FILE_MODE });
+    hardenPermissions(configPath, CONFIG_FILE_MODE);
+};
+export const InitialLoading = ({ setExistingConfig, setStep }) => {
+    useEffect(() => {
+        const config = readConfig();
+        if (config) {
+            setExistingConfig(config);
+            setStep(1);
+        }
+        else {
+            setStep(2);
+        }
+    }, []);
+    return _jsx(Text, { children: "Loading configuration..." });
+};
+export const ResetPrompt = ({ existingConfig, setStep, setConfigWritten }) => {
+    const [resetInput, setResetInput] = useState('');
+    const provider = getProvider(existingConfig.provider);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Existing configuration found:" }), _jsxs(Text, { children: ["  Provider: ", provider?.name || existingConfig.provider] }), _jsxs(Text, { children: ["  Model: ", existingConfig.model] }), _jsxs(Text, { children: ["  API Key: ", '*'.repeat(8)] }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Do you want to reset and configure a new one? (y/n)" }), _jsx(TextInput, { onSubmit: (answer) => {
+                    if (answer.toLowerCase() === 'y') {
+                        setStep(2);
+                    }
+                    else {
+                        setConfigWritten(false);
+                        setStep(4);
+                    }
+                } })] }));
+};
+export const ModelSelection = ({ setSelectedProviderId, setSelectedModelId, setStep, }) => {
+    const items = SUPPORTED_MODELS.flatMap((provider) => provider.models.map((model) => ({
+        label: `${provider.name} - ${model.name}`,
+        value: `${provider.id}:::${model.id}`,
+    })));
+    const handleSelect = (value) => {
+        const [providerId, modelId] = value.split(':::');
+        setSelectedProviderId(providerId);
+        setSelectedModelId(modelId);
+        setStep(3);
+    };
+    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, }) => {
+    const [errorMessage, setErrorMessage] = useState('');
+    const provider = getProvider(selectedProviderId);
+    const handleApiKeySubmit = (value) => {
+        if (value.trim().length === 0) {
+            setErrorMessage('API key cannot be empty.');
+            return;
+        }
+        const newConfig = {
+            provider: selectedProviderId,
+            model: selectedModelId,
+            apiKey: value.trim(),
+        };
+        writeConfig(newConfig);
+        setConfigWritten(true);
+        setStep(4);
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Enter API Key for ", provider?.name || selectedProviderId, ":"] }), errorMessage && _jsx(Text, { color: "red", children: errorMessage }), _jsx(PasswordInput, { placeholder: `Enter your ${provider?.apiKeyEnvVar || 'API'} key`, onSubmit: handleApiKeySubmit })] }));
+};
+export const ConfigResult = ({ configWritten }) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [configWritten ? (_jsx(Text, { color: "green", children: "Configuration saved successfully!" })) : (_jsx(Text, { color: "yellow", children: "Configuration not changed." })), _jsx(Text, { children: "You can now run ProtoAgent." })] }));
+};
+export const ConfigureComponent = () => {
+    const [step, setStep] = useState(0);
+    const [existingConfig, setExistingConfig] = useState(null);
+    const [selectedProviderId, setSelectedProviderId] = useState('');
+    const [selectedModelId, setSelectedModelId] = useState('');
+    const [configWritten, setConfigWritten] = useState(false);
+    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 }));
+        case 4:
+            return _jsx(ConfigResult, { configWritten: configWritten });
+        default:
+            return _jsx(Text, { children: "Unknown step." });
+    }
+};

package/dist/mcp.js

@@ -0,0 +1,170 @@
+/**
+ * MCP (Model Context Protocol) client.
+ *
+ * Uses the official @modelcontextprotocol/sdk to connect to MCP servers
+ * over both stdio (spawned processes) and HTTP transports.
+ *
+ * Configuration in `.protoagent/mcp.json`:
+ * {
+ *   "servers": {
+ *     "my-stdio-server": {
+ *       "type": "stdio",
+ *       "command": "npx",
+ *       "args": ["-y", "@my/mcp-server"],
+ *       "env": { "API_KEY": "..." }
+ *     },
+ *     "my-http-server": {
+ *       "type": "http",
+ *       "url": "http://localhost:3000/mcp"
+ *     }
+ *   }
+ * }
+ *
+ * Stdio servers are spawned as child processes communicating over stdin/stdout.
+ * HTTP servers connect to a running server via HTTP POST/GET with SSE streaming.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { logger } from './utils/logger.js';
+import { registerDynamicTool, registerDynamicHandler } from './tools/index.js';
+const connections = new Map();
+/**
+ * Create an MCP client connection for a stdio server.
+ */
+async function connectStdioServer(serverName, config) {
+    const transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args || [],
+        env: config.env || {},
+    });
+    const client = new Client({
+        name: 'protoagent',
+        version: '0.0.1',
+    }, {
+        capabilities: {},
+    });
+    await client.connect(transport);
+    return {
+        client,
+        serverName,
+        transport,
+    };
+}
+/**
+ * Create an MCP client connection for an HTTP server.
+ */
+async function connectHttpServer(serverName, config) {
+    const transport = new StreamableHTTPClientTransport(new URL(config.url));
+    const client = new Client({
+        name: 'protoagent',
+        version: '0.0.1',
+    }, {
+        capabilities: {},
+    });
+    await client.connect(transport);
+    return {
+        client,
+        serverName,
+        transport,
+    };
+}
+/**
+ * Register all tools from an MCP server into the dynamic tool registry.
+ */
+async function registerMcpTools(conn) {
+    try {
+        const response = await conn.client.listTools();
+        const tools = response.tools || [];
+        logger.info(`MCP [${conn.serverName}] discovered ${tools.length} tools`);
+        for (const tool of tools) {
+            const toolName = `mcp_${conn.serverName}_${tool.name}`;
+            registerDynamicTool({
+                type: 'function',
+                function: {
+                    name: toolName,
+                    description: `[MCP: ${conn.serverName}] ${tool.description || tool.name}`,
+                    parameters: tool.inputSchema,
+                },
+            });
+            registerDynamicHandler(toolName, async (args) => {
+                const result = await conn.client.callTool({
+                    name: tool.name,
+                    arguments: args,
+                });
+                // MCP tool results are arrays of content blocks
+                if (Array.isArray(result.content)) {
+                    return result.content
+                        .map((c) => {
+                        if (c.type === 'text')
+                            return c.text;
+                        return JSON.stringify(c);
+                    })
+                        .join('\n');
+                }
+                return JSON.stringify(result);
+            });
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to register tools for MCP [${conn.serverName}]: ${err}`);
+    }
+}
+/**
+ * Load MCP configuration and connect to all configured servers.
+ * Registers their tools in the dynamic tool registry.
+ */
+export async function initializeMcp() {
+    const configPath = path.join(process.cwd(), '.protoagent', 'mcp.json');
+    let config;
+    try {
+        const content = await fs.readFile(configPath, 'utf8');
+        config = JSON.parse(content);
+    }
+    catch {
+        // No MCP config — that's fine, most projects won't have one
+        return;
+    }
+    if (!config.servers || Object.keys(config.servers).length === 0)
+        return;
+    logger.info(`Loading MCP servers from ${configPath}`);
+    for (const [name, serverConfig] of Object.entries(config.servers)) {
+        try {
+            let conn;
+            if (serverConfig.type === 'stdio') {
+                logger.debug(`Connecting to stdio MCP server: ${name}`);
+                conn = await connectStdioServer(name, serverConfig);
+            }
+            else if (serverConfig.type === 'http') {
+                logger.debug(`Connecting to HTTP MCP server: ${name} (${serverConfig.url})`);
+                conn = await connectHttpServer(name, serverConfig);
+            }
+            else {
+                logger.error(`Unknown MCP server type for "${name}": ${serverConfig.type}`);
+                continue;
+            }
+            connections.set(name, conn);
+            await registerMcpTools(conn);
+        }
+        catch (err) {
+            logger.error(`Failed to connect to MCP server "${name}": ${err}`);
+        }
+    }
+}
+/**
+ * Close all MCP connections.
+ */
+export async function closeMcp() {
+    for (const [name, conn] of connections) {
+        try {
+            logger.debug(`Closing MCP connection: ${name}`);
+            await conn.client.close();
+        }
+        catch (err) {
+            logger.error(`Error closing MCP connection [${name}]: ${err}`);
+        }
+    }
+    connections.clear();
+}

package/dist/providers.js

@@ -0,0 +1,137 @@
+/**
+ * Model and provider definitions.
+ *
+ * All providers use the OpenAI SDK via compatible endpoints.
+ * To add a new provider, add an entry here with its baseURL
+ * and API key env var name, and any models it supports.
+ */
+export const SUPPORTED_MODELS = [
+    {
+        id: 'openai',
+        name: 'OpenAI',
+        apiKeyEnvVar: 'OPENAI_API_KEY',
+        models: [
+            {
+                id: 'gpt-5.2',
+                name: 'GPT-5.2',
+                contextWindow: 200_000,
+                pricingPerMillionInput: 6.00,
+                pricingPerMillionOutput: 24.00,
+            },
+            {
+                id: 'gpt-5-mini',
+                name: 'GPT-5 Mini',
+                contextWindow: 200_000,
+                pricingPerMillionInput: 0.15,
+                pricingPerMillionOutput: 0.60,
+            },
+            {
+                id: 'gpt-4.1',
+                name: 'GPT-4.1',
+                contextWindow: 128_000,
+                pricingPerMillionInput: 2.50,
+                pricingPerMillionOutput: 10.00,
+            },
+        ],
+    },
+    {
+        id: 'anthropic',
+        name: 'Anthropic Claude',
+        baseURL: 'https://api.anthropic.com/v1/',
+        apiKeyEnvVar: 'ANTHROPIC_API_KEY',
+        models: [
+            {
+                id: 'claude-opus-4-6',
+                name: 'Claude Opus 4.6',
+                contextWindow: 200_000,
+                pricingPerMillionInput: 5.00,
+                pricingPerMillionOutput: 25.00,
+            },
+            {
+                id: 'claude-sonnet-4-6',
+                name: 'Claude Sonnet 4.6',
+                contextWindow: 200_000,
+                pricingPerMillionInput: 3.00,
+                pricingPerMillionOutput: 15.00,
+            },
+            {
+                id: 'claude-haiku-4-5',
+                name: 'Claude Haiku 4.5',
+                contextWindow: 200_000,
+                pricingPerMillionInput: 1.00,
+                pricingPerMillionOutput: 5.00,
+            },
+        ],
+    },
+    {
+        id: 'google',
+        name: 'Google Gemini',
+        baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+        apiKeyEnvVar: 'GEMINI_API_KEY',
+        models: [
+            {
+                id: 'gemini-3-flash-preview',
+                name: 'Gemini 3 Flash (Preview)',
+                contextWindow: 1_000_000,
+                pricingPerMillionInput: 0.075,
+                pricingPerMillionOutput: 0.30,
+            },
+            {
+                id: 'gemini-3-pro-preview',
+                name: 'Gemini 3 Pro (Preview)',
+                contextWindow: 1_000_000,
+                pricingPerMillionInput: 1.25,
+                pricingPerMillionOutput: 10.00,
+            },
+            {
+                id: 'gemini-2.5-flash',
+                name: 'Gemini 2.5 Flash',
+                contextWindow: 1_000_000,
+                pricingPerMillionInput: 0.075,
+                pricingPerMillionOutput: 0.30,
+            },
+            {
+                id: 'gemini-2.5-pro',
+                name: 'Gemini 2.5 Pro',
+                contextWindow: 1_000_000,
+                pricingPerMillionInput: 1.25,
+                pricingPerMillionOutput: 10.00,
+            },
+        ],
+    },
+    {
+        id: 'cerebras',
+        name: 'Cerebras',
+        baseURL: 'https://api.cerebras.ai/v1',
+        apiKeyEnvVar: 'CEREBRAS_API_KEY',
+        models: [
+            {
+                id: 'llama-4-scout-17b-16e-instruct',
+                name: 'Llama 4 Scout 17B',
+                contextWindow: 128_000,
+                pricingPerMillionInput: 0.00,
+                pricingPerMillionOutput: 0.00,
+            },
+        ],
+    },
+];
+/** Find a provider by ID. */
+export function getProvider(providerId) {
+    return SUPPORTED_MODELS.find((p) => p.id === providerId);
+}
+/** Find a model's details by provider and model ID. */
+export function getModelDetails(providerId, modelId) {
+    const provider = getProvider(providerId);
+    return provider?.models.find((m) => m.id === modelId);
+}
+/** Get model pricing in per-token format (for cost-tracker). */
+export function getModelPricing(providerId, modelId) {
+    const details = getModelDetails(providerId, modelId);
+    if (!details)
+        return undefined;
+    return {
+        inputPerToken: details.pricingPerMillionInput / 1_000_000,
+        outputPerToken: details.pricingPerMillionOutput / 1_000_000,
+        contextWindow: details.contextWindow,
+    };
+}

package/dist/sessions.js

@@ -0,0 +1,161 @@
+/**
+ * Session persistence — Save and load conversation history.
+ *
+ * Sessions are stored as JSON files in `~/.local/share/protoagent/sessions/`.
+ * Each session has a unique ID, a title, and the full message history.
+ *
+ * The agent can resume a previous session or start a new one.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { chmodSync } from 'node:fs';
+import { logger } from './utils/logger.js';
+const SESSION_DIR_MODE = 0o700;
+const SESSION_FILE_MODE = 0o600;
+const SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function hardenPermissions(targetPath, mode) {
+    if (process.platform === 'win32')
+        return;
+    chmodSync(targetPath, mode);
+}
+function assertValidSessionId(id) {
+    if (!SESSION_ID_PATTERN.test(id)) {
+        throw new Error(`Invalid session ID: ${id}`);
+    }
+}
+export function ensureSystemPromptAtTop(messages, systemPrompt) {
+    const firstSystemIndex = messages.findIndex((message) => message.role === 'system');
+    if (firstSystemIndex === -1) {
+        return [{ role: 'system', content: systemPrompt }, ...messages];
+    }
+    const firstSystemMessage = messages[firstSystemIndex];
+    const normalizedSystemMessage = {
+        ...firstSystemMessage,
+        role: 'system',
+        content: systemPrompt,
+    };
+    return [
+        normalizedSystemMessage,
+        ...messages.slice(0, firstSystemIndex),
+        ...messages.slice(firstSystemIndex + 1),
+    ];
+}
+function getSessionsDir() {
+    const homeDir = os.homedir();
+    if (process.platform === 'win32') {
+        return path.join(homeDir, 'AppData', 'Local', 'protoagent', 'sessions');
+    }
+    return path.join(homeDir, '.local', 'share', 'protoagent', 'sessions');
+}
+async function ensureSessionsDir() {
+    const dir = getSessionsDir();
+    await fs.mkdir(dir, { recursive: true, mode: SESSION_DIR_MODE });
+    hardenPermissions(dir, SESSION_DIR_MODE);
+    return dir;
+}
+function sessionPath(id) {
+    assertValidSessionId(id);
+    return path.join(getSessionsDir(), `${id}.json`);
+}
+/** Create a new session. */
+export function createSession(model, provider) {
+    return {
+        id: crypto.randomUUID(),
+        title: 'New session',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        model,
+        provider,
+        todos: [],
+        completionMessages: [],
+    };
+}
+/** Save a session to disk. */
+export async function saveSession(session) {
+    await ensureSessionsDir();
+    session.updatedAt = new Date().toISOString();
+    const filePath = sessionPath(session.id);
+    await fs.writeFile(filePath, JSON.stringify(session, null, 2), { encoding: 'utf8', mode: SESSION_FILE_MODE });
+    hardenPermissions(filePath, SESSION_FILE_MODE);
+    logger.debug(`Session saved: ${session.id}`);
+}
+/** Load a session by ID. Returns null if not found. */
+export async function loadSession(id) {
+    try {
+        const content = await fs.readFile(sessionPath(id), 'utf8');
+        const session = JSON.parse(content);
+        return {
+            id: session.id ?? id,
+            title: session.title ?? 'New session',
+            createdAt: session.createdAt ?? new Date().toISOString(),
+            updatedAt: session.updatedAt ?? new Date().toISOString(),
+            model: session.model ?? '',
+            provider: session.provider ?? '',
+            todos: Array.isArray(session.todos) ? session.todos : [],
+            completionMessages: Array.isArray(session.completionMessages) ? session.completionMessages : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** List all sessions (sorted by most recently updated). */
+export async function listSessions() {
+    const dir = getSessionsDir();
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const summaries = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        try {
+            const content = await fs.readFile(path.join(dir, entry), 'utf8');
+            const session = JSON.parse(content);
+            summaries.push({
+                id: session.id,
+                title: session.title,
+                createdAt: session.createdAt,
+                updatedAt: session.updatedAt,
+                messageCount: session.completionMessages.length,
+            });
+        }
+        catch {
+            // Skip corrupt session files
+        }
+    }
+    // Sort by most recently updated
+    summaries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    return summaries;
+}
+/** Delete a session. */
+export async function deleteSession(id) {
+    try {
+        await fs.unlink(sessionPath(id));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Generate a short title for a session from the first user message.
+ * Uses the LLM to summarise if the message is long.
+ */
+export function generateTitle(messages) {
+    const firstUserMsg = messages.find((m) => m.role === 'user');
+    if (!firstUserMsg || !('content' in firstUserMsg) || typeof firstUserMsg.content !== 'string') {
+        return 'New session';
+    }
+    const content = firstUserMsg.content;
+    // Simple heuristic: take first 60 chars of the first user message
+    if (content.length <= 60)
+        return content;
+    return content.slice(0, 57) + '...';
+}