sparkecoder 0.1.86 → 0.1.87

package/dist/agent/index.js

@@ -27,7 +27,12 @@ var init_types = __esm({
       // Whether to always inject this skill into context (vs on-demand loading)
       alwaysApply: z.boolean().optional().default(false),
       // Glob patterns - auto-inject when working with matching files
-      globs: z.array(z.string()).optional().default([])
+      globs: z.array(z.string()).optional().default([]),
+      // Platform requirements — skill is hidden from the model on platforms
+      // not listed here. Values match `process.platform`
+      // (darwin, linux, win32, freebsd, ...). If omitted or empty, the skill is
+      // available on all platforms.
+      platforms: z.array(z.string()).optional().default([])
     });
     TaskConfigSchema = z.object({
       enabled: z.boolean(),
@@ -45,7 +50,13 @@ var init_types = __esm({
       approvalWebhook: z.string().url().optional(),
       skillsDirectory: z.string().optional(),
       maxContextChars: z.number().optional().default(2e5),
-      task: TaskConfigSchema.optional()
+      task: TaskConfigSchema.optional(),
+      // Anthropic computer use tool — opt-in. When true, the `computer` tool is
+      // included in the toolset for Anthropic models. Default false.
+      computerUseEnabled: z.boolean().optional(),
+      // Display dimensions for the computer use tool (defaults: 1280x800).
+      computerUseDisplayWidth: z.number().int().positive().optional(),
+      computerUseDisplayHeight: z.number().int().positive().optional()
     });
     VectorGatewayConfigSchema = z.object({
       // Redis cluster nodes URL for Vector Gateway (or use REDIS_CLUSTER_NODES env var)
@@ -802,7 +813,8 @@ async function loadSkillsFromDirectory(directory, options = {}) {
         globs: parsed.metadata.globs,
         loadType,
         priority,
-        sourceDir: directory
+        sourceDir: directory,
+        platforms: parsed.metadata.platforms
       });
     } else {
       const name = getSkillNameFromPath(filePath);
@@ -815,11 +827,14 @@ async function loadSkillsFromDirectory(directory, options = {}) {
         globs: [],
         loadType: forceAlwaysApply ? "always" : defaultLoadType,
         priority,
-        sourceDir: directory
+        sourceDir: directory,
+        platforms: []
       });
     }
   }
-  return skills;
+  return skills.filter(
+    (s) => s.platforms.length === 0 || s.platforms.includes(process.platform)
+  );
 }
 async function loadAllSkills(directories) {
   const allSkills = [];
@@ -1616,15 +1631,15 @@ var recorder_exports = {};
 __export(recorder_exports, {
   FrameRecorder: () => FrameRecorder
 });
-import { exec as exec5 } from "child_process";
-import { promisify as promisify5 } from "util";
+import { exec as exec6 } from "child_process";
+import { promisify as promisify6 } from "util";
 import { writeFile as writeFile5, mkdir as mkdir4, readFile as readFile11, unlink as unlink2, readdir as readdir5, rm } from "fs/promises";
-import { join as join8 } from "path";
-import { tmpdir } from "os";
-import { nanoid as nanoid3 } from "nanoid";
+import { join as join9 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { nanoid as nanoid4 } from "nanoid";
 async function checkFfmpeg() {
   try {
-    await execAsync5("ffmpeg -version", { timeout: 5e3 });
+    await execAsync6("ffmpeg -version", { timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -1636,11 +1651,11 @@ async function cleanup(dir) {
   } catch {
   }
 }
-var execAsync5, FrameRecorder;
+var execAsync6, FrameRecorder;
 var init_recorder = __esm({
   "src/browser/recorder.ts"() {
     "use strict";
-    execAsync5 = promisify5(exec5);
+    execAsync6 = promisify6(exec6);
     FrameRecorder = class {
       frames = [];
       startTime = null;
@@ -1676,21 +1691,21 @@ var init_recorder = __esm({
        */
       async encode() {
         if (this.frames.length === 0) return null;
-        const workDir = join8(tmpdir(), `sparkecoder-recording-${nanoid3(8)}`);
+        const workDir = join9(tmpdir2(), `sparkecoder-recording-${nanoid4(8)}`);
         await mkdir4(workDir, { recursive: true });
         try {
           for (let i = 0; i < this.frames.length; i++) {
-            const framePath = join8(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
+            const framePath = join9(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
             await writeFile5(framePath, this.frames[i].data);
           }
           const duration = (this.frames[this.frames.length - 1].timestamp - this.frames[0].timestamp) / 1e3;
           const fps = duration > 0 ? Math.round(this.frames.length / duration) : 10;
           const clampedFps = Math.max(1, Math.min(fps, 30));
-          const outputPath = join8(workDir, `recording_${this.sessionId}.mp4`);
+          const outputPath = join9(workDir, `recording_${this.sessionId}.mp4`);
           const hasFfmpeg = await checkFfmpeg();
           if (hasFfmpeg) {
-            await execAsync5(
-              `ffmpeg -y -framerate ${clampedFps} -i "${join8(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
+            await execAsync6(
+              `ffmpeg -y -framerate ${clampedFps} -i "${join9(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
               { timeout: 12e4 }
             );
           } else {
@@ -1702,7 +1717,7 @@ var init_recorder = __esm({
           const files = await readdir5(workDir);
           for (const f of files) {
             if (f.startsWith("frame_")) {
-              await unlink2(join8(workDir, f)).catch(() => {
+              await unlink2(join9(workDir, f)).catch(() => {
               });
             }
           }
@@ -1727,7 +1742,7 @@ var init_recorder = __esm({
 import {
   streamText as streamText2,
   generateText as generateText3,
-  tool as tool13,
+  tool as tool14,
   stepCountIs as stepCountIs2
 } from "ai";
 
@@ -1918,8 +1933,8 @@ var SUBAGENT_MODELS = {
 // src/agent/index.ts
 init_db();
 init_config();
-import { z as z14 } from "zod";
-import { nanoid as nanoid4 } from "nanoid";
+import { z as z15 } from "zod";
+import { nanoid as nanoid5 } from "nanoid";
 
 // src/tools/bash.ts
 import { tool } from "ai";
@@ -2802,12 +2817,12 @@ function findNearestRoot(startDir, markers) {
 }
 async function commandExists(cmd) {
   try {
-    const { exec: exec6 } = await import("child_process");
-    const { promisify: promisify6 } = await import("util");
-    const execAsync6 = promisify6(exec6);
+    const { exec: exec7 } = await import("child_process");
+    const { promisify: promisify7 } = await import("util");
+    const execAsync7 = promisify7(exec7);
     const isWindows = process.platform === "win32";
     const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
-    await execAsync6(checkCmd);
+    await execAsync7(checkCmd);
     return true;
   } catch {
     return false;
@@ -5566,6 +5581,568 @@ function createUploadFileTool(options) {
   });
 }
 
+// src/tools/computer-use.ts
+import { anthropic } from "@ai-sdk/anthropic";
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { mkdirSync as mkdirSync5, existsSync as existsSync15, readFileSync as readFileSync7, unlinkSync as unlinkSync2 } from "fs";
+import { join as join8 } from "path";
+import { tmpdir } from "os";
+import { nanoid as nanoid3 } from "nanoid";
+var execAsync5 = promisify5(exec5);
+var DEFAULT_WIDTH = 1280;
+var DEFAULT_HEIGHT = 800;
+function isMacOs() {
+  return process.platform === "darwin";
+}
+async function isCliclickInstalled() {
+  try {
+    await execAsync5("command -v cliclick", { timeout: 2e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runJxa(script) {
+  try {
+    const escaped = script.replace(/'/g, `'\\''`);
+    const { stdout } = await execAsync5(`osascript -l JavaScript -e '${escaped}'`, {
+      timeout: 5e3
+    });
+    return JSON.parse(stdout.trim());
+  } catch {
+    return null;
+  }
+}
+async function hasAccessibilityPermissions() {
+  try {
+    const { stderr } = await execAsync5("cliclick p:.", { timeout: 3e3 });
+    if (/accessibility privileges not enabled/i.test(stderr)) {
+      return { ok: false, error: stderr.trim().split("\n")[0] };
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+}
+async function hasScreenRecordingPermissions() {
+  const result = await runJxa(
+    `ObjC.import("Cocoa");
+     ObjC.import("CoreGraphics");
+     ObjC.bindFunction("CGPreflightScreenCaptureAccess", ["bool", []]);
+     JSON.stringify({ hasAccess: !!$.CGPreflightScreenCaptureAccess() });`
+  );
+  return result?.hasAccess ?? false;
+}
+async function requestAccessibilityPrompt() {
+  const result = await runJxa(
+    `ObjC.import("ApplicationServices");
+     var key = $.kAXTrustedCheckOptionPrompt;
+     var dict = $.NSDictionary.dictionaryWithObjectForKey($.kCFBooleanTrue, key);
+     var trusted = $.AXIsProcessTrustedWithOptions(dict);
+     JSON.stringify({ trusted: !!trusted });`
+  );
+  return result?.trusted ?? false;
+}
+async function requestScreenRecordingPrompt() {
+  const result = await runJxa(
+    `ObjC.import("Cocoa");
+     ObjC.import("CoreGraphics");
+     ObjC.bindFunction("CGRequestScreenCaptureAccess", ["bool", []]);
+     JSON.stringify({ granted: !!$.CGRequestScreenCaptureAccess() });`
+  );
+  return result?.granted ?? false;
+}
+async function openSystemSettings(pane) {
+  const url = pane === "accessibility" ? "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility" : "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture";
+  try {
+    await execAsync5(`open '${url}'`, { timeout: 3e3 });
+  } catch {
+  }
+}
+async function detectScreenSize() {
+  try {
+    const { stdout } = await execAsync5(
+      `osascript -e 'tell application "Finder" to get bounds of window of desktop'`,
+      { timeout: 3e3 }
+    );
+    const parts = stdout.trim().split(",").map((s) => parseInt(s.trim(), 10));
+    if (parts.length >= 4 && parts.every((n) => Number.isFinite(n))) {
+      const [x1, y1, x2, y2] = parts;
+      return { width: x2 - x1, height: y2 - y1 };
+    }
+  } catch {
+  }
+  return null;
+}
+async function runCliclick(args) {
+  const quoted = args.map((a) => `'${a.replace(/'/g, `'\\''`)}'`).join(" ");
+  const { stdout, stderr } = await execAsync5(`cliclick ${quoted}`, {
+    timeout: 15e3,
+    maxBuffer: 1024 * 1024
+  });
+  if (/accessibility privileges not enabled/i.test(stderr)) {
+    throw new Error(
+      "Accessibility permissions not granted to cliclick. Open System Settings \u2192 Privacy & Security \u2192 Accessibility, add cliclick (or the agent runtime), and toggle it on."
+    );
+  }
+  if (stderr && !stdout) throw new Error(stderr.trim());
+  return (stdout || "").trim();
+}
+async function runScreencapture(path) {
+  await execAsync5(`screencapture -x -t png '${path.replace(/'/g, `'\\''`)}'`, {
+    timeout: 5e3
+  });
+}
+async function resizeScreenshotToPoints(path, targetWidth, targetHeight) {
+  const sharpModule = await import("sharp");
+  const sharp2 = sharpModule.default || sharpModule;
+  const meta = await sharp2(path).metadata();
+  if (meta.width === targetWidth && meta.height === targetHeight) {
+    return readFileSync7(path);
+  }
+  return await sharp2(path).resize(targetWidth, targetHeight, { fit: "fill" }).png().toBuffer();
+}
+async function runScroll(dx, dy) {
+  const wheelY = -Math.round(dy);
+  const wheelX = -Math.round(dx);
+  const script = `ObjC.import('CoreGraphics');var ev = $.CGEventCreateScrollWheelEvent(null, 0, 2, ${wheelY}, ${wheelX});$.CGEventPost(0, ev);`;
+  await execAsync5(
+    `osascript -l JavaScript -e '${script.replace(/'/g, `'\\''`)}'`,
+    { timeout: 5e3 }
+  );
+}
+function translateKeyForCliclick(key) {
+  if (!key) return [];
+  const parts = key.split("+").map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0) return [];
+  const modMap = {
+    ctrl: "ctrl",
+    control: "ctrl",
+    alt: "alt",
+    option: "alt",
+    shift: "shift",
+    cmd: "cmd",
+    super: "cmd",
+    meta: "cmd",
+    win: "cmd",
+    fn: "fn"
+  };
+  const keyMap = {
+    return: "enter",
+    enter: "enter",
+    esc: "esc",
+    escape: "esc",
+    backspace: "delete",
+    back_space: "delete",
+    delete: "fwd-delete",
+    fwd_delete: "fwd-delete",
+    forward_delete: "fwd-delete",
+    tab: "tab",
+    space: "space",
+    up: "arrow-up",
+    arrow_up: "arrow-up",
+    down: "arrow-down",
+    arrow_down: "arrow-down",
+    left: "arrow-left",
+    arrow_left: "arrow-left",
+    right: "arrow-right",
+    arrow_right: "arrow-right",
+    page_up: "page-up",
+    pageup: "page-up",
+    page_down: "page-down",
+    pagedown: "page-down",
+    home: "home",
+    end: "end",
+    f1: "f1",
+    f2: "f2",
+    f3: "f3",
+    f4: "f4",
+    f5: "f5",
+    f6: "f6",
+    f7: "f7",
+    f8: "f8",
+    f9: "f9",
+    f10: "f10",
+    f11: "f11",
+    f12: "f12"
+  };
+  const modifiers = [];
+  let mainKey = null;
+  for (let i = 0; i < parts.length; i++) {
+    const lower = parts[i].toLowerCase().replace(/-/g, "_");
+    if (i < parts.length - 1 && modMap[lower]) {
+      modifiers.push(modMap[lower]);
+    } else {
+      mainKey = keyMap[lower] || lower;
+    }
+  }
+  const args = [];
+  if (modifiers.length > 0) args.push(`kd:${modifiers.join(",")}`);
+  if (mainKey) {
+    const isNamedKey = Object.values(keyMap).includes(mainKey) || /^f([1-9]|1[0-9]|20)$/.test(mainKey) || /^num-/.test(mainKey);
+    if (isNamedKey) {
+      args.push(`kp:${mainKey}`);
+    } else {
+      args.push(`t:${mainKey}`);
+    }
+  }
+  if (modifiers.length > 0) args.push(`ku:${modifiers.join(",")}`);
+  return args;
+}
+function modifierStringToCliclick(text) {
+  return text.split("+").map((p) => p.trim().toLowerCase()).map((p) => {
+    if (p === "ctrl" || p === "control") return "ctrl";
+    if (p === "alt" || p === "option") return "alt";
+    if (p === "shift") return "shift";
+    if (p === "super" || p === "meta" || p === "cmd") return "cmd";
+    return "";
+  }).filter(Boolean);
+}
+function createComputerUseTool(options) {
+  const displayWidth = options.displayWidth ?? DEFAULT_WIDTH;
+  const displayHeight = options.displayHeight ?? DEFAULT_HEIGHT;
+  return anthropic.tools.computer_20251124({
+    displayWidthPx: displayWidth,
+    displayHeightPx: displayHeight,
+    enableZoom: true,
+    execute: async (input) => {
+      try {
+        switch (input.action) {
+          case "screenshot": {
+            const path = join8(tmpdir(), `cu-${nanoid3(8)}.png`);
+            await runScreencapture(path);
+            const resized = await resizeScreenshotToPoints(path, displayWidth, displayHeight);
+            try {
+              unlinkSync2(path);
+            } catch {
+            }
+            return { type: "image", data: resized.toString("base64") };
+          }
+          case "left_click": {
+            const [x, y] = input.coordinate ?? [0, 0];
+            if (input.text) {
+              const mods = modifierStringToCliclick(input.text);
+              if (mods.length > 0) {
+                await runCliclick([`kd:${mods.join(",")}`, `c:${x},${y}`, `ku:${mods.join(",")}`]);
+              } else {
+                await runCliclick([`c:${x},${y}`]);
+              }
+            } else {
+              await runCliclick([`c:${x},${y}`]);
+            }
+            return `clicked at (${x}, ${y})${input.text ? ` with ${input.text}` : ""}`;
+          }
+          case "right_click": {
+            const [x, y] = input.coordinate ?? [0, 0];
+            await runCliclick([`rc:${x},${y}`]);
+            return `right-clicked at (${x}, ${y})`;
+          }
+          case "middle_click": {
+            const [x, y] = input.coordinate ?? [0, 0];
+            const script = `ObjC.import('CoreGraphics');var loc = $.CGPointMake(${x}, ${y});var down = $.CGEventCreateMouseEvent(null, 25, loc, 2);var up = $.CGEventCreateMouseEvent(null, 26, loc, 2);$.CGEventPost(0, down); $.CGEventPost(0, up);`;
+            await execAsync5(
+              `osascript -l JavaScript -e '${script.replace(/'/g, `'\\''`)}'`,
+              { timeout: 3e3 }
+            );
+            return `middle-clicked at (${x}, ${y})`;
+          }
+          case "double_click": {
+            const [x, y] = input.coordinate ?? [0, 0];
+            await runCliclick([`dc:${x},${y}`]);
+            return `double-clicked at (${x}, ${y})`;
+          }
+          case "triple_click": {
+            const [x, y] = input.coordinate ?? [0, 0];
+            await runCliclick([`tc:${x},${y}`]);
+            return `triple-clicked at (${x}, ${y})`;
+          }
+          case "mouse_move": {
+            const [x, y] = input.coordinate ?? [0, 0];
+            await runCliclick([`m:${x},${y}`]);
+            return `moved cursor to (${x}, ${y})`;
+          }
+          case "left_mouse_down": {
+            const [x, y] = input.coordinate ?? [0, 0];
+            await runCliclick([`dd:${x},${y}`]);
+            return `left mouse button pressed at (${x}, ${y})`;
+          }
+          case "left_mouse_up": {
+            const [x, y] = input.coordinate ?? [0, 0];
+            await runCliclick([`du:${x},${y}`]);
+            return `left mouse button released at (${x}, ${y})`;
+          }
+          case "left_click_drag": {
+            const [sx, sy] = input.start_coordinate ?? [0, 0];
+            const [ex, ey] = input.coordinate ?? [0, 0];
+            await runCliclick([`dd:${sx},${sy}`, `m:${ex},${ey}`, `du:${ex},${ey}`]);
+            return `dragged from (${sx}, ${sy}) to (${ex}, ${ey})`;
+          }
+          case "type": {
+            const text = input.text ?? "";
+            await runCliclick([`t:${text}`]);
+            return `typed ${text.length} character(s)`;
+          }
+          case "key": {
+            const args = translateKeyForCliclick(input.text ?? "");
+            if (args.length === 0) return "no key specified";
+            await runCliclick(args);
+            return `pressed ${input.text}`;
+          }
+          case "hold_key": {
+            const text = (input.text ?? "").toLowerCase();
+            const duration = input.duration ?? 1;
+            const modMap = {
+              ctrl: "ctrl",
+              control: "ctrl",
+              alt: "alt",
+              option: "alt",
+              shift: "shift",
+              cmd: "cmd",
+              super: "cmd",
+              meta: "cmd",
+              fn: "fn"
+            };
+            const cliName = modMap[text] || text;
+            await runCliclick([`kd:${cliName}`]);
+            await new Promise((r) => setTimeout(r, duration * 1e3));
+            await runCliclick([`ku:${cliName}`]);
+            return `held ${text} for ${duration}s`;
+          }
+          case "scroll": {
+            const direction = input.scroll_direction ?? "down";
+            const amount = input.scroll_amount ?? 3;
+            const px = amount * 100;
+            const dx = direction === "left" ? -px : direction === "right" ? px : 0;
+            const dy = direction === "up" ? -px : direction === "down" ? px : 0;
+            if (input.coordinate) {
+              const [x, y] = input.coordinate;
+              await runCliclick([`m:${x},${y}`]);
+            }
+            const mods = input.text ? modifierStringToCliclick(input.text) : [];
+            if (mods.length > 0) {
+              await runCliclick([`kd:${mods.join(",")}`]);
+            }
+            await runScroll(dx, dy);
+            if (mods.length > 0) {
+              await runCliclick([`ku:${mods.join(",")}`]);
+            }
+            return `scrolled ${direction} by ${amount}`;
+          }
+          case "wait": {
+            const duration = input.duration ?? 1;
+            await new Promise((r) => setTimeout(r, duration * 1e3));
+            return `waited ${duration}s`;
+          }
+          case "cursor_position": {
+            const out = await runCliclick(["p:."]);
+            return `cursor at ${out}`;
+          }
+          case "zoom": {
+            const region = input.region ?? [0, 0, displayWidth, displayHeight];
+            const [x1, y1, x2, y2] = region;
+            const tmpPath = join8(tmpdir(), `cu-zoom-${nanoid3(8)}.png`);
+            await runScreencapture(tmpPath);
+            const sharpModule = await import("sharp");
+            const sharp2 = sharpModule.default || sharpModule;
+            const meta = await sharp2(tmpPath).metadata();
+            const scaleX = (meta.width || displayWidth) / displayWidth;
+            const scaleY = (meta.height || displayHeight) / displayHeight;
+            const px = {
+              left: Math.max(0, Math.round(x1 * scaleX)),
+              top: Math.max(0, Math.round(y1 * scaleY)),
+              width: Math.max(1, Math.round((x2 - x1) * scaleX)),
+              height: Math.max(1, Math.round((y2 - y1) * scaleY))
+            };
+            const buf = await sharp2(tmpPath).extract(px).png().toBuffer();
+            try {
+              unlinkSync2(tmpPath);
+            } catch {
+            }
+            return { type: "image", data: buf.toString("base64") };
+          }
+          default: {
+            const exhaustive = input.action;
+            return `unsupported action: ${String(exhaustive)}`;
+          }
+        }
+      } catch (err) {
+        const msg = err?.message || String(err);
+        let hint = "";
+        if (/accessibility|not authorized|tcc|operation not permitted/i.test(msg)) {
+          hint = " (Hint: call enable_computer_use to (re-)check permissions and open System Settings)";
+        } else if (/command not found/i.test(msg)) {
+          hint = " (Hint: install cliclick with `brew install cliclick`)";
+        }
+        return `Error: ${msg}${hint}`;
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toModelOutput({ output }) {
+      if (typeof output === "string") {
+        return { type: "content", value: [{ type: "text", text: output }] };
+      }
+      return {
+        type: "content",
+        value: [{ type: "media", data: output.data, mediaType: "image/png" }]
+      };
+    }
+  });
+}
+
+// src/tools/enable-computer-use.ts
+init_db();
+import { tool as tool13 } from "ai";
+import { z as z14 } from "zod";
+var inputSchema = z14.object({
+  display_width: z14.number().int().positive().optional().describe("Display width in pixels (defaults to detected primary display, fallback 1280)"),
+  display_height: z14.number().int().positive().optional().describe("Display height in pixels (defaults to detected primary display, fallback 800)"),
+  request_permissions: z14.boolean().optional().default(true).describe(
+    "When true (default), proactively trigger macOS permission prompts and open System Settings panes for any missing permissions."
+  )
+});
+var ACCESSIBILITY_URL = "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility";
+var SCREEN_RECORDING_URL = "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture";
+function createEnableComputerUseTool(options) {
+  return tool13({
+    description: "Enable Anthropic's computer use beta tool for this session. macOS only. Drives the actual desktop (mouse, keyboard, screenshots) at pixel coordinates. Requires `cliclick` (brew install cliclick), Accessibility permissions, and Screen Recording permissions. When called, this tool will automatically request any missing permissions and open System Settings to the right pane. Only works on Anthropic Claude models. After this tool succeeds, you MUST stop the current turn and ask the user to send another message \u2014 the `computer` tool only becomes available on the NEXT message because the toolset is fixed for the current turn.",
+    inputSchema,
+    execute: async ({ display_width, display_height, request_permissions }) => {
+      try {
+        if (!isMacOs()) {
+          return {
+            success: false,
+            error: "Computer use is currently only supported on macOS.",
+            platform: process.platform
+          };
+        }
+        if (!await isCliclickInstalled()) {
+          return {
+            success: false,
+            error: "`cliclick` is not installed. It is required for mouse/keyboard control on macOS.",
+            installCommand: "brew install cliclick",
+            fixSteps: [
+              "In a terminal on this Mac, run: brew install cliclick",
+              "(If Homebrew is not installed, install it first from https://brew.sh)",
+              "Then call enable_computer_use again"
+            ]
+          };
+        }
+        const acc = await hasAccessibilityPermissions();
+        const screen = await hasScreenRecordingPermissions();
+        const missing = [];
+        if (!acc.ok) {
+          let prompted = false;
+          let panelOpened = false;
+          if (request_permissions) {
+            prompted = await requestAccessibilityPrompt().then(() => true).catch(() => false);
+            await openSystemSettings("accessibility").then(() => {
+              panelOpened = true;
+            }).catch(() => void 0);
+          }
+          missing.push({
+            name: "Accessibility",
+            reason: "cliclick failed: " + (acc.error?.split("\n")[0] || "no permission"),
+            pane: "accessibility",
+            settingsUrl: ACCESSIBILITY_URL,
+            fixSteps: [
+              "In the System Settings \u2192 Privacy & Security \u2192 Accessibility pane that opened",
+              "Click the + button",
+              "Add the application running the agent (Terminal, iTerm, your IDE, or `node`)",
+              "Toggle the switch ON",
+              "Restart the agent process so the new permission takes effect",
+              "Then call enable_computer_use again"
+            ],
+            prompted,
+            panelOpened
+          });
+        }
+        if (!screen) {
+          let prompted = false;
+          let panelOpened = false;
+          if (request_permissions) {
+            prompted = await requestScreenRecordingPrompt().then(() => true).catch(() => false);
+            await openSystemSettings("screen-recording").then(() => {
+              panelOpened = true;
+            }).catch(() => void 0);
+          }
+          missing.push({
+            name: "Screen Recording",
+            reason: "CGPreflightScreenCaptureAccess returned false",
+            pane: "screen-recording",
+            settingsUrl: SCREEN_RECORDING_URL,
+            fixSteps: [
+              "In the System Settings \u2192 Privacy & Security \u2192 Screen Recording pane that opened",
+              "Click the + button",
+              "Add the application running the agent (Terminal, iTerm, your IDE, or `node`)",
+              "Toggle the switch ON",
+              "Restart the agent process so the new permission takes effect",
+              "Then call enable_computer_use again"
+            ],
+            prompted,
+            panelOpened
+          });
+        }
+        if (missing.length > 0) {
+          return {
+            success: false,
+            error: `Missing permission${missing.length > 1 ? "s" : ""}: ` + missing.map((m) => m.name).join(" and ") + ".",
+            missingPermissions: missing,
+            note: request_permissions ? "System permission prompts have been triggered (best-effort) and System Settings has been opened to the relevant pane(s). After granting and restarting the agent, call enable_computer_use again." : "Re-run with request_permissions: true to auto-open System Settings."
+          };
+        }
+        let width = display_width;
+        let height = display_height;
+        let detected = null;
+        if (width === void 0 || height === void 0) {
+          detected = await detectScreenSize();
+          width = width ?? detected?.width ?? 1280;
+          height = height ?? detected?.height ?? 800;
+        }
+        const session = await sessionQueries.getById(options.sessionId);
+        if (!session) {
+          return { success: false, error: "Session not found" };
+        }
+        const config = session.config || {};
+        if (config.computerUseEnabled === true && config.computerUseDisplayWidth === width && config.computerUseDisplayHeight === height) {
+          return {
+            success: true,
+            alreadyEnabled: true,
+            message: "Computer use was already enabled for this session.",
+            displayWidth: width,
+            displayHeight: height
+          };
+        }
+        const updated = {
+          ...config,
+          computerUseEnabled: true,
+          computerUseDisplayWidth: width,
+          computerUseDisplayHeight: height
+        };
+        await sessionQueries.update(options.sessionId, { config: updated });
+        return {
+          success: true,
+          enabled: true,
+          platform: "darwin",
+          displayWidth: width,
+          displayHeight: height,
+          detectedScreenSize: detected || void 0,
+          permissions: {
+            accessibility: "granted",
+            screenRecording: "granted"
+          },
+          message: `Computer use is now enabled for this session. IMPORTANT: The \`computer\` tool is NOT yet available in this turn. Stop here, send a brief message to the user telling them computer use is enabled (display: ${width}x${height}), and ask them to send their next message to begin using it.`
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err?.message || String(err)
+        };
+      }
+    }
+  });
+}
+
 // src/tools/index.ts
 init_semantic();
 init_remote();
@@ -5613,6 +6190,20 @@ async function createTools(options) {
       sessionId: options.sessionId
     });
   }
+  if (process.platform === "darwin") {
+    if (options.enableComputerUse) {
+      tools.computer = createComputerUseTool({
+        workingDirectory: options.workingDirectory,
+        sessionId: options.sessionId,
+        displayWidth: options.computerUseDisplayWidth,
+        displayHeight: options.computerUseDisplayHeight
+      });
+    } else {
+      tools.enable_computer_use = createEnableComputerUseTool({
+        sessionId: options.sessionId
+      });
+    }
+  }
   if (options.enableSemanticSearch !== false) {
     try {
       if (isVectorGatewayConfigured()) {
@@ -6598,7 +7189,14 @@ function repairToolPairing(messages) {
 }
 
 // src/utils/webhook.ts
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set([
+  "task.started",
+  "task.completed",
+  "task.failed"
+]);
+var QUIET = process.env.SPARKECODER_QUIET_WEBHOOKS === "1";
 async function sendWebhook(url, event) {
+  const t0 = Date.now();
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 5e3);
@@ -6612,12 +7210,24 @@ async function sendWebhook(url, event) {
       signal: controller.signal
     });
     clearTimeout(timeout);
+    const ms = Date.now() - t0;
     if (!response.ok) {
-      console.warn(`[WEBHOOK] ${event.type} to ${url} returned HTTP ${response.status}`);
+      const body = await response.text().catch(() => "");
+      console.warn(
+        `[WEBHOOK] ${event.type} task=${event.taskId} -> HTTP ${response.status} in ${ms}ms${body ? ` (${body.slice(0, 200)})` : ""}`
+      );
+      return;
+    }
+    if (!QUIET || TERMINAL_EVENTS.has(event.type)) {
+      console.log(
+        `[WEBHOOK] ${event.type} task=${event.taskId} -> 200 in ${ms}ms`
+      );
     }
   } catch (err) {
     const reason = err.name === "AbortError" ? "timeout (5s)" : err.message;
-    console.warn(`[WEBHOOK] ${event.type} to ${url} failed: ${reason}`);
+    console.warn(
+      `[WEBHOOK] ${event.type} task=${event.taskId} -> failed: ${reason}`
+    );
   }
 }
 
@@ -6660,10 +7270,14 @@ var Agent = class _Agent {
    */
   async createToolsWithCallbacks(options) {
     const config = getConfig();
+    const sessionConfig = this.session.config || {};
     return createTools({
       sessionId: this.session.id,
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
+      enableComputerUse: sessionConfig.computerUseEnabled === true,
+      computerUseDisplayWidth: sessionConfig.computerUseDisplayWidth,
+      computerUseDisplayHeight: sessionConfig.computerUseDisplayHeight,
       onBashProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "bash", data: progress }) : void 0,
       onWriteFileProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "write_file", data: progress }) : void 0,
       onSearchProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "explore_agent", data: progress }) : void 0
@@ -6696,10 +7310,14 @@ var Agent = class _Agent {
       keepRecentMessages: config.context?.keepRecentMessages || 10,
       autoSummarize: config.context?.autoSummarize ?? true
     });
+    const sessionConfig = session.config || {};
     const tools = await createTools({
       sessionId: session.id,
       workingDirectory: session.workingDirectory,
-      skillsDirectories: config.resolvedSkillsDirectories
+      skillsDirectories: config.resolvedSkillsDirectories,
+      enableComputerUse: sessionConfig.computerUseEnabled === true,
+      computerUseDisplayWidth: sessionConfig.computerUseDisplayWidth,
+      computerUseDisplayHeight: sessionConfig.computerUseDisplayHeight
     });
     return new _Agent(session, context, tools);
   }
@@ -6918,10 +7536,14 @@ ${prompt}` });
         });
       }
     };
+    const taskSessionConfig = this.session.config || {};
     const taskTools = await createTools({
       sessionId: this.session.id,
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
+      enableComputerUse: taskSessionConfig.computerUseEnabled === true,
+      computerUseDisplayWidth: taskSessionConfig.computerUseDisplayWidth,
+      computerUseDisplayHeight: taskSessionConfig.computerUseDisplayHeight,
       onBashProgress: bashProgressHandler,
       onWriteFileProgress: (progress) => {
         options.onToolProgress?.({ toolName: "write_file", data: progress });
@@ -7204,11 +7826,11 @@ ${taskAddendum}`;
       const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
       if (!isRemoteConfigured2()) return [];
       const { readFile: readFile12 } = await import("fs/promises");
-      const { join: join9, basename: basename5 } = await import("path");
+      const { join: join10, basename: basename5 } = await import("path");
       const urls = [];
       for (const filePath of filePaths) {
         try {
-          const fullPath = filePath.startsWith("/") ? filePath : join9(this.session.workingDirectory, filePath);
+          const fullPath = filePath.startsWith("/") ? filePath : join10(this.session.workingDirectory, filePath);
           const fileName = basename5(fullPath);
           const ext = fileName.split(".").pop()?.toLowerCase() || "";
           const mimeMap = {
@@ -7266,11 +7888,11 @@ ${taskAddendum}`;
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool13({
+      wrappedTools[name] = tool14({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z14.object({}),
+        inputSchema: originalTool.inputSchema || z15.object({}),
         execute: async (input, toolOptions) => {
-          const toolCallId = toolOptions.toolCallId || nanoid4();
+          const toolCallId = toolOptions.toolCallId || nanoid5();
           const execution = toolExecutionQueries.create({
             sessionId: this.session.id,
             toolName: name,
@@ -7288,10 +7910,10 @@ ${taskAddendum}`;
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
           this.pendingApprovals.delete(toolCallId);
-          const exec6 = await execution;
+          const exec7 = await execution;
           if (!approved) {
             const reason = resolverData?.reason || "User rejected the tool execution";
-            await toolExecutionQueries.reject(exec6.id);
+            await toolExecutionQueries.reject(exec7.id);
             await sessionQueries.updateStatus(this.session.id, "active");
             return {
               status: "rejected",
@@ -7301,14 +7923,14 @@ ${taskAddendum}`;
               message: `Tool "${name}" was rejected by the user. Reason: ${reason}`
             };
           }
-          await toolExecutionQueries.approve(exec6.id);
+          await toolExecutionQueries.approve(exec7.id);
           await sessionQueries.updateStatus(this.session.id, "active");
           try {
             const result = await originalTool.execute(input, toolOptions);
-            await toolExecutionQueries.complete(exec6.id, result);
+            await toolExecutionQueries.complete(exec7.id, result);
             return result;
           } catch (error) {
-            await toolExecutionQueries.complete(exec6.id, null, error.message);
+            await toolExecutionQueries.complete(exec7.id, null, error.message);
             throw error;
           }
         }