@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/core/tools/read-image.js

@@ -0,0 +1,98 @@
+import { readFileSync, statSync } from "node:fs";
+import { WorkspaceSandbox } from "./workspace-sandbox.js";
+const MEDIA_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+};
+/** Magic-byte sniffing: extension lies often enough to reject valid files. */
+function sniffMediaType(bytes) {
+    if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)
+        return "image/png";
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff)
+        return "image/jpeg";
+    if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46)
+        return "image/gif";
+    const riff = String.fromCharCode(...bytes.slice(0, 4));
+    const webp = String.fromCharCode(...bytes.slice(8, 12));
+    if (riff === "RIFF" && webp === "WEBP")
+        return "image/webp";
+    return undefined;
+}
+/** Max image bytes returned to the model (base64 inflates ~1.33x). */
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+/** read_image: return a workspace image as a vision tool result block. */
+export function createReadImageTool(opts) {
+    const { cwd } = opts;
+    const sandbox = new WorkspaceSandbox(cwd);
+    return {
+        name: "read_image",
+        description: "Read an image file (png/jpeg/gif/webp) from the workspace and attach it for vision analysis. " +
+            "Use this instead of `read` when the goal is to understand an image (screenshots, diagrams, photos).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Path to the image file, relative to workspace root",
+                },
+            },
+            required: ["path"],
+        },
+        async execute(input, _signal) {
+            const args = input;
+            const raw = args.path;
+            if (typeof raw !== "string" || raw.trim() === "") {
+                return { content: "Error: path is required", isError: true };
+            }
+            let abs;
+            try {
+                // validate() resolves + realpath-checks, catching sibling-prefix
+                // paths and symlinks pointing outside the workspace.
+                abs = sandbox.validate(raw);
+            }
+            catch {
+                return { content: `Error: path escapes workspace: ${raw}`, isError: true };
+            }
+            try {
+                const st = statSync(abs);
+                if (!st.isFile())
+                    return { content: `Error: not a file: ${raw}`, isError: true };
+                if (st.size > MAX_IMAGE_BYTES) {
+                    return {
+                        content: `Error: image too large (${st.size} bytes > 5MB)`,
+                        isError: true,
+                    };
+                }
+                const bytes = new Uint8Array(readFileSync(abs));
+                const ext = abs.slice(abs.lastIndexOf(".")).toLowerCase();
+                const mediaType = sniffMediaType(bytes) ?? MEDIA_TYPES[ext];
+                if (!mediaType) {
+                    return { content: `Error: unsupported image format: ${raw}`, isError: true };
+                }
+                let binary = "";
+                for (const byte of bytes)
+                    binary += String.fromCharCode(byte);
+                return {
+                    content: `[image ${raw} attached for vision]`,
+                    mediaType,
+                    images: [
+                        {
+                            type: "image",
+                            mediaType: mediaType,
+                            base64: btoa(binary),
+                        },
+                    ],
+                };
+            }
+            catch (err) {
+                return {
+                    content: `Error: read_image failed: ${err instanceof Error ? err.message : String(err)}`,
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/dist/core/tools/skill.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from "../agent-runtime.js";
+export interface SkillOptions {
+    readonly roots: readonly string[];
+}
+/** Create the oma skill module: Meta index + skill_load tool.
+ *  Absorbed from @chengchenccc/plugin-progressive-skill; the shared index
+ *  builder now lives in ./skills.ts (tools-common merged into oma). Skill loading is
+ *  progressive by definition: the index stays in context, the body loads
+ *  on demand. */
+export declare function createSkill(opts: SkillOptions): Plugin;
+//# sourceMappingURL=skill.d.ts.map

package/dist/core/tools/skill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../../src/core/tools/skill.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAuB,MAAM,EAAc,MAAM,qBAAqB,CAAC;AAGnF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAWD;;;;iBAIiB;AACjB,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAmDtD"}

package/dist/core/tools/skill.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { buildSkillIndex } from "./index.js";
+function isWithinRoot(root, target) {
+    try {
+        const real = realpathSync(target);
+        return real === root || real.startsWith(`${root}/`);
+    }
+    catch {
+        return false;
+    }
+}
+/** Create the oma skill module: Meta index + skill_load tool.
+ *  Absorbed from @chengchenccc/plugin-progressive-skill; the shared index
+ *  builder now lives in ./skills.ts (tools-common merged into oma). Skill loading is
+ *  progressive by definition: the index stays in context, the body loads
+ *  on demand. */
+export function createSkill(opts) {
+    const index = buildSkillIndex(opts.roots);
+    const metaProvider = {
+        name: "Skills",
+        render() {
+            if (index.length === 0)
+                return "No skills available.";
+            return index.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+        },
+    };
+    const skillLoadTool = {
+        name: "skill_load",
+        description: "Load the full body of a skill by name. Only the name/description is in the index; use this to read the actual instructions. Relative paths in the body resolve against the returned `dir`.",
+        inputSchema: {
+            type: "object",
+            properties: { name: { type: "string", description: "Skill name from the index" } },
+            required: ["name"],
+        },
+        async execute(args) {
+            const name = args.name;
+            if (typeof name !== "string")
+                return { error: "Skill name must be a string" };
+            const entry = index.find((s) => s.name === name);
+            if (!entry)
+                return { error: `Skill "${name}" not found` };
+            const fullPath = resolve(entry.root, entry.relativePath);
+            if (!isWithinRoot(entry.root, fullPath)) {
+                return { error: "Path escape detected" };
+            }
+            if (!existsSync(fullPath))
+                return { error: `Skill file not found` };
+            const content = readFileSync(fullPath, "utf8");
+            const body = content.replace(/^---\n[\s\S]*?\n---\n?/, "");
+            const skillDir = fullPath.slice(0, fullPath.lastIndexOf("/"));
+            return {
+                name: entry.name,
+                dir: skillDir,
+                hint: "Resolve relative paths and scripts against `dir`.",
+                body: body.replaceAll("${SKILL_DIR}", skillDir),
+            };
+        },
+    };
+    return {
+        name: "progressive-skill",
+        tools: [skillLoadTool],
+        meta: [metaProvider],
+    };
+}

package/dist/core/tools/skills.d.ts

@@ -0,0 +1,10 @@
+export interface SkillIndexEntry {
+    readonly name: string;
+    readonly description: string;
+    readonly root: string;
+    readonly relativePath: string;
+}
+/** Scan configured roots for SKILL.md files, parse frontmatter for
+ *  name + description. Deterministic order by root then name. */
+export declare function buildSkillIndex(roots: readonly string[]): SkillIndexEntry[];
+//# sourceMappingURL=skills.d.ts.map

package/dist/core/tools/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../../src/core/tools/skills.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AA2BD;iEACiE;AACjE,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,eAAe,EAAE,CAgB3E"}

package/dist/core/tools/skills.js

@@ -0,0 +1,116 @@
+import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+function isWithinRoot(root, target) {
+    try {
+        const real = realpathSync(target);
+        return real === root || real.startsWith(`${root}/`);
+    }
+    catch {
+        return false;
+    }
+}
+/** Canonicalize a skill root: resolve symlinks so realpath(target) comparisons
+ *  work on platforms where the root itself is a symlink (e.g. macOS /tmp →
+ *  /private/tmp). Returns null if the root does not exist or is not a dir. */
+function canonicalRoot(root) {
+    try {
+        const real = realpathSync(root);
+        return statSync(real).isDirectory() ? real : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Safety bound: symlink containment + total entry count, not directory
+ *  depth — deep but bounded trees are legitimate skill packs. */
+const MAX_ENTRIES = 1000;
+/** Scan configured roots for SKILL.md files, parse frontmatter for
+ *  name + description. Deterministic order by root then name. */
+export function buildSkillIndex(roots) {
+    // Roots are ordered by precedence (earliest = highest priority for the
+    // Product Skill Pack contract). A later root overrides an earlier one for
+    // the same skill name; the final index keeps exactly one entry per name.
+    const byName = new Map();
+    for (const root of roots) {
+        const canonical = canonicalRoot(root);
+        if (!canonical)
+            continue;
+        const scanned = [];
+        scanDir(canonical, canonical, scanned);
+        for (const entry of scanned) {
+            byName.set(entry.name, entry);
+        }
+    }
+    // Deterministic Meta order: sort by name.
+    return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function scanDir(root, currentDir, entries) {
+    let items;
+    try {
+        items = readdirSync(currentDir);
+    }
+    catch {
+        return;
+    }
+    for (const item of items) {
+        if (entries.length >= MAX_ENTRIES) {
+            throw new Error("skill pack contains too many skills (limit 1000)");
+        }
+        const fullPath = join(currentDir, item);
+        if (!isWithinRoot(root, fullPath))
+            continue;
+        if (item === "SKILL.md") {
+            const parsed = parseFrontmatter(fullPath);
+            if (parsed) {
+                entries.push({
+                    name: parsed.name,
+                    description: parsed.description,
+                    root,
+                    relativePath: fullPath.slice(root.length + 1),
+                });
+            }
+            continue;
+        }
+        try {
+            if (statSync(fullPath).isDirectory())
+                scanDir(root, fullPath, entries);
+        }
+        catch {
+            /* not a dir */
+        }
+    }
+}
+function parseFrontmatter(path) {
+    try {
+        const content = readFileSync(path, "utf8");
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!match)
+            return null;
+        const frontmatter = match[1] ?? "";
+        const name = frontmatter.match(/name:\s*(.+)/)?.[1]?.trim();
+        if (!name)
+            return null;
+        return { name, description: parseDescription(frontmatter) };
+    }
+    catch {
+        return null;
+    }
+}
+/** Minimal YAML folded-block support for `description: >` / `description: |`:
+ *  join the following indented lines. Plain single-line descriptions are
+ *  returned unchanged. (No YAML parser dependency for two fields.) */
+function parseDescription(frontmatter) {
+    const line = frontmatter.match(/^description:\s*(.*)$/m)?.[1] ?? "";
+    const trimmed = line.trim();
+    if (trimmed !== ">" && trimmed !== "|")
+        return trimmed;
+    const lines = frontmatter.split("\n");
+    const index = lines.findIndex((l) => l.startsWith("description:"));
+    const body = [];
+    for (const l of lines.slice(index + 1)) {
+        if (!/^\s+/.test(l))
+            break;
+        body.push(l.trim());
+    }
+    return body.join(" ");
+}

package/dist/core/tools/todo-store.d.ts

@@ -0,0 +1,8 @@
+import type { SessionStore, TodoItem } from "../agent-runtime.js";
+export declare function readTodoFile(workspaceRoot: string): readonly TodoItem[];
+export declare function writeTodoFile(workspaceRoot: string, items: readonly TodoItem[]): void;
+/** SessionStore shim that satisfies the todo plugin's read/write contract,
+ *  but persists todo entries to the workspace file instead of the per-Run
+ *  in-memory branch. Every other SessionStore method is a no-op. */
+export declare function createFileTodoStore(workspaceRoot: string): SessionStore;
+//# sourceMappingURL=todo-store.d.ts.map

package/dist/core/tools/todo-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo-store.d.ts","sourceRoot":"","sources":["../../../src/core/tools/todo-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,YAAY,EACZ,QAAQ,EACT,MAAM,qBAAqB,CAAC;AAqB7B,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CAUvE;AAED,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI,CAIrF;AAED;;oEAEoE;AACpE,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,YAAY,CAyDvE"}

package/dist/core/tools/todo-store.js

@@ -0,0 +1,100 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** Standalone oma's local todo store: a single `.oma/todo.json` in the
+ *  workspace, so todo_write persists across TUI runs (unlike the per-Run
+ *  in-memory SessionStore that backend product tools use). Backend-invoked
+ *  RPC mode gets todo via the backend-injected MCP, never this file. */
+const TODO_REL_PATH = ".oma/todo.json";
+function isTodoItem(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "id" in value &&
+        typeof value.id === "string" &&
+        "text" in value &&
+        typeof value.text === "string" &&
+        "status" in value &&
+        typeof value.status === "string");
+}
+export function readTodoFile(workspaceRoot) {
+    const path = join(workspaceRoot, TODO_REL_PATH);
+    if (!existsSync(path))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!Array.isArray(parsed.items))
+            return [];
+        return parsed.items.filter(isTodoItem);
+    }
+    catch {
+        return [];
+    }
+}
+export function writeTodoFile(workspaceRoot, items) {
+    const path = join(workspaceRoot, TODO_REL_PATH);
+    mkdirSync(join(workspaceRoot, ".oma"), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ items }, null, 2)}\n`);
+}
+/** SessionStore shim that satisfies the todo plugin's read/write contract,
+ *  but persists todo entries to the workspace file instead of the per-Run
+ *  in-memory branch. Every other SessionStore method is a no-op. */
+export function createFileTodoStore(workspaceRoot) {
+    return {
+        async create() {
+            // Nothing to create; the file is written lazily on first todo_write.
+        },
+        async open() {
+            const snapshot = {
+                metadata: {
+                    sessionId: "",
+                    backendKind: "oma",
+                    workspaceRoot,
+                    leafEntryId: null,
+                    createdAt: 0,
+                    updatedAt: 0,
+                },
+                entries: [],
+                operations: [],
+            };
+            return snapshot;
+        },
+        async delete() {
+            // todo.json is shared across sessions in a workspace; /delete stays local.
+        },
+        async appendBatch(_sessionId, input) {
+            for (const entry of input.entries) {
+                if (entry.type !== "todo")
+                    continue;
+                if (!("state" in entry) || typeof entry.state !== "object" || entry.state === null)
+                    continue;
+                const state = entry.state;
+                if (!("items" in state) || !Array.isArray(state.items))
+                    continue;
+                const items = state.items.filter(isTodoItem);
+                writeTodoFile(workspaceRoot, items);
+            }
+            return { appendedIds: input.entries.map((_, i) => `todo-${i}`) };
+        },
+        async readBranch() {
+            const items = readTodoFile(workspaceRoot);
+            if (items.length === 0)
+                return [];
+            const entry = {
+                type: "todo",
+                entryId: "todo-file",
+                parentId: null,
+                state: { items },
+                createdAt: Date.now(),
+            };
+            return [entry];
+        },
+        async moveLeaf() {
+            // No leaf operations on a file-backed todo store.
+        },
+        async findByProductEntryIds() {
+            return [];
+        },
+        async close() {
+            // No resources to release.
+        },
+    };
+}

package/dist/core/tools/todo.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin, PluginTool, SessionStore } from "../agent-runtime.js";
+export interface TodoPluginOptions {
+    readonly sessionId: string;
+    readonly store: SessionStore;
+}
+export declare function createTodo(opts: TodoPluginOptions): Plugin;
+export declare function createTodoReadTool(opts: TodoPluginOptions): PluginTool;
+//# sourceMappingURL=todo.d.ts.map

package/dist/core/tools/todo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo.d.ts","sourceRoot":"","sources":["../../../src/core/tools/todo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAY,MAAM,qBAAqB,CAAC;AAGtF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B;AA8DD,wBAAgB,UAAU,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAsB1D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,UAAU,CAUtE"}

package/dist/core/tools/todo.js

@@ -0,0 +1,91 @@
+import { readTodo, writeTodo } from "../agent-runtime.js";
+function isTodoItemShape(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return ("id" in value &&
+        typeof value.id === "string" &&
+        "text" in value &&
+        typeof value.text === "string" &&
+        "status" in value &&
+        typeof value.status === "string");
+}
+function toTodoItem(item) {
+    const status = item.status;
+    if (status !== "pending" &&
+        status !== "in_progress" &&
+        status !== "done" &&
+        status !== "cancelled") {
+        return { id: item.id, text: item.text, status: "pending" };
+    }
+    return { id: item.id, text: item.text, status };
+}
+function createTodoWriteTool(opts) {
+    return {
+        name: "todo_write",
+        description: "Update the task list. Provide the full desired state.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                items: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string" },
+                            text: { type: "string" },
+                            status: { type: "string", enum: ["pending", "in_progress", "done", "cancelled"] },
+                        },
+                        required: ["id", "text", "status"],
+                    },
+                },
+            },
+            required: ["items"],
+        },
+        async execute(args) {
+            const rawItems = args.items;
+            if (!Array.isArray(rawItems))
+                return { error: "items must be an array" };
+            const typed = rawItems.filter(isTodoItemShape);
+            const items = typed.map(toTodoItem);
+            await writeTodo(opts.store, opts.sessionId, { items });
+            return { items };
+        },
+    };
+}
+export function createTodo(opts) {
+    return {
+        name: "todo",
+        tools: [createTodoWriteTool(opts)],
+        hooks: {
+            afterTool(toolName, result) {
+                if (toolName !== "todo_write")
+                    return undefined;
+                if (typeof result !== "object" || result === null)
+                    return undefined;
+                if (!("items" in result) || !Array.isArray(result.items))
+                    return undefined;
+                const items = result.items.filter(isTodoItemShape).map(toTodoItem);
+                return { type: "todo_update", items };
+            },
+        },
+        meta: [
+            {
+                name: "Todo",
+                render() {
+                    return "Use todo_write to track tasks. State persists across sessions.";
+                },
+            },
+        ],
+    };
+}
+export function createTodoReadTool(opts) {
+    return {
+        name: "todo_read",
+        description: "Read the current task list.",
+        inputSchema: { type: "object", properties: {} },
+        async execute() {
+            const state = await readTodo(opts.store, opts.sessionId);
+            return { items: state.items };
+        },
+    };
+}

package/dist/core/tools/url-guard.d.ts

@@ -0,0 +1,12 @@
+export declare class UrlGuardError extends Error {
+    constructor(message: string);
+}
+/** Validate URL is safe to fetch. Throws UrlGuardError if not. */
+export declare function assertSafeUrl(rawUrl: string): URL;
+/** Max redirect count for fetch safety */
+export declare const MAX_REDIRECTS = 5;
+/** Max response bytes before cancellation */
+export declare const MAX_RESPONSE_BYTES = 20000;
+/** Fetch timeout in ms */
+export declare const FETCH_TIMEOUT_MS = 10000;
+//# sourceMappingURL=url-guard.d.ts.map

package/dist/core/tools/url-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-guard.d.ts","sourceRoot":"","sources":["../../../src/core/tools/url-guard.ts"],"names":[],"mappings":"AA+BA,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AAED,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAiBjD;AAED,0CAA0C;AAC1C,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,6CAA6C;AAC7C,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,0BAA0B;AAC1B,eAAO,MAAM,gBAAgB,QAAS,CAAC"}

package/dist/core/tools/url-guard.js

@@ -0,0 +1,58 @@
+const BLOCKED_HOSTS = new Set(["localhost", "127.0.0.1", "0.0.0.0", "[::1]", "169.254.169.254"]);
+const BLOCKED_PREFIXES = [
+    "127.",
+    "10.",
+    "192.168.",
+    "172.16.",
+    "172.17.",
+    "172.18.",
+    "172.19.",
+    "172.20.",
+    "172.21.",
+    "172.22.",
+    "172.23.",
+    "172.24.",
+    "172.25.",
+    "172.26.",
+    "172.27.",
+    "172.28.",
+    "172.29.",
+    "172.30.",
+    "172.31.",
+];
+function isPrivateIP(hostname) {
+    if (BLOCKED_HOSTS.has(hostname))
+        return true;
+    if (hostname.startsWith("["))
+        return hostname === "[::1]" || hostname.startsWith("[fc") || hostname.startsWith("[fd");
+    return BLOCKED_PREFIXES.some((p) => hostname.startsWith(p));
+}
+export class UrlGuardError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UrlGuardError";
+    }
+}
+/** Validate URL is safe to fetch. Throws UrlGuardError if not. */
+export function assertSafeUrl(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        throw new UrlGuardError(`Invalid URL: ${rawUrl}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new UrlGuardError(`Blocked protocol: ${parsed.protocol}`);
+    }
+    if (isPrivateIP(parsed.hostname)) {
+        throw new UrlGuardError(`Blocked host: ${parsed.hostname}`);
+    }
+    return parsed;
+}
+/** Max redirect count for fetch safety */
+export const MAX_REDIRECTS = 5;
+/** Max response bytes before cancellation */
+export const MAX_RESPONSE_BYTES = 20_000;
+/** Fetch timeout in ms */
+export const FETCH_TIMEOUT_MS = 10_000;

package/dist/core/tools/web-ports-std.d.ts

@@ -0,0 +1,6 @@
+import type { WebFetchPort, WebSearchPort } from "./web-ports.js";
+/** Std fetch port: global fetch, manual redirect walk (each hop re-validated
+ *  against the url guard), timeout + size caps, HTML→text. */
+export declare function createStdWebFetchPort(): WebFetchPort;
+export declare function createDdgWebSearchPort(): WebSearchPort;
+//# sourceMappingURL=web-ports-std.d.ts.map

package/dist/core/tools/web-ports-std.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-ports-std.d.ts","sourceRoot":"","sources":["../../../src/core/tools/web-ports-std.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AA8BlE;8DAC8D;AAC9D,wBAAgB,qBAAqB,IAAI,YAAY,CAqCpD;AA8DD,wBAAgB,sBAAsB,IAAI,aAAa,CAmBtD"}