clawdbot 2026.1.4-1

package/dist/agents/tools/nodes-tool.js

@@ -0,0 +1,413 @@
+import crypto from "node:crypto";
+import { Type } from "@sinclair/typebox";
+import { cameraTempPath, parseCameraClipPayload, parseCameraSnapPayload, writeBase64ToFile, } from "../../cli/nodes-camera.js";
+import { parseScreenRecordPayload, screenRecordTempPath, writeScreenRecordToFile, } from "../../cli/nodes-screen.js";
+import { parseDurationMs } from "../../cli/parse-duration.js";
+import { imageMimeFromFormat } from "../../media/mime.js";
+import { sanitizeToolResultImages } from "../tool-images.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+import { resolveNodeId } from "./nodes-utils.js";
+const NodesToolSchema = Type.Union([
+    Type.Object({
+        action: Type.Literal("status"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("describe"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("pending"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("approve"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        requestId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("reject"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        requestId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("notify"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.String(),
+        title: Type.Optional(Type.String()),
+        body: Type.Optional(Type.String()),
+        sound: Type.Optional(Type.String()),
+        priority: Type.Optional(Type.Union([
+            Type.Literal("passive"),
+            Type.Literal("active"),
+            Type.Literal("timeSensitive"),
+        ])),
+        delivery: Type.Optional(Type.Union([
+            Type.Literal("system"),
+            Type.Literal("overlay"),
+            Type.Literal("auto"),
+        ])),
+    }),
+    Type.Object({
+        action: Type.Literal("camera_snap"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.String(),
+        facing: Type.Optional(Type.Union([
+            Type.Literal("front"),
+            Type.Literal("back"),
+            Type.Literal("both"),
+        ])),
+        maxWidth: Type.Optional(Type.Number()),
+        quality: Type.Optional(Type.Number()),
+        delayMs: Type.Optional(Type.Number()),
+        deviceId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("camera_list"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("camera_clip"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.String(),
+        facing: Type.Optional(Type.Union([Type.Literal("front"), Type.Literal("back")])),
+        duration: Type.Optional(Type.String()),
+        durationMs: Type.Optional(Type.Number()),
+        includeAudio: Type.Optional(Type.Boolean()),
+        deviceId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("screen_record"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.String(),
+        duration: Type.Optional(Type.String()),
+        durationMs: Type.Optional(Type.Number()),
+        fps: Type.Optional(Type.Number()),
+        screenIndex: Type.Optional(Type.Number()),
+        includeAudio: Type.Optional(Type.Boolean()),
+        outPath: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("location_get"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.String(),
+        maxAgeMs: Type.Optional(Type.Number()),
+        locationTimeoutMs: Type.Optional(Type.Number()),
+        desiredAccuracy: Type.Optional(Type.Union([
+            Type.Literal("coarse"),
+            Type.Literal("balanced"),
+            Type.Literal("precise"),
+        ])),
+    }),
+]);
+export function createNodesTool() {
+    return {
+        label: "Nodes",
+        name: "nodes",
+        description: "Discover and control paired nodes (status/describe/pairing/notify/camera/screen/location).",
+        parameters: NodesToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const gatewayOpts = {
+                gatewayUrl: readStringParam(params, "gatewayUrl", { trim: false }),
+                gatewayToken: readStringParam(params, "gatewayToken", { trim: false }),
+                timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : undefined,
+            };
+            switch (action) {
+                case "status":
+                    return jsonResult(await callGatewayTool("node.list", gatewayOpts, {}));
+                case "describe": {
+                    const node = readStringParam(params, "node", { required: true });
+                    const nodeId = await resolveNodeId(gatewayOpts, node);
+                    return jsonResult(await callGatewayTool("node.describe", gatewayOpts, { nodeId }));
+                }
+                case "pending":
+                    return jsonResult(await callGatewayTool("node.pair.list", gatewayOpts, {}));
+                case "approve": {
+                    const requestId = readStringParam(params, "requestId", {
+                        required: true,
+                    });
+                    return jsonResult(await callGatewayTool("node.pair.approve", gatewayOpts, {
+                        requestId,
+                    }));
+                }
+                case "reject": {
+                    const requestId = readStringParam(params, "requestId", {
+                        required: true,
+                    });
+                    return jsonResult(await callGatewayTool("node.pair.reject", gatewayOpts, {
+                        requestId,
+                    }));
+                }
+                case "notify": {
+                    const node = readStringParam(params, "node", { required: true });
+                    const title = typeof params.title === "string" ? params.title : "";
+                    const body = typeof params.body === "string" ? params.body : "";
+                    if (!title.trim() && !body.trim()) {
+                        throw new Error("title or body required");
+                    }
+                    const nodeId = await resolveNodeId(gatewayOpts, node);
+                    await callGatewayTool("node.invoke", gatewayOpts, {
+                        nodeId,
+                        command: "system.notify",
+                        params: {
+                            title: title.trim() || undefined,
+                            body: body.trim() || undefined,
+                            sound: typeof params.sound === "string" ? params.sound : undefined,
+                            priority: typeof params.priority === "string"
+                                ? params.priority
+                                : undefined,
+                            delivery: typeof params.delivery === "string"
+                                ? params.delivery
+                                : undefined,
+                        },
+                        idempotencyKey: crypto.randomUUID(),
+                    });
+                    return jsonResult({ ok: true });
+                }
+                case "camera_snap": {
+                    const node = readStringParam(params, "node", { required: true });
+                    const nodeId = await resolveNodeId(gatewayOpts, node);
+                    const facingRaw = typeof params.facing === "string"
+                        ? params.facing.toLowerCase()
+                        : "both";
+                    const facings = facingRaw === "both"
+                        ? ["front", "back"]
+                        : facingRaw === "front" || facingRaw === "back"
+                            ? [facingRaw]
+                            : (() => {
+                                throw new Error("invalid facing (front|back|both)");
+                            })();
+                    const maxWidth = typeof params.maxWidth === "number" &&
+                        Number.isFinite(params.maxWidth)
+                        ? params.maxWidth
+                        : undefined;
+                    const quality = typeof params.quality === "number" &&
+                        Number.isFinite(params.quality)
+                        ? params.quality
+                        : undefined;
+                    const delayMs = typeof params.delayMs === "number" &&
+                        Number.isFinite(params.delayMs)
+                        ? params.delayMs
+                        : undefined;
+                    const deviceId = typeof params.deviceId === "string" && params.deviceId.trim()
+                        ? params.deviceId.trim()
+                        : undefined;
+                    const content = [];
+                    const details = [];
+                    for (const facing of facings) {
+                        const raw = (await callGatewayTool("node.invoke", gatewayOpts, {
+                            nodeId,
+                            command: "camera.snap",
+                            params: {
+                                facing,
+                                maxWidth,
+                                quality,
+                                format: "jpg",
+                                delayMs,
+                                deviceId,
+                            },
+                            idempotencyKey: crypto.randomUUID(),
+                        }));
+                        const payload = parseCameraSnapPayload(raw?.payload);
+                        const normalizedFormat = payload.format.toLowerCase();
+                        if (normalizedFormat !== "jpg" &&
+                            normalizedFormat !== "jpeg" &&
+                            normalizedFormat !== "png") {
+                            throw new Error(`unsupported camera.snap format: ${payload.format}`);
+                        }
+                        const isJpeg = normalizedFormat === "jpg" || normalizedFormat === "jpeg";
+                        const filePath = cameraTempPath({
+                            kind: "snap",
+                            facing,
+                            ext: isJpeg ? "jpg" : "png",
+                        });
+                        await writeBase64ToFile(filePath, payload.base64);
+                        content.push({ type: "text", text: `MEDIA:${filePath}` });
+                        content.push({
+                            type: "image",
+                            data: payload.base64,
+                            mimeType: imageMimeFromFormat(payload.format) ??
+                                (isJpeg ? "image/jpeg" : "image/png"),
+                        });
+                        details.push({
+                            facing,
+                            path: filePath,
+                            width: payload.width,
+                            height: payload.height,
+                        });
+                    }
+                    const result = { content, details };
+                    return await sanitizeToolResultImages(result, "nodes:camera_snap");
+                }
+                case "camera_list": {
+                    const node = readStringParam(params, "node", { required: true });
+                    const nodeId = await resolveNodeId(gatewayOpts, node);
+                    const raw = (await callGatewayTool("node.invoke", gatewayOpts, {
+                        nodeId,
+                        command: "camera.list",
+                        params: {},
+                        idempotencyKey: crypto.randomUUID(),
+                    }));
+                    const payload = raw && typeof raw.payload === "object" && raw.payload !== null
+                        ? raw.payload
+                        : {};
+                    return jsonResult(payload);
+                }
+                case "camera_clip": {
+                    const node = readStringParam(params, "node", { required: true });
+                    const nodeId = await resolveNodeId(gatewayOpts, node);
+                    const facing = typeof params.facing === "string"
+                        ? params.facing.toLowerCase()
+                        : "front";
+                    if (facing !== "front" && facing !== "back") {
+                        throw new Error("invalid facing (front|back)");
+                    }
+                    const durationMs = typeof params.durationMs === "number" &&
+                        Number.isFinite(params.durationMs)
+                        ? params.durationMs
+                        : typeof params.duration === "string"
+                            ? parseDurationMs(params.duration)
+                            : 3000;
+                    const includeAudio = typeof params.includeAudio === "boolean"
+                        ? params.includeAudio
+                        : true;
+                    const deviceId = typeof params.deviceId === "string" && params.deviceId.trim()
+                        ? params.deviceId.trim()
+                        : undefined;
+                    const raw = (await callGatewayTool("node.invoke", gatewayOpts, {
+                        nodeId,
+                        command: "camera.clip",
+                        params: {
+                            facing,
+                            durationMs,
+                            includeAudio,
+                            format: "mp4",
+                            deviceId,
+                        },
+                        idempotencyKey: crypto.randomUUID(),
+                    }));
+                    const payload = parseCameraClipPayload(raw?.payload);
+                    const filePath = cameraTempPath({
+                        kind: "clip",
+                        facing,
+                        ext: payload.format,
+                    });
+                    await writeBase64ToFile(filePath, payload.base64);
+                    return {
+                        content: [{ type: "text", text: `FILE:${filePath}` }],
+                        details: {
+                            facing,
+                            path: filePath,
+                            durationMs: payload.durationMs,
+                            hasAudio: payload.hasAudio,
+                        },
+                    };
+                }
+                case "screen_record": {
+                    const node = readStringParam(params, "node", { required: true });
+                    const nodeId = await resolveNodeId(gatewayOpts, node);
+                    const durationMs = typeof params.durationMs === "number" &&
+                        Number.isFinite(params.durationMs)
+                        ? params.durationMs
+                        : typeof params.duration === "string"
+                            ? parseDurationMs(params.duration)
+                            : 10_000;
+                    const fps = typeof params.fps === "number" && Number.isFinite(params.fps)
+                        ? params.fps
+                        : 10;
+                    const screenIndex = typeof params.screenIndex === "number" &&
+                        Number.isFinite(params.screenIndex)
+                        ? params.screenIndex
+                        : 0;
+                    const includeAudio = typeof params.includeAudio === "boolean"
+                        ? params.includeAudio
+                        : true;
+                    const raw = (await callGatewayTool("node.invoke", gatewayOpts, {
+                        nodeId,
+                        command: "screen.record",
+                        params: {
+                            durationMs,
+                            screenIndex,
+                            fps,
+                            format: "mp4",
+                            includeAudio,
+                        },
+                        idempotencyKey: crypto.randomUUID(),
+                    }));
+                    const payload = parseScreenRecordPayload(raw?.payload);
+                    const filePath = typeof params.outPath === "string" && params.outPath.trim()
+                        ? params.outPath.trim()
+                        : screenRecordTempPath({ ext: payload.format || "mp4" });
+                    const written = await writeScreenRecordToFile(filePath, payload.base64);
+                    return {
+                        content: [{ type: "text", text: `FILE:${written.path}` }],
+                        details: {
+                            path: written.path,
+                            durationMs: payload.durationMs,
+                            fps: payload.fps,
+                            screenIndex: payload.screenIndex,
+                            hasAudio: payload.hasAudio,
+                        },
+                    };
+                }
+                case "location_get": {
+                    const node = readStringParam(params, "node", { required: true });
+                    const nodeId = await resolveNodeId(gatewayOpts, node);
+                    const maxAgeMs = typeof params.maxAgeMs === "number" &&
+                        Number.isFinite(params.maxAgeMs)
+                        ? params.maxAgeMs
+                        : undefined;
+                    const desiredAccuracy = params.desiredAccuracy === "coarse" ||
+                        params.desiredAccuracy === "balanced" ||
+                        params.desiredAccuracy === "precise"
+                        ? params.desiredAccuracy
+                        : undefined;
+                    const locationTimeoutMs = typeof params.locationTimeoutMs === "number" &&
+                        Number.isFinite(params.locationTimeoutMs)
+                        ? params.locationTimeoutMs
+                        : undefined;
+                    const raw = (await callGatewayTool("node.invoke", gatewayOpts, {
+                        nodeId,
+                        command: "location.get",
+                        params: {
+                            maxAgeMs,
+                            desiredAccuracy,
+                            timeoutMs: locationTimeoutMs,
+                        },
+                        idempotencyKey: crypto.randomUUID(),
+                    }));
+                    return jsonResult(raw?.payload ?? {});
+                }
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+        },
+    };
+}

package/dist/agents/tools/nodes-utils.js

@@ -0,0 +1,92 @@
+import { callGatewayTool } from "./gateway.js";
+function parseNodeList(value) {
+    const obj = typeof value === "object" && value !== null
+        ? value
+        : {};
+    return Array.isArray(obj.nodes) ? obj.nodes : [];
+}
+function parsePairingList(value) {
+    const obj = typeof value === "object" && value !== null
+        ? value
+        : {};
+    const pending = Array.isArray(obj.pending)
+        ? obj.pending
+        : [];
+    const paired = Array.isArray(obj.paired) ? obj.paired : [];
+    return { pending, paired };
+}
+function normalizeNodeKey(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+}
+async function loadNodes(opts) {
+    try {
+        const res = (await callGatewayTool("node.list", opts, {}));
+        return parseNodeList(res);
+    }
+    catch {
+        const res = (await callGatewayTool("node.pair.list", opts, {}));
+        const { paired } = parsePairingList(res);
+        return paired.map((n) => ({
+            nodeId: n.nodeId,
+            displayName: n.displayName,
+            platform: n.platform,
+            remoteIp: n.remoteIp,
+        }));
+    }
+}
+function pickDefaultNode(nodes) {
+    const withCanvas = nodes.filter((n) => Array.isArray(n.caps) ? n.caps.includes("canvas") : true);
+    if (withCanvas.length === 0)
+        return null;
+    const connected = withCanvas.filter((n) => n.connected);
+    const candidates = connected.length > 0 ? connected : withCanvas;
+    if (candidates.length === 1)
+        return candidates[0];
+    const local = candidates.filter((n) => n.platform?.toLowerCase().startsWith("mac") &&
+        typeof n.nodeId === "string" &&
+        n.nodeId.startsWith("mac-"));
+    if (local.length === 1)
+        return local[0];
+    return null;
+}
+export async function resolveNodeId(opts, query, allowDefault = false) {
+    const nodes = await loadNodes(opts);
+    const q = String(query ?? "").trim();
+    if (!q) {
+        if (allowDefault) {
+            const picked = pickDefaultNode(nodes);
+            if (picked)
+                return picked.nodeId;
+        }
+        throw new Error("node required");
+    }
+    const qNorm = normalizeNodeKey(q);
+    const matches = nodes.filter((n) => {
+        if (n.nodeId === q)
+            return true;
+        if (typeof n.remoteIp === "string" && n.remoteIp === q)
+            return true;
+        const name = typeof n.displayName === "string" ? n.displayName : "";
+        if (name && normalizeNodeKey(name) === qNorm)
+            return true;
+        if (q.length >= 6 && n.nodeId.startsWith(q))
+            return true;
+        return false;
+    });
+    if (matches.length === 1)
+        return matches[0].nodeId;
+    if (matches.length === 0) {
+        const known = nodes
+            .map((n) => n.displayName || n.remoteIp || n.nodeId)
+            .filter(Boolean)
+            .join(", ");
+        throw new Error(`unknown node: ${q}${known ? ` (known: ${known})` : ""}`);
+    }
+    throw new Error(`ambiguous node: ${q} (matches: ${matches
+        .map((n) => n.displayName || n.remoteIp || n.nodeId)
+        .join(", ")})`);
+}

package/dist/agents/tools/sessions-helpers.js

@@ -0,0 +1,88 @@
+function normalizeKey(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function resolveMainSessionAlias(cfg) {
+    const mainKey = normalizeKey(cfg.session?.mainKey) ?? "main";
+    const scope = cfg.session?.scope ?? "per-sender";
+    const alias = scope === "global" ? "global" : mainKey;
+    return { mainKey, alias, scope };
+}
+export function resolveDisplaySessionKey(params) {
+    if (params.key === params.alias)
+        return "main";
+    if (params.key === params.mainKey)
+        return "main";
+    return params.key;
+}
+export function resolveInternalSessionKey(params) {
+    if (params.key === "main")
+        return params.alias;
+    return params.key;
+}
+export function classifySessionKind(params) {
+    const key = params.key;
+    if (key === params.alias || key === params.mainKey)
+        return "main";
+    if (key.startsWith("cron:"))
+        return "cron";
+    if (key.startsWith("hook:"))
+        return "hook";
+    if (key.startsWith("node-") || key.startsWith("node:"))
+        return "node";
+    if (params.gatewayKind === "group")
+        return "group";
+    if (key.startsWith("group:") ||
+        key.includes(":group:") ||
+        key.includes(":channel:")) {
+        return "group";
+    }
+    return "other";
+}
+export function deriveProvider(params) {
+    if (params.kind === "cron" ||
+        params.kind === "hook" ||
+        params.kind === "node")
+        return "internal";
+    const surface = normalizeKey(params.surface ?? undefined);
+    if (surface)
+        return surface;
+    const lastChannel = normalizeKey(params.lastChannel ?? undefined);
+    if (lastChannel)
+        return lastChannel;
+    const parts = params.key.split(":").filter(Boolean);
+    if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) {
+        return parts[0];
+    }
+    return "unknown";
+}
+export function stripToolMessages(messages) {
+    return messages.filter((msg) => {
+        if (!msg || typeof msg !== "object")
+            return true;
+        const role = msg.role;
+        return role !== "toolResult";
+    });
+}
+export function extractAssistantText(message) {
+    if (!message || typeof message !== "object")
+        return undefined;
+    if (message.role !== "assistant")
+        return undefined;
+    const content = message.content;
+    if (!Array.isArray(content))
+        return undefined;
+    const chunks = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        if (block.type !== "text")
+            continue;
+        const text = block.text;
+        if (typeof text === "string" && text.trim()) {
+            chunks.push(text);
+        }
+    }
+    const joined = chunks.join("").trim();
+    return joined ? joined : undefined;
+}

package/dist/agents/tools/sessions-history-tool.js

@@ -0,0 +1,53 @@
+import { Type } from "@sinclair/typebox";
+import { loadConfig } from "../../config/config.js";
+import { callGateway } from "../../gateway/call.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { resolveDisplaySessionKey, resolveInternalSessionKey, resolveMainSessionAlias, stripToolMessages, } from "./sessions-helpers.js";
+const SessionsHistoryToolSchema = Type.Object({
+    sessionKey: Type.String(),
+    limit: Type.Optional(Type.Integer({ minimum: 1 })),
+    includeTools: Type.Optional(Type.Boolean()),
+});
+export function createSessionsHistoryTool() {
+    return {
+        label: "Session History",
+        name: "sessions_history",
+        description: "Fetch message history for a session.",
+        parameters: SessionsHistoryToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const sessionKey = readStringParam(params, "sessionKey", {
+                required: true,
+            });
+            const cfg = loadConfig();
+            const { mainKey, alias } = resolveMainSessionAlias(cfg);
+            const resolvedKey = resolveInternalSessionKey({
+                key: sessionKey,
+                alias,
+                mainKey,
+            });
+            const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                ? Math.max(1, Math.floor(params.limit))
+                : undefined;
+            const includeTools = Boolean(params.includeTools);
+            const result = (await callGateway({
+                method: "chat.history",
+                params: { sessionKey: resolvedKey, limit },
+            }));
+            const rawMessages = Array.isArray(result?.messages)
+                ? result.messages
+                : [];
+            const messages = includeTools
+                ? rawMessages
+                : stripToolMessages(rawMessages);
+            return jsonResult({
+                sessionKey: resolveDisplaySessionKey({
+                    key: sessionKey,
+                    alias,
+                    mainKey,
+                }),
+                messages,
+            });
+        },
+    };
+}