Claude Computer Use macOS

import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
async function performDesktopAutomation(task: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 4096,
    system: `You are a macOS desktop automation expert.
Always verify actions visually before proceeding.`,
    messages: [
      {
        role: "user",
        content: task,
      },
    ],
  });
 
  return response.content[0].type === "text" ? response.content[0].text : "";
}

interface OperationResult {
  success: boolean;
  screenshot?: string;
  error?: string;
  confidence: number;
}
 
async function clickWithVerification(
  x: number,
  y: number
): Promise<OperationResult> {
  try {
    const beforeScreenshot = await captureScreen();
    await performClick(x, y);
    const afterScreenshot = await captureScreen();
    const hasChanged = await detectScreenChange(
      beforeScreenshot,
      afterScreenshot
    );
 
    return {
      success: hasChanged,
      screenshot: afterScreenshot,
      confidence: 85,
    };
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : "Unknown error",
      confidence: 0,
    };
  }
}

sudo dscl . -create /Users/claude-automation
sudo dscl . -create /Users/claude-automation UserShell /bin/bash
sudo dscl . -create /Users/claude-automation RealName "Claude Automation"

import { execSync } from "child_process";
 
function getCredentialsFromKeychain(serviceName: string): string {
  try {
    const credential = execSync(
      `security find-generic-password -s "${serviceName}" -w`,
      { encoding: "utf-8" }
    );
    return credential.trim();
  } catch {
    throw new Error(`Could not retrieve credentials for ${serviceName}`);
  }
}
 
async function loginSecurely(serviceName: string): Promise<void> {
  const password = getCredentialsFromKeychain(serviceName);
 
  await client.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 2048,
    messages: [
      {
        role: "user",
        content: `Use Keychain credentials to log in securely.`,
      },
    ],
  });
}

interface AuditLog {
  timestamp: string;
  action: string;
  result: "success" | "failure";
  details: Record<string, unknown>;
}
 
async function logAction(
  action: string,
  result: "success" | "failure",
  details: Record<string, unknown>
): Promise<void> {
  const log: AuditLog = {
    timestamp: new Date().toISOString(),
    action,
    result,
    details,
  };
 
  await saveAuditLog(log);
  console.log(`[${log.timestamp}] ${log.action}: ${log.result}`);
}

interface ROIRegion {
  x: number;
  y: number;
  width: number;
  height: number;
}
 
async function captureROI(roi: ROIRegion): Promise<Buffer> {
  const cmd = `screencapture -R${roi.x},${roi.y},${roi.width},${roi.height} -`;
 
  return new Promise((resolve, reject) => {
    execFile("bash", ["-c", cmd], (error, stdout) => {
      if (error) reject(error);
      resolve(Buffer.from(stdout, "binary"));
    });
  });
}

async function parallelAutomation(tasks: string[]): Promise<string[]> {
  return Promise.all(
    tasks.map(async (task) => {
      const response = await client.messages.create({
        model: "claude-opus-4-6",
        max_tokens: 2048,
        messages: [{ role: "user", content: task }],
      });
      return response.content[0].type === "text"
        ? response.content[0].text
        : "No response";
    })
  );
}