@vraxis/agent-v 0.5.2 → 0.7.0

package/dist/tools/http.js

@@ -0,0 +1,123 @@
+import { defineOutput, defineTool } from "../core/index.js";
+import { standardToolNames } from "./names.js";
+async function readBoundedBody(response, limit) {
+    if (!response.body)
+        return { body: "", truncated: false };
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            const remaining = limit - total;
+            if (remaining <= 0) {
+                truncated = true;
+                break;
+            }
+            const chunk = next.value.byteLength > remaining ? next.value.slice(0, remaining) : next.value;
+            chunks.push(chunk);
+            total += chunk.byteLength;
+            if (chunk.byteLength < next.value.byteLength) {
+                truncated = true;
+                break;
+            }
+        }
+    }
+    finally {
+        if (truncated)
+            await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { body: new TextDecoder().decode(combined), truncated };
+}
+function allowedUrl(raw, allowedHosts) {
+    if (typeof raw !== "string" || !raw.trim())
+        throw new TypeError("url must be a non-empty string.");
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new TypeError("url must be a valid URL.");
+    }
+    if (url.username || url.password)
+        throw new TypeError("URLs containing credentials are not allowed.");
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback))
+        throw new TypeError("Remote requests must use HTTPS.");
+    if (!allowedHosts.has(url.host.toLowerCase()) && !allowedHosts.has(url.hostname.toLowerCase()))
+        throw new TypeError(`Host ${url.host} is not allowed.`);
+    return url;
+}
+export function createHttpFetchTool(options) {
+    const allowedHosts = new Set(options.allowedHosts.map((host) => host.trim().toLowerCase()).filter(Boolean));
+    if (!allowedHosts.size)
+        throw new TypeError("http-fetch requires at least one allowed host.");
+    const performFetch = options.fetch ?? globalThis.fetch;
+    if (!performFetch)
+        throw new TypeError("No fetch implementation is available.");
+    const maxResponseBytes = options.maxResponseBytes ?? 256_000;
+    return defineTool({
+        name: standardToolNames.httpFetch,
+        version: "1.0.0",
+        description: "Fetch a bounded HTTPS or loopback resource from an explicit host allowlist.",
+        input: defineOutput({
+            name: "http-fetch-input",
+            jsonSchema: {
+                type: "object",
+                properties: { url: { type: "string" }, method: { enum: ["GET", "HEAD"] } },
+                required: ["url"],
+                additionalProperties: false,
+            },
+            parse(value) {
+                if (!value || typeof value !== "object" || Array.isArray(value))
+                    throw new TypeError("HTTP input must be an object.");
+                const input = value;
+                const url = allowedUrl(input.url, allowedHosts);
+                const method = input.method === undefined ? "GET" : input.method;
+                if (method !== "GET" && method !== "HEAD")
+                    throw new TypeError("method must be GET or HEAD.");
+                return { url: url.href, method };
+            },
+        }),
+        output: defineOutput({
+            name: "http-fetch-output",
+            jsonSchema: { type: "object" },
+            parse(value) {
+                if (!value || typeof value !== "object" || Array.isArray(value))
+                    throw new TypeError("HTTP output must be an object.");
+                return value;
+            },
+        }),
+        risk: "external-side-effect",
+        sideEffect: "none",
+        requiredPermissions: ["network:fetch"],
+        requiresApproval: true,
+        approvalCategory: "network",
+        approvalReason: "Allow this agent to send a request to an approved network host.",
+        timeoutMs: options.timeoutMs ?? 15_000,
+        async execute(input, context) {
+            const response = await performFetch(input.url, { method: input.method, redirect: "manual", signal: context.abortSignal });
+            const bounded = input.method === "HEAD" ? { body: "", truncated: false } : await readBoundedBody(response, maxResponseBytes);
+            return {
+                url: input.url,
+                status: response.status,
+                ok: response.ok,
+                contentType: response.headers.get("content-type") ?? "",
+                body: bounded.body,
+                truncated: bounded.truncated,
+                redirectLocation: response.headers.get("location") ?? "",
+            };
+        },
+    });
+}
+//# sourceMappingURL=http.js.map

package/dist/tools/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","sourceRoot":"","sources":["../../src/tools/http.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAmC,MAAM,kBAAkB,CAAC;AAC7F,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAS/C,KAAK,UAAU,eAAe,CAAC,QAAkB,EAAE,KAAa;IAC9D,IAAI,CAAC,QAAQ,CAAC,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IAC1D,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;IACzC,MAAM,MAAM,GAAiB,EAAE,CAAC;IAChC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,IAAI,CAAC;QACH,OAAO,IAAI,EAAE,CAAC;YACZ,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;YACjC,IAAI,IAAI,CAAC,IAAI;gBAAE,MAAM;YACrB,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;YAChC,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;gBAAC,SAAS,GAAG,IAAI,CAAC;gBAAC,MAAM;YAAC,CAAC;YAChD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;YAC9F,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,KAAK,IAAI,KAAK,CAAC,UAAU,CAAC;YAC1B,IAAI,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;gBAAC,SAAS,GAAG,IAAI,CAAC;gBAAC,MAAM;YAAC,CAAC;QAC5E,CAAC;IACH,CAAC;YAAS,CAAC;QACT,IAAI,SAAS;YAAE,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC5D,MAAM,CAAC,WAAW,EAAE,CAAC;IACvB,CAAC;IACD,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IACvC,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAAC,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC;IAAC,CAAC;IACxF,OAAO,EAAE,IAAI,EAAE,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAC;AACjE,CAAC;AAED,SAAS,UAAU,CAAC,GAAY,EAAE,YAAiC;IACjE,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QAAE,MAAM,IAAI,SAAS,CAAC,iCAAiC,CAAC,CAAC;IACnG,IAAI,GAAQ,CAAC;IACb,IAAI,CAAC;QAAC,GAAG,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;IAAC,CAAC;IAAC,MAAM,CAAC;QAAC,MAAM,IAAI,SAAS,CAAC,0BAA0B,CAAC,CAAC;IAAC,CAAC;IACtF,IAAI,GAAG,CAAC,QAAQ,IAAI,GAAG,CAAC,QAAQ;QAAE,MAAM,IAAI,SAAS,CAAC,8CAA8C,CAAC,CAAC;IACtG,MAAM,QAAQ,GAAG,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC5E,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,QAAQ,CAAC;QAAE,MAAM,IAAI,SAAS,CAAC,iCAAiC,CAAC,CAAC;IACjI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAAE,MAAM,IAAI,SAAS,CAAC,QAAQ,GAAG,CAAC,IAAI,kBAAkB,CAAC,CAAC;IACxJ,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,OAA6B;IAC/D,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5G,IAAI,CAAC,YAAY,CAAC,IAAI;QAAE,MAAM,IAAI,SAAS,CAAC,gDAAgD,CAAC,CAAC;IAC9F,MAAM,YAAY,GAAG,OAAO,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,CAAC;IACvD,IAAI,CAAC,YAAY;QAAE,MAAM,IAAI,SAAS,CAAC,uCAAuC,CAAC,CAAC;IAChF,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,OAAO,CAAC;IAC7D,OAAO,UAAU,CAAC;QAChB,IAAI,EAAE,iBAAiB,CAAC,SAAS;QACjC,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,6EAA6E;QAC1F,KAAK,EAAE,YAAY,CAAC;YAClB,IAAI,EAAE,kBAAkB;YACxB,UAAU,EAAE;gBACV,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE;gBAC1E,QAAQ,EAAE,CAAC,KAAK,CAAC;gBACjB,oBAAoB,EAAE,KAAK;aAC5B;YACD,KAAK,CAAC,KAAK;gBACT,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;oBAAE,MAAM,IAAI,SAAS,CAAC,+BAA+B,CAAC,CAAC;gBACtH,MAAM,KAAK,GAAG,KAAgC,CAAC;gBAC/C,MAAM,GAAG,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;gBAChD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;gBACjE,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,MAAM;oBAAE,MAAM,IAAI,SAAS,CAAC,6BAA6B,CAAC,CAAC;gBAC9F,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;YACnC,CAAC;SACF,CAAC;QACF,MAAM,EAAE,YAAY,CAAC;YACnB,IAAI,EAAE,mBAAmB;YACzB,UAAU,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YAC9B,KAAK,CAAC,KAAK;gBACT,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;oBAAE,MAAM,IAAI,SAAS,CAAC,gCAAgC,CAAC,CAAC;gBACvH,OAAO,KAAmB,CAAC;YAC7B,CAAC;SACF,CAAC;QACF,IAAI,EAAE,sBAAsB;QAC5B,UAAU,EAAE,MAAM;QAClB,mBAAmB,EAAE,CAAC,eAAe,CAAC;QACtC,gBAAgB,EAAE,IAAI;QACtB,gBAAgB,EAAE,SAAS;QAC3B,cAAc,EAAE,iEAAiE;QACjF,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,MAAM;QACtC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO;YAC1B,MAAM,QAAQ,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;YAC1H,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,eAAe,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;YAC7H,OAAO;gBACL,GAAG,EAAE,KAAK,CAAC,GAAG;gBACd,MAAM,EAAE,QAAQ,CAAC,MAAM;gBACvB,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE;gBACvD,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,gBAAgB,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE;aACzD,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/tools/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./approval.js";
+export * from "./browser.js";
+export * from "./http.js";
+export * from "./names.js";
+export * from "./pure.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,6 @@
+export * from "./approval.js";
+export * from "./browser.js";
+export * from "./http.js";
+export * from "./names.js";
+export * from "./pure.js";
+//# sourceMappingURL=index.js.map

package/dist/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/dist/tools/names.d.ts

@@ -0,0 +1,19 @@
+export declare const standardToolNames: {
+    readonly calculate: "calculate";
+    readonly dateTime: "date-time";
+    readonly validateJson: "validate-json";
+    readonly listDirectory: "list-directory";
+    readonly readText: "read-text";
+    readonly searchText: "search-text";
+    readonly writeText: "write-text";
+    readonly applyTextEdits: "apply-text-edits";
+    readonly gitStatus: "git-status";
+    readonly gitDiff: "git-diff";
+    readonly runCommand: "run-command";
+    readonly httpFetch: "http-fetch";
+    readonly browserSnapshot: "browser-snapshot";
+    readonly browserNavigate: "browser-navigate";
+    readonly browserClick: "browser-click";
+    readonly browserType: "browser-type";
+};
+//# sourceMappingURL=names.d.ts.map

package/dist/tools/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/tools/names.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;CAiBpB,CAAC"}

package/dist/tools/names.js

@@ -0,0 +1,19 @@
+export const standardToolNames = {
+    calculate: "calculate",
+    dateTime: "date-time",
+    validateJson: "validate-json",
+    listDirectory: "list-directory",
+    readText: "read-text",
+    searchText: "search-text",
+    writeText: "write-text",
+    applyTextEdits: "apply-text-edits",
+    gitStatus: "git-status",
+    gitDiff: "git-diff",
+    runCommand: "run-command",
+    httpFetch: "http-fetch",
+    browserSnapshot: "browser-snapshot",
+    browserNavigate: "browser-navigate",
+    browserClick: "browser-click",
+    browserType: "browser-type",
+};
+//# sourceMappingURL=names.js.map

package/dist/tools/names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.js","sourceRoot":"","sources":["../../src/tools/names.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW;IACtB,QAAQ,EAAE,WAAW;IACrB,YAAY,EAAE,eAAe;IAC7B,aAAa,EAAE,gBAAgB;IAC/B,QAAQ,EAAE,WAAW;IACrB,UAAU,EAAE,aAAa;IACzB,SAAS,EAAE,YAAY;IACvB,cAAc,EAAE,kBAAkB;IAClC,SAAS,EAAE,YAAY;IACvB,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,aAAa;IACzB,SAAS,EAAE,YAAY;IACvB,eAAe,EAAE,kBAAkB;IACnC,eAAe,EAAE,kBAAkB;IACnC,YAAY,EAAE,eAAe;IAC7B,WAAW,EAAE,cAAc;CACnB,CAAC"}

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

@@ -0,0 +1,20 @@
+import { type AgentTool } from "../../core/index.js";
+export interface FilesystemToolOptions {
+    rootPath: string;
+    maxFileBytes?: number;
+    maxSearchFiles?: number;
+    maxSearchResults?: number;
+    ignoredDirectories?: readonly string[];
+}
+export declare function createFilesystemTools(options: FilesystemToolOptions): Promise<readonly AgentTool[]>;
+export interface DevelopmentToolOptions {
+    rootPath: string;
+    allowedCommands: readonly string[];
+    inheritedEnvironment?: readonly string[];
+    environment?: Readonly<Record<string, string>>;
+    maxOutputBytes?: number;
+    timeoutMs?: number;
+}
+export declare function createDevelopmentTools(options: DevelopmentToolOptions): Promise<readonly AgentTool[]>;
+export declare function createWorkspaceTools(options: FilesystemToolOptions & Partial<Omit<DevelopmentToolOptions, "rootPath">>): Promise<readonly AgentTool[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/node/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAA4B,KAAK,SAAS,EAAmB,MAAM,qBAAqB,CAAC;AA0DhG,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,SAAS,EAAE,CAAC,CAqMzG;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAYD,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,SAAS,SAAS,EAAE,CAAC,CAuF3G;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,UAAU,CAAC,CAAC,GAAG,OAAO,CAAC,SAAS,SAAS,EAAE,CAAC,CAW5J"}

package/dist/tools/node/index.js

@@ -0,0 +1,406 @@
+import { execFile } from "node:child_process";
+import { readdir, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { defineOutput, defineTool } from "../../core/index.js";
+import { standardToolNames } from "../names.js";
+const execFileAsync = promisify(execFile);
+function record(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError(`${label} must be an object.`);
+    return value;
+}
+function stringField(value, field, options = {}) {
+    const selected = record(value, "Tool input")[field];
+    if (typeof selected !== "string" || (!options.allowEmpty && !selected.trim()))
+        throw new TypeError(`${field} must be ${options.allowEmpty ? "a string" : "a non-empty string"}.`);
+    if (selected.includes("\0"))
+        throw new TypeError(`${field} contains an invalid null byte.`);
+    return selected;
+}
+function within(root, candidate) {
+    const path = relative(root, candidate);
+    return path === "" || (!path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path));
+}
+class BoundedWorkspace {
+    rootPath;
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+    }
+    static async create(rootPath) {
+        const canonical = await realpath(rootPath);
+        if (!(await stat(canonical)).isDirectory())
+            throw new TypeError("Workspace root must be a directory.");
+        return new BoundedWorkspace(canonical);
+    }
+    lexical(relativePath) {
+        if (!relativePath || isAbsolute(relativePath))
+            throw new TypeError("Paths must be non-empty and relative to the workspace root.");
+        const candidate = resolve(this.rootPath, relativePath);
+        if (!within(this.rootPath, candidate))
+            throw new TypeError("Path escapes the approved workspace root.");
+        return candidate;
+    }
+    async existing(relativePath) {
+        const candidate = this.lexical(relativePath);
+        const canonical = await realpath(candidate);
+        if (!within(this.rootPath, canonical))
+            throw new TypeError("Path resolves outside the approved workspace root.");
+        return canonical;
+    }
+    async writable(relativePath) {
+        const candidate = this.lexical(relativePath);
+        const canonicalParent = await realpath(dirname(candidate));
+        if (!within(this.rootPath, canonicalParent))
+            throw new TypeError("Path parent resolves outside the approved workspace root.");
+        const existing = await realpath(candidate).catch((error) => {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        });
+        if (existing && !within(this.rootPath, existing))
+            throw new TypeError("Path resolves outside the approved workspace root.");
+        return candidate;
+    }
+}
+export async function createFilesystemTools(options) {
+    const workspace = await BoundedWorkspace.create(options.rootPath);
+    const maxFileBytes = options.maxFileBytes ?? 1_000_000;
+    const maxSearchFiles = options.maxSearchFiles ?? 5_000;
+    const maxSearchResults = options.maxSearchResults ?? 200;
+    const ignored = new Set(options.ignoredDirectories ?? [".git", "node_modules"]);
+    const objectOutput = defineOutput({
+        name: "workspace-tool-output",
+        jsonSchema: { type: "object" },
+        parse(value) { return record(value, "Workspace tool output"); },
+    });
+    const pathInput = (name) => defineOutput({
+        name,
+        jsonSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"], additionalProperties: false },
+        parse(value) { return { path: stringField(value, "path") }; },
+    });
+    const readBoundedText = async (path) => {
+        const info = await stat(path);
+        if (!info.isFile())
+            throw new TypeError("Path must identify a regular file.");
+        if (info.size > maxFileBytes)
+            throw new RangeError(`File exceeds the ${maxFileBytes} byte read limit.`);
+        const content = await readFile(path, "utf8");
+        if (content.includes("\0"))
+            throw new TypeError("Binary files are not supported.");
+        return content;
+    };
+    return [
+        defineTool({
+            name: standardToolNames.listDirectory,
+            version: "1.0.0",
+            description: "List one directory inside the approved workspace root.",
+            input: pathInput("list-directory-input"),
+            output: objectOutput,
+            risk: "read",
+            sideEffect: "none",
+            requiredPermissions: ["filesystem:read"],
+            requiresApproval: false,
+            timeoutMs: 5_000,
+            async execute({ path }) {
+                const directory = await workspace.existing(path);
+                const entries = await readdir(directory, { withFileTypes: true });
+                if (entries.length > 1_000)
+                    throw new RangeError("Directory exceeds the 1000-entry listing limit.");
+                return {
+                    path,
+                    entries: entries.sort((left, right) => left.name.localeCompare(right.name)).map((entry) => ({
+                        name: entry.name,
+                        type: entry.isDirectory() ? "directory" : entry.isFile() ? "file" : entry.isSymbolicLink() ? "symlink" : "other",
+                    })),
+                };
+            },
+        }),
+        defineTool({
+            name: standardToolNames.readText,
+            version: "1.0.0",
+            description: "Read one bounded UTF-8 text file inside the approved workspace root.",
+            input: pathInput("read-text-input"),
+            output: objectOutput,
+            risk: "read",
+            sideEffect: "none",
+            requiredPermissions: ["filesystem:read"],
+            requiresApproval: false,
+            timeoutMs: 5_000,
+            async execute({ path }) {
+                const file = await workspace.existing(path);
+                return { path, content: await readBoundedText(file) };
+            },
+        }),
+        defineTool({
+            name: standardToolNames.searchText,
+            version: "1.0.0",
+            description: "Search bounded workspace text files without following symlinks.",
+            input: defineOutput({
+                name: "search-text-input",
+                jsonSchema: { type: "object", properties: { query: { type: "string" }, path: { type: "string" } }, required: ["query"], additionalProperties: false },
+                parse(value) {
+                    const input = record(value, "Search input");
+                    return { query: stringField(value, "query"), path: input.path === undefined ? "." : stringField(value, "path") };
+                },
+            }),
+            output: objectOutput,
+            risk: "read",
+            sideEffect: "none",
+            requiredPermissions: ["filesystem:read"],
+            requiresApproval: false,
+            timeoutMs: 15_000,
+            async execute({ query, path }) {
+                const start = await workspace.existing(path);
+                const results = [];
+                let files = 0;
+                const walk = async (directory) => {
+                    for (const entry of await readdir(directory, { withFileTypes: true })) {
+                        if (results.length >= maxSearchResults || files >= maxSearchFiles)
+                            return;
+                        if (entry.isSymbolicLink() || (entry.isDirectory() && ignored.has(entry.name)))
+                            continue;
+                        const child = resolve(directory, entry.name);
+                        if (entry.isDirectory()) {
+                            await walk(child);
+                            continue;
+                        }
+                        if (!entry.isFile())
+                            continue;
+                        files += 1;
+                        const info = await stat(child);
+                        if (info.size > maxFileBytes)
+                            continue;
+                        const content = await readFile(child, "utf8").catch(() => "");
+                        if (content.includes("\0"))
+                            continue;
+                        for (const [index, line] of content.split(/\r?\n/).entries()) {
+                            if (line.includes(query))
+                                results.push({ path: relative(workspace.rootPath, child), line: index + 1, text: line.slice(0, 500) });
+                            if (results.length >= maxSearchResults)
+                                break;
+                        }
+                    }
+                };
+                const info = await stat(start);
+                if (info.isDirectory())
+                    await walk(start);
+                else {
+                    files = 1;
+                    const content = await readBoundedText(start);
+                    for (const [index, line] of content.split(/\r?\n/).entries()) {
+                        if (line.includes(query))
+                            results.push({ path: relative(workspace.rootPath, start), line: index + 1, text: line.slice(0, 500) });
+                        if (results.length >= maxSearchResults)
+                            break;
+                    }
+                }
+                return { query, path, filesSearched: files, results, truncated: files >= maxSearchFiles || results.length >= maxSearchResults };
+            },
+        }),
+        defineTool({
+            name: standardToolNames.writeText,
+            version: "1.0.0",
+            description: "Create or replace one UTF-8 text file inside the approved workspace root.",
+            input: defineOutput({
+                name: "write-text-input",
+                jsonSchema: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"], additionalProperties: false },
+                parse(value) { return { path: stringField(value, "path"), content: stringField(value, "content", { allowEmpty: true }) }; },
+            }),
+            output: objectOutput,
+            risk: "write",
+            sideEffect: "idempotent",
+            requiredPermissions: ["filesystem:write"],
+            requiresApproval: true,
+            approvalCategory: "write",
+            approvalReason: "Allow this agent to create or replace a file inside the approved workspace.",
+            timeoutMs: 5_000,
+            async execute({ path, content }) {
+                if (new TextEncoder().encode(content).byteLength > maxFileBytes)
+                    throw new RangeError(`Content exceeds the ${maxFileBytes} byte write limit.`);
+                const file = await workspace.writable(path);
+                const temporary = resolve(dirname(file), `.${basename(file)}.${crypto.randomUUID()}.tmp`);
+                await writeFile(temporary, content, { encoding: "utf8", mode: 0o600 });
+                await rename(temporary, file);
+                return { path, bytes: new TextEncoder().encode(content).byteLength };
+            },
+        }),
+        defineTool({
+            name: standardToolNames.applyTextEdits,
+            version: "1.0.0",
+            description: "Apply exact, deterministic text replacements to one workspace file.",
+            input: defineOutput({
+                name: "apply-text-edits-input",
+                jsonSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string" },
+                        edits: { type: "array", minItems: 1, maxItems: 100, items: { type: "object", properties: { find: { type: "string" }, replace: { type: "string" }, all: { type: "boolean" } }, required: ["find", "replace"], additionalProperties: false } },
+                    },
+                    required: ["path", "edits"],
+                    additionalProperties: false,
+                },
+                parse(value) {
+                    const input = record(value, "Text edit input");
+                    if (!Array.isArray(input.edits) || input.edits.length < 1 || input.edits.length > 100)
+                        throw new TypeError("edits must contain between 1 and 100 entries.");
+                    const edits = input.edits.map((item) => {
+                        const edit = record(item, "Text edit");
+                        if (typeof edit.find !== "string" || !edit.find)
+                            throw new TypeError("Each edit find value must be non-empty.");
+                        if (typeof edit.replace !== "string")
+                            throw new TypeError("Each edit replace value must be a string.");
+                        if (edit.all !== undefined && typeof edit.all !== "boolean")
+                            throw new TypeError("Each edit all value must be a boolean.");
+                        return { find: edit.find, replace: edit.replace, all: edit.all === true };
+                    });
+                    return { path: stringField(value, "path"), edits };
+                },
+            }),
+            output: objectOutput,
+            risk: "write",
+            sideEffect: "non-idempotent",
+            requiredPermissions: ["filesystem:write"],
+            requiresApproval: true,
+            approvalCategory: "write",
+            approvalReason: "Allow this agent to apply reviewed text edits inside the approved workspace.",
+            timeoutMs: 5_000,
+            async execute({ path, edits }) {
+                const file = await workspace.existing(path);
+                let content = await readBoundedText(file);
+                for (const edit of edits) {
+                    const occurrences = content.split(edit.find).length - 1;
+                    if (occurrences === 0)
+                        throw new TypeError("An expected edit target was not found.");
+                    if (!edit.all && occurrences !== 1)
+                        throw new TypeError("An edit target is ambiguous; set all only when every occurrence should change.");
+                    content = edit.all ? content.split(edit.find).join(edit.replace) : content.replace(edit.find, edit.replace);
+                }
+                if (new TextEncoder().encode(content).byteLength > maxFileBytes)
+                    throw new RangeError(`Edited content exceeds the ${maxFileBytes} byte limit.`);
+                const temporary = resolve(dirname(file), `.${basename(file)}.${crypto.randomUUID()}.tmp`);
+                await writeFile(temporary, content, { encoding: "utf8", mode: 0o600 });
+                await rename(temporary, file);
+                return { path, editsApplied: edits.length, bytes: new TextEncoder().encode(content).byteLength };
+            },
+        }),
+    ];
+}
+async function execute(command, args, options) {
+    try {
+        const result = await execFileAsync(command, [...args], { cwd: options.cwd, signal: options.signal, timeout: options.timeout, env: options.env, maxBuffer: options.maxBuffer, encoding: "utf8" });
+        return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
+    }
+    catch (error) {
+        const failure = error;
+        return { stdout: failure.stdout ?? "", stderr: failure.stderr ?? failure.message, exitCode: typeof failure.code === "number" ? failure.code : 1 };
+    }
+}
+export async function createDevelopmentTools(options) {
+    const workspace = await BoundedWorkspace.create(options.rootPath);
+    const allowedCommands = new Set(options.allowedCommands.map((item) => item.trim()).filter(Boolean));
+    if (!allowedCommands.size)
+        throw new TypeError("Development tools require an explicit command allowlist.");
+    const maxOutputBytes = options.maxOutputBytes ?? 512_000;
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const output = defineOutput({ name: "process-output", jsonSchema: { type: "object" }, parse(value) { return record(value, "Process output"); } });
+    const bounded = (value) => value.length > maxOutputBytes ? value.slice(0, maxOutputBytes) : value;
+    const environment = { ...options.environment };
+    for (const key of options.inheritedEnvironment ?? ["PATH", "TMPDIR", "LANG", "LC_ALL", "TERM"]) {
+        if (process.env[key] !== undefined)
+            environment[key] = process.env[key];
+    }
+    const git = async (args, signal) => {
+        const result = await execute("git", ["-C", workspace.rootPath, ...args], { cwd: workspace.rootPath, signal, timeout: timeoutMs, env: environment, maxBuffer: maxOutputBytes });
+        return { ...result, stdout: bounded(result.stdout), stderr: bounded(result.stderr), truncated: result.stdout.length > maxOutputBytes || result.stderr.length > maxOutputBytes };
+    };
+    return [
+        defineTool({
+            name: standardToolNames.gitStatus,
+            version: "1.0.0",
+            description: "Read concise Git working-tree status for the approved workspace.",
+            input: defineOutput({ name: "git-status-input", jsonSchema: { type: "object", additionalProperties: false }, parse: () => ({}) }),
+            output,
+            risk: "read",
+            sideEffect: "none",
+            requiredPermissions: ["git:read"],
+            requiresApproval: false,
+            timeoutMs,
+            execute(_, context) { return git(["status", "--short", "--branch"], context.abortSignal); },
+        }),
+        defineTool({
+            name: standardToolNames.gitDiff,
+            version: "1.0.0",
+            description: "Read a bounded Git diff for the approved workspace.",
+            input: defineOutput({
+                name: "git-diff-input",
+                jsonSchema: { type: "object", properties: { staged: { type: "boolean" } }, additionalProperties: false },
+                parse(value) {
+                    const input = record(value, "Git diff input");
+                    if (input.staged !== undefined && typeof input.staged !== "boolean")
+                        throw new TypeError("staged must be a boolean.");
+                    return { staged: input.staged === true };
+                },
+            }),
+            output,
+            risk: "read",
+            sideEffect: "none",
+            requiredPermissions: ["git:read"],
+            requiresApproval: false,
+            timeoutMs,
+            execute({ staged }, context) { return git(["diff", ...(staged ? ["--staged"] : []), "--no-ext-diff"], context.abortSignal); },
+        }),
+        defineTool({
+            name: standardToolNames.runCommand,
+            version: "1.0.0",
+            description: "Run one argument-array command from an explicit host allowlist with cwd constrained to the approved workspace.",
+            input: defineOutput({
+                name: "run-command-input",
+                jsonSchema: {
+                    type: "object",
+                    properties: { command: { type: "string" }, args: { type: "array", items: { type: "string" }, maxItems: 100 }, cwd: { type: "string" } },
+                    required: ["command"],
+                    additionalProperties: false,
+                },
+                parse(value) {
+                    const input = record(value, "Command input");
+                    const command = stringField(value, "command");
+                    if (!allowedCommands.has(command))
+                        throw new TypeError(`Command ${command} is not in the host allowlist.`);
+                    if (input.args !== undefined && (!Array.isArray(input.args) || input.args.some((item) => typeof item !== "string") || input.args.length > 100))
+                        throw new TypeError("args must contain at most 100 strings.");
+                    return { command, args: input.args ?? [], cwd: input.cwd === undefined ? "." : stringField(value, "cwd") };
+                },
+            }),
+            output,
+            risk: "privileged",
+            sideEffect: "non-idempotent",
+            requiredPermissions: ["process:execute"],
+            requiresApproval: true,
+            approvalCategory: "command",
+            approvalReason: "Allow this agent to execute an allowlisted command inside the approved workspace.",
+            timeoutMs,
+            async execute({ command, args, cwd }, context) {
+                const workingDirectory = await workspace.existing(cwd);
+                if (!(await stat(workingDirectory)).isDirectory())
+                    throw new TypeError("Command cwd must be a directory.");
+                const result = await execute(command, args, { cwd: workingDirectory, signal: context.abortSignal, timeout: timeoutMs, env: environment, maxBuffer: maxOutputBytes });
+                return { ...result, stdout: bounded(result.stdout), stderr: bounded(result.stderr), truncated: result.stdout.length > maxOutputBytes || result.stderr.length > maxOutputBytes };
+            },
+        }),
+    ];
+}
+export async function createWorkspaceTools(options) {
+    const filesystem = await createFilesystemTools(options);
+    if (!options.allowedCommands?.length)
+        return filesystem;
+    return [...filesystem, ...await createDevelopmentTools({
+            rootPath: options.rootPath,
+            allowedCommands: options.allowedCommands,
+            inheritedEnvironment: options.inheritedEnvironment,
+            environment: options.environment,
+            maxOutputBytes: options.maxOutputBytes,
+            timeoutMs: options.timeoutMs,
+        })];
+}
+//# sourceMappingURL=index.js.map