@hasna/computer 0.1.8 → 0.1.10

package/dist/mcp/index.js

@@ -4917,9 +4917,11 @@ var require_lib2 = __commonJS((exports, module) => {
 });
 
 // src/mcp/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -19055,6 +19057,188 @@ function getAccessibilityHelperPath() {
   throw new Error("Accessibility helper not found. Run `swiftc helpers/accessibility.swift -o helpers/accessibility -framework AppKit` from the project root.");
 }
 
+// src/apps/ghostty/driver.ts
+import { existsSync as existsSync4 } from "fs";
+
+// src/apps/ghostty/applescript.ts
+function parseGrid(spec) {
+  const m = /^(\d+)x(\d+)$/.exec(spec.trim());
+  if (!m)
+    throw new Error(`Invalid grid spec "${spec}" \u2014 expected RxC (e.g. 2x2, 3x1)`);
+  const rows = parseInt(m[1], 10);
+  const cols = parseInt(m[2], 10);
+  if (rows < 1 || cols < 1) {
+    throw new Error(`Invalid grid spec "${spec}" \u2014 rows and cols must be >= 1`);
+  }
+  return { rows, cols };
+}
+function parseTabsSpec(spec) {
+  const parts = spec.split(",");
+  if (parts.length === 0 || spec.trim() === "") {
+    throw new Error(`Invalid tabs spec "${spec}" \u2014 expected comma-separated grids (e.g. "2x2,1x2")`);
+  }
+  return parts.map((p) => parseGrid(p));
+}
+function escapeAppleScript(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function assignPaneCommands(totalPanes, run, all) {
+  if (all) {
+    if (run.length !== 1) {
+      throw new Error(`--all requires exactly one --run command (got ${run.length})`);
+    }
+    return Array.from({ length: totalPanes }, () => run[0]);
+  }
+  if (run.length > totalPanes) {
+    throw new Error(`Got ${run.length} commands for ${totalPanes} pane${totalPanes === 1 ? "" : "s"} \u2014 add panes or drop commands`);
+  }
+  return Array.from({ length: totalPanes }, (_, i) => run[i]);
+}
+function buildGhosttyScript(opts) {
+  const { tabs, commands = [], dir, max = false } = opts;
+  if (tabs.length === 0)
+    throw new Error("At least one tab grid is required");
+  const lines = [];
+  lines.push('tell application "Ghostty"');
+  lines.push("  activate");
+  lines.push("  set w to new window");
+  const term = (t, r, c) => `t${t}_${r}_${c}`;
+  let paneIndex = 0;
+  for (let t = 0;t < tabs.length; t++) {
+    const { rows, cols } = tabs[t];
+    if (t === 0) {
+      lines.push(`  set ${term(0, 0, 0)} to focused terminal of selected tab of w`);
+      if (max) {
+        lines.push(`  perform action "toggle_maximize" on ${term(0, 0, 0)}`);
+      }
+    } else {
+      lines.push(`  set tb${t} to new tab in w`);
+      lines.push(`  set ${term(t, 0, 0)} to focused terminal of tb${t}`);
+    }
+    for (let r = 1;r < rows; r++) {
+      lines.push(`  set ${term(t, r, 0)} to split ${term(t, r - 1, 0)} direction down`);
+    }
+    for (let r = 0;r < rows; r++) {
+      for (let c = 1;c < cols; c++) {
+        lines.push(`  set ${term(t, r, c)} to split ${term(t, r, c - 1)} direction right`);
+      }
+    }
+    if (rows * cols > 1) {
+      lines.push(`  perform action "equalize_splits" on ${term(t, 0, 0)}`);
+    }
+    for (let r = 0;r < rows; r++) {
+      for (let c = 0;c < cols; c++) {
+        const raw = commands[paneIndex];
+        paneIndex++;
+        let cmd;
+        if (dir && raw)
+          cmd = `cd ${shellQuote(dir)} && ${raw}`;
+        else if (dir)
+          cmd = `cd ${shellQuote(dir)}`;
+        else
+          cmd = raw;
+        if (cmd) {
+          lines.push(`  input text "${escapeAppleScript(cmd)}" to ${term(t, r, c)}`);
+          lines.push(`  send key "enter" to ${term(t, r, c)}`);
+        }
+      }
+    }
+  }
+  lines.push(`  focus ${term(0, 0, 0)}`);
+  lines.push("end tell");
+  return lines.join(`
+`) + `
+`;
+}
+
+// src/apps/ghostty/driver.ts
+var APP_BUNDLE = "/Applications/Ghostty.app";
+function ghosttyAvailability(env = {}) {
+  const platform = env.platform ?? process.platform;
+  if (platform !== "darwin") {
+    return { available: false, reason: "Ghostty orchestration requires macOS (AppleScript)" };
+  }
+  const hasAppBundle = env.hasAppBundle ?? existsSync4(APP_BUNDLE);
+  const hasBinary = env.hasBinary ?? Bun.which("ghostty") !== null;
+  if (!hasAppBundle && !hasBinary) {
+    return { available: false, reason: `Ghostty not found (${APP_BUNDLE} missing and no \`ghostty\` on PATH)` };
+  }
+  return { available: true };
+}
+async function runOsascript(script) {
+  const proc = Bun.spawn(["osascript", "-e", script], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const code = await proc.exited;
+  const stderr = await new Response(proc.stderr).text();
+  return { ok: code === 0, stderr: stderr.trim() };
+}
+function resolveTabs(spec) {
+  if (spec.tabs && spec.tabs.length > 0)
+    return spec.tabs;
+  return [spec.grid ?? { rows: 1, cols: 1 }];
+}
+var ghosttyDriver = {
+  name: "ghostty",
+  description: "Ghostty terminal \u2014 windows with pane grids, tabs, and a command per pane",
+  available() {
+    return ghosttyAvailability();
+  },
+  async open(spec) {
+    const availability = ghosttyAvailability();
+    if (!availability.available) {
+      return { ok: false, message: availability.reason ?? "Ghostty is not available" };
+    }
+    const tabs = resolveTabs(spec);
+    const totalPanes = tabs.reduce((sum, g) => sum + g.rows * g.cols, 0);
+    let commands;
+    try {
+      commands = assignPaneCommands(totalPanes, spec.run ?? [], spec.all ?? false);
+    } catch (err) {
+      return { ok: false, message: err instanceof Error ? err.message : String(err) };
+    }
+    const script = buildGhosttyScript({
+      tabs,
+      commands,
+      dir: spec.dir,
+      max: spec.max
+    });
+    const result = await runOsascript(script);
+    if (!result.ok) {
+      return {
+        ok: false,
+        message: `osascript failed: ${result.stderr || "unknown error"}`,
+        panes: totalPanes,
+        tabs: tabs.length
+      };
+    }
+    const tabDesc = tabs.map((g) => `${g.rows}x${g.cols}`).join(",");
+    return {
+      ok: true,
+      message: `Opened Ghostty: ${tabs.length} tab${tabs.length === 1 ? "" : "s"} (${tabDesc}), ${totalPanes} pane${totalPanes === 1 ? "" : "s"}`,
+      panes: totalPanes,
+      tabs: tabs.length
+    };
+  }
+};
+
+// src/apps/registry.ts
+var drivers = new Map;
+function registerAppDriver(driver) {
+  drivers.set(driver.name.toLowerCase(), driver);
+}
+function getAppDriver(name) {
+  return drivers.get(name.toLowerCase());
+}
+function listAppDrivers() {
+  return [...drivers.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+registerAppDriver(ghosttyDriver);
+
 // src/db/pg-migrations.ts
 var PG_MIGRATIONS = [
   `
@@ -19164,32 +19348,65 @@ class PgAdapterAsync {
   }
 }
 
-// src/db/cloud-sync.ts
-var CLOUD_TABLES = ["sessions", "action_logs", "feedback"];
+// src/db/storage-sync.ts
+var STORAGE_TABLES = ["sessions", "action_logs", "feedback"];
+var COMPUTER_STORAGE_ENV = "HASNA_COMPUTER_DATABASE_URL";
+var COMPUTER_STORAGE_FALLBACK_ENV = "COMPUTER_DATABASE_URL";
+var COMPUTER_STORAGE_MODE_ENV = "HASNA_COMPUTER_STORAGE_MODE";
+var COMPUTER_STORAGE_MODE_FALLBACK_ENV = "COMPUTER_STORAGE_MODE";
+var STORAGE_DATABASE_ENV = [COMPUTER_STORAGE_ENV, COMPUTER_STORAGE_FALLBACK_ENV];
 var PRIMARY_KEYS = {
   sessions: ["id"],
   action_logs: ["id"],
   feedback: ["id"]
 };
-function getCloudDatabaseUrl() {
-  return process.env["HASNA_COMPUTER_CLOUD_DATABASE_URL"] ?? process.env["OPEN_COMPUTER_CLOUD_DATABASE_URL"] ?? process.env["COMPUTER_CLOUD_DATABASE_URL"] ?? null;
+function readEnv3(name) {
+  const value = process.env[name]?.trim();
+  return value || undefined;
+}
+function normalizeStorageMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "local" || normalized === "hybrid" || normalized === "remote")
+    return normalized;
+  return;
+}
+function getStorageDatabaseEnvName() {
+  for (const name of STORAGE_DATABASE_ENV) {
+    if (readEnv3(name))
+      return name;
+  }
+  return null;
+}
+function getStorageDatabaseEnv() {
+  const name = getStorageDatabaseEnvName();
+  return name ? { name } : null;
 }
-async function getCloudPg() {
-  const url = getCloudDatabaseUrl();
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv3(env.name) ?? null : null;
+}
+function getStorageMode() {
+  const mode = normalizeStorageMode(readEnv3(COMPUTER_STORAGE_MODE_ENV) ?? readEnv3(COMPUTER_STORAGE_MODE_FALLBACK_ENV));
+  if (mode)
+    return mode;
+  return getStorageDatabaseUrl() ? "hybrid" : "local";
+}
+async function getStoragePg() {
+  const url = getStorageDatabaseUrl();
   if (!url) {
-    throw new Error("Missing HASNA_COMPUTER_CLOUD_DATABASE_URL, OPEN_COMPUTER_CLOUD_DATABASE_URL, or COMPUTER_CLOUD_DATABASE_URL");
+    throw new Error("Missing HASNA_COMPUTER_DATABASE_URL");
   }
   return new PgAdapterAsync(url);
 }
-async function runCloudMigrations(remote) {
+async function runStorageMigrations(remote) {
   for (const sql of PG_MIGRATIONS)
     await remote.run(sql);
 }
-async function cloudPush(options) {
-  const remote = await getCloudPg();
+async function storagePush(options) {
+  const remote = await getStoragePg();
   const db2 = getDb();
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     const results = [];
     for (const table of resolveTables(options?.tables))
       results.push(await pushTable(db2, remote, table));
@@ -19199,11 +19416,11 @@ async function cloudPush(options) {
     await remote.close();
   }
 }
-async function cloudPull(options) {
-  const remote = await getCloudPg();
+async function storagePull(options) {
+  const remote = await getStoragePg();
   const db2 = getDb();
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     const results = [];
     for (const table of resolveTables(options?.tables))
       results.push(await pullTable(remote, db2, table));
@@ -19213,9 +19430,9 @@ async function cloudPull(options) {
     await remote.close();
   }
 }
-async function cloudSync(options) {
-  const pull = await cloudPull(options);
-  const push2 = await cloudPush(options);
+async function storageSync(options) {
+  const pull = await storagePull(options);
+  const push2 = await storagePush(options);
   return { pull, push: push2 };
 }
 function getSyncMetaAll() {
@@ -19223,10 +19440,22 @@ function getSyncMetaAll() {
   ensureSyncMetaTable(db2);
   return db2.prepare("SELECT table_name, last_synced_at, direction FROM _computer_sync_meta ORDER BY table_name, direction").all();
 }
+function getStorageStatus() {
+  const activeEnv = getStorageDatabaseEnv();
+  return {
+    configured: Boolean(activeEnv),
+    mode: getStorageMode(),
+    env: STORAGE_DATABASE_ENV,
+    activeEnv: activeEnv?.name ?? null,
+    service: "computer",
+    tables: STORAGE_TABLES,
+    sync: getSyncMetaAll()
+  };
+}
 function resolveTables(tables) {
   if (!tables || tables.length === 0)
-    return [...CLOUD_TABLES];
-  const allowed = new Set(CLOUD_TABLES);
+    return [...STORAGE_TABLES];
+  const allowed = new Set(STORAGE_TABLES);
   const requested = tables.map((table) => table.trim()).filter(Boolean);
   const invalid = requested.filter((table) => !allowed.has(table));
   if (invalid.length > 0)
@@ -19352,256 +19581,374 @@ function coerceForSqlite(value) {
   return String(value);
 }
 
-// src/mcp/index.ts
-var server = new McpServer({
-  name: "computer",
-  version: "0.1.0"
-});
-function cloudResult(value) {
+// src/mcp/server.ts
+function storageResult(value) {
   return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
 }
-server.tool("computer_run_task", "Run a computer use task \u2014 the AI sees your screen and controls mouse/keyboard to complete it", {
-  task: exports_external.string().describe("Natural language description of what to do"),
-  provider: exports_external.enum(["anthropic", "openai"]).default("anthropic").describe("AI provider"),
-  model: exports_external.string().optional().describe("Specific model to use"),
-  max_steps: exports_external.number().default(50).describe("Maximum steps before stopping"),
-  save_screenshots: exports_external.boolean().default(false).describe("Save screenshots to disk"),
-  dry_run: exports_external.boolean().default(false).describe("Plan actions without executing them")
-}, async (params) => {
-  const session = await runTask({
-    task: params.task,
-    provider: params.provider,
-    model: params.model,
-    maxSteps: params.max_steps,
-    saveScreenshots: params.save_screenshots,
-    dryRun: params.dry_run
+function buildServer() {
+  const server = new McpServer({
+    name: "computer",
+    version: "0.1.10"
   });
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(session, null, 2)
-      }
-    ]
-  };
-});
-server.tool("computer_screenshot", "Capture a screenshot of the current screen", {
-  save_to: exports_external.string().optional().describe("Optional file path to save the screenshot")
-}, async (params) => {
-  const ss = await captureScreenshot();
-  if (params.save_to) {
-    const dir = params.save_to.substring(0, params.save_to.lastIndexOf("/"));
-    const file = params.save_to.substring(params.save_to.lastIndexOf("/") + 1);
-    await saveScreenshotToFile(ss, dir, file);
-  }
-  return {
-    content: [
-      {
-        type: "image",
-        data: ss.base64,
-        mimeType: "image/png"
-      },
-      {
-        type: "text",
-        text: `Screen: ${ss.size.width}x${ss.size.height}`
+  server.tool("computer_run_task", "Run a computer use task \u2014 the AI sees your screen and controls mouse/keyboard to complete it", {
+    task: exports_external.string().describe("Natural language description of what to do"),
+    provider: exports_external.enum(["anthropic", "openai"]).default("anthropic").describe("AI provider"),
+    model: exports_external.string().optional().describe("Specific model to use"),
+    max_steps: exports_external.number().default(50).describe("Maximum steps before stopping"),
+    save_screenshots: exports_external.boolean().default(false).describe("Save screenshots to disk"),
+    dry_run: exports_external.boolean().default(false).describe("Plan actions without executing them")
+  }, async (params) => {
+    const session = await runTask({
+      task: params.task,
+      provider: params.provider,
+      model: params.model,
+      maxSteps: params.max_steps,
+      saveScreenshots: params.save_screenshots,
+      dryRun: params.dry_run
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(session, null, 2)
+        }
+      ]
+    };
+  });
+  server.tool("computer_screenshot", "Capture a screenshot of the current screen", {
+    save_to: exports_external.string().optional().describe("Optional file path to save the screenshot")
+  }, async (params) => {
+    const ss = await captureScreenshot();
+    if (params.save_to) {
+      const dir = params.save_to.substring(0, params.save_to.lastIndexOf("/"));
+      const file = params.save_to.substring(params.save_to.lastIndexOf("/") + 1);
+      await saveScreenshotToFile(ss, dir, file);
+    }
+    return {
+      content: [
+        {
+          type: "image",
+          data: ss.base64,
+          mimeType: "image/png"
+        },
+        {
+          type: "text",
+          text: `Screen: ${ss.size.width}x${ss.size.height}`
+        }
+      ]
+    };
+  });
+  server.tool("computer_click", "Click at a specific screen coordinate", {
+    x: exports_external.number().describe("X coordinate"),
+    y: exports_external.number().describe("Y coordinate"),
+    button: exports_external.enum(["left", "right", "middle"]).default("left").describe("Mouse button"),
+    count: exports_external.number().default(1).describe("Click count (1=single, 2=double, 3=triple)")
+  }, async (params) => {
+    const result = await executeAction({
+      type: "click",
+      point: { x: params.x, y: params.y },
+      button: params.button,
+      count: params.count
+    });
+    const content = [{ type: "text", text: result.success ? "Click executed" : `Click failed: ${result.error}` }];
+    if (result.screenshot) {
+      content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
+    }
+    return { content };
+  });
+  server.tool("computer_type", "Type text using the keyboard", {
+    text: exports_external.string().describe("Text to type")
+  }, async (params) => {
+    const result = await executeAction({ type: "type", text: params.text });
+    const content = [{ type: "text", text: result.success ? "Text typed" : `Type failed: ${result.error}` }];
+    if (result.screenshot) {
+      content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
+    }
+    return { content };
+  });
+  server.tool("computer_key", "Press a key or key combination (e.g. 'enter', 'cmd+c', 'ctrl+shift+a')", {
+    keys: exports_external.string().describe("Key or combination to press")
+  }, async (params) => {
+    const result = await executeAction({ type: "key", keys: params.keys });
+    const content = [{ type: "text", text: result.success ? "Key pressed" : `Key failed: ${result.error}` }];
+    if (result.screenshot) {
+      content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
+    }
+    return { content };
+  });
+  server.tool("computer_scroll", "Scroll at a specific position", {
+    x: exports_external.number().describe("X coordinate"),
+    y: exports_external.number().describe("Y coordinate"),
+    direction: exports_external.enum(["up", "down"]).describe("Scroll direction"),
+    amount: exports_external.number().default(3).describe("Scroll amount")
+  }, async (params) => {
+    const dy = params.direction === "down" ? params.amount : -params.amount;
+    const result = await executeAction({
+      type: "scroll",
+      point: { x: params.x, y: params.y },
+      deltaX: 0,
+      deltaY: dy
+    });
+    const content = [{ type: "text", text: result.success ? "Scrolled" : `Scroll failed: ${result.error}` }];
+    if (result.screenshot) {
+      content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
+    }
+    return { content };
+  });
+  server.tool("computer_mouse_move", "Move the mouse to a position", {
+    x: exports_external.number().describe("X coordinate"),
+    y: exports_external.number().describe("Y coordinate")
+  }, async (params) => {
+    const result = await executeAction({ type: "mouse_move", point: { x: params.x, y: params.y } });
+    return { content: [{ type: "text", text: result.success ? "Mouse moved" : `Move failed: ${result.error}` }] };
+  });
+  server.tool("computer_open_url", "Open a URL in the default browser", {
+    url: exports_external.string().describe("URL to open")
+  }, async (params) => {
+    const result = await executeAction({ type: "open_url", url: params.url });
+    const content = [{ type: "text", text: result.success ? "URL opened" : `Open failed: ${result.error}` }];
+    if (result.screenshot) {
+      content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
+    }
+    return { content };
+  });
+  server.tool("computer_open_app", "Open a macOS application. Apps with a registered driver (see computer_list_apps) support deterministic orchestration: pane grids, multiple tabs, a command per pane, working directory, and maximize. Other apps open normally.", {
+    app: exports_external.string().optional().describe("Application or driver name (e.g. 'ghostty', 'Safari', 'Slack')"),
+    name: exports_external.string().optional().describe("Deprecated alias for `app`"),
+    grid: exports_external.string().optional().describe('Pane grid RxC, e.g. "2x2" (driver apps only)'),
+    tabs: exports_external.string().optional().describe('Comma-separated grid specs, one per tab, e.g. "2x2,1x2,1x2" (driver apps only)'),
+    run: exports_external.array(exports_external.string()).optional().describe("Commands per pane in row-major order across tabs (driver apps only)"),
+    all: exports_external.boolean().default(false).describe("Run the single `run` command in every pane"),
+    dir: exports_external.string().optional().describe("Working directory \u2014 every pane cds here first"),
+    max: exports_external.boolean().default(false).describe("Maximize the new window (not native fullscreen)")
+  }, async (params) => {
+    const appName = params.app ?? params.name;
+    if (!appName) {
+      return { content: [{ type: "text", text: "Missing required parameter: app" }] };
+    }
+    const driver = getAppDriver(appName);
+    if (driver) {
+      try {
+        const result2 = await driver.open({
+          grid: params.grid ? parseGrid(params.grid) : undefined,
+          tabs: params.tabs ? parseTabsSpec(params.tabs) : undefined,
+          run: params.run,
+          all: params.all,
+          dir: params.dir,
+          max: params.max
+        });
+        return { content: [{ type: "text", text: result2.message }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Open failed: ${err instanceof Error ? err.message : err}` }] };
       }
-    ]
-  };
-});
-server.tool("computer_click", "Click at a specific screen coordinate", {
-  x: exports_external.number().describe("X coordinate"),
-  y: exports_external.number().describe("Y coordinate"),
-  button: exports_external.enum(["left", "right", "middle"]).default("left").describe("Mouse button"),
-  count: exports_external.number().default(1).describe("Click count (1=single, 2=double, 3=triple)")
-}, async (params) => {
-  const result = await executeAction({
-    type: "click",
-    point: { x: params.x, y: params.y },
-    button: params.button,
-    count: params.count
+    }
+    if (params.grid || params.tabs || params.run?.length || params.dir) {
+      return {
+        content: [
+          { type: "text", text: `No app driver registered for "${appName}" \u2014 grid/tabs/run/dir need a driver (see computer_list_apps). Opening normally requires dropping those params.` }
+        ]
+      };
+    }
+    const result = await executeAction({ type: "open_app", name: appName });
+    const content = [{ type: "text", text: result.success ? `Opened ${appName}` : `Open failed: ${result.error}` }];
+    if (result.screenshot) {
+      content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
+    }
+    return { content };
+  });
+  server.tool("computer_list_apps", "List registered app drivers (deterministic orchestration) and their availability on this machine", {}, async () => {
+    const apps = listAppDrivers().map((driver) => {
+      const availability = driver.available();
+      return {
+        name: driver.name,
+        description: driver.description,
+        available: availability.available,
+        ...availability.reason ? { reason: availability.reason } : {}
+      };
+    });
+    return { content: [{ type: "text", text: JSON.stringify(apps, null, 2) }] };
+  });
+  server.tool("computer_screen_size", "Get the current screen resolution", {}, async () => {
+    const size = await getScreenSize();
+    return { content: [{ type: "text", text: `${size.width}x${size.height}` }] };
+  });
+  server.tool("computer_list_sessions", "List past computer use sessions", {
+    limit: exports_external.number().default(20).describe("Max sessions to return"),
+    status: exports_external.enum(["running", "paused", "completed", "failed", "cancelled"]).optional().describe("Filter by status")
+  }, async (params) => {
+    const sessions = listSessions({ limit: params.limit, status: params.status });
+    return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
+  });
+  server.tool("computer_get_session", "Get details of a specific session including action log", {
+    id: exports_external.string().describe("Session ID")
+  }, async (params) => {
+    const session = getSession(params.id);
+    if (!session)
+      return { content: [{ type: "text", text: "Session not found" }] };
+    const logs = getActionLogs(params.id);
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ session, action_logs: logs }, null, 2) }
+      ]
+    };
+  });
+  server.tool("computer_delete_session", "Delete a session and its action logs", {
+    id: exports_external.string().describe("Session ID")
+  }, async (params) => {
+    const deleted = deleteSession(params.id);
+    return { content: [{ type: "text", text: deleted ? "Session deleted" : "Session not found" }] };
+  });
+  server.tool("computer_search", "Full-text search across sessions (by task) and action logs (by reasoning)", {
+    query: exports_external.string().describe("Search query"),
+    scope: exports_external.enum(["sessions", "actions", "both"]).default("both").describe("Where to search"),
+    limit: exports_external.number().default(20).describe("Max results")
+  }, async (params) => {
+    const results = {};
+    if (params.scope === "sessions" || params.scope === "both") {
+      results.sessions = searchSessions(params.query, params.limit);
+    }
+    if (params.scope === "actions" || params.scope === "both") {
+      results.action_logs = searchActionLogs(params.query, params.limit);
+    }
+    return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+  });
+  server.tool("computer_stats", "Get usage statistics for computer use", {}, async () => {
+    const stats = getStats();
+    return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
   });
-  const content = [{ type: "text", text: result.success ? "Click executed" : `Click failed: ${result.error}` }];
-  if (result.screenshot) {
-    content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
+  server.tool("computer_accessibility", "Query the macOS accessibility tree \u2014 get structured UI elements (buttons, fields, labels) with positions. Much more precise than pixel-guessing from screenshots.", {
+    app: exports_external.string().optional().describe("App name to query (default: frontmost)"),
+    focused_only: exports_external.boolean().default(false).describe("Only get focused element's subtree"),
+    depth: exports_external.number().default(3).describe("Max tree traversal depth"),
+    format: exports_external.enum(["json", "summary"]).default("summary").describe("Output format")
+  }, async (params) => {
+    try {
+      const elements = await queryAccessibilityTree({
+        app: params.app,
+        focusedOnly: params.focused_only,
+        depth: params.depth
+      });
+      const text = params.format === "json" ? JSON.stringify(elements, null, 2) : summarizeAccessibilityTree(elements);
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Accessibility query failed: ${err instanceof Error ? err.message : err}` }] };
+    }
+  });
+  server.tool("computer_register_agent", "Register an agent for multi-agent coordination", {
+    name: exports_external.string().describe("Agent name"),
+    description: exports_external.string().optional().describe("Agent description"),
+    capabilities: exports_external.array(exports_external.string()).optional().describe("Agent capabilities")
+  }, async (params) => {
+    const agent = registerAgent(params);
+    return { content: [{ type: "text", text: JSON.stringify(agent, null, 2) }] };
+  });
+  server.tool("computer_heartbeat", "Send a heartbeat to mark an agent as active", {
+    agent_id: exports_external.string().describe("Agent ID")
+  }, async (params) => {
+    const ok = heartbeat(params.agent_id);
+    return { content: [{ type: "text", text: ok ? "Heartbeat received" : "Agent not found" }] };
+  });
+  server.tool("computer_set_focus", "Set what an agent is currently focused on", {
+    agent_id: exports_external.string().describe("Agent ID"),
+    focus: exports_external.string().describe("Current focus description")
+  }, async (params) => {
+    const ok = setFocus(params.agent_id, params.focus);
+    return { content: [{ type: "text", text: ok ? "Focus updated" : "Agent not found" }] };
+  });
+  server.tool("computer_list_agents", "List all registered agents", {}, async () => {
+    const agents = listAgents();
+    return { content: [{ type: "text", text: JSON.stringify(agents, null, 2) }] };
+  });
+  server.tool("storage_status", "Show computer storage sync configuration and local sync history", {}, async () => storageResult(getStorageStatus()));
+  server.tool("storage_push", "Push local computer data to storage PostgreSQL", { tables: exports_external.array(exports_external.string()).optional() }, async ({ tables }) => storageResult(await storagePush(tables ? { tables } : undefined)));
+  server.tool("storage_pull", "Pull computer data from storage PostgreSQL to local SQLite", { tables: exports_external.array(exports_external.string()).optional() }, async ({ tables }) => storageResult(await storagePull(tables ? { tables } : undefined)));
+  server.tool("storage_sync", "Bidirectional computer sync: pull then push", { tables: exports_external.array(exports_external.string()).optional() }, async ({ tables }) => storageResult(await storageSync(tables ? { tables } : undefined)));
+  return server;
+}
+
+// src/mcp/http.ts
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+var MCP_HTTP_PORT = 8883;
+var MCP_NAME = "computer";
+function isStdioMode(argv) {
+  return argv.includes("--stdio") || process.env.MCP_STDIO === "1";
+}
+function resolveHttpPort(argv) {
+  const eqArg = argv.find((a) => a.startsWith("--port="));
+  if (eqArg) {
+    const parsed = Number.parseInt(eqArg.slice("--port=".length), 10);
+    if (!Number.isNaN(parsed))
+      return parsed;
   }
-  return { content };
-});
-server.tool("computer_type", "Type text using the keyboard", {
-  text: exports_external.string().describe("Text to type")
-}, async (params) => {
-  const result = await executeAction({ type: "type", text: params.text });
-  const content = [{ type: "text", text: result.success ? "Text typed" : `Type failed: ${result.error}` }];
-  if (result.screenshot) {
-    content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
-  }
-  return { content };
-});
-server.tool("computer_key", "Press a key or key combination (e.g. 'enter', 'cmd+c', 'ctrl+shift+a')", {
-  keys: exports_external.string().describe("Key or combination to press")
-}, async (params) => {
-  const result = await executeAction({ type: "key", keys: params.keys });
-  const content = [{ type: "text", text: result.success ? "Key pressed" : `Key failed: ${result.error}` }];
-  if (result.screenshot) {
-    content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
-  }
-  return { content };
-});
-server.tool("computer_scroll", "Scroll at a specific position", {
-  x: exports_external.number().describe("X coordinate"),
-  y: exports_external.number().describe("Y coordinate"),
-  direction: exports_external.enum(["up", "down"]).describe("Scroll direction"),
-  amount: exports_external.number().default(3).describe("Scroll amount")
-}, async (params) => {
-  const dy = params.direction === "down" ? params.amount : -params.amount;
-  const result = await executeAction({
-    type: "scroll",
-    point: { x: params.x, y: params.y },
-    deltaX: 0,
-    deltaY: dy
+  const idx = argv.indexOf("--port");
+  if (idx >= 0) {
+    const parsed = Number.parseInt(argv[idx + 1] ?? "", 10);
+    if (!Number.isNaN(parsed))
+      return parsed;
+  }
+  const envPort = process.env.MCP_HTTP_PORT;
+  if (envPort) {
+    const parsed = Number.parseInt(envPort, 10);
+    if (!Number.isNaN(parsed))
+      return parsed;
+  }
+  return MCP_HTTP_PORT;
+}
+function healthPayload() {
+  return { status: "ok", name: MCP_NAME };
+}
+async function handleMcpRequest(req) {
+  const server = buildServer();
+  const transport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: undefined,
+    enableJsonResponse: true
   });
-  const content = [{ type: "text", text: result.success ? "Scrolled" : `Scroll failed: ${result.error}` }];
-  if (result.screenshot) {
-    content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
+  await server.connect(transport);
+  return transport.handleRequest(req);
+}
+async function handleMcpHttpRequest(req) {
+  const url = new URL(req.url);
+  if (url.pathname === "/health" && req.method === "GET") {
+    return Response.json(healthPayload());
   }
-  return { content };
-});
-server.tool("computer_mouse_move", "Move the mouse to a position", {
-  x: exports_external.number().describe("X coordinate"),
-  y: exports_external.number().describe("Y coordinate")
-}, async (params) => {
-  const result = await executeAction({ type: "mouse_move", point: { x: params.x, y: params.y } });
-  return { content: [{ type: "text", text: result.success ? "Mouse moved" : `Move failed: ${result.error}` }] };
-});
-server.tool("computer_open_url", "Open a URL in the default browser", {
-  url: exports_external.string().describe("URL to open")
-}, async (params) => {
-  const result = await executeAction({ type: "open_url", url: params.url });
-  const content = [{ type: "text", text: result.success ? "URL opened" : `Open failed: ${result.error}` }];
-  if (result.screenshot) {
-    content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
-  }
-  return { content };
-});
-server.tool("computer_open_app", "Open a macOS application by name", {
-  name: exports_external.string().describe("Application name (e.g. 'Safari', 'Terminal', 'Slack')")
-}, async (params) => {
-  const result = await executeAction({ type: "open_app", name: params.name });
-  const content = [{ type: "text", text: result.success ? `Opened ${params.name}` : `Open failed: ${result.error}` }];
-  if (result.screenshot) {
-    content.push({ type: "image", data: result.screenshot.base64, mimeType: "image/png" });
-  }
-  return { content };
-});
-server.tool("computer_screen_size", "Get the current screen resolution", {}, async () => {
-  const size = await getScreenSize();
-  return { content: [{ type: "text", text: `${size.width}x${size.height}` }] };
-});
-server.tool("computer_list_sessions", "List past computer use sessions", {
-  limit: exports_external.number().default(20).describe("Max sessions to return"),
-  status: exports_external.enum(["running", "paused", "completed", "failed", "cancelled"]).optional().describe("Filter by status")
-}, async (params) => {
-  const sessions = listSessions({ limit: params.limit, status: params.status });
-  return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
-});
-server.tool("computer_get_session", "Get details of a specific session including action log", {
-  id: exports_external.string().describe("Session ID")
-}, async (params) => {
-  const session = getSession(params.id);
-  if (!session)
-    return { content: [{ type: "text", text: "Session not found" }] };
-  const logs = getActionLogs(params.id);
-  return {
-    content: [
-      { type: "text", text: JSON.stringify({ session, action_logs: logs }, null, 2) }
-    ]
-  };
-});
-server.tool("computer_delete_session", "Delete a session and its action logs", {
-  id: exports_external.string().describe("Session ID")
-}, async (params) => {
-  const deleted = deleteSession(params.id);
-  return { content: [{ type: "text", text: deleted ? "Session deleted" : "Session not found" }] };
-});
-server.tool("computer_search", "Full-text search across sessions (by task) and action logs (by reasoning)", {
-  query: exports_external.string().describe("Search query"),
-  scope: exports_external.enum(["sessions", "actions", "both"]).default("both").describe("Where to search"),
-  limit: exports_external.number().default(20).describe("Max results")
-}, async (params) => {
-  const results = {};
-  if (params.scope === "sessions" || params.scope === "both") {
-    results.sessions = searchSessions(params.query, params.limit);
-  }
-  if (params.scope === "actions" || params.scope === "both") {
-    results.action_logs = searchActionLogs(params.query, params.limit);
-  }
-  return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
-});
-server.tool("computer_stats", "Get usage statistics for computer use", {}, async () => {
-  const stats = getStats();
-  return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
-});
-server.tool("computer_accessibility", "Query the macOS accessibility tree \u2014 get structured UI elements (buttons, fields, labels) with positions. Much more precise than pixel-guessing from screenshots.", {
-  app: exports_external.string().optional().describe("App name to query (default: frontmost)"),
-  focused_only: exports_external.boolean().default(false).describe("Only get focused element's subtree"),
-  depth: exports_external.number().default(3).describe("Max tree traversal depth"),
-  format: exports_external.enum(["json", "summary"]).default("summary").describe("Output format")
-}, async (params) => {
-  try {
-    const elements = await queryAccessibilityTree({
-      app: params.app,
-      focusedOnly: params.focused_only,
-      depth: params.depth
-    });
-    const text = params.format === "json" ? JSON.stringify(elements, null, 2) : summarizeAccessibilityTree(elements);
-    return { content: [{ type: "text", text }] };
-  } catch (err) {
-    return { content: [{ type: "text", text: `Accessibility query failed: ${err instanceof Error ? err.message : err}` }] };
+  if (url.pathname === "/mcp") {
+    return handleMcpRequest(req);
   }
-});
-server.tool("computer_register_agent", "Register an agent for multi-agent coordination", {
-  name: exports_external.string().describe("Agent name"),
-  description: exports_external.string().optional().describe("Agent description"),
-  capabilities: exports_external.array(exports_external.string()).optional().describe("Agent capabilities")
-}, async (params) => {
-  const agent = registerAgent(params);
-  return { content: [{ type: "text", text: JSON.stringify(agent, null, 2) }] };
-});
-server.tool("computer_heartbeat", "Send a heartbeat to mark an agent as active", {
-  agent_id: exports_external.string().describe("Agent ID")
-}, async (params) => {
-  const ok = heartbeat(params.agent_id);
-  return { content: [{ type: "text", text: ok ? "Heartbeat received" : "Agent not found" }] };
-});
-server.tool("computer_set_focus", "Set what an agent is currently focused on", {
-  agent_id: exports_external.string().describe("Agent ID"),
-  focus: exports_external.string().describe("Current focus description")
-}, async (params) => {
-  const ok = setFocus(params.agent_id, params.focus);
-  return { content: [{ type: "text", text: ok ? "Focus updated" : "Agent not found" }] };
-});
-server.tool("computer_list_agents", "List all registered agents", {}, async () => {
-  const agents = listAgents();
-  return { content: [{ type: "text", text: JSON.stringify(agents, null, 2) }] };
-});
-server.tool("cloud_status", "Show computer cloud sync configuration and local sync history", {}, async () => cloudResult({
-  configured: Boolean(getCloudDatabaseUrl()),
-  env: [
-    "HASNA_COMPUTER_CLOUD_DATABASE_URL",
-    "OPEN_COMPUTER_CLOUD_DATABASE_URL",
-    "COMPUTER_CLOUD_DATABASE_URL"
-  ],
-  service: "computer",
-  tables: CLOUD_TABLES,
-  sync: getSyncMetaAll()
-}));
-server.tool("cloud_push", "Push local computer data to cloud PostgreSQL", { tables: exports_external.array(exports_external.string()).optional() }, async ({ tables }) => cloudResult(await cloudPush(tables ? { tables } : undefined)));
-server.tool("cloud_pull", "Pull computer data from cloud PostgreSQL to local SQLite", { tables: exports_external.array(exports_external.string()).optional() }, async ({ tables }) => cloudResult(await cloudPull(tables ? { tables } : undefined)));
-server.tool("cloud_sync", "Bidirectional computer sync: pull then push", { tables: exports_external.array(exports_external.string()).optional() }, async ({ tables }) => cloudResult(await cloudSync(tables ? { tables } : undefined)));
+  return null;
+}
+async function startMcpHttpServer(port) {
+  const httpServer = Bun.serve({
+    hostname: "127.0.0.1",
+    port,
+    async fetch(req) {
+      const handled = await handleMcpHttpRequest(req);
+      if (handled)
+        return handled;
+      return Response.json({ error: "Not found" }, { status: 404 });
+    }
+  });
+  return { port: httpServer.port, stop: () => httpServer.stop() };
+}
+
+// src/mcp/index.ts
 async function main() {
-  const transport = new StdioServerTransport;
-  await server.connect(transport);
+  const argv = process.argv.slice(2);
+  if (isStdioMode(argv)) {
+    const server = buildServer();
+    const transport = new StdioServerTransport;
+    await server.connect(transport);
+    return;
+  }
+  const port = resolveHttpPort(argv);
+  const { port: boundPort } = await startMcpHttpServer(port);
+  console.error(`computer-mcp HTTP listening on http://127.0.0.1:${boundPort}/mcp`);
 }
-main().catch((err) => {
-  console.error("MCP server error:", err);
-  process.exit(1);
-});
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error("MCP server error:", err);
+    process.exit(1);
+  });
+}
+export {
+  buildServer
+};