@hasna/computer 0.1.8 → 0.1.9

package/dist/cli/index.js

@@ -993,7 +993,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {}
+          }
         };
       }
       return this;
@@ -2091,11 +2091,11 @@ __export(exports_config, {
   getConfigPath: () => getConfigPath,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG
 });
-import { join as join4 } from "path";
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join as join5 } from "path";
+import { existsSync as existsSync3, readFileSync, writeFileSync, mkdirSync } from "fs";
 function loadConfig() {
   try {
-    if (existsSync2(CONFIG_PATH)) {
+    if (existsSync3(CONFIG_PATH)) {
       const raw = readFileSync(CONFIG_PATH, "utf-8");
       const user = JSON.parse(raw);
       return mergeConfig(DEFAULT_CONFIG, user);
@@ -2162,8 +2162,8 @@ function getConfigPath() {
 }
 var CONFIG_DIR, CONFIG_PATH, DEFAULT_CONFIG;
 var init_config = __esm(() => {
-  CONFIG_DIR = join4(process.env.HOME ?? "~", ".hasna", "computer");
-  CONFIG_PATH = join4(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join5(process.env.HOME ?? "~", ".hasna", "computer");
+  CONFIG_PATH = join5(CONFIG_DIR, "config.json");
   DEFAULT_CONFIG = {
     provider: "anthropic",
     maxSteps: 50,
@@ -7133,20 +7133,698 @@ var {
   Help
 } = import__.default;
 
+// node_modules/@hasna/events/dist/commander.js
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createHmac, timingSafeEqual } from "crypto";
+import { randomUUID } from "crypto";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+function getPathValue(input, path) {
+  return path.split(".").reduce((value, part) => {
+    if (value && typeof value === "object" && part in value) {
+      return value[part];
+    }
+    return;
+  }, input);
+}
+function wildcardToRegExp(pattern) {
+  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function matchString(value, matcher) {
+  if (matcher === undefined)
+    return true;
+  if (value === undefined)
+    return false;
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.some((item) => wildcardToRegExp(item).test(value));
+}
+function matchRecord(input, matcher) {
+  if (!matcher)
+    return true;
+  return Object.entries(matcher).every(([path, expected]) => {
+    const actual = getPathValue(input, path);
+    if (typeof expected === "string" || Array.isArray(expected)) {
+      return matchString(actual === undefined ? undefined : String(actual), expected);
+    }
+    return actual === expected;
+  });
+}
+function eventMatchesFilter(event, filter) {
+  return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
+}
+function channelMatchesEvent(channel, event) {
+  if (!channel.enabled)
+    return false;
+  if (!channel.filters || channel.filters.length === 0)
+    return true;
+  return channel.filters.some((filter) => eventMatchesFilter(event, filter));
+}
+var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
+var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
+function getEventsDataDir(override) {
+  return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join(homedir(), ".hasna", "events");
+}
+
+class JsonEventsStore {
+  dataDir;
+  channelsPath;
+  eventsPath;
+  deliveriesPath;
+  constructor(dataDir = getEventsDataDir()) {
+    this.dataDir = dataDir;
+    this.channelsPath = join(dataDir, "channels.json");
+    this.eventsPath = join(dataDir, "events.json");
+    this.deliveriesPath = join(dataDir, "deliveries.json");
+  }
+  async init() {
+    await mkdir(this.dataDir, { recursive: true, mode: 448 });
+    await chmod(this.dataDir, 448).catch(() => {
+      return;
+    });
+    await this.ensureArrayFile(this.channelsPath);
+    await this.ensureArrayFile(this.eventsPath);
+    await this.ensureArrayFile(this.deliveriesPath);
+  }
+  async addChannel(channel) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const index = channels.findIndex((item) => item.id === channel.id);
+    if (index >= 0) {
+      channels[index] = { ...channel, createdAt: channels[index].createdAt, updatedAt: new Date().toISOString() };
+    } else {
+      channels.push(channel);
+    }
+    await this.writeJson(this.channelsPath, channels);
+    return index >= 0 ? channels[index] : channel;
+  }
+  async listChannels() {
+    await this.init();
+    return this.readJson(this.channelsPath, []);
+  }
+  async getChannel(id) {
+    const channels = await this.listChannels();
+    return channels.find((channel) => channel.id === id);
+  }
+  async removeChannel(id) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const next = channels.filter((channel) => channel.id !== id);
+    await this.writeJson(this.channelsPath, next);
+    return next.length !== channels.length;
+  }
+  async appendEvent(event) {
+    await this.init();
+    const events = await this.readJson(this.eventsPath, []);
+    events.push(event);
+    await this.writeJson(this.eventsPath, events);
+    return event;
+  }
+  async listEvents() {
+    await this.init();
+    return this.readJson(this.eventsPath, []);
+  }
+  async findEventByIdentity(identity) {
+    const events = await this.listEvents();
+    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
+  }
+  async appendDelivery(result) {
+    await this.init();
+    const deliveries = await this.readJson(this.deliveriesPath, []);
+    deliveries.push(result);
+    await this.writeJson(this.deliveriesPath, deliveries);
+    return result;
+  }
+  async listDeliveries() {
+    await this.init();
+    return this.readJson(this.deliveriesPath, []);
+  }
+  async exportData() {
+    return {
+      channels: await this.listChannels(),
+      events: await this.listEvents(),
+      deliveries: await this.listDeliveries()
+    };
+  }
+  async ensureArrayFile(path) {
+    if (!existsSync(path)) {
+      await writeFile(path, `[]
+`, { encoding: "utf-8", mode: 384 });
+    }
+    await chmod(path, 384).catch(() => {
+      return;
+    });
+  }
+  async readJson(path, fallback) {
+    try {
+      const raw = await readFile(path, "utf-8");
+      if (!raw.trim())
+        return fallback;
+      return JSON.parse(raw);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return fallback;
+      throw error;
+    }
+  }
+  async writeJson(path, value) {
+    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf-8", mode: 384 });
+    await rename(tempPath, path);
+    await chmod(path, 384).catch(() => {
+      return;
+    });
+  }
+}
+var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
+function buildSignatureBase(timestamp, body) {
+  return `${timestamp}.${body}`;
+}
+function signPayload(secret, timestamp, body) {
+  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
+  return `sha256=${digest}`;
+}
+function now() {
+  return new Date().toISOString();
+}
+function truncate(value, max = 4096) {
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+function buildWebhookRequest(event, channel) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const body = JSON.stringify(event);
+  const timestamp = event.time;
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "@hasna/events",
+    "X-Hasna-Event-Id": event.id,
+    "X-Hasna-Event-Type": event.type,
+    "X-Hasna-Timestamp": timestamp,
+    ...channel.webhook.headers
+  };
+  if (channel.webhook.secret) {
+    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
+  }
+  return { body, headers };
+}
+async function dispatchWebhook(event, channel, options = {}) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const startedAt = now();
+  const { body, headers } = buildWebhookRequest(event, channel);
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
+  try {
+    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal
+    });
+    const responseBody = truncate(await response.text());
+    return {
+      attempt: 1,
+      status: response.ok ? "success" : "failed",
+      startedAt,
+      completedAt: now(),
+      responseStatus: response.status,
+      responseBody,
+      error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
+    };
+  } catch (error) {
+    return {
+      attempt: 1,
+      status: "failed",
+      startedAt,
+      completedAt: now(),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function dispatchCommand(event, channel) {
+  if (!channel.command)
+    throw new Error(`Channel ${channel.id} has no command config`);
+  const startedAt = now();
+  const eventJson = JSON.stringify(event);
+  const env = {
+    ...process.env,
+    ...channel.command.env,
+    HASNA_CHANNEL_ID: channel.id,
+    HASNA_EVENT_ID: event.id,
+    HASNA_EVENT_TYPE: event.type,
+    HASNA_EVENT_SOURCE: event.source,
+    HASNA_EVENT_SUBJECT: event.subject ?? "",
+    HASNA_EVENT_SEVERITY: event.severity,
+    HASNA_EVENT_TIME: event.time,
+    HASNA_EVENT_DEDUPE_KEY: event.dedupeKey ?? "",
+    HASNA_EVENT_SCHEMA_VERSION: event.schemaVersion,
+    HASNA_EVENT_JSON: eventJson
+  };
+  return new Promise((resolve) => {
+    const child = spawn(channel.command.command, channel.command.args ?? [], {
+      cwd: channel.command.cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = setTimeout(() => child.kill("SIGTERM"), channel.command.timeoutMs ?? 15000);
+    child.stdin.end(eventJson);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      resolve({
+        attempt: 1,
+        status: "failed",
+        startedAt,
+        completedAt: now(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: error.message
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      const success = code === 0;
+      resolve({
+        attempt: 1,
+        status: success ? "success" : "failed",
+        startedAt,
+        completedAt: now(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: success ? undefined : `Command exited with ${signal ? `signal ${signal}` : `code ${code}`}`
+      });
+    });
+  });
+}
+async function dispatchChannel(event, channel, options = {}) {
+  if (channel.transport === "webhook")
+    return dispatchWebhook(event, channel, options);
+  if (channel.transport === "command")
+    return dispatchCommand(event, channel);
+  return {
+    attempt: 1,
+    status: "skipped",
+    startedAt: now(),
+    completedAt: now(),
+    error: `Unsupported transport: ${channel.transport}`
+  };
+}
+function createDeliveryResult(event, channel, attempts) {
+  const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
+  return {
+    id: randomUUID(),
+    eventId: event.id,
+    channelId: channel.id,
+    transport: channel.transport,
+    status,
+    attempts,
+    createdAt: attempts[0]?.startedAt ?? now(),
+    completedAt: attempts.at(-1)?.completedAt ?? now()
+  };
+}
+function createEvent(input) {
+  return {
+    id: input.id ?? randomUUID2(),
+    source: input.source,
+    type: input.type,
+    time: normalizeTime(input.time),
+    subject: input.subject,
+    severity: input.severity ?? "info",
+    data: input.data ?? {},
+    message: input.message,
+    dedupeKey: input.dedupeKey,
+    schemaVersion: input.schemaVersion ?? "1.0",
+    metadata: input.metadata ?? {}
+  };
+}
+
+class EventsClient {
+  store;
+  redactors;
+  transportOptions;
+  constructor(options = {}) {
+    this.store = options.store ?? new JsonEventsStore(options.dataDir);
+    this.redactors = options.redactors ?? [];
+    this.transportOptions = { fetchImpl: options.fetchImpl };
+  }
+  async addChannel(input) {
+    const timestamp = new Date().toISOString();
+    return this.store.addChannel({
+      ...input,
+      createdAt: input.createdAt ?? timestamp,
+      updatedAt: input.updatedAt ?? timestamp
+    });
+  }
+  async listChannels() {
+    return this.store.listChannels();
+  }
+  async removeChannel(id) {
+    return this.store.removeChannel(id);
+  }
+  async emit(input, options = {}) {
+    const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
+    if (options.dedupe !== false) {
+      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
+      if (existing) {
+        return { event: existing, deliveries: [], deduped: true };
+      }
+    }
+    await this.store.appendEvent(event);
+    const deliveries = options.deliver === false ? [] : await this.deliver(event);
+    return { event, deliveries, deduped: false };
+  }
+  async listEvents() {
+    return this.store.listEvents();
+  }
+  async listDeliveries() {
+    return this.store.listDeliveries();
+  }
+  async deliver(event) {
+    const channels = await this.store.listChannels();
+    const selected = channels.filter((channel) => channelMatchesEvent(channel, event));
+    const deliveries = [];
+    for (const channel of selected) {
+      const eventForChannel = await this.applyRedaction(event, channel);
+      const result = await this.deliverWithRetry(eventForChannel, channel);
+      await this.store.appendDelivery(result);
+      deliveries.push(result);
+    }
+    return deliveries;
+  }
+  async testChannel(id, input = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const event = createEvent({
+      source: input.source ?? "hasna.events",
+      type: input.type ?? "events.test",
+      subject: input.subject ?? id,
+      severity: input.severity ?? "info",
+      data: input.data ?? { test: true },
+      message: input.message ?? "Hasna events test delivery",
+      dedupeKey: input.dedupeKey,
+      schemaVersion: input.schemaVersion,
+      metadata: input.metadata,
+      time: input.time,
+      id: input.id
+    });
+    const eventForChannel = await this.applyRedaction(event, channel);
+    const result = await this.deliverWithRetry(eventForChannel, channel);
+    await this.store.appendDelivery(result);
+    return result;
+  }
+  async replay(options = {}) {
+    const events = (await this.store.listEvents()).filter((event) => {
+      if (options.eventId && event.id !== options.eventId)
+        return false;
+      if (options.source && event.source !== options.source)
+        return false;
+      if (options.type && event.type !== options.type)
+        return false;
+      return true;
+    });
+    if (options.dryRun)
+      return { events, deliveries: [] };
+    const deliveries = [];
+    for (const event of events) {
+      deliveries.push(...await this.deliver(event));
+    }
+    return { events, deliveries };
+  }
+  async applyRedaction(event, channel) {
+    let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
+    for (const redactor of this.redactors) {
+      next = await redactor(next, channel);
+    }
+    return next;
+  }
+  async deliverWithRetry(event, channel) {
+    const policy = normalizeRetryPolicy(channel.retry);
+    const attempts = [];
+    for (let index = 0;index < policy.maxAttempts; index += 1) {
+      const attempt = await dispatchChannel(event, channel, this.transportOptions);
+      attempt.attempt = index + 1;
+      if (attempt.status === "failed" && index + 1 < policy.maxAttempts) {
+        attempt.nextBackoffMs = Math.round(policy.backoffMs * policy.multiplier ** index);
+      }
+      attempts.push(attempt);
+      if (attempt.status !== "failed")
+        break;
+      if (attempt.nextBackoffMs)
+        await Bun.sleep(attempt.nextBackoffMs);
+    }
+    return createDeliveryResult(event, channel, attempts);
+  }
+}
+function redactPaths(event, paths, replacement = "[REDACTED]") {
+  if (paths.length === 0)
+    return event;
+  const copy = structuredClone(event);
+  for (const path of paths) {
+    setPath(copy, path, replacement);
+  }
+  return copy;
+}
+function sanitizeChannelForOutput(channel) {
+  const copy = structuredClone(channel);
+  if (copy.webhook?.secret)
+    copy.webhook.secret = "[REDACTED]";
+  if (copy.command?.env) {
+    copy.command.env = Object.fromEntries(Object.entries(copy.command.env).map(([key, value]) => [key, shouldRedactKey(key) ? "[REDACTED]" : value]));
+  }
+  return copy;
+}
+function sanitizeChannelsForOutput(channels) {
+  return channels.map(sanitizeChannelForOutput);
+}
+function redactSensitiveKeys(event, replacement = "[REDACTED]") {
+  return redactValue(event, replacement);
+}
+function shouldRedactKey(key) {
+  return /secret|token|password|api[_-]?key|authorization/i.test(key);
+}
+function redactValue(value, replacement) {
+  if (Array.isArray(value))
+    return value.map((item) => redactValue(item, replacement));
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    shouldRedactKey(key) ? replacement : redactValue(item, replacement)
+  ]));
+}
+function setPath(input, path, replacement) {
+  const parts = path.split(".");
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object")
+      return;
+    cursor = next;
+  }
+  const last = parts.at(-1);
+  if (last && last in cursor)
+    cursor[last] = replacement;
+}
+function normalizeTime(value) {
+  if (!value)
+    return new Date().toISOString();
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeRetryPolicy(policy) {
+  return {
+    maxAttempts: Math.max(1, policy?.maxAttempts ?? 1),
+    backoffMs: Math.max(0, policy?.backoffMs ?? 250),
+    multiplier: Math.max(1, policy?.multiplier ?? 2)
+  };
+}
+function parseJsonObject(value, fallback) {
+  if (!value)
+    return fallback;
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Expected a JSON object");
+  }
+  return parsed;
+}
+function parseHeaders(values) {
+  if (!values?.length)
+    return;
+  const headers = {};
+  for (const value of values) {
+    const separator = value.indexOf("=");
+    if (separator === -1)
+      throw new Error(`Invalid header, expected name=value: ${value}`);
+    headers[value.slice(0, separator)] = value.slice(separator + 1);
+  }
+  return headers;
+}
+function parseFilter(options) {
+  const filter2 = {};
+  if (options.source)
+    filter2.source = options.source;
+  if (options.type)
+    filter2.type = options.type;
+  if (options.subject)
+    filter2.subject = options.subject;
+  if (options.severity)
+    filter2.severity = options.severity;
+  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
+}
+function createClient(options) {
+  if (options.createClient)
+    return options.createClient();
+  return new EventsClient({ store: new JsonEventsStore(options.dataDir) });
+}
+function print(value, json, text) {
+  if (json)
+    console.log(JSON.stringify(value, null, 2));
+  else
+    console.log(text);
+}
+function registerWebhookCommands(program2, options) {
+  const webhooks = program2.command(options.webhooksCommandName ?? "webhooks").description("Manage Hasna event webhook subscriptions");
+  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions) => {
+    const timestamp = new Date().toISOString();
+    const channel = {
+      id: actionOptions.id,
+      name: actionOptions.name,
+      enabled: !actionOptions.disabled,
+      transport: actionOptions.transport,
+      filters: parseFilter(actionOptions),
+      retry: actionOptions.retryAttempts || actionOptions.retryBackoffMs ? { maxAttempts: actionOptions.retryAttempts, backoffMs: actionOptions.retryBackoffMs } : undefined,
+      redact: actionOptions.redact?.length ? { paths: actionOptions.redact } : undefined,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    if (actionOptions.transport === "webhook") {
+      channel.webhook = { url: target, secret: actionOptions.secret, headers: parseHeaders(actionOptions.header), timeoutMs: actionOptions.timeoutMs };
+    } else if (actionOptions.transport === "command") {
+      channel.command = { command: target, args: actionOptions.arg ?? [], timeoutMs: actionOptions.timeoutMs };
+    } else {
+      throw new Error(`Transport ${actionOptions.transport} is reserved for future use and cannot be added yet`);
+    }
+    const saved = await createClient(options).addChannel(channel);
+    print(sanitizeChannelForOutput(saved), Boolean(actionOptions.json), `Added ${saved.transport} channel ${saved.id}`);
+  });
+  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
+    const channels = await createClient(options).listChannels();
+    if (actionOptions.json) {
+      console.log(JSON.stringify(sanitizeChannelsForOutput(channels), null, 2));
+      return;
+    }
+    if (!channels.length) {
+      console.log("No channels configured.");
+      return;
+    }
+    for (const channel of channels) {
+      console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
+    }
+  });
+  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions) => {
+    const removed = await createClient(options).removeChannel(id);
+    print({ removed }, Boolean(actionOptions.json), removed ? `Removed ${id}` : `Channel not found: ${id}`);
+  });
+  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions) => {
+    const result = await createClient(options).testChannel(id, {
+      source: options.source,
+      type: actionOptions.type,
+      subject: actionOptions.subject ?? id,
+      message: actionOptions.message,
+      data: parseJsonObject(actionOptions.data, { test: true })
+    });
+    print(result, Boolean(actionOptions.json), `${result.status}: ${result.channelId}`);
+  });
+  return webhooks;
+}
+function registerEventCommands(program2, options) {
+  const events = program2.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
+  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions) => {
+    const result = await createClient(options).emit({
+      source: actionOptions.source ?? options.source,
+      type,
+      subject: actionOptions.subject,
+      severity: actionOptions.severity,
+      message: actionOptions.message,
+      dedupeKey: actionOptions.dedupeKey,
+      data: parseJsonObject(actionOptions.data, {}),
+      metadata: parseJsonObject(actionOptions.metadata, {})
+    }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
+    print(result, Boolean(actionOptions.json), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
+  });
+  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
+    let rows = await createClient(options).listEvents();
+    if (actionOptions.source)
+      rows = rows.filter((event) => event.source === actionOptions.source);
+    if (actionOptions.type)
+      rows = rows.filter((event) => event.type === actionOptions.type);
+    if (actionOptions.limit)
+      rows = rows.slice(-actionOptions.limit);
+    if (actionOptions.json) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    if (!rows.length) {
+      console.log("No events recorded.");
+      return;
+    }
+    for (const event of rows)
+      console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
+  });
+  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
+    const result = await createClient(options).replay({
+      eventId: actionOptions.id,
+      source: actionOptions.source,
+      type: actionOptions.type,
+      dryRun: actionOptions.dryRun
+    });
+    print(result, Boolean(actionOptions.json), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
+  });
+  return events;
+}
+function registerEventsCommands(program2, options) {
+  registerWebhookCommands(program2, options);
+  registerEventCommands(program2, options);
+}
+function parseNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed))
+    throw new Error(`Expected a number, got ${value}`);
+  return parsed;
+}
+function collectValues(value, previous) {
+  previous.push(value);
+  return previous;
+}
+
 // src/cli/index.ts
 import chalk from "chalk";
 
 // src/agent/loop.ts
-import { randomUUID } from "crypto";
-import { mkdir } from "fs/promises";
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir2 } from "fs/promises";
 
 // src/drivers/mac/screenshot.ts
 import { tmpdir } from "os";
-import { join } from "path";
-import { readFile, unlink } from "fs/promises";
+import { join as join2 } from "path";
+import { readFile as readFile2, unlink } from "fs/promises";
 async function captureScreenshot(displayNumber) {
   const timestamp = Date.now();
-  const tmpPath = join(tmpdir(), `computer-screenshot-${timestamp}.png`);
+  const tmpPath = join2(tmpdir(), `computer-screenshot-${timestamp}.png`);
   const args = ["screencapture", "-x", "-C", "-t", "png"];
   if (displayNumber) {
     args.push(`-D${displayNumber}`);
@@ -7161,7 +7839,7 @@ async function captureScreenshot(displayNumber) {
     const stderr = await new Response(proc.stderr).text();
     throw new Error(`screencapture failed: ${stderr}`);
   }
-  const data = await readFile(tmpPath);
+  const data = await readFile2(tmpPath);
   const base64 = data.toString("base64");
   await unlink(tmpPath).catch(() => {});
   const size = await getScreenSize();
@@ -7185,15 +7863,15 @@ async function getScreenSize() {
   return { width: 1920, height: 1080 };
 }
 async function saveScreenshotToFile(screenshot, dir, filename) {
-  const path = join(dir, filename);
+  const path = join2(dir, filename);
   const buffer = Buffer.from(screenshot.base64, "base64");
   await Bun.write(path, buffer);
   return path;
 }
 
 // src/drivers/mac/input.ts
-import { join as join2, dirname } from "path";
-import { existsSync } from "fs";
+import { join as join3, dirname } from "path";
+import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath } from "url";
 async function executeAction(action) {
   const start = Date.now();
@@ -7360,12 +8038,12 @@ function getScrollHelperPath() {
   if (_scrollHelperPath)
     return _scrollHelperPath;
   const candidates = [
-    join2(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "helpers", "scroll"),
-    join2(dirname(fileURLToPath(import.meta.url)), "..", "helpers", "scroll"),
-    join2(process.env.HOME ?? "~", ".hasna", "computer", "helpers", "scroll")
+    join3(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "helpers", "scroll"),
+    join3(dirname(fileURLToPath(import.meta.url)), "..", "helpers", "scroll"),
+    join3(process.env.HOME ?? "~", ".hasna", "computer", "helpers", "scroll")
   ];
   for (const candidate of candidates) {
-    if (existsSync(candidate)) {
+    if (existsSync2(candidate)) {
       _scrollHelperPath = candidate;
       return candidate;
     }
@@ -16376,8 +17054,8 @@ function createProvider(provider, opts) {
 
 // src/lib/scale.ts
 import { tmpdir as tmpdir2 } from "os";
-import { join as join3 } from "path";
-import { readFile as readFile2, unlink as unlink2, writeFile } from "fs/promises";
+import { join as join4 } from "path";
+import { readFile as readFile3, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 var RECOMMENDED_WIDTHS = {
   xga: 1024,
   wxga: 1280,
@@ -16392,11 +17070,11 @@ async function scaleScreenshot(screenshot, maxWidth = DEFAULT_MAX_WIDTH) {
   const newWidth = maxWidth;
   const newHeight = Math.round(screenshot.size.height * ratio);
   const timestamp = Date.now();
-  const tmpInput = join3(tmpdir2(), `computer-scale-in-${timestamp}.png`);
-  const tmpOutput = join3(tmpdir2(), `computer-scale-out-${timestamp}.png`);
+  const tmpInput = join4(tmpdir2(), `computer-scale-in-${timestamp}.png`);
+  const tmpOutput = join4(tmpdir2(), `computer-scale-out-${timestamp}.png`);
   try {
     const buffer = Buffer.from(screenshot.base64, "base64");
-    await writeFile(tmpInput, buffer);
+    await writeFile2(tmpInput, buffer);
     const proc = Bun.spawn([
       "sips",
       "--resampleWidth",
@@ -16411,7 +17089,7 @@ async function scaleScreenshot(screenshot, maxWidth = DEFAULT_MAX_WIDTH) {
       console.warn(`sips resize failed (${stderr}), using original screenshot`);
       return screenshot;
     }
-    const resized = await readFile2(tmpOutput);
+    const resized = await readFile3(tmpOutput);
     const base64 = resized.toString("base64");
     return {
       base64,
@@ -16520,8 +17198,8 @@ function checkAction(action, config) {
   }
 }
 function checkRateLimit(maxPerMinute) {
-  const now = Date.now();
-  const oneMinuteAgo = now - 60000;
+  const now2 = Date.now();
+  const oneMinuteAgo = now2 - 60000;
   actionTimestamps = actionTimestamps.filter((t) => t > oneMinuteAgo);
   if (actionTimestamps.length >= maxPerMinute) {
     return {
@@ -16529,7 +17207,7 @@ function checkRateLimit(maxPerMinute) {
       reason: `Rate limit exceeded: ${actionTimestamps.length}/${maxPerMinute} actions per minute`
     };
   }
-  actionTimestamps.push(now);
+  actionTimestamps.push(now2);
   return { allowed: true };
 }
 function looksLikePassword(text) {
@@ -16575,26 +17253,26 @@ function screenshotsMatch(prev, curr, threshold = 0.98) {
 
 // src/db/index.ts
 import { Database } from "bun:sqlite";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { mkdirSync as mkdirSync2 } from "fs";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 var SERVICE_NAME = "computer";
 function getDataDir(service = SERVICE_NAME) {
   if (service === SERVICE_NAME && process.env["COMPUTER_DATA_DIR"]) {
     mkdirSync2(process.env["COMPUTER_DATA_DIR"], { recursive: true });
     return process.env["COMPUTER_DATA_DIR"];
   }
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
-  const dir = join5(home, ".hasna", service);
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir2();
+  const dir = join6(home, ".hasna", service);
   mkdirSync2(dir, { recursive: true });
   return dir;
 }
 function getDbPath(service = SERVICE_NAME) {
   if (service === SERVICE_NAME && process.env["COMPUTER_DB_PATH"]) {
-    mkdirSync2(join5(process.env["COMPUTER_DB_PATH"], ".."), { recursive: true });
+    mkdirSync2(join6(process.env["COMPUTER_DB_PATH"], ".."), { recursive: true });
     return process.env["COMPUTER_DB_PATH"];
   }
-  return join5(getDataDir(service), `${service}.db`);
+  return join6(getDataDir(service), `${service}.db`);
 }
 var db = null;
 function getDb() {
@@ -16910,7 +17588,7 @@ async function runTask(options) {
   const provider = createProvider(providerName, { model });
   const config = loadConfig();
   const safetyConfig = config.safety;
-  const sessionId = randomUUID();
+  const sessionId = randomUUID3();
   const session = {
     id: sessionId,
     task,
@@ -16927,7 +17605,7 @@ async function runTask(options) {
   await createSession(session);
   const ssDir = screenshotsDir ?? `${process.env.HOME}/.hasna/computer/screenshots/${sessionId}`;
   if (saveScreenshots) {
-    await mkdir(ssDir, { recursive: true });
+    await mkdir2(ssDir, { recursive: true });
   }
   const history = [];
   const startTime = Date.now();
@@ -17231,32 +17909,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;
+}
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv3(env.name) ?? null : null;
 }
-async function getCloudPg() {
-  const url = getCloudDatabaseUrl();
+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));
@@ -17266,11 +17977,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));
@@ -17280,9 +17991,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() {
@@ -17290,10 +18001,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)
@@ -17381,7 +18104,7 @@ function upsertSqlite(db2, table, columns, rows) {
 }
 function recordSyncMeta(db2, direction, results) {
   ensureSyncMetaTable(db2);
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   for (const result of results) {
     if (result.errors.length > 0)
       continue;
@@ -17389,7 +18112,7 @@ function recordSyncMeta(db2, direction, results) {
       INSERT INTO _computer_sync_meta (table_name, last_synced_at, direction)
       VALUES (?, ?, ?)
       ON CONFLICT(table_name, direction) DO UPDATE SET last_synced_at = excluded.last_synced_at
-    `).run(result.table, now, direction);
+    `).run(result.table, now2, direction);
   }
 }
 function ensureSyncMetaTable(db2) {
@@ -17419,12 +18142,7 @@ function coerceForSqlite(value) {
   return String(value);
 }
 
-// src/cli/cloud.ts
-var CLOUD_ENV = [
-  "HASNA_COMPUTER_CLOUD_DATABASE_URL",
-  "OPEN_COMPUTER_CLOUD_DATABASE_URL",
-  "COMPUTER_CLOUD_DATABASE_URL"
-];
+// src/cli/storage.ts
 function parseTables(value) {
   if (!value)
     return;
@@ -17441,21 +18159,15 @@ function printResults(results, label) {
   }
   console.log(`Done. ${total} rows ${label}.`);
 }
-function registerCloudCommands(program2) {
-  const cloudCmd = program2.command("cloud").description("Cloud sync commands");
-  cloudCmd.command("status").description("Show cloud config and local sync state").option("--json", "Output as JSON").action((opts) => {
-    const info = {
-      configured: Boolean(getCloudDatabaseUrl()),
-      env: CLOUD_ENV,
-      service: "computer",
-      tables: CLOUD_TABLES,
-      sync: getSyncMetaAll()
-    };
+function registerStorageCommands(program2) {
+  const storageCmd = program2.command("storage").description("Storage sync commands");
+  storageCmd.command("status").description("Show storage config and local sync state").option("--json", "Output as JSON").action((opts) => {
+    const info = getStorageStatus();
     if (opts.json) {
       printJson(info);
       return;
     }
-    console.log(`Cloud configured: ${info.configured ? "yes" : "no"}`);
+    console.log(`Storage configured: ${info.configured ? "yes" : "no"}`);
     console.log(`Tables: ${info.tables.join(", ")}`);
     if (info.sync.length === 0)
       console.log("Sync: no local sync history");
@@ -17463,9 +18175,9 @@ function registerCloudCommands(program2) {
       console.log(`  ${entry.table_name} ${entry.direction}: ${entry.last_synced_at ?? "never"}`);
     }
   });
-  cloudCmd.command("push").description("Push local computer data to cloud PostgreSQL").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
+  storageCmd.command("push").description("Push local computer data to storage PostgreSQL").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const results = await cloudPush({ tables: parseTables(opts.tables) });
+      const results = await storagePush({ tables: parseTables(opts.tables) });
       if (opts.json) {
         printJson(results);
         return;
@@ -17476,9 +18188,9 @@ function registerCloudCommands(program2) {
       process.exit(1);
     }
   });
-  cloudCmd.command("pull").description("Pull computer data from cloud PostgreSQL to local SQLite").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
+  storageCmd.command("pull").description("Pull computer data from storage PostgreSQL to local SQLite").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const results = await cloudPull({ tables: parseTables(opts.tables) });
+      const results = await storagePull({ tables: parseTables(opts.tables) });
       if (opts.json) {
         printJson(results);
         return;
@@ -17489,9 +18201,9 @@ function registerCloudCommands(program2) {
       process.exit(1);
     }
   });
-  cloudCmd.command("sync").description("Bidirectional sync: pull then push").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
+  storageCmd.command("sync").description("Bidirectional sync: pull then push").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const result = await cloudSync({ tables: parseTables(opts.tables) });
+      const result = await storageSync({ tables: parseTables(opts.tables) });
       if (opts.json) {
         printJson(result);
         return;
@@ -17560,6 +18272,188 @@ function renderKitty(base64, width, height) {
 `;
 }
 
+// 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/cli/index.ts
 var program2 = new Command;
 program2.name("computer").description("Open-source computer use for AI agents \u2014 control your Mac with AI").version("0.1.0");
@@ -17626,6 +18520,60 @@ program2.command("screenshot").description("Take a screenshot of the current scr
     console.log(chalk.dim(`Base64 length: ${ss.base64.length} chars`));
   }
 });
+var collectRun = (value, previous) => [...previous, value];
+program2.command("open").description("Open an app deterministically via its driver (no AI; see `computer apps`)").argument("<app>", "App to open (registered driver name, e.g. ghostty)").option("--grid <RxC>", 'Split the window into R rows x C cols (e.g. "2x2")').option("--tabs <specs>", 'Multiple tabs in one window, one grid spec each (e.g. "2x2,1x2,1x2")').option("--run <command>", "Command for the next pane in order (repeatable)", collectRun, []).option("--all", "Run the single --run command in every pane", false).option("--dir <path>", "Working directory \u2014 every pane cds here first").option("--max", "Maximize the new window (not native fullscreen)", false).action(async (app, opts) => {
+  const driver = getAppDriver(app);
+  if (!driver) {
+    console.error(chalk.red(`No app driver registered for "${app}".`));
+    console.error(chalk.dim("List available drivers with `computer apps`."));
+    process.exit(1);
+  }
+  const availability = driver.available();
+  if (!availability.available) {
+    console.error(chalk.red(`${driver.name} is not available on this machine.`));
+    if (availability.reason)
+      console.error(chalk.dim(`Reason: ${availability.reason}`));
+    process.exit(1);
+  }
+  let spec;
+  try {
+    spec = {
+      grid: opts.grid ? parseGrid(opts.grid) : undefined,
+      tabs: opts.tabs ? parseTabsSpec(opts.tabs) : undefined,
+      run: opts.run,
+      all: opts.all,
+      dir: opts.dir,
+      max: opts.max
+    };
+  } catch (err) {
+    console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+  const result = await driver.open(spec);
+  if (result.ok) {
+    console.log(chalk.green(result.message));
+  } else {
+    console.error(chalk.red(result.message));
+    process.exit(1);
+  }
+});
+program2.command("apps").description("List registered app drivers and their availability on this machine").action(async () => {
+  const drivers2 = listAppDrivers();
+  if (drivers2.length === 0) {
+    console.log(chalk.dim("No app drivers registered."));
+    return;
+  }
+  console.log(chalk.bold(`App drivers
+`));
+  for (const driver of drivers2) {
+    const availability = driver.available();
+    const status = availability.available ? chalk.green("available") : chalk.red("unavailable");
+    console.log(`  ${chalk.cyan(driver.name.padEnd(12))} ${status}  ${chalk.dim(driver.description)}`);
+    if (!availability.available && availability.reason) {
+      console.log(chalk.dim(`  ${" ".repeat(12)} ${availability.reason}`));
+    }
+  }
+});
 program2.command("sessions").description("List computer use sessions").option("-n, --limit <n>", "Number of sessions to show", "20").option("--status <status>", "Filter by status").option("--tag <tag>", "Filter by tag").action(async (opts) => {
   const sessions = listSessions({
     limit: parseInt(opts.limit),
@@ -17878,16 +18826,16 @@ program2.command("headless").description("Check headless mode status and availab
   console.log(status.recommendation);
 });
 program2.command("record").description("Record mouse/keyboard events as a replayable macro").option("-d, --duration <seconds>", "Max recording duration in seconds", "60").option("-o, --output <file>", "Save recording to JSON file").action(async (opts) => {
-  const { join: join6, dirname: dirname2 } = await import("path");
+  const { join: join7, dirname: dirname2 } = await import("path");
   const { fileURLToPath: fileURLToPath2 } = await import("url");
-  const { existsSync: existsSync3, writeFileSync: writeFileSync2 } = await import("fs");
+  const { existsSync: existsSync5, writeFileSync: writeFileSync2 } = await import("fs");
   const __dirname2 = dirname2(fileURLToPath2(import.meta.url));
   const candidates = [
-    join6(__dirname2, "..", "..", "helpers", "record"),
-    join6(__dirname2, "..", "helpers", "record"),
-    join6(process.env.HOME ?? "~", ".hasna", "computer", "helpers", "record")
+    join7(__dirname2, "..", "..", "helpers", "record"),
+    join7(__dirname2, "..", "helpers", "record"),
+    join7(process.env.HOME ?? "~", ".hasna", "computer", "helpers", "record")
   ];
-  const helperPath = candidates.find((c) => existsSync3(c));
+  const helperPath = candidates.find((c) => existsSync5(c));
   if (!helperPath) {
     console.log(chalk.red("Record helper not found. Run: swiftc helpers/record.swift -o helpers/record -framework CoreGraphics"));
     process.exit(1);
@@ -17908,9 +18856,9 @@ program2.command("record").description("Record mouse/keyboard events as a replay
     } else {
       const dir = getDataDir("computer");
       const filename = `recording-${Date.now()}.json`;
-      const path = join6(dir, "recordings", filename);
+      const path = join7(dir, "recordings", filename);
       const { mkdirSync: mkdirSync3 } = await import("fs");
-      mkdirSync3(join6(dir, "recordings"), { recursive: true });
+      mkdirSync3(join7(dir, "recordings"), { recursive: true });
       writeFileSync2(path, stdout);
       console.log(chalk.green(`Recording saved: ${path}`));
     }
@@ -17926,7 +18874,8 @@ program2.command("completions").description("Generate shell completions").argume
     process.exit(1);
   }
 });
-registerCloudCommands(program2);
+registerStorageCommands(program2);
+registerEventsCommands(program2, { source: "computer" });
 program2.parse();
 function generateZshCompletions() {
   return `#compdef computer
@@ -17937,6 +18886,8 @@ _computer() {
   local -a commands
   commands=(
     'run:Run a computer use task'
+    'open:Open an app via its driver'
+    'apps:List app drivers'
     'screenshot:Take a screenshot'
     'sessions:List sessions'
     'session:Show session details'
@@ -17946,7 +18897,7 @@ _computer() {
     'search:Search sessions'
     'config:View or modify configuration'
     'completions:Generate shell completions'
-    'cloud:Cloud sync and feedback'
+    'storage:Storage sync and feedback'
   )
 
   _arguments -C \\
@@ -17971,6 +18922,16 @@ _computer() {
             '--no-preview[Disable inline preview]' \\
             '1:task:'
           ;;
+        open)
+          _arguments \\
+            '--grid[Pane grid RxC]:grid:' \\
+            '--tabs[Tab grid specs]:tabs:' \\
+            '*--run[Command per pane]:command:' \\
+            '--all[Same command in every pane]' \\
+            '--dir[Working directory]:dir:_files -/' \\
+            '--max[Maximize window]' \\
+            '1:app:(ghostty)'
+          ;;
         sessions)
           _arguments \\
             '-n[Limit]:limit:' \\
@@ -18001,7 +18962,7 @@ _computer_completions() {
   COMPREPLY=()
   cur="\${COMP_WORDS[COMP_CWORD]}"
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  commands="run screenshot sessions session delete stats watch search config completions cloud"
+  commands="run open apps screenshot sessions session delete stats watch search config completions storage"
 
   if [ "$COMP_CWORD" -eq 1 ]; then
     COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
@@ -18012,6 +18973,9 @@ _computer_completions() {
     run)
       COMPREPLY=( $(compgen -W "-p --provider -m --model -s --max-steps --save-screenshots --dry-run --tag --max-width --no-preview" -- "$cur") )
       ;;
+    open)
+      COMPREPLY=( $(compgen -W "ghostty --grid --tabs --run --all --dir --max" -- "$cur") )
+      ;;
     sessions)
       COMPREPLY=( $(compgen -W "-n --limit --status --tag" -- "$cur") )
       ;;