clawdbot 2026.1.4-1

package/dist/agents/pi-tools.js

@@ -0,0 +1,433 @@
+import { codingTools, createEditTool, createReadTool, createWriteTool, readTool, } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { detectMime } from "../media/mime.js";
+import { startWebLoginWithQr, waitForWebLogin } from "../web/login-qr.js";
+import { createBashTool, createProcessTool, } from "./bash-tools.js";
+import { createClawdbotTools } from "./clawdbot-tools.js";
+import { assertSandboxPath } from "./sandbox-paths.js";
+import { sanitizeToolResultImages } from "./tool-images.js";
+async function sniffMimeFromBase64(base64) {
+    const trimmed = base64.trim();
+    if (!trimmed)
+        return undefined;
+    const take = Math.min(256, trimmed.length);
+    const sliceLen = take - (take % 4);
+    if (sliceLen < 8)
+        return undefined;
+    try {
+        const head = Buffer.from(trimmed.slice(0, sliceLen), "base64");
+        return await detectMime({ buffer: head });
+    }
+    catch {
+        return undefined;
+    }
+}
+function rewriteReadImageHeader(text, mimeType) {
+    // pi-coding-agent uses: "Read image file [image/png]"
+    if (text.startsWith("Read image file [") && text.endsWith("]")) {
+        return `Read image file [${mimeType}]`;
+    }
+    return text;
+}
+async function normalizeReadImageResult(result, filePath) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    const image = content.find((b) => !!b &&
+        typeof b === "object" &&
+        b.type === "image" &&
+        typeof b.data === "string" &&
+        typeof b.mimeType === "string");
+    if (!image)
+        return result;
+    if (!image.data.trim()) {
+        throw new Error(`read: image payload is empty (${filePath})`);
+    }
+    const sniffed = await sniffMimeFromBase64(image.data);
+    if (!sniffed)
+        return result;
+    if (!sniffed.startsWith("image/")) {
+        throw new Error(`read: file looks like ${sniffed} but was treated as ${image.mimeType} (${filePath})`);
+    }
+    if (sniffed === image.mimeType)
+        return result;
+    const nextContent = content.map((block) => {
+        if (block &&
+            typeof block === "object" &&
+            block.type === "image") {
+            const b = block;
+            return { ...b, mimeType: sniffed };
+        }
+        if (block &&
+            typeof block === "object" &&
+            block.type === "text" &&
+            typeof block.text === "string") {
+            const b = block;
+            return {
+                ...b,
+                text: rewriteReadImageHeader(b.text, sniffed),
+            };
+        }
+        return block;
+    });
+    return { ...result, content: nextContent };
+}
+function extractEnumValues(schema) {
+    if (!schema || typeof schema !== "object")
+        return undefined;
+    const record = schema;
+    if (Array.isArray(record.enum))
+        return record.enum;
+    if ("const" in record)
+        return [record.const];
+    return undefined;
+}
+function mergePropertySchemas(existing, incoming) {
+    if (!existing)
+        return incoming;
+    if (!incoming)
+        return existing;
+    const existingEnum = extractEnumValues(existing);
+    const incomingEnum = extractEnumValues(incoming);
+    if (existingEnum || incomingEnum) {
+        const values = Array.from(new Set([...(existingEnum ?? []), ...(incomingEnum ?? [])]));
+        const merged = {};
+        for (const source of [existing, incoming]) {
+            if (!source || typeof source !== "object")
+                continue;
+            const record = source;
+            for (const key of ["title", "description", "default"]) {
+                if (!(key in merged) && key in record)
+                    merged[key] = record[key];
+            }
+        }
+        const types = new Set(values.map((value) => typeof value));
+        if (types.size === 1)
+            merged.type = Array.from(types)[0];
+        merged.enum = values;
+        return merged;
+    }
+    return existing;
+}
+function cleanSchemaForGemini(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(cleanSchemaForGemini);
+    const obj = schema;
+    const hasAnyOf = "anyOf" in obj && Array.isArray(obj.anyOf);
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+        // Skip unsupported schema features for Gemini:
+        // - patternProperties: not in OpenAPI 3.0 subset
+        // - const: convert to enum with single value instead
+        if (key === "patternProperties") {
+            // Gemini doesn't support patternProperties - skip it
+            continue;
+        }
+        // Convert const to enum (Gemini doesn't support const)
+        if (key === "const") {
+            cleaned.enum = [value];
+            continue;
+        }
+        // Skip 'type' if we have 'anyOf' — Gemini doesn't allow both
+        if (key === "type" && hasAnyOf) {
+            continue;
+        }
+        if (key === "properties" && value && typeof value === "object") {
+            // Recursively clean nested properties
+            const props = value;
+            cleaned[key] = Object.fromEntries(Object.entries(props).map(([k, v]) => [k, cleanSchemaForGemini(v)]));
+        }
+        else if (key === "items" && value && typeof value === "object") {
+            // Recursively clean array items schema
+            cleaned[key] = cleanSchemaForGemini(value);
+        }
+        else if (key === "anyOf" && Array.isArray(value)) {
+            // Clean each anyOf variant
+            cleaned[key] = value.map((variant) => cleanSchemaForGemini(variant));
+        }
+        else if (key === "oneOf" && Array.isArray(value)) {
+            // Clean each oneOf variant
+            cleaned[key] = value.map((variant) => cleanSchemaForGemini(variant));
+        }
+        else if (key === "allOf" && Array.isArray(value)) {
+            // Clean each allOf variant
+            cleaned[key] = value.map((variant) => cleanSchemaForGemini(variant));
+        }
+        else if (key === "additionalProperties" &&
+            value &&
+            typeof value === "object") {
+            // Recursively clean additionalProperties schema
+            cleaned[key] = cleanSchemaForGemini(value);
+        }
+        else {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}
+function normalizeToolParameters(tool) {
+    const schema = tool.parameters && typeof tool.parameters === "object"
+        ? tool.parameters
+        : undefined;
+    if (!schema)
+        return tool;
+    // If schema already has type + properties (no top-level anyOf to merge),
+    // still clean it for Gemini compatibility
+    if ("type" in schema &&
+        "properties" in schema &&
+        !Array.isArray(schema.anyOf)) {
+        return {
+            ...tool,
+            parameters: cleanSchemaForGemini(schema),
+        };
+    }
+    if (!Array.isArray(schema.anyOf))
+        return tool;
+    const mergedProperties = {};
+    const requiredCounts = new Map();
+    let objectVariants = 0;
+    for (const entry of schema.anyOf) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const props = entry.properties;
+        if (!props || typeof props !== "object")
+            continue;
+        objectVariants += 1;
+        for (const [key, value] of Object.entries(props)) {
+            if (!(key in mergedProperties)) {
+                mergedProperties[key] = value;
+                continue;
+            }
+            mergedProperties[key] = mergePropertySchemas(mergedProperties[key], value);
+        }
+        const required = Array.isArray(entry.required)
+            ? entry.required
+            : [];
+        for (const key of required) {
+            if (typeof key !== "string")
+                continue;
+            requiredCounts.set(key, (requiredCounts.get(key) ?? 0) + 1);
+        }
+    }
+    const baseRequired = Array.isArray(schema.required)
+        ? schema.required.filter((key) => typeof key === "string")
+        : undefined;
+    const mergedRequired = baseRequired && baseRequired.length > 0
+        ? baseRequired
+        : objectVariants > 0
+            ? Array.from(requiredCounts.entries())
+                .filter(([, count]) => count === objectVariants)
+                .map(([key]) => key)
+            : undefined;
+    const nextSchema = { ...schema };
+    return {
+        ...tool,
+        parameters: cleanSchemaForGemini({
+            ...nextSchema,
+            type: nextSchema.type ?? "object",
+            properties: Object.keys(mergedProperties).length > 0
+                ? mergedProperties
+                : (schema.properties ?? {}),
+            ...(mergedRequired && mergedRequired.length > 0
+                ? { required: mergedRequired }
+                : {}),
+            additionalProperties: "additionalProperties" in schema ? schema.additionalProperties : true,
+        }),
+    };
+}
+function normalizeToolNames(list) {
+    if (!list)
+        return [];
+    return list.map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+}
+function filterToolsByPolicy(tools, policy) {
+    if (!policy)
+        return tools;
+    const deny = new Set(normalizeToolNames(policy.deny));
+    const allowRaw = normalizeToolNames(policy.allow);
+    const allow = allowRaw.length > 0 ? new Set(allowRaw) : null;
+    return tools.filter((tool) => {
+        const name = tool.name.toLowerCase();
+        if (deny.has(name))
+            return false;
+        if (allow)
+            return allow.has(name);
+        return true;
+    });
+}
+function wrapSandboxPathGuard(tool, root) {
+    return {
+        ...tool,
+        execute: async (toolCallId, args, signal, onUpdate) => {
+            const record = args && typeof args === "object"
+                ? args
+                : undefined;
+            const filePath = record?.path;
+            if (typeof filePath === "string" && filePath.trim()) {
+                await assertSandboxPath({ filePath, cwd: root, root });
+            }
+            return tool.execute(toolCallId, args, signal, onUpdate);
+        },
+    };
+}
+function createSandboxedReadTool(root) {
+    const base = createReadTool(root);
+    return wrapSandboxPathGuard(createClawdbotReadTool(base), root);
+}
+function createSandboxedWriteTool(root) {
+    const base = createWriteTool(root);
+    return wrapSandboxPathGuard(base, root);
+}
+function createSandboxedEditTool(root) {
+    const base = createEditTool(root);
+    return wrapSandboxPathGuard(base, root);
+}
+function createWhatsAppLoginTool() {
+    return {
+        label: "WhatsApp Login",
+        name: "whatsapp_login",
+        description: "Generate a WhatsApp QR code for linking, or wait for the scan to complete.",
+        parameters: Type.Object({
+            action: Type.Union([Type.Literal("start"), Type.Literal("wait")]),
+            timeoutMs: Type.Optional(Type.Number()),
+            force: Type.Optional(Type.Boolean()),
+        }),
+        execute: async (_toolCallId, args) => {
+            const action = args?.action ?? "start";
+            if (action === "wait") {
+                const result = await waitForWebLogin({
+                    timeoutMs: typeof args.timeoutMs === "number"
+                        ? args.timeoutMs
+                        : undefined,
+                });
+                return {
+                    content: [{ type: "text", text: result.message }],
+                    details: { connected: result.connected },
+                };
+            }
+            const result = await startWebLoginWithQr({
+                timeoutMs: typeof args.timeoutMs === "number"
+                    ? args.timeoutMs
+                    : undefined,
+                force: typeof args.force === "boolean"
+                    ? args.force
+                    : false,
+            });
+            if (!result.qrDataUrl) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result.message,
+                        },
+                    ],
+                    details: { qr: false },
+                };
+            }
+            const text = [
+                result.message,
+                "",
+                "Open WhatsApp → Linked Devices and scan:",
+                "",
+                `![whatsapp-qr](${result.qrDataUrl})`,
+            ].join("\n");
+            return {
+                content: [{ type: "text", text }],
+                details: { qr: true },
+            };
+        },
+    };
+}
+function createClawdbotReadTool(base) {
+    return {
+        ...base,
+        execute: async (toolCallId, params, signal) => {
+            const result = (await base.execute(toolCallId, params, signal));
+            const record = params && typeof params === "object"
+                ? params
+                : undefined;
+            const filePath = typeof record?.path === "string" ? String(record.path) : "<unknown>";
+            const normalized = await normalizeReadImageResult(result, filePath);
+            return sanitizeToolResultImages(normalized, `read:${filePath}`);
+        },
+    };
+}
+function normalizeSurface(surface) {
+    const trimmed = surface?.trim().toLowerCase();
+    return trimmed ? trimmed : undefined;
+}
+function shouldIncludeDiscordTool(surface) {
+    const normalized = normalizeSurface(surface);
+    if (!normalized)
+        return false;
+    return normalized === "discord" || normalized.startsWith("discord:");
+}
+function shouldIncludeSlackTool(surface) {
+    const normalized = normalizeSurface(surface);
+    if (!normalized)
+        return false;
+    return normalized === "slack" || normalized.startsWith("slack:");
+}
+export function createClawdbotCodingTools(options) {
+    const bashToolName = "bash";
+    const sandbox = options?.sandbox?.enabled ? options.sandbox : undefined;
+    const sandboxRoot = sandbox?.workspaceDir;
+    const base = codingTools.flatMap((tool) => {
+        if (tool.name === readTool.name) {
+            return sandboxRoot
+                ? [createSandboxedReadTool(sandboxRoot)]
+                : [createClawdbotReadTool(tool)];
+        }
+        if (tool.name === bashToolName)
+            return [];
+        if (sandboxRoot && (tool.name === "write" || tool.name === "edit")) {
+            return [];
+        }
+        return [tool];
+    });
+    const bashTool = createBashTool({
+        ...options?.bash,
+        sandbox: sandbox
+            ? {
+                containerName: sandbox.containerName,
+                workspaceDir: sandbox.workspaceDir,
+                containerWorkdir: sandbox.containerWorkdir,
+                env: sandbox.docker.env,
+            }
+            : undefined,
+    });
+    const processTool = createProcessTool({
+        cleanupMs: options?.bash?.cleanupMs,
+    });
+    const tools = [
+        ...base,
+        ...(sandboxRoot
+            ? [
+                createSandboxedEditTool(sandboxRoot),
+                createSandboxedWriteTool(sandboxRoot),
+            ]
+            : []),
+        bashTool,
+        processTool,
+        createWhatsAppLoginTool(),
+        ...createClawdbotTools({
+            browserControlUrl: sandbox?.browser?.controlUrl,
+            agentSessionKey: options?.sessionKey,
+            agentSurface: options?.surface,
+            config: options?.config,
+        }),
+    ];
+    const allowDiscord = shouldIncludeDiscordTool(options?.surface);
+    const allowSlack = shouldIncludeSlackTool(options?.surface);
+    const filtered = tools.filter((tool) => {
+        if (tool.name === "discord")
+            return allowDiscord;
+        if (tool.name === "slack")
+            return allowSlack;
+        return true;
+    });
+    const sandboxed = sandbox
+        ? filterToolsByPolicy(filtered, sandbox.tools)
+        : filtered;
+    return sandboxed.map(normalizeToolParameters);
+}

package/dist/agents/sandbox-paths.js

@@ -0,0 +1,68 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+function normalizeUnicodeSpaces(str) {
+    return str.replace(UNICODE_SPACES, " ");
+}
+function expandPath(filePath) {
+    const normalized = normalizeUnicodeSpaces(filePath);
+    if (normalized === "~") {
+        return os.homedir();
+    }
+    if (normalized.startsWith("~/")) {
+        return os.homedir() + normalized.slice(1);
+    }
+    return normalized;
+}
+function resolveToCwd(filePath, cwd) {
+    const expanded = expandPath(filePath);
+    if (path.isAbsolute(expanded))
+        return expanded;
+    return path.resolve(cwd, expanded);
+}
+export function resolveSandboxPath(params) {
+    const resolved = resolveToCwd(params.filePath, params.cwd);
+    const rootResolved = path.resolve(params.root);
+    const relative = path.relative(rootResolved, resolved);
+    if (!relative || relative === "") {
+        return { resolved, relative: "" };
+    }
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Path escapes sandbox root (${shortPath(rootResolved)}): ${params.filePath}`);
+    }
+    return { resolved, relative };
+}
+export async function assertSandboxPath(params) {
+    const resolved = resolveSandboxPath(params);
+    await assertNoSymlink(resolved.relative, path.resolve(params.root));
+    return resolved;
+}
+async function assertNoSymlink(relative, root) {
+    if (!relative)
+        return;
+    const parts = relative.split(path.sep).filter(Boolean);
+    let current = root;
+    for (const part of parts) {
+        current = path.join(current, part);
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new Error(`Symlink not allowed in sandbox path: ${current}`);
+            }
+        }
+        catch (err) {
+            const anyErr = err;
+            if (anyErr.code === "ENOENT") {
+                return;
+            }
+            throw err;
+        }
+    }
+}
+function shortPath(value) {
+    if (value.startsWith(os.homedir())) {
+        return `~${value.slice(os.homedir().length)}`;
+    }
+    return value;
+}