opc-agent 1.4.0 → 2.0.1

package/dist/telemetry/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * OPC Agent Telemetry — Lightweight OTel-compatible tracing & metrics.
+ * Zero external dependencies. Produces OTLP-compatible JSON.
+ */
+export interface Span {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind: 'internal' | 'client' | 'server';
+    startTime: number;
+    endTime?: number;
+    status: 'ok' | 'error' | 'unset';
+    attributes: Record<string, string | number | boolean>;
+    events: SpanEvent[];
+}
+export interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, string | number | boolean>;
+}
+export interface Metric {
+    name: string;
+    type: 'counter' | 'gauge' | 'histogram';
+    value: number;
+    timestamp: number;
+    labels: Record<string, string>;
+}
+export interface TraceExporter {
+    export(spans: Span[]): Promise<void>;
+}
+export declare function generateTraceId(): string;
+export declare function generateSpanId(): string;
+export declare class Tracer {
+    private spans;
+    private metrics;
+    private maxSpans;
+    private maxMetrics;
+    private exporters;
+    constructor(options?: {
+        maxSpans?: number;
+        maxMetrics?: number;
+    });
+    startSpan(name: string, options?: {
+        parent?: Span;
+        attributes?: Record<string, string | number | boolean>;
+        kind?: Span['kind'];
+    }): Span;
+    endSpan(span: Span, status?: Span['status']): void;
+    addEvent(span: Span, name: string, attributes?: Record<string, string | number | boolean>): void;
+    increment(name: string, value?: number, labels?: Record<string, string>): void;
+    gauge(name: string, value: number, labels?: Record<string, string>): void;
+    histogram(name: string, value: number, labels?: Record<string, string>): void;
+    private addMetric;
+    getSpans(options?: {
+        limit?: number;
+        traceId?: string;
+        name?: string;
+        since?: number;
+    }): Span[];
+    getMetrics(options?: {
+        name?: string;
+        since?: number;
+    }): Metric[];
+    getTrace(traceId: string): Span[];
+    addExporter(exporter: TraceExporter): void;
+    exportOTLP(): object;
+    getStats(): {
+        totalSpans: number;
+        totalTraces: number;
+        avgDuration: number;
+        errorRate: number;
+        spansByName: Record<string, number>;
+        p50Latency: number;
+        p95Latency: number;
+        p99Latency: number;
+    };
+    clear(): void;
+}
+export declare class ConsoleExporter implements TraceExporter {
+    export(spans: Span[]): Promise<void>;
+}
+export declare class FileExporter implements TraceExporter {
+    private filePath;
+    constructor(filePath: string);
+    export(spans: Span[]): Promise<void>;
+}
+export declare class OTLPHttpExporter implements TraceExporter {
+    private endpoint;
+    constructor(endpoint: string);
+    export(spans: Span[]): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * OPC Agent Telemetry — Lightweight OTel-compatible tracing & metrics.
+ * Zero external dependencies. Produces OTLP-compatible JSON.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTLPHttpExporter = exports.FileExporter = exports.ConsoleExporter = exports.Tracer = void 0;
+exports.generateTraceId = generateTraceId;
+exports.generateSpanId = generateSpanId;
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+// ─── ID Generation ───────────────────────────────────────────
+function generateTraceId() {
+    return crypto.randomBytes(16).toString('hex'); // 32 hex chars
+}
+function generateSpanId() {
+    return crypto.randomBytes(8).toString('hex'); // 16 hex chars
+}
+// ─── Tracer ──────────────────────────────────────────────────
+class Tracer {
+    spans = [];
+    metrics = [];
+    maxSpans;
+    maxMetrics;
+    exporters = [];
+    constructor(options) {
+        this.maxSpans = options?.maxSpans || 10000;
+        this.maxMetrics = options?.maxMetrics || 50000;
+    }
+    startSpan(name, options) {
+        const span = {
+            traceId: options?.parent?.traceId || generateTraceId(),
+            spanId: generateSpanId(),
+            parentSpanId: options?.parent?.spanId,
+            name,
+            kind: options?.kind || 'internal',
+            startTime: Date.now(),
+            status: 'unset',
+            attributes: options?.attributes ? { ...options.attributes } : {},
+            events: [],
+        };
+        this.spans.push(span);
+        // Evict oldest spans if over limit
+        if (this.spans.length > this.maxSpans) {
+            const excess = this.spans.length - this.maxSpans;
+            this.spans.splice(0, excess);
+        }
+        return span;
+    }
+    endSpan(span, status) {
+        span.endTime = Date.now();
+        span.status = status || 'ok';
+        // Notify exporters
+        for (const exporter of this.exporters) {
+            exporter.export([span]).catch(() => { });
+        }
+    }
+    addEvent(span, name, attributes) {
+        span.events.push({ name, timestamp: Date.now(), attributes });
+    }
+    // ─── Metrics ─────────────────────────────────────────────
+    increment(name, value = 1, labels = {}) {
+        this.addMetric(name, 'counter', value, labels);
+    }
+    gauge(name, value, labels = {}) {
+        this.addMetric(name, 'gauge', value, labels);
+    }
+    histogram(name, value, labels = {}) {
+        this.addMetric(name, 'histogram', value, labels);
+    }
+    addMetric(name, type, value, labels) {
+        this.metrics.push({ name, type, value, timestamp: Date.now(), labels });
+        if (this.metrics.length > this.maxMetrics) {
+            this.metrics.splice(0, this.metrics.length - this.maxMetrics);
+        }
+    }
+    // ─── Query ───────────────────────────────────────────────
+    getSpans(options) {
+        let result = [...this.spans];
+        if (options?.traceId)
+            result = result.filter(s => s.traceId === options.traceId);
+        if (options?.name)
+            result = result.filter(s => s.name === options.name);
+        if (options?.since)
+            result = result.filter(s => s.startTime >= options.since);
+        // Most recent first
+        result.sort((a, b) => b.startTime - a.startTime);
+        if (options?.limit)
+            result = result.slice(0, options.limit);
+        return result;
+    }
+    getMetrics(options) {
+        let result = [...this.metrics];
+        if (options?.name)
+            result = result.filter(m => m.name === options.name);
+        if (options?.since)
+            result = result.filter(m => m.timestamp >= options.since);
+        return result;
+    }
+    getTrace(traceId) {
+        return this.spans.filter(s => s.traceId === traceId).sort((a, b) => a.startTime - b.startTime);
+    }
+    // ─── Export (OTLP-compatible) ────────────────────────────
+    addExporter(exporter) {
+        this.exporters.push(exporter);
+    }
+    exportOTLP() {
+        // OTLP JSON format: https://opentelemetry.io/docs/specs/otlp/
+        const spansByResource = this.spans.filter(s => s.endTime != null);
+        return {
+            resourceSpans: [{
+                    resource: {
+                        attributes: [
+                            { key: 'service.name', value: { stringValue: 'opc-agent' } },
+                        ],
+                    },
+                    scopeSpans: [{
+                            scope: { name: 'opc-telemetry', version: '1.0.0' },
+                            spans: spansByResource.map(s => ({
+                                traceId: s.traceId,
+                                spanId: s.spanId,
+                                parentSpanId: s.parentSpanId || '',
+                                name: s.name,
+                                kind: s.kind === 'server' ? 2 : s.kind === 'client' ? 3 : 1,
+                                startTimeUnixNano: String(s.startTime * 1_000_000),
+                                endTimeUnixNano: String((s.endTime || s.startTime) * 1_000_000),
+                                attributes: Object.entries(s.attributes).map(([key, value]) => ({
+                                    key,
+                                    value: typeof value === 'string' ? { stringValue: value }
+                                        : typeof value === 'number' ? (Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value })
+                                            : { boolValue: value },
+                                })),
+                                events: s.events.map(e => ({
+                                    timeUnixNano: String(e.timestamp * 1_000_000),
+                                    name: e.name,
+                                    attributes: e.attributes ? Object.entries(e.attributes).map(([key, value]) => ({
+                                        key,
+                                        value: typeof value === 'string' ? { stringValue: value }
+                                            : typeof value === 'number' ? { intValue: String(value) }
+                                                : { boolValue: value },
+                                    })) : [],
+                                })),
+                                status: {
+                                    code: s.status === 'ok' ? 1 : s.status === 'error' ? 2 : 0,
+                                },
+                            })),
+                        }],
+                }],
+        };
+    }
+    // ─── Stats ───────────────────────────────────────────────
+    getStats() {
+        const completed = this.spans.filter(s => s.endTime != null);
+        const durations = completed.map(s => s.endTime - s.startTime).sort((a, b) => a - b);
+        const traceIds = new Set(this.spans.map(s => s.traceId));
+        const errors = completed.filter(s => s.status === 'error').length;
+        const spansByName = {};
+        for (const s of this.spans) {
+            spansByName[s.name] = (spansByName[s.name] || 0) + 1;
+        }
+        const percentile = (arr, p) => {
+            if (arr.length === 0)
+                return 0;
+            const idx = Math.ceil(arr.length * p / 100) - 1;
+            return arr[Math.max(0, idx)];
+        };
+        return {
+            totalSpans: this.spans.length,
+            totalTraces: traceIds.size,
+            avgDuration: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+            errorRate: completed.length > 0 ? errors / completed.length : 0,
+            spansByName,
+            p50Latency: percentile(durations, 50),
+            p95Latency: percentile(durations, 95),
+            p99Latency: percentile(durations, 99),
+        };
+    }
+    clear() {
+        this.spans = [];
+        this.metrics = [];
+    }
+}
+exports.Tracer = Tracer;
+// ─── Exporters ───────────────────────────────────────────────
+class ConsoleExporter {
+    async export(spans) {
+        for (const span of spans) {
+            const duration = span.endTime ? `${span.endTime - span.startTime}ms` : 'ongoing';
+            console.log(`[TRACE] ${span.name} (${duration}) [${span.status}] trace=${span.traceId.slice(0, 8)}`);
+        }
+    }
+}
+exports.ConsoleExporter = ConsoleExporter;
+class FileExporter {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async export(spans) {
+        const lines = spans.map(s => JSON.stringify(s)).join('\n') + '\n';
+        fs.appendFileSync(this.filePath, lines);
+    }
+}
+exports.FileExporter = FileExporter;
+class OTLPHttpExporter {
+    endpoint;
+    constructor(endpoint) {
+        this.endpoint = endpoint.replace(/\/$/, '');
+    }
+    async export(spans) {
+        const body = {
+            resourceSpans: [{
+                    resource: {
+                        attributes: [
+                            { key: 'service.name', value: { stringValue: 'opc-agent' } },
+                        ],
+                    },
+                    scopeSpans: [{
+                            scope: { name: 'opc-telemetry', version: '1.0.0' },
+                            spans: spans.filter(s => s.endTime).map(s => ({
+                                traceId: s.traceId,
+                                spanId: s.spanId,
+                                parentSpanId: s.parentSpanId || '',
+                                name: s.name,
+                                kind: s.kind === 'server' ? 2 : s.kind === 'client' ? 3 : 1,
+                                startTimeUnixNano: String(s.startTime * 1_000_000),
+                                endTimeUnixNano: String((s.endTime || s.startTime) * 1_000_000),
+                                attributes: Object.entries(s.attributes).map(([key, value]) => ({
+                                    key,
+                                    value: typeof value === 'string' ? { stringValue: value }
+                                        : typeof value === 'number' ? { intValue: String(value) }
+                                            : { boolValue: value },
+                                })),
+                                status: { code: s.status === 'ok' ? 1 : s.status === 'error' ? 2 : 0 },
+                            })),
+                        }],
+                }],
+        };
+        try {
+            await fetch(`${this.endpoint}/v1/traces`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+        }
+        catch {
+            // Best effort
+        }
+    }
+}
+exports.OTLPHttpExporter = OTLPHttpExporter;
+//# sourceMappingURL=index.js.map

package/dist/tools/builtin/datetime.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const datetimeTool: MCPTool;
+//# sourceMappingURL=datetime.d.ts.map

package/dist/tools/builtin/datetime.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datetimeTool = void 0;
+exports.datetimeTool = {
+    name: 'datetime',
+    description: 'Get current date, time, timezone info',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            format: { type: 'string', default: 'iso' },
+            timezone: { type: 'string' },
+        },
+    },
+    async execute(input) {
+        const now = new Date();
+        const timezone = input.timezone;
+        const format = input.format || 'iso';
+        let content;
+        if (format === 'iso') {
+            content = now.toISOString();
+        }
+        else if (format === 'locale') {
+            content = timezone
+                ? now.toLocaleString('en-US', { timeZone: timezone })
+                : now.toLocaleString();
+        }
+        else if (format === 'unix') {
+            content = String(Math.floor(now.getTime() / 1000));
+        }
+        else {
+            content = now.toISOString();
+        }
+        return {
+            content: JSON.stringify({
+                iso: now.toISOString(),
+                unix: Math.floor(now.getTime() / 1000),
+                formatted: content,
+                timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+            }),
+            isError: false,
+        };
+    },
+};
+//# sourceMappingURL=datetime.js.map

package/dist/tools/builtin/file.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const fileTool: MCPTool;
+//# sourceMappingURL=file.d.ts.map

package/dist/tools/builtin/file.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function resolveSafe(basePath, targetPath) {
+    const resolved = path.resolve(basePath, targetPath);
+    if (!resolved.startsWith(path.resolve(basePath)))
+        return null;
+    return resolved;
+}
+function searchFiles(dir, query, results = [], maxResults = 20) {
+    if (results.length >= maxResults)
+        return results;
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (results.length >= maxResults)
+                break;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '.git')
+                    continue;
+                searchFiles(full, query, results, maxResults);
+            }
+            else if (entry.isFile()) {
+                try {
+                    const content = fs.readFileSync(full, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (lines[i].includes(query)) {
+                            results.push(`${full}:${i + 1}: ${lines[i].trim()}`);
+                            if (results.length >= maxResults)
+                                break;
+                        }
+                    }
+                }
+                catch { /* skip binary/unreadable */ }
+            }
+        }
+    }
+    catch { /* skip inaccessible dirs */ }
+    return results;
+}
+exports.fileTool = {
+    name: 'file_operations',
+    description: 'Read, write, list, and search files in the workspace',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', enum: ['read', 'write', 'list', 'search', 'exists'] },
+            path: { type: 'string' },
+            content: { type: 'string' },
+            query: { type: 'string' },
+        },
+        required: ['action'],
+    },
+    async execute(input, context) {
+        const action = input.action;
+        const workspace = process.cwd();
+        const targetPath = input.path;
+        if (action === 'search') {
+            const query = input.query;
+            if (!query)
+                return { content: 'query is required for search', isError: true };
+            const results = searchFiles(workspace, query);
+            return { content: results.length ? results.join('\n') : 'No matches found', isError: false };
+        }
+        if (action === 'list') {
+            const dir = targetPath ? resolveSafe(workspace, targetPath) : workspace;
+            if (!dir)
+                return { content: 'Path outside workspace', isError: true };
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                const listing = entries.map(e => `${e.isDirectory() ? '[DIR] ' : ''}${e.name}`).join('\n');
+                return { content: listing || '(empty directory)', isError: false };
+            }
+            catch (err) {
+                return { content: `Error listing directory: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+            }
+        }
+        if (!targetPath)
+            return { content: 'path is required', isError: true };
+        const resolved = resolveSafe(workspace, targetPath);
+        if (!resolved)
+            return { content: 'Path outside workspace', isError: true };
+        switch (action) {
+            case 'read': {
+                try {
+                    const content = fs.readFileSync(resolved, 'utf-8');
+                    return { content: content.slice(0, 50000), isError: false };
+                }
+                catch (err) {
+                    return { content: `Error reading file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+                }
+            }
+            case 'write': {
+                const content = input.content;
+                if (content === undefined)
+                    return { content: 'content is required for write', isError: true };
+                try {
+                    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+                    fs.writeFileSync(resolved, content, 'utf-8');
+                    return { content: `Written ${content.length} bytes to ${targetPath}`, isError: false };
+                }
+                catch (err) {
+                    return { content: `Error writing file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+                }
+            }
+            case 'exists': {
+                return { content: String(fs.existsSync(resolved)), isError: false };
+            }
+            default:
+                return { content: `Unknown action: ${action}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=file.js.map

package/dist/tools/builtin/index.d.ts

@@ -0,0 +1,15 @@
+import type { MCPTool } from '../mcp';
+import { fileTool } from './file';
+import { webTool } from './web';
+import { shellTool } from './shell';
+import { datetimeTool } from './datetime';
+export { fileTool, webTool, shellTool, datetimeTool };
+/**
+ * Get all built-in tools.
+ */
+export declare function getBuiltinTools(): MCPTool[];
+/**
+ * Get specific built-in tools by name. If no names given, returns all.
+ */
+export declare function getBuiltinToolsByName(names?: string[]): MCPTool[];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/builtin/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datetimeTool = exports.shellTool = exports.webTool = exports.fileTool = void 0;
+exports.getBuiltinTools = getBuiltinTools;
+exports.getBuiltinToolsByName = getBuiltinToolsByName;
+const file_1 = require("./file");
+Object.defineProperty(exports, "fileTool", { enumerable: true, get: function () { return file_1.fileTool; } });
+const web_1 = require("./web");
+Object.defineProperty(exports, "webTool", { enumerable: true, get: function () { return web_1.webTool; } });
+const shell_1 = require("./shell");
+Object.defineProperty(exports, "shellTool", { enumerable: true, get: function () { return shell_1.shellTool; } });
+const datetime_1 = require("./datetime");
+Object.defineProperty(exports, "datetimeTool", { enumerable: true, get: function () { return datetime_1.datetimeTool; } });
+const ALL_BUILTIN_TOOLS = [file_1.fileTool, web_1.webTool, shell_1.shellTool, datetime_1.datetimeTool];
+const BUILTIN_MAP = new Map(ALL_BUILTIN_TOOLS.map(t => [t.name, t]));
+/**
+ * Get all built-in tools.
+ */
+function getBuiltinTools() {
+    return [...ALL_BUILTIN_TOOLS];
+}
+/**
+ * Get specific built-in tools by name. If no names given, returns all.
+ */
+function getBuiltinToolsByName(names) {
+    if (!names || names.length === 0)
+        return getBuiltinTools();
+    return names.map(n => BUILTIN_MAP.get(n)).filter((t) => !!t);
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/builtin/shell.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const shellTool: MCPTool;
+//# sourceMappingURL=shell.d.ts.map

package/dist/tools/builtin/shell.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellTool = void 0;
+const child_process_1 = require("child_process");
+exports.shellTool = {
+    name: 'shell_exec',
+    description: 'Execute a shell command (sandboxed to workspace)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            command: { type: 'string' },
+            timeout: { type: 'number', default: 30000 },
+        },
+        required: ['command'],
+    },
+    async execute(input) {
+        const command = input.command;
+        const timeout = input.timeout || 30000;
+        const workspace = process.cwd();
+        // Block path traversal attempts
+        if (command.includes('..')) {
+            return { content: 'Commands with ".." are not allowed for security', isError: true };
+        }
+        try {
+            const output = (0, child_process_1.execSync)(command, {
+                cwd: workspace,
+                timeout,
+                encoding: 'utf-8',
+                maxBuffer: 1024 * 1024,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const result = (output || '').slice(0, 5000);
+            return { content: result || '(no output)', isError: false };
+        }
+        catch (err) {
+            const stderr = err.stderr ? String(err.stderr).slice(0, 2500) : '';
+            const stdout = err.stdout ? String(err.stdout).slice(0, 2500) : '';
+            const output = [stdout, stderr].filter(Boolean).join('\n') || err.message;
+            return { content: `Command failed: ${output.slice(0, 5000)}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=shell.js.map

package/dist/tools/builtin/web.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const webTool: MCPTool;
+//# sourceMappingURL=web.d.ts.map