@ikarmic/forge-core 4.5.0 → 5.1.0

package/dist/steering/folder-instructions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The `AGENTS.md` of every folder between the workspace root and the file just read (nearest first), each shown
+ * once per run. The root one is already in the system prompt, so it is never repeated here.
+ */
+export declare function folderInstructionsFor(filePath: string, cwd: string, shown: Set<string>): Promise<Array<{
+    file: string;
+    text: string;
+}> | undefined>;

package/dist/steering/folder-instructions.js

@@ -0,0 +1,28 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+const MAX_BYTES = 8_000;
+/**
+ * The `AGENTS.md` of every folder between the workspace root and the file just read (nearest first), each shown
+ * once per run. The root one is already in the system prompt, so it is never repeated here.
+ */
+export async function folderInstructionsFor(filePath, cwd, shown) {
+    const root = path.resolve(cwd);
+    let dir = path.dirname(path.resolve(filePath));
+    const out = [];
+    while (dir !== root && dir.startsWith(root + path.sep)) {
+        const abs = path.join(dir, 'AGENTS.md');
+        if (!shown.has(abs)) {
+            try {
+                const text = (await readFile(abs, 'utf8')).trim();
+                shown.add(abs);
+                if (text)
+                    out.push({ file: path.relative(root, abs), text: text.length > MAX_BYTES ? `${text.slice(0, MAX_BYTES)}\n…(truncated)` : text });
+            }
+            catch {
+                shown.add(abs);
+            }
+        }
+        dir = path.dirname(dir);
+    }
+    return out.length ? out : undefined;
+}

package/dist/steering/glob.d.ts

@@ -12,4 +12,3 @@
  * Spec: docs/superpowers/specs/2026-09-29-steering-files-design.md §5.1
  */
 export declare function pathMatchesGlob(rawPattern: string, relPath: string): boolean;
-//# sourceMappingURL=glob.d.ts.map

package/dist/steering/glob.js

@@ -88,4 +88,3 @@ export function pathMatchesGlob(rawPattern, relPath) {
     const subject = pattern.includes('/') ? relPath : relPath.slice(relPath.lastIndexOf('/') + 1);
     return matchTokens(tokenize(pattern), subject);
 }
-//# sourceMappingURL=glob.js.map

package/dist/steering/index.d.ts

@@ -4,4 +4,3 @@ export { isSafeSteeringName, loadSteering, overrideFilePath, parseSteering, read
 export { MAX_TOOL_INJECTIONS, START_BUDGET_BYTES, TOOL_DOC_BYTES, formatSteeringLine, selectAtStart, selectOnToolTouch, stripSteering, toWorkspaceRelative, wrapSteering, } from './select.js';
 export type { StartSelection } from './select.js';
 export type { SteeringConfig, SteeringDoc, SteeringInclusion, SteeringLoadResult, SteeringSkip } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/steering/index.js

@@ -2,4 +2,3 @@
 export { pathMatchesGlob } from './glob.js';
 export { isSafeSteeringName, loadSteering, overrideFilePath, parseSteering, readOverride, setSteeringDisabled, } from './loader.js';
 export { MAX_TOOL_INJECTIONS, START_BUDGET_BYTES, TOOL_DOC_BYTES, formatSteeringLine, selectAtStart, selectOnToolTouch, stripSteering, toWorkspaceRelative, wrapSteering, } from './select.js';
-//# sourceMappingURL=index.js.map

package/dist/steering/loader.d.ts

@@ -12,4 +12,3 @@ export declare function loadSteering(cwd: string, opts?: {
     includeProject?: boolean;
     homeDir?: string;
 }): Promise<SteeringLoadResult>;
-//# sourceMappingURL=loader.d.ts.map

package/dist/steering/loader.js

@@ -150,4 +150,3 @@ export async function loadSteering(cwd, opts = {}) {
         .sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
     return { docs, warnings };
 }
-//# sourceMappingURL=loader.js.map

package/dist/steering/project-instructions.d.ts

@@ -1,4 +1,3 @@
 export declare const PROJECT_INSTRUCTION_FILES: readonly ["AGENTS.md", "CLAUDE.md", "CONVENTIONS.md"];
 export declare const MAX_INSTRUCTION_BYTES = 16000;
 export declare function buildProjectInstructionsBlock(cwd: string): Promise<string>;
-//# sourceMappingURL=project-instructions.d.ts.map

package/dist/steering/project-instructions.js

@@ -25,4 +25,3 @@ export async function buildProjectInstructionsBlock(cwd) {
     }
     return blocks.join('\n\n');
 }
-//# sourceMappingURL=project-instructions.js.map

package/dist/steering/select.d.ts

@@ -26,4 +26,3 @@ export declare function formatSteeringLine(e: {
     skipped: SteeringSkip[];
     path?: string;
 }): string;
-//# sourceMappingURL=select.d.ts.map

package/dist/steering/select.js

@@ -4,6 +4,7 @@
  */
 import path from 'node:path';
 import { pathMatchesGlob } from './glob.js';
+import { isOutsideRel } from '../tools/shared.js';
 export const START_BUDGET_BYTES = 12_000;
 export const TOOL_DOC_BYTES = 8_000;
 export const MAX_TOOL_INJECTIONS = 3;
@@ -19,7 +20,7 @@ export function stripSteering(text) {
 export function toWorkspaceRelative(cwd, p) {
     const abs = path.resolve(cwd, p);
     const rel = path.relative(cwd, abs);
-    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+    if (!rel || isOutsideRel(rel))
         return null;
     return rel.split(path.sep).join('/');
 }
@@ -94,4 +95,3 @@ export function formatSteeringLine(e) {
     const skipped = e.skipped.length > 0 ? ` · skipped: ${e.skipped.map((s) => `${s.name} (${s.reason})`).join(', ')}` : '';
     return `${head}: ${applied}${skipped}`;
 }
-//# sourceMappingURL=select.js.map

package/dist/steering/types.d.ts

@@ -32,4 +32,3 @@ export interface SteeringSkip {
     name: string;
     reason: 'budget' | 'cap';
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/steering/types.js

@@ -1,3 +1,2 @@
 /** Steering files (SP3a). Spec: docs/superpowers/specs/2026-09-29-steering-files-design.md §5.1 */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/structured/index.d.ts

@@ -16,4 +16,3 @@ export type { ZodTypeAny } from 'zod';
 export { formatZodError, jsonSchemaToZod, loadSchemaFile, } from './schema.js';
 export { defaultRetryPrompt, isStructuredOutputError, runStructuredAgent, StructuredOutputError, validateFinalText, } from './retry.js';
 export type { StructuredRunOptions, StructuredRunResult } from './retry.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/structured/index.js

@@ -1,3 +1,2 @@
 export { formatZodError, jsonSchemaToZod, loadSchemaFile, } from './schema.js';
 export { defaultRetryPrompt, isStructuredOutputError, runStructuredAgent, StructuredOutputError, validateFinalText, } from './retry.js';
-//# sourceMappingURL=index.js.map

package/dist/structured/retry.d.ts

@@ -131,4 +131,3 @@ export declare class StructuredOutputError extends Error {
  */
 export declare function isStructuredOutputError(err: unknown): err is StructuredOutputError;
 export { z };
-//# sourceMappingURL=retry.d.ts.map

package/dist/structured/retry.js

@@ -200,4 +200,3 @@ export function isStructuredOutputError(err) {
 }
 // Re-export so callers don't need a second import.
 export { z };
-//# sourceMappingURL=retry.js.map

package/dist/structured/schema.d.ts

@@ -60,4 +60,3 @@ export declare function jsonSchemaToZod(schema: Record<string, unknown>): ZodTyp
  * Paths use JSON Pointer-ish dotted notation; values are quoted.
  */
 export declare function formatZodError(err: ZodError): string;
-//# sourceMappingURL=schema.d.ts.map

package/dist/structured/schema.js

@@ -291,4 +291,3 @@ function describeReceived(issue) {
         return '';
     return JSON.stringify(issue.received);
 }
-//# sourceMappingURL=schema.js.map

package/dist/timed-fetch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wraps `fetch` with the two timeouts Kilo calls `timeout` and `chunkTimeout`:
+ * - `timeoutMs`: how long to wait for the response to start (headers). It stops counting once the answer begins,
+ *   so a slow stream is never cut short by it.
+ * - `chunkTimeoutMs`: how long a streamed answer may stay silent. A stalled stream is aborted with a clear error
+ *   instead of hanging forever (a connection can stay open while the provider has stopped sending).
+ */
+export interface FetchTimeouts {
+    timeoutMs?: number;
+    chunkTimeoutMs?: number;
+}
+export declare function withTimeouts(base: typeof fetch, opts: FetchTimeouts): typeof fetch;

package/dist/timed-fetch.js

@@ -0,0 +1,83 @@
+export function withTimeouts(base, opts) {
+    const { timeoutMs, chunkTimeoutMs } = opts;
+    if (!timeoutMs && !chunkTimeoutMs)
+        return base;
+    return (async (input, init) => {
+        const controller = new AbortController();
+        const outer = init?.signal;
+        if (outer?.aborted)
+            controller.abort();
+        else
+            outer?.addEventListener('abort', () => controller.abort(), { once: true });
+        let reason;
+        const host = (() => {
+            try {
+                return new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url).host;
+            }
+            catch {
+                return 'the provider';
+            }
+        })();
+        const fail = (message) => {
+            reason = new Error(message);
+            controller.abort();
+        };
+        const headerTimer = timeoutMs ? setTimeout(() => fail(`The request to ${host} timed out after ${timeoutMs} ms.`), timeoutMs) : undefined;
+        let res;
+        try {
+            res = await base(input, { ...init, signal: controller.signal });
+        }
+        catch (err) {
+            throw reason ?? err;
+        }
+        finally {
+            if (headerTimer)
+                clearTimeout(headerTimer);
+        }
+        if (!chunkTimeoutMs || !res.body)
+            return res;
+        const reader = res.body.getReader();
+        let idle;
+        const arm = (onIdle) => {
+            if (idle)
+                clearTimeout(idle);
+            idle = setTimeout(onIdle, chunkTimeoutMs);
+        };
+        const body = new ReadableStream({
+            start(stream) {
+                arm(() => {
+                    fail(`No data for ${chunkTimeoutMs} ms from ${host}.`);
+                    stream.error(reason);
+                });
+            },
+            async pull(stream) {
+                try {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        if (idle)
+                            clearTimeout(idle);
+                        stream.close();
+                        return;
+                    }
+                    arm(() => {
+                        fail(`No data for ${chunkTimeoutMs} ms from ${host}.`);
+                        stream.error(reason);
+                        void reader.cancel().catch(() => undefined);
+                    });
+                    stream.enqueue(value);
+                }
+                catch (err) {
+                    if (idle)
+                        clearTimeout(idle);
+                    stream.error(reason ?? err);
+                }
+            },
+            cancel(why) {
+                if (idle)
+                    clearTimeout(idle);
+                return reader.cancel(why);
+            },
+        });
+        return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+    });
+}

package/dist/tools/apply-patch.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const params: z.ZodObject<{
+    patch: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    patch: string;
+}, {
+    patch: string;
+}>;
+export type PatchOp = {
+    kind: 'add';
+    path: string;
+    content: string;
+} | {
+    kind: 'delete';
+    path: string;
+} | {
+    kind: 'update';
+    path: string;
+    hunks: Array<{
+        lines: Array<{
+            tag: ' ' | '-' | '+';
+            text: string;
+        }>;
+    }>;
+};
+/** Parse the patch text into operations. Throws on a malformed patch. */
+export declare function parsePatch(text: string): PatchOp[];
+/** Every path a patch touches, once each; empty when the text is not a valid patch (callers then fall back to the broadest target). */
+export declare function patchedPaths(patch: string): string[];
+export interface PatchPreview {
+    path: string;
+    /** Text before the patch; null when the file does not exist yet. */
+    before: string | null;
+    /** Text after the patch; null when the patch deletes the file. */
+    after: string | null;
+    /** Why this file's change could not be worked out (a hunk that does not match). */
+    error?: string;
+}
+/**
+ * What an `apply_patch` call would leave in each file, worked out in memory so it can be shown before it is approved.
+ * Never writes. Throws only for a patch that cannot be parsed at all.
+ */
+export declare function previewPatch(patch: string, read: (path: string) => Promise<string | null>): Promise<PatchPreview[]>;
+export interface ApplyPatchResult {
+    files: Array<{
+        action: 'add' | 'update' | 'delete';
+        path: string;
+    }>;
+}
+export declare const applyPatchTool: ToolDefinition<z.infer<typeof params>, ApplyPatchResult>;
+export {};

package/dist/tools/apply-patch.js

@@ -0,0 +1,197 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { resolveAndCheckPath } from './shared.js';
+import { decodeText, encodeText } from './text-encoding.js';
+const params = z.object({
+    patch: z
+        .string()
+        .min(1)
+        .describe('The patch. Starts with "*** Begin Patch", ends with "*** End Patch". Between them, per file: "*** Add File: path" followed by lines starting with +; "*** Delete File: path"; or "*** Update File: path" followed by hunks that begin with "@@" and whose lines start with a space (kept), - (removed) or + (added).'),
+});
+/** Parse the patch text into operations. Throws on a malformed patch. */
+export function parsePatch(text) {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    while (lines.length && lines[0].trim() === '')
+        lines.shift();
+    while (lines.length && lines[lines.length - 1].trim() === '')
+        lines.pop();
+    if (lines[0]?.trim() !== '*** Begin Patch' || lines[lines.length - 1]?.trim() !== '*** End Patch') {
+        throw new Error('A patch must start with "*** Begin Patch" and end with "*** End Patch".');
+    }
+    const body = lines.slice(1, -1);
+    const ops = [];
+    let i = 0;
+    while (i < body.length) {
+        const line = body[i];
+        if (line.trim() === '') {
+            i++;
+            continue;
+        }
+        const add = /^\*\*\* Add File: (.+)$/.exec(line);
+        const del = /^\*\*\* Delete File: (.+)$/.exec(line);
+        const upd = /^\*\*\* Update File: (.+)$/.exec(line);
+        if (add) {
+            const content = [];
+            i++;
+            while (i < body.length && !body[i].startsWith('*** ')) {
+                const l = body[i];
+                if (!l.startsWith('+'))
+                    throw new Error(`Add File ${add[1]}: every line must start with + (got "${l.slice(0, 40)}").`);
+                content.push(l.slice(1));
+                i++;
+            }
+            ops.push({ kind: 'add', path: add[1].trim(), content: content.length ? `${content.join('\n')}\n` : '' });
+        }
+        else if (del) {
+            ops.push({ kind: 'delete', path: del[1].trim() });
+            i++;
+        }
+        else if (upd) {
+            const hunks = [];
+            i++;
+            while (i < body.length && !body[i].startsWith('*** ')) {
+                if (body[i].startsWith('@@')) {
+                    hunks.push({ lines: [] });
+                    i++;
+                    continue;
+                }
+                const l = body[i];
+                const tag = l[0];
+                if (tag !== ' ' && tag !== '-' && tag !== '+')
+                    throw new Error(`Update File ${upd[1]}: bad hunk line "${l.slice(0, 40)}" (start with space, - or +).`);
+                if (hunks.length === 0)
+                    hunks.push({ lines: [] });
+                hunks[hunks.length - 1].lines.push({ tag, text: l.slice(1) });
+                i++;
+            }
+            if (hunks.length === 0)
+                throw new Error(`Update File ${upd[1]} has no hunks.`);
+            ops.push({ kind: 'update', path: upd[1].trim(), hunks });
+        }
+        else {
+            throw new Error(`Unknown patch directive: "${line.slice(0, 60)}"`);
+        }
+    }
+    if (ops.length === 0)
+        throw new Error('The patch has no operations.');
+    return ops;
+}
+/** Every path a patch touches, once each; empty when the text is not a valid patch (callers then fall back to the broadest target). */
+export function patchedPaths(patch) {
+    try {
+        return [...new Set(parsePatch(patch).map((o) => o.path))];
+    }
+    catch {
+        return [];
+    }
+}
+function indexOfSeq(hay, needle, from, norm) {
+    if (needle.length === 0)
+        return from;
+    outer: for (let s = from; s <= hay.length - needle.length; s++) {
+        for (let k = 0; k < needle.length; k++)
+            if (norm(hay[s + k]) !== norm(needle[k]))
+                continue outer;
+        return s;
+    }
+    return -1;
+}
+/** Apply update hunks to file text, in order, each searching after the previous one. Exact match first, then ignoring trailing whitespace. */
+function applyHunks(file, original, hunks) {
+    const eol = original.includes('\r\n') ? '\r\n' : '\n';
+    const endsWithNewline = original.endsWith('\n');
+    const lines = original.replace(/\r\n/g, '\n').split('\n');
+    if (endsWithNewline)
+        lines.pop();
+    let cursor = 0;
+    for (const [n, hunk] of hunks.entries()) {
+        const oldSeq = hunk.lines.filter((l) => l.tag !== '+').map((l) => l.text);
+        const newSeq = hunk.lines.filter((l) => l.tag !== '-').map((l) => l.text);
+        let at = indexOfSeq(lines, oldSeq, cursor, (s) => s);
+        if (at === -1)
+            at = indexOfSeq(lines, oldSeq, cursor, (s) => s.trimEnd());
+        if (at === -1)
+            throw new Error(`Hunk ${n + 1} of ${file} did not match the file. Re-read it and make the context lines exact.`);
+        lines.splice(at, oldSeq.length, ...newSeq);
+        cursor = at + newSeq.length;
+    }
+    return lines.join(eol) + (endsWithNewline ? eol : '');
+}
+/**
+ * What an `apply_patch` call would leave in each file, worked out in memory so it can be shown before it is approved.
+ * Never writes. Throws only for a patch that cannot be parsed at all.
+ */
+export async function previewPatch(patch, read) {
+    const out = [];
+    for (const op of parsePatch(patch)) {
+        const before = await read(op.path);
+        if (op.kind === 'add')
+            out.push({ path: op.path, before, after: op.content });
+        else if (op.kind === 'delete')
+            out.push({ path: op.path, before, after: null });
+        else if (before === null)
+            out.push({ path: op.path, before, after: null, error: `File not found: ${op.path}` });
+        else {
+            try {
+                out.push({ path: op.path, before, after: applyHunks(op.path, before, op.hunks) });
+            }
+            catch (err) {
+                out.push({ path: op.path, before, after: null, error: err.message });
+            }
+        }
+    }
+    return out;
+}
+export const applyPatchTool = {
+    name: 'apply_patch',
+    description: 'Change several files in one step with a patch: add files, delete files, or update files by hunks of context and changed lines. All or nothing: if one hunk does not match, no file is touched. Prefer edit_file for a single small change.',
+    parameters: params,
+    destructive: false,
+    execute: async (args, ctx) => {
+        const ops = parsePatch(args.patch);
+        // Plan every change in memory first, so a bad hunk leaves the workspace as it was.
+        const writes = new Map();
+        const encodings = new Map();
+        const deletes = new Set();
+        const files = [];
+        for (const op of ops) {
+            const abs = resolveAndCheckPath(op.path, ctx);
+            const rel = op.path.split(String.fromCharCode(92)).join('/');
+            if (op.kind === 'add') {
+                const exists = await readFile(abs, 'utf8').then(() => true, () => false);
+                if ((exists && !deletes.has(abs)) || writes.has(abs))
+                    throw new Error(`Cannot add ${op.path}: it already exists.`);
+                writes.set(abs, op.content);
+                files.push({ action: 'add', path: rel });
+            }
+            else if (op.kind === 'delete') {
+                await readFile(abs, 'utf8').catch(() => {
+                    throw new Error(`Cannot delete ${op.path}: file not found.`);
+                });
+                deletes.add(abs);
+                writes.delete(abs);
+                files.push({ action: 'delete', path: rel });
+            }
+            else {
+                let current = writes.get(abs);
+                if (current === undefined) {
+                    const decoded = await readFile(abs).then(decodeText, () => {
+                        throw new Error(`Cannot update ${op.path}: file not found.`);
+                    });
+                    current = decoded.text;
+                    encodings.set(abs, decoded.encoding);
+                }
+                writes.set(abs, applyHunks(op.path, current, op.hunks));
+                files.push({ action: 'update', path: rel });
+            }
+        }
+        for (const abs of deletes)
+            await rm(abs);
+        for (const [abs, content] of writes) {
+            await mkdir(path.dirname(abs), { recursive: true });
+            await writeFile(abs, encodeText(content, encodings.get(abs) ?? 'utf8'));
+        }
+        return { files };
+    },
+};

package/dist/tools/ask-user.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+/**
+ * Ask the person a question with optional choices. The agent only offers this tool when a surface can answer
+ * (AgentConfig.askUser) and the run is not autonomous; if it is called anyway, or the run is stopped while the
+ * question is open, it returns a result that tells the model to carry on with the safest option.
+ */
+declare const params: z.ZodObject<{
+    question: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowCustom: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    question: string;
+    options?: string[] | undefined;
+    allowCustom?: boolean | undefined;
+}, {
+    question: string;
+    options?: string[] | undefined;
+    allowCustom?: boolean | undefined;
+}>;
+export interface AskUserResult {
+    answer: string;
+    unavailable?: boolean;
+    note?: string;
+}
+export declare const askUserTool: ToolDefinition<z.infer<typeof params>, AskUserResult>;
+export {};

package/dist/tools/ask-user.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * Ask the person a question with optional choices. The agent only offers this tool when a surface can answer
+ * (AgentConfig.askUser) and the run is not autonomous; if it is called anyway, or the run is stopped while the
+ * question is open, it returns a result that tells the model to carry on with the safest option.
+ */
+const params = z.object({
+    question: z.string().min(1).max(1000).describe('One clear question.'),
+    options: z.array(z.string().min(1).max(200)).max(8).optional().describe('Suggested answers to pick from.'),
+    allowCustom: z.boolean().optional().describe('Let the person type their own answer. Default true.'),
+});
+const UNAVAILABLE = {
+    answer: '',
+    unavailable: true,
+    note: 'No user is available. Choose the safest reasonable option and say what you assumed.',
+};
+export const askUserTool = {
+    name: 'ask_user',
+    description: 'Ask the user a clarifying question when you cannot proceed safely without their answer. Give a few options when you can. Do not ask for permission to run tools; approvals are handled separately.',
+    parameters: params,
+    noApproval: true,
+    execute: async (args, ctx) => {
+        if (!ctx.askUser || ctx.auto)
+            return UNAVAILABLE;
+        const signal = ctx.abortSignal;
+        if (signal?.aborted)
+            return UNAVAILABLE;
+        const answered = ctx.askUser(args, signal).then((answer) => ({ answer }));
+        const aborted = new Promise((resolve) => signal?.addEventListener('abort', () => resolve(UNAVAILABLE), { once: true }));
+        return Promise.race([answered, aborted]);
+    },
+};

package/dist/tools/browser-tools.d.ts

@@ -7,10 +7,10 @@ declare const observeParams: z.ZodObject<{
     action: z.ZodEnum<["open", "screenshot", "text", "console", "close"]>;
     url: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    action: "close" | "open" | "text" | "screenshot" | "console";
+    action: "close" | "text" | "open" | "screenshot" | "console";
     url?: string | undefined;
 }, {
-    action: "close" | "open" | "text" | "screenshot" | "console";
+    action: "close" | "text" | "open" | "screenshot" | "console";
     url?: string | undefined;
 }>;
 export type BrowserResult = {
@@ -55,24 +55,23 @@ declare const actParams: z.ZodEffects<z.ZodObject<{
     expression: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     action: "type" | "click" | "evaluate";
-    expression?: string | undefined;
     text?: string | undefined;
+    expression?: string | undefined;
     selector?: string | undefined;
 }, {
     action: "type" | "click" | "evaluate";
-    expression?: string | undefined;
     text?: string | undefined;
+    expression?: string | undefined;
     selector?: string | undefined;
 }>, {
     action: "type" | "click" | "evaluate";
-    expression?: string | undefined;
     text?: string | undefined;
+    expression?: string | undefined;
     selector?: string | undefined;
 }, {
     action: "type" | "click" | "evaluate";
-    expression?: string | undefined;
     text?: string | undefined;
+    expression?: string | undefined;
     selector?: string | undefined;
 }>;
 export {};
-//# sourceMappingURL=browser-tools.d.ts.map

package/dist/tools/browser-tools.js

@@ -13,6 +13,7 @@ import { lookup } from 'node:dns/promises';
 import net from 'node:net';
 import { z } from 'zod';
 import { redact } from './redact.js';
+import { isBlockedAddress } from './fetch-url.js';
 import { checkPolicyViolation } from './policy.js';
 function isLoopback(ip) {
     if (net.isIPv4(ip))
@@ -20,20 +21,9 @@ function isLoopback(ip) {
     const lower = ip.toLowerCase();
     return lower === '::1' || lower === '::ffff:127.0.0.1';
 }
+/** Private, link-local or otherwise internal: the same list as `fetch_url`, minus loopback (a local dev server is the point here). */
 function isPrivateOrLinkLocal(ip) {
-    if (net.isIPv4(ip)) {
-        const [a, b] = ip.split('.').map(Number);
-        return a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 169 && b === 254) || a === 0;
-    }
-    if (net.isIPv6(ip)) {
-        const lower = ip.toLowerCase();
-        const mapped = lower.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
-        if (mapped)
-            return isPrivateOrLinkLocal(mapped[1]);
-        const first = parseInt(lower.split(':')[0] ?? '', 16);
-        return (!Number.isNaN(first) && first >= 0xfe80 && first <= 0xfebf) || lower.startsWith('fc') || lower.startsWith('fd');
-    }
-    return false;
+    return isBlockedAddress(ip) && !isLoopback(ip);
 }
 /** Throws unless `rawUrl` is an http(s) URL the browser may visit. */
 export async function assertBrowsableUrl(rawUrl, policy) {
@@ -136,4 +126,3 @@ const actParams = z
     if (v.action === 'evaluate' && !v.expression)
         ctx.addIssue({ code: 'custom', message: 'expression is required' });
 });
-//# sourceMappingURL=browser-tools.js.map