agen-vektor 0.1.0

package/dist/tools/shell.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runShell = runShell;
+exports.createShellTool = createShellTool;
+/**
+ * Shell tool — run commands in the project directory.
+ * Every command is classified by the command policy and gated by permissions.
+ */
+const node_child_process_1 = require("node:child_process");
+function runShell(command, cwd, opts = {}) {
+    return new Promise((resolve) => {
+        const timeoutMs = opts.timeoutMs || 120_000;
+        const child = (0, node_child_process_1.spawn)(command, {
+            cwd,
+            shell: '/bin/sh',
+            env: { ...process.env, ...opts.env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.stdout.on('data', (d) => {
+            stdout += d.toString();
+            if (stdout.length > 2_000_000)
+                child.kill('SIGKILL');
+        });
+        child.stderr.on('data', (d) => {
+            stderr += d.toString();
+            if (stderr.length > 2_000_000)
+                child.kill('SIGKILL');
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ stdout, stderr, exitCode: code, timedOut });
+        });
+        child.on('error', (e) => {
+            clearTimeout(timer);
+            resolve({ stdout, stderr: `spawn error: ${e.message}`, exitCode: -1, timedOut });
+        });
+    });
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max) + `\n... [truncated ${text.length - max} chars]`;
+}
+function createShellTool() {
+    return {
+        definition: {
+            name: 'shell',
+            description: 'Run a shell command in the project directory. The command is classified for safety; risky commands require permission. Use for building, testing, installing, git, or any command execution. Long output is truncated.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'The shell command to run (single line; use && to chain)' },
+                    timeout_ms: { type: 'number', description: 'Timeout in ms (default 120000)' },
+                },
+                required: ['command'],
+            },
+        },
+        async execute(args, ctx) {
+            const command = String(args.command || '').trim();
+            if (!command)
+                return { output: 'ERROR: empty command' };
+            ctx.onActivity?.('shell', `$ ${command}`);
+            const level = ctx.permissions.classifyCommand(command);
+            if (level === 'blocked') {
+                return {
+                    output: `BLOCKED: command is not permitted by VECTOR security policy:\n${command}`,
+                    summary: 'blocked by policy',
+                };
+            }
+            const allowed = await ctx.permissions.decide({
+                tool: 'shell',
+                summary: command,
+                level,
+            });
+            if (!allowed) {
+                return {
+                    output: `Permission denied by user:\n${command}`,
+                    summary: 'denied by user',
+                };
+            }
+            const result = await runShell(command, ctx.cwd, {
+                timeoutMs: Number(args.timeout_ms) || 120_000,
+            });
+            const maxOut = ctx.maxOutput || 30_000;
+            let out = '';
+            if (result.stdout)
+                out += truncate(result.stdout, maxOut);
+            if (result.stderr)
+                out += (out ? '\n[stderr]\n' : '') + truncate(result.stderr, Math.min(maxOut, 10_000));
+            if (result.timedOut)
+                out += '\n[command timed out and was killed]';
+            const status = result.exitCode === 0 ? 'exit 0' : `exit ${result.exitCode ?? '?'}`;
+            out = `${status}${out ? '\n' + out : ''}`;
+            return {
+                output: out,
+                summary: `$ ${command} → ${status}`,
+                data: { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr },
+            };
+        },
+    };
+}

package/dist/tools/web.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebTool = createWebTool;
+async function fetchText(url, maxChars) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 20_000);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { 'User-Agent': 'VECTOR-AI-Agent/0.1' },
+            redirect: 'follow',
+        });
+        if (!res.ok)
+            return `ERROR: HTTP ${res.status} for ${url}`;
+        const contentType = res.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            const text = await res.text();
+            return text.slice(0, maxChars);
+        }
+        if (contentType.includes('text') || contentType.includes('html')) {
+            const html = await res.text();
+            return stripHtml(html).slice(0, maxChars);
+        }
+        const buf = Buffer.from(await res.arrayBuffer());
+        return buf.toString('utf8').slice(0, maxChars);
+    }
+    catch (e) {
+        return `ERROR: fetch failed: ${e.message}`;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<noscript[\s\S]*?<\/noscript>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function createWebTool() {
+    return {
+        definition: {
+            name: 'web_fetch',
+            description: 'Fetch a URL and return its readable text content. Use for documentation, errors, or any page needed to solve the task. Web search engines are not built in.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'The http(s) URL to fetch' },
+                    max_chars: { type: 'number', description: 'Max characters to return (default 8000)' },
+                },
+                required: ['url'],
+            },
+        },
+        async execute(args, ctx) {
+            const url = String(args.url || '');
+            if (!/^https?:\/\//i.test(url))
+                return { output: `ERROR: invalid URL: ${url}` };
+            const maxChars = Math.min(30_000, Math.max(1000, Number(args.max_chars) || 8000));
+            ctx.onActivity?.('web', `fetching ${url}`);
+            const text = await fetchText(url, maxChars);
+            return {
+                output: text,
+                summary: `fetched ${url}`,
+            };
+        },
+    };
+}