@runcofactor/cli 0.10.0

package/dist/session-MYFNZPRP.js

@@ -0,0 +1,2414 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  LocalBrowserHost,
+  USER_PAUSED_ERROR
+} from "./chunk-I4QLI3JO.js";
+import {
+  INTERACTION_CAPTURE_SCRIPT
+} from "./chunk-IMPZAX6L.js";
+import {
+  callTool,
+  createSession,
+  deleteAllSessions,
+  deleteSession,
+  getSession,
+  getSessionStorageState,
+  listSessions,
+  resolveTargetSession,
+  resumeCloud,
+  swapSessionContext,
+  takeControl
+} from "./chunk-J6SH7GQT.js";
+import {
+  downloadStorageState,
+  selectCredential,
+  uploadStorageState
+} from "./chunk-WOHL4FTB.js";
+import "./chunk-SJJW77WN.js";
+import "./chunk-3CZU7XCS.js";
+import {
+  getArgValue,
+  hasFlag,
+  resolveConfig
+} from "./chunk-A4OFTUVV.js";
+import {
+  BrowserToolExecutor,
+  PlaywrightClient,
+  captureElementAtPoint,
+  dispatchBrowserTool,
+  dispatchBrowserToolWithTimeout
+} from "./chunk-4PNOV7OV.js";
+import "./chunk-JWHYXEA2.js";
+import "./chunk-6LEZCKKV.js";
+import {
+  consoleLogger
+} from "./chunk-ZD3KHESI.js";
+import "./chunk-VKVL7WBN.js";
+
+// src/session/index.ts
+import fs3 from "fs";
+import os3 from "os";
+import path3 from "path";
+import process2 from "process";
+
+// src/session/claude-settings.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function findClaudeSettingsDir(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const candidate = path.join(dir, ".claude");
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function getScreenshotDirPath() {
+  return path.join(os.homedir(), ".canary", "screenshots");
+}
+function getScreenshotReadPattern() {
+  return `Read(${getScreenshotDirPath()}/**)`;
+}
+function hasScreenshotPermission(settingsDir) {
+  const filePath = path.join(settingsDir, "settings.local.json");
+  if (!fs.existsSync(filePath)) return false;
+  try {
+    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const allow = content?.permissions?.allow ?? [];
+    const pattern = getScreenshotReadPattern();
+    return allow.includes(pattern);
+  } catch {
+    return false;
+  }
+}
+function addScreenshotPermission(settingsDir) {
+  const filePath = path.join(settingsDir, "settings.local.json");
+  const pattern = getScreenshotReadPattern();
+  let content = {};
+  if (fs.existsSync(filePath)) {
+    try {
+      content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    } catch (err) {
+      throw new Error(
+        `Failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (!content.permissions || typeof content.permissions !== "object") {
+    content.permissions = { allow: [], deny: [], ask: [] };
+  }
+  const permissions = content.permissions;
+  if (!Array.isArray(permissions.allow)) {
+    permissions.allow = [];
+  }
+  const allow = permissions.allow;
+  if (allow.includes(pattern)) {
+    return { added: null, alreadyPresent: true };
+  }
+  allow.push(pattern);
+  fs.writeFileSync(filePath, JSON.stringify(content, null, 2) + "\n", "utf-8");
+  return { added: pattern, alreadyPresent: false };
+}
+
+// src/session/credentials.ts
+async function resolveCredential(argv, credentialArg) {
+  const { apiUrl, token } = await resolveConfig(argv);
+  const credential = await selectCredential(apiUrl, token, credentialArg);
+  if (!credential) {
+    return null;
+  }
+  console.log(`Fetching credential "${credential.name}"...`);
+  let storageStatePath;
+  if (credential.storageStateS3Key) {
+    storageStatePath = await downloadStorageState({
+      apiUrl,
+      token,
+      propertyId: credential.propertyId,
+      credentialId: credential.id,
+      prefix: "session-ss"
+    });
+    if (storageStatePath) {
+      console.log("Downloaded storage state.");
+    } else {
+      console.warn("Warning: Could not download storage state. Starting without auth.");
+    }
+  } else {
+    console.log("Credential has no storage state. Starting without auth.");
+  }
+  return {
+    storageStatePath,
+    credentialName: credential.name
+  };
+}
+
+// src/session/daemon.ts
+import { createServer } from "http";
+import fs2 from "fs/promises";
+import path2 from "path";
+import os2 from "os";
+
+// src/session/controller-badge.ts
+var BADGE_ID = "__canary_controller_badge__";
+var STORAGE_KEY = "__canaryUserPaused";
+var INTERACTIVE_BADGE_SCRIPT = `(() => {
+  function initBadge() {
+    const BADGE_ID = '${BADGE_ID}';
+    const STORAGE_KEY = '${STORAGE_KEY}';
+
+    // Restore pause state from sessionStorage (survives same-origin nav)
+    if (typeof window.__canaryUserPaused === 'undefined') {
+      try {
+        window.__canaryUserPaused = sessionStorage.getItem(STORAGE_KEY) === 'true';
+      } catch { window.__canaryUserPaused = false; }
+    }
+
+    // Ensure keyframes exist
+    if (!document.getElementById('canary-badge-keyframes')) {
+      const style = document.createElement('style');
+      style.id = 'canary-badge-keyframes';
+      style.textContent = [
+        '@keyframes canary-badge-pulse{0%,100%{opacity:.75}50%{opacity:.4}}',
+        '#' + BADGE_ID + '{transition:background .2s,opacity .2s}',
+        '#' + BADGE_ID + ':hover{opacity:1!important}',
+      ].join('\\n');
+      document.head.appendChild(style);
+    }
+
+    let el = document.getElementById(BADGE_ID);
+    if (!el) {
+      el = document.createElement('div');
+      el.id = BADGE_ID;
+      el.style.cssText = 'position:fixed;bottom:20px;right:20px;z-index:2147483647;'
+        + 'padding:6px 12px;border-radius:6px;font:600 12px/1.2 system-ui,sans-serif;'
+        + 'cursor:pointer;user-select:none;opacity:.75;color:#fff;'
+        + 'display:flex;align-items:center;gap:6px;box-shadow:0 2px 8px rgba(0,0,0,.2);';
+      document.body.appendChild(el);
+    }
+
+    function render() {
+      if (!el) return;
+      var paused = !!window.__canaryUserPaused;
+      if (paused) {
+        el.style.background = '#4DA6FF';
+        el.style.animation = 'canary-badge-pulse 2s ease-in-out infinite';
+        el.innerHTML = '<span style="font-size:8px;vertical-align:middle;">\\u25CF</span> You'
+          + '<span style="margin-left:4px;padding:2px 6px;background:rgba(255,255,255,.25);'
+          + 'border-radius:3px;font-size:10px;">Resume Agent</span>';
+        el.title = 'Click to resume agent control';
+      } else {
+        el.style.background = '#FFBD0F';
+        el.style.animation = '';
+        el.innerHTML = 'Agent';
+        el.title = 'Click to take control of the browser';
+      }
+    }
+
+    el.onclick = function(e) {
+      e.stopPropagation();
+      e.preventDefault();
+      window.__canaryUserPaused = !window.__canaryUserPaused;
+      try { sessionStorage.setItem(STORAGE_KEY, String(window.__canaryUserPaused)); } catch {}
+      render();
+    };
+
+    render();
+
+    // Re-inject if the page removes the badge (e.g. framework DOM cleanup)
+    try {
+      var observer = new MutationObserver(function() {
+        if (!document.getElementById(BADGE_ID)) {
+          observer.disconnect();
+          initBadge();
+        }
+      });
+      observer.observe(document.body, { childList: true, subtree: true });
+    } catch {}
+  }
+
+  // Wait for body to exist (addInitScript runs before DOM is ready)
+  if (document.body) {
+    initBadge();
+  } else if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initBadge);
+  } else {
+    initBadge();
+  }
+})()`;
+function staticBadgeScript(controller) {
+  const color = controller === "cli" ? "#4DA6FF" : "#FFBD0F";
+  const label = controller === "cli" ? "CLI" : "Cloud";
+  return `(() => {
+    let el = document.getElementById('${BADGE_ID}');
+    if (!el) {
+      el = document.createElement('div');
+      el.id = '${BADGE_ID}';
+      el.style.cssText = 'position:fixed;bottom:20px;right:20px;z-index:2147483647;'
+        + 'padding:6px 12px;border-radius:6px;font:600 12px/1.2 system-ui,sans-serif;'
+        + 'pointer-events:none;opacity:.7;color:#fff;'
+        + 'box-shadow:0 2px 8px rgba(0,0,0,.2);';
+      document.body.appendChild(el);
+    }
+    el.style.background = '${color}';
+    el.style.animation = '';
+    el.style.cursor = 'default';
+    el.style.pointerEvents = 'none';
+    el.onclick = null;
+    el.textContent = '${label}';
+    el.title = '';
+  })()`;
+}
+async function updateControllerBadge(client, controller, options) {
+  try {
+    const interactive = options?.interactive ?? false;
+    if (interactive) {
+      await client.evaluate(INTERACTIVE_BADGE_SCRIPT);
+    } else {
+      await client.evaluate(staticBadgeScript(controller));
+    }
+  } catch (err) {
+    options?.logger?.debug?.("[badge] updateControllerBadge failed", {
+      controller,
+      interactive: options?.interactive ?? false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+
+// src/session/user-takeover.ts
+var PAUSE_POLL_INTERVAL_MS = 500;
+var MAX_PAUSE_EVENTS = 500;
+var EVALUATE_TIMEOUT_MS = 3e3;
+var MAX_STRING_LENGTH = 200;
+function truncate(s, maxLen = MAX_STRING_LENGTH) {
+  if (typeof s !== "string") return void 0;
+  return s.length > maxLen ? s.slice(0, maxLen) : s;
+}
+function sanitizeEvent(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const evt = raw;
+  const ts = typeof evt.ts === "number" ? evt.ts : Date.now();
+  switch (evt.type) {
+    case "click":
+      if (typeof evt.x !== "number" || typeof evt.y !== "number") return null;
+      return {
+        type: "click",
+        ts,
+        x: evt.x,
+        y: evt.y,
+        tagName: truncate(evt.tagName, 50) ?? "UNKNOWN",
+        id: truncate(evt.id, 100),
+        testId: truncate(evt.testId, 100),
+        ariaLabel: truncate(evt.ariaLabel),
+        role: truncate(evt.role, 50),
+        textContent: truncate(evt.textContent),
+        className: truncate(evt.className)
+      };
+    case "input":
+      return {
+        type: "input",
+        ts,
+        tagName: truncate(evt.tagName, 50) ?? "INPUT",
+        id: truncate(evt.id, 100),
+        inputType: truncate(evt.inputType, 50),
+        ariaLabel: truncate(evt.ariaLabel),
+        value: truncate(evt.value) ?? "",
+        isFinal: evt.isFinal === true
+      };
+    case "change":
+      return {
+        type: "change",
+        ts,
+        tagName: truncate(evt.tagName, 50) ?? "INPUT",
+        id: truncate(evt.id, 100),
+        inputType: truncate(evt.inputType, 50),
+        ariaLabel: truncate(evt.ariaLabel),
+        value: truncate(evt.value) ?? ""
+      };
+    case "keydown":
+      if (typeof evt.key !== "string") return null;
+      return { type: "keydown", ts, key: evt.key.slice(0, 20) };
+    case "navigation":
+      if (typeof evt.url !== "string") return null;
+      try {
+        const parsed = new URL(evt.url);
+        const safeUrl = `${parsed.origin}${parsed.pathname}`.slice(0, 2048);
+        return {
+          type: "navigation",
+          ts,
+          url: safeUrl,
+          navigationType: truncate(evt.navigationType, 50)
+        };
+      } catch {
+        return null;
+      }
+    default:
+      return null;
+  }
+}
+function timeoutReject(ms = EVALUATE_TIMEOUT_MS) {
+  return new Promise(
+    (_, reject) => setTimeout(() => reject(new Error("evaluate timed out")), ms)
+  );
+}
+async function discardCapturedEvents(session) {
+  if (session.mode !== "headed") return;
+  const page = await session.client.getPageForReplay();
+  if (!page) return;
+  try {
+    await Promise.race([
+      page.evaluate(() => {
+        const w = window;
+        if (typeof w.__canaryFlushAndDiscard === "function") {
+          w.__canaryFlushAndDiscard();
+        } else {
+          w.__canaryRecordedEvents = [];
+        }
+      }),
+      timeoutReject()
+    ]);
+  } catch (err) {
+    consoleLogger.debug?.(`[takeover:${session.id}] discardCapturedEvents failed`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function drainAndSanitize(session) {
+  const page = await session.client.getPageForReplay();
+  if (!page) return [];
+  const raw = await Promise.race([
+    page.evaluate(() => {
+      const w = window;
+      const evts = w.__canaryRecordedEvents ?? [];
+      w.__canaryRecordedEvents = [];
+      return evts;
+    }),
+    timeoutReject()
+  ]);
+  if (!Array.isArray(raw)) return [];
+  const events = [];
+  for (const e of raw) {
+    const sanitized = sanitizeEvent(e);
+    if (sanitized) events.push(sanitized);
+  }
+  return events;
+}
+async function checkPauseAndDrainEvents(session) {
+  if (session.mode !== "headed") return { paused: false, events: [] };
+  if (session.userPaused) return { paused: true, events: [] };
+  const page = await session.client.getPageForReplay();
+  if (!page) return { paused: false, events: [] };
+  try {
+    const raw = await Promise.race([
+      page.evaluate(() => {
+        const w = window;
+        const paused2 = !!w.__canaryUserPaused;
+        const evts = w.__canaryRecordedEvents ?? [];
+        w.__canaryRecordedEvents = [];
+        return { paused: paused2, events: evts };
+      }),
+      timeoutReject()
+    ]);
+    const paused = raw?.paused === true;
+    if (paused) session.userPaused = true;
+    const events = [];
+    if (Array.isArray(raw?.events)) {
+      for (const e of raw.events) {
+        const sanitized = sanitizeEvent(e);
+        if (sanitized) events.push(sanitized);
+      }
+    }
+    return { paused, events };
+  } catch (err) {
+    consoleLogger.debug?.(`[takeover:${session.id}] checkPauseAndDrain failed`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return { paused: session.userPaused, events: [] };
+  }
+}
+async function drainUserEvents(session) {
+  if (session.mode !== "headed") return [];
+  try {
+    return await drainAndSanitize(session);
+  } catch (err) {
+    consoleLogger.debug?.(`[takeover:${session.id}] drainUserEvents failed`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return [];
+  }
+}
+function startPauseEnrichment(session) {
+  if (session.userPausePollTimer) return;
+  session.pauseEnrichedEvents = [];
+  session.userPausePollTimer = setInterval(async () => {
+    try {
+      if (session.pauseEnrichedEvents.length >= MAX_PAUSE_EVENTS) {
+        consoleLogger.debug?.(`[takeover:${session.id}] Event cap reached, skipping drain`);
+        return;
+      }
+      const events = await drainUserEvents(session);
+      for (const evt of events) {
+        if (session.pauseEnrichedEvents.length >= MAX_PAUSE_EVENTS) break;
+        if (evt.type === "click" && !evt.ariaLabel && !evt.textContent) {
+          try {
+            const page = await session.client.getPageForReplay();
+            if (page) {
+              const info = await captureElementAtPoint(page, evt.x, evt.y);
+              if (info) {
+                evt.elementInfo = info;
+              }
+            }
+          } catch (err) {
+            consoleLogger.debug?.(`[takeover:${session.id}] captureElementAtPoint failed`, {
+              error: err instanceof Error ? err.message : String(err),
+              x: evt.x,
+              y: evt.y
+            });
+          }
+        }
+        session.pauseEnrichedEvents.push(evt);
+      }
+    } catch (err) {
+      consoleLogger.debug?.(`[takeover:${session.id}] Pause poll error`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }, PAUSE_POLL_INTERVAL_MS);
+  consoleLogger.info(`[takeover:${session.id}] Pause enrichment started`);
+}
+async function stopPauseEnrichment(session) {
+  if (session.userPausePollTimer) {
+    clearInterval(session.userPausePollTimer);
+    session.userPausePollTimer = null;
+  }
+  const remaining = await drainUserEvents(session);
+  for (const evt of remaining) {
+    if (session.pauseEnrichedEvents.length >= MAX_PAUSE_EVENTS) break;
+    session.pauseEnrichedEvents.push(evt);
+  }
+  if (session.pauseEnrichedEvents.length > 0) {
+    try {
+      const result = await dispatchBrowserTool(session.executor, "browser_snapshot", {});
+      session.pauseResumeSnapshot = typeof result === "string" ? result : result.text ?? null;
+    } catch (err) {
+      consoleLogger.debug?.(`[takeover:${session.id}] Resume snapshot failed`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      session.pauseResumeSnapshot = null;
+    }
+  }
+  session.userPaused = false;
+  consoleLogger.info(
+    `[takeover:${session.id}] Pause enrichment stopped, ${session.pauseEnrichedEvents.length} events captured`
+  );
+}
+function cleanupPauseTimer(session) {
+  if (session.userPausePollTimer) {
+    clearInterval(session.userPausePollTimer);
+    session.userPausePollTimer = null;
+  }
+}
+async function injectCaptureScript(client) {
+  const page = await client.getPageForReplay();
+  if (!page) return;
+  try {
+    await page.addInitScript(INTERACTION_CAPTURE_SCRIPT);
+    await page.evaluate(INTERACTION_CAPTURE_SCRIPT);
+  } catch (err) {
+    consoleLogger.warn("[capture] Failed to inject interaction capture script", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function formatUserActionsSummary(events, snapshot) {
+  const lines = ["[User Actions]"];
+  lines.push("The user performed the following actions since your last tool call:");
+  let actionNum = 0;
+  for (const evt of events) {
+    switch (evt.type) {
+      case "click": {
+        actionNum++;
+        const info = evt.elementInfo;
+        const target = evt.ariaLabel ? `"${evt.ariaLabel}"` : evt.textContent ? `"${evt.textContent.slice(0, 60)}"` : info?.ariaLabel ? `"${info.ariaLabel}"` : info?.textContent ? `"${String(info.textContent).slice(0, 60)}"` : evt.testId ? `[data-testid="${evt.testId}"]` : evt.tagName;
+        lines.push(`${actionNum}. Clicked ${target} (${evt.tagName})`);
+        break;
+      }
+      case "input": {
+        if (!evt.isFinal) continue;
+        actionNum++;
+        const field = evt.ariaLabel ? `"${evt.ariaLabel}"` : evt.id ? `#${evt.id}` : evt.tagName;
+        const displayValue = evt.inputType === "password" ? "***" : `"${evt.value}"`;
+        lines.push(`${actionNum}. Typed ${displayValue} in ${field}`);
+        break;
+      }
+      case "change": {
+        actionNum++;
+        const changeTarget = evt.ariaLabel ?? evt.id ?? evt.tagName;
+        lines.push(`${actionNum}. Changed ${changeTarget} to "${evt.value}"`);
+        break;
+      }
+      case "keydown": {
+        if (evt.key === "Enter" || evt.key === "Escape") {
+          actionNum++;
+          lines.push(`${actionNum}. Pressed ${evt.key}`);
+        }
+        break;
+      }
+      case "navigation": {
+        actionNum++;
+        lines.push(`${actionNum}. Navigated to ${evt.url}`);
+        break;
+      }
+    }
+  }
+  if (actionNum === 0) return "";
+  if (snapshot) {
+    lines.push("");
+    lines.push("Current page state after user actions:");
+    lines.push(snapshot);
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+
+// src/session/cdp-proxy/mcp-client.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+var CHROME_DEVTOOLS_MCP_VERSION = "0.21.0";
+var CALL_TIMEOUT_MS = 6e4;
+var INITIALIZE_TIMEOUT_MS = 3e4;
+var SHUTDOWN_GRACE_MS = 5e3;
+var ChromeDevtoolsMcpClient = class {
+  child = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  initialized = false;
+  logger;
+  constructor(logger) {
+    this.logger = logger ?? {
+      info: (m) => console.log(`[cdp-proxy] ${m}`),
+      warn: (m) => console.warn(`[cdp-proxy] ${m}`),
+      error: (m) => console.error(`[cdp-proxy] ${m}`)
+    };
+  }
+  async start() {
+    if (this.child) throw new Error("ChromeDevtoolsMcpClient already started");
+    const child = spawn(
+      "npx",
+      ["-y", `chrome-devtools-mcp@${CHROME_DEVTOOLS_MCP_VERSION}`, "--autoConnect"],
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: process.platform === "win32",
+        windowsHide: true
+      }
+    );
+    this.child = child;
+    child.on("exit", (code, signal) => {
+      this.logger.info(`chrome-devtools-mcp exited (code=${code} signal=${signal})`);
+      for (const [, p] of this.pending) {
+        clearTimeout(p.timer);
+        p.reject(new Error(`chrome-devtools-mcp subprocess exited before responding to ${p.method}`));
+      }
+      this.pending.clear();
+      this.child = null;
+    });
+    child.stderr.on("data", (chunk) => {
+      const line = chunk.toString().trimEnd();
+      if (line) this.logger.info(`[cdp-mcp stderr] ${line}`);
+    });
+    const rl = createInterface({ input: child.stdout });
+    rl.on("line", (line) => this.onLine(line));
+    await this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "canary-cli", version: "0.0.0" }
+    }, INITIALIZE_TIMEOUT_MS);
+    this.notify("notifications/initialized", {});
+    this.initialized = true;
+  }
+  async callTool(name, args) {
+    if (!this.initialized) throw new Error("ChromeDevtoolsMcpClient not initialized");
+    const result = await this.request("tools/call", { name, arguments: args });
+    return result;
+  }
+  async listTools() {
+    if (!this.initialized) throw new Error("ChromeDevtoolsMcpClient not initialized");
+    const result = await this.request("tools/list", {});
+    return result.tools ?? [];
+  }
+  async shutdown() {
+    const child = this.child;
+    if (!child) return;
+    try {
+      child.stdin.end();
+    } catch {
+    }
+    await new Promise((resolve) => {
+      let done = false;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        resolve();
+      };
+      child.once("exit", finish);
+      setTimeout(() => {
+        if (!done) {
+          try {
+            child.kill("SIGTERM");
+          } catch {
+          }
+        }
+      }, SHUTDOWN_GRACE_MS);
+      setTimeout(() => {
+        if (!done) {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+          finish();
+        }
+      }, SHUTDOWN_GRACE_MS * 2);
+    });
+    this.child = null;
+    this.initialized = false;
+  }
+  request(method, params, timeoutMs = CALL_TIMEOUT_MS) {
+    const child = this.child;
+    if (!child) return Promise.reject(new Error("chrome-devtools-mcp subprocess not running"));
+    const id = this.nextId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pending.delete(id)) {
+          reject(new Error(`Timeout waiting for ${method} (id=${id}) after ${timeoutMs}ms`));
+        }
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer, method });
+      try {
+        child.stdin.write(payload + "\n");
+      } catch (err) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  notify(method, params) {
+    const child = this.child;
+    if (!child) return;
+    try {
+      child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+    } catch (err) {
+      this.logger.warn(`notify ${method} failed: ${String(err)}`);
+    }
+  }
+  onLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      this.logger.warn(`non-JSON line from chrome-devtools-mcp: ${trimmed.slice(0, 200)}`);
+      return;
+    }
+    if (typeof msg.id === "number" && this.pending.has(msg.id)) {
+      const p = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      clearTimeout(p.timer);
+      if (msg.error) {
+        p.reject(new Error(`${msg.error.code}: ${msg.error.message}`));
+      } else {
+        p.resolve(msg.result);
+      }
+    }
+  }
+};
+
+// src/session/cdp-proxy/translators.ts
+function textFromMcp(result) {
+  if (!result.content) return "";
+  return result.content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+}
+function imagesFromMcp(result) {
+  if (!result.content) return void 0;
+  const images = result.content.filter((c) => c.type === "image" && typeof c.data === "string").map((c) => ({ data: c.data, mimeType: c.mimeType ?? "image/png" }));
+  return images.length > 0 ? images : void 0;
+}
+function toResult(result) {
+  const text = textFromMcp(result);
+  const images = imagesFromMcp(result);
+  if (result.isError) {
+    return { ok: false, error: text || "chrome-devtools-mcp returned an error with no message" };
+  }
+  return { ok: true, text, images };
+}
+function normalizeUid(ref) {
+  if (!ref) return ref;
+  return ref.startsWith("uid=") ? ref.slice(4) : ref;
+}
+function notSupportedInAttachedMode(canaryTool) {
+  return {
+    ok: false,
+    error: `${canaryTool} is not supported in attached mode (real Chrome). Use a fresh session (--credential) if you need this.`
+  };
+}
+var translators = {
+  browser_navigate: async (mcp, args) => {
+    const url = args.url;
+    return toResult(await mcp.callTool("navigate_page", { url }));
+  },
+  browser_navigate_back: async (mcp) => {
+    return toResult(await mcp.callTool("navigate_page", { type: "back" }));
+  },
+  browser_snapshot: async (mcp, args) => {
+    const mode = args.mode;
+    if (mode === "screenshot") {
+      return toResult(await mcp.callTool("take_screenshot", {}));
+    }
+    const snap = await mcp.callTool("take_snapshot", {});
+    const snapResult = toResult(snap);
+    if (!snapResult.ok) return snapResult;
+    const search = args.search;
+    let filteredText = snapResult.text;
+    if (search) {
+      const terms = search.split("|").map((t) => t.trim().toLowerCase()).filter(Boolean);
+      if (terms.length > 0) {
+        const lines = filteredText.split("\n");
+        const matching = lines.filter((line) => {
+          const low = line.toLowerCase();
+          return terms.some((t) => low.includes(t));
+        });
+        filteredText = matching.length > 0 ? `# Filtered snapshot (search=${JSON.stringify(search)}, ${matching.length} matches)
+${matching.join("\n")}` : `# No matches for search=${JSON.stringify(search)}
+
+${filteredText}`;
+      }
+    }
+    if (mode === "both" || mode === void 0) {
+      const shot = await mcp.callTool("take_screenshot", {});
+      const shotResult = toResult(shot);
+      return {
+        ok: true,
+        text: filteredText,
+        images: shotResult.ok ? shotResult.images : void 0
+      };
+    }
+    return { ok: true, text: filteredText };
+  },
+  browser_screenshot: async (mcp, args) => {
+    return toResult(
+      await mcp.callTool("take_screenshot", {
+        uid: normalizeUid(args.ref),
+        fullPage: args.fullPage
+      })
+    );
+  },
+  browser_evaluate: async (mcp, args) => {
+    const fn = args.function;
+    return toResult(await mcp.callTool("evaluate_script", { function: fn }));
+  },
+  browser_console_messages: async (mcp, args) => {
+    const res = await mcp.callTool("list_console_messages", {});
+    const result = toResult(res);
+    if (!result.ok) return result;
+    if (args.onlyErrors) {
+      const filtered = result.text.split("\n").filter((l) => /error/i.test(l)).join("\n");
+      return { ok: true, text: filtered || "(no errors)" };
+    }
+    return result;
+  },
+  browser_network_requests: async (mcp) => {
+    return toResult(await mcp.callTool("list_network_requests", {}));
+  },
+  browser_click: async (mcp, args) => {
+    const ref = normalizeUid(args.ref);
+    const x = args.x;
+    const y = args.y;
+    if (ref) {
+      return toResult(
+        await mcp.callTool("click", {
+          uid: ref,
+          dblClick: args.doubleClick
+        })
+      );
+    }
+    if (typeof x === "number" && typeof y === "number") {
+      const dbl = args.doubleClick === true;
+      const fn = `() => { const el = document.elementFromPoint(${x}, ${y}); if (!el) throw new Error('No element at (${x},${y})'); el.${dbl ? "click(); el.click" : "click"}(); return el.outerHTML.slice(0, 200); }`;
+      return toResult(await mcp.callTool("evaluate_script", { function: fn }));
+    }
+    return { ok: false, error: "browser_click requires either ref or (x, y)" };
+  },
+  browser_hover: async (mcp, args) => {
+    return toResult(await mcp.callTool("hover", { uid: normalizeUid(args.ref) }));
+  },
+  browser_drag: async (mcp, args) => {
+    const startRef = normalizeUid(args.startRef);
+    const endRef = normalizeUid(args.endRef);
+    if (!startRef || !endRef) {
+      return {
+        ok: false,
+        error: "browser_drag in attached mode requires startRef and endRef (coordinate drag not supported)."
+      };
+    }
+    return toResult(await mcp.callTool("drag", { from_uid: startRef, to_uid: endRef }));
+  },
+  browser_type: async (mcp, args) => {
+    const ref = normalizeUid(args.ref);
+    const text = args.text;
+    const submit = args.submit;
+    if (ref) {
+      const fill = await mcp.callTool("fill", { uid: ref, value: text });
+      const fillResult = toResult(fill);
+      if (!fillResult.ok || !submit) return fillResult;
+      const press = await mcp.callTool("press_key", { key: "Enter" });
+      const pressResult = toResult(press);
+      if (!pressResult.ok) return pressResult;
+      return { ok: true, text: `${fillResult.text}
+${pressResult.text}`.trim() };
+    }
+    const typed = await mcp.callTool("type_text", {
+      text,
+      submitKey: submit ? "Enter" : void 0
+    });
+    return toResult(typed);
+  },
+  browser_press_key: async (mcp, args) => {
+    return toResult(await mcp.callTool("press_key", { key: args.key }));
+  },
+  browser_fill_form: async (mcp, args) => {
+    const fields = args.fields;
+    if (!Array.isArray(fields)) return { ok: false, error: "browser_fill_form requires fields[]" };
+    const elements = fields.map((f) => ({ uid: normalizeUid(f.ref), value: f.value }));
+    return toResult(await mcp.callTool("fill_form", { elements }));
+  },
+  browser_select_option: async (mcp, args) => {
+    return toResult(
+      await mcp.callTool("fill", { uid: normalizeUid(args.ref), value: args.value })
+    );
+  },
+  browser_file_upload: async (mcp, args) => {
+    const paths = args.paths;
+    const ref = normalizeUid(args.ref);
+    if (!paths || paths.length === 0 || !ref) {
+      return { ok: false, error: "browser_file_upload in attached mode requires ref and a single path" };
+    }
+    return toResult(await mcp.callTool("upload_file", { uid: ref, filePath: paths[0] }));
+  },
+  browser_scroll: async (mcp, args) => {
+    const direction = args.direction;
+    const amount = args.amount ?? 3;
+    const pixels = amount * 300;
+    let dx = 0;
+    let dy = 0;
+    if (direction === "down") dy = pixels;
+    else if (direction === "up") dy = -pixels;
+    else if (direction === "right") dx = pixels;
+    else if (direction === "left") dx = -pixels;
+    const fn = `() => { window.scrollBy(${dx}, ${dy}); return { scrollX: window.scrollX, scrollY: window.scrollY }; }`;
+    return toResult(await mcp.callTool("evaluate_script", { function: fn }));
+  },
+  browser_handle_dialog: async (mcp, args) => {
+    return toResult(
+      await mcp.callTool("handle_dialog", {
+        action: args.action,
+        promptText: args.promptText
+      })
+    );
+  },
+  browser_dismiss_overlay: async (mcp) => {
+    return toResult(await mcp.callTool("press_key", { key: "Escape" }));
+  },
+  browser_wait_for: async (mcp, args) => {
+    const text = args.text;
+    const timeSec = args.timeSec;
+    const timeout = args.timeout;
+    if (text) {
+      return toResult(await mcp.callTool("wait_for", { text: [text], timeout }));
+    }
+    if (typeof timeSec === "number") {
+      const fn = `async () => { await new Promise(r => setTimeout(r, ${Math.round(timeSec * 1e3)})); return 'waited ${timeSec}s'; }`;
+      return toResult(await mcp.callTool("evaluate_script", { function: fn }));
+    }
+    return { ok: false, error: "browser_wait_for in attached mode requires text or time" };
+  },
+  browser_close: async () => {
+    return { ok: true, text: "browser_close is a no-op in attached mode (the user owns the browser)." };
+  },
+  browser_resize: async (mcp, args) => {
+    return toResult(
+      await mcp.callTool("resize_page", {
+        width: args.width,
+        height: args.height
+      })
+    );
+  },
+  browser_tabs: async (mcp, args) => {
+    const action = args.action;
+    const index = args.index;
+    switch (action) {
+      case "list":
+        return toResult(await mcp.callTool("list_pages", {}));
+      case "new":
+        return toResult(await mcp.callTool("new_page", { url: "about:blank" }));
+      case "close":
+        if (typeof index !== "number")
+          return { ok: false, error: "browser_tabs close requires an index" };
+        return toResult(await mcp.callTool("close_page", { pageId: index }));
+      case "select":
+        if (typeof index !== "number")
+          return { ok: false, error: "browser_tabs select requires an index" };
+        return toResult(await mcp.callTool("select_page", { pageId: index, bringToFront: true }));
+      default:
+        return { ok: false, error: `browser_tabs: unknown action "${String(action)}"` };
+    }
+  },
+  browser_list_downloads: async () => notSupportedInAttachedMode("browser_list_downloads"),
+  browser_read_download: async () => notSupportedInAttachedMode("browser_read_download"),
+  browser_pdf_read: async () => notSupportedInAttachedMode("browser_pdf_read")
+};
+async function translateAndCall(mcp, toolName, args) {
+  const translator = translators[toolName];
+  if (!translator) {
+    return { ok: false, error: `Unknown browser tool: ${toolName}` };
+  }
+  try {
+    return await translator(mcp, args);
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// src/session/cdp-proxy/index.ts
+var CdpProxyClient = class {
+  mcp;
+  constructor(logger) {
+    this.mcp = new ChromeDevtoolsMcpClient(logger);
+  }
+  async start() {
+    await this.mcp.start();
+  }
+  async callByCanaryName(toolName, args) {
+    const fullName = toolName.startsWith("browser_") ? toolName : `browser_${toolName}`;
+    return translateAndCall(this.mcp, fullName, args);
+  }
+  async shutdown() {
+    await this.mcp.shutdown();
+  }
+};
+
+// src/session/daemon.ts
+var PIDFILE_DIR = path2.join(os2.homedir(), ".config", "canary-cli");
+var PIDFILE_PATH = path2.join(PIDFILE_DIR, "daemon.json");
+var IDLE_TIMEOUT_MS = 6e4;
+var SESSION_IDLE_TIMEOUT_MS = (() => {
+  const env = process.env.CANARY_SESSION_IDLE_TIMEOUT_MS;
+  if (env) {
+    const n = Number(env);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return 60 * 60 * 1e3;
+})();
+var SESSION_IDLE_SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
+function isAttached(s) {
+  return s.kind === "attached";
+}
+var sessions = /* @__PURE__ */ new Map();
+var nextId = 1;
+var idleTimer = null;
+var idleSweepTimer = null;
+function touch(s) {
+  s.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+function formatIdle(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${minutes % 60}m`;
+}
+function resetIdleTimer() {
+  if (idleTimer) clearTimeout(idleTimer);
+  if (sessions.size === 0) {
+    idleTimer = setTimeout(async () => {
+      if (sessions.size === 0) {
+        await removePidfile();
+        process.exit(0);
+      }
+    }, IDLE_TIMEOUT_MS);
+  }
+}
+function generateId() {
+  return `s${nextId++}`;
+}
+async function getSessionUrl(session) {
+  if (isAttached(session)) {
+    return void 0;
+  }
+  try {
+    return await session.client.getCurrentUrl();
+  } catch {
+    return void 0;
+  }
+}
+async function toSessionInfo(s) {
+  if (isAttached(s)) {
+    return {
+      id: s.id,
+      name: s.name,
+      mode: "attached",
+      credentialName: void 0,
+      url: void 0,
+      startedAt: s.startedAt,
+      lastActivityAt: s.lastActivityAt,
+      lock: s.lock
+    };
+  }
+  return {
+    id: s.id,
+    name: s.name,
+    mode: s.mode,
+    credentialName: s.credentialName,
+    url: await getSessionUrl(s),
+    startedAt: s.startedAt,
+    lastActivityAt: s.lastActivityAt,
+    lock: s.lock,
+    cloudRelay: s.localBrowserSessionId ? { localBrowserSessionId: s.localBrowserSessionId, connected: !!s.relayHost } : void 0
+  };
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function parseJson(body) {
+  if (!body.trim()) return {};
+  try {
+    return JSON.parse(body);
+  } catch {
+    return {};
+  }
+}
+function json(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+function parseRoute(url) {
+  const [pathname] = url.split("?");
+  const segments = pathname.split("/").filter(Boolean);
+  return { path: segments, query: {} };
+}
+async function setupCloudRelay(session, apiUrl, token) {
+  const res = await fetch(`${apiUrl}/local-browser/sessions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ browserMode: "playwright" })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to create cloud session: ${res.status} ${text}`);
+  }
+  const cloudSession = await res.json();
+  if (!cloudSession.ok) {
+    throw new Error(`Cloud session creation failed: ${cloudSession.error}`);
+  }
+  session.localBrowserSessionId = cloudSession.sessionId;
+  const host = new LocalBrowserHost({
+    apiUrl,
+    wsToken: cloudSession.wsToken,
+    sessionId: cloudSession.sessionId,
+    browserMode: "playwright",
+    existingClient: session.client,
+    skipBrowserLaunch: true,
+    shouldExecute: () => session.lock.controller === "cloud",
+    onLog: (level, message, data) => {
+      const fn = level === "error" ? consoleLogger.error : level === "warn" ? consoleLogger.warn : consoleLogger.info;
+      fn(`[relay:${session.id}] ${message}`, data);
+    }
+  });
+  await host.start();
+  session.relayHost = host;
+}
+async function handleHealth(res) {
+  json(res, 200, { ok: true, sessions: sessions.size });
+}
+async function handleCreateSession(body, res) {
+  const params = parseJson(body);
+  const id = generateId();
+  const name = params.name ?? id;
+  if (params.attachRealChrome) {
+    const conflicts = [];
+    if (params.headless) conflicts.push("headless");
+    if (params.credentialName) conflicts.push("credential");
+    if (params.storageStatePath) conflicts.push("storage-state");
+    if (params.url) conflicts.push("url");
+    if (params.cloudRelay) conflicts.push("cloud-relay");
+    if (conflicts.length > 0) {
+      json(res, 400, {
+        ok: false,
+        error: `--attach-real-chrome cannot be combined with: ${conflicts.join(", ")} (attached mode uses the live browser's profile and tabs).`
+      });
+      return;
+    }
+    for (const existing of sessions.values()) {
+      if (existing.kind === "attached") {
+        json(res, 409, {
+          ok: false,
+          error: `Another attached session is already active ("${existing.id}"). Stop it first with: canary session stop ${existing.id}`
+        });
+        return;
+      }
+    }
+    try {
+      const cdpProxy = new CdpProxyClient();
+      await cdpProxy.start();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const session = {
+        kind: "attached",
+        id,
+        name,
+        mode: "attached",
+        startedAt: now,
+        lastActivityAt: now,
+        lock: { controller: "cli", acquiredAt: now, cloudPaused: false },
+        cdpProxy
+      };
+      sessions.set(id, session);
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+      json(res, 201, {
+        ok: true,
+        data: await toSessionInfo(session)
+      });
+    } catch (err) {
+      json(res, 500, {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return;
+  }
+  const mode = params.headless ? "headless" : "headed";
+  try {
+    const client = new PlaywrightClient({ logger: consoleLogger });
+    await client.connect({
+      browserMode: mode,
+      storageStatePath: params.storageStatePath,
+      cursorOverlay: mode === "headed"
+    });
+    const executor = new BrowserToolExecutor(client, {
+      autoSnapshotAfterAction: true,
+      includeScreenshotWithSnapshot: true,
+      clickValidation: true,
+      logger: consoleLogger
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const session = {
+      kind: "playwright",
+      id,
+      name,
+      mode,
+      credentialName: params.credentialName,
+      client,
+      executor,
+      startedAt: now,
+      lastActivityAt: now,
+      lock: { controller: "cli", acquiredAt: now, cloudPaused: false },
+      userPaused: false,
+      userPausePollTimer: null,
+      pauseEnrichedEvents: [],
+      pauseResumeSnapshot: null
+    };
+    if (mode === "headed") {
+      await injectCaptureScript(client);
+      const page = await client.getPageForReplay();
+      if (page) {
+        try {
+          await page.addInitScript(INTERACTIVE_BADGE_SCRIPT);
+        } catch {
+        }
+      }
+      await updateControllerBadge(client, "cli", { interactive: true });
+    }
+    sessions.set(id, session);
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    if (params.cloudRelay) {
+      try {
+        await setupCloudRelay(session, params.cloudRelay.apiUrl, params.cloudRelay.token);
+      } catch (err) {
+        consoleLogger.warn(`Cloud relay setup failed: ${err}`);
+      }
+    }
+    const result = {
+      ok: true,
+      data: await toSessionInfo(session)
+    };
+    json(res, 201, result);
+    if (params.url) {
+      client.navigate(params.url).catch((err) => {
+        consoleLogger.warn(`Initial navigation to ${params.url} failed: ${err}`);
+      });
+    }
+  } catch (err) {
+    const result = {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+    json(res, 500, result);
+  }
+}
+async function handleListSessions(res) {
+  const list = await Promise.all(Array.from(sessions.values()).map(toSessionInfo));
+  json(res, 200, { ok: true, data: list });
+}
+async function handleGetSession(sessionId, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, {
+      ok: false,
+      error: `Session "${sessionId}" not found`
+    });
+    return;
+  }
+  json(res, 200, {
+    ok: true,
+    data: await toSessionInfo(session)
+  });
+}
+async function teardownSession(session) {
+  if (isAttached(session)) {
+    try {
+      await session.cdpProxy.shutdown();
+    } catch {
+    }
+    return;
+  }
+  cleanupPauseTimer(session);
+  if (session.relayHost) {
+    try {
+      await session.relayHost.stop();
+    } catch {
+    }
+  }
+  try {
+    await session.client.disconnect();
+  } catch {
+  }
+}
+async function stopSession(sessionId, reason) {
+  const session = sessions.get(sessionId);
+  if (!session) return false;
+  if (reason === "idle") {
+    const idleMs = Date.now() - Date.parse(session.lastActivityAt);
+    consoleLogger.info(
+      `[daemon] auto-stopping session ${session.id} (${session.name}) \u2014 idle ${formatIdle(idleMs)}`
+    );
+  }
+  await teardownSession(session);
+  sessions.delete(sessionId);
+  return true;
+}
+async function handleDeleteSession(sessionId, res) {
+  const stopped = await stopSession(sessionId, "manual");
+  if (!stopped) {
+    json(res, 404, {
+      ok: false,
+      error: `Session "${sessionId}" not found`
+    });
+    return;
+  }
+  json(res, 200, { ok: true });
+  resetIdleTimer();
+}
+async function handleDeleteAllSessions(res) {
+  const ids = Array.from(sessions.keys());
+  for (const id of ids) {
+    await stopSession(id, "all");
+  }
+  json(res, 200, { ok: true });
+  resetIdleTimer();
+}
+async function sweepIdleSessions() {
+  const now = Date.now();
+  const toStop = [];
+  for (const [id, s] of sessions) {
+    if (s.lock.controller === "cloud") continue;
+    const idleMs = now - Date.parse(s.lastActivityAt);
+    if (idleMs >= SESSION_IDLE_TIMEOUT_MS) toStop.push(id);
+  }
+  for (const id of toStop) {
+    try {
+      await stopSession(id, "idle");
+    } catch (err) {
+      consoleLogger.warn(`[daemon] idle-stop failed for ${id}: ${err}`);
+    }
+  }
+  if (toStop.length > 0) resetIdleTimer();
+}
+async function handleSwapContext(sessionId, body, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, {
+      ok: false,
+      error: `Session "${sessionId}" not found`
+    });
+    return;
+  }
+  if (isAttached(session)) {
+    json(res, 400, {
+      ok: false,
+      error: "swap-context is not supported in attached mode (real Chrome owns the profile)."
+    });
+    return;
+  }
+  touch(session);
+  const params = parseJson(body);
+  try {
+    await session.client.swapContext({
+      storageStatePath: params.storageStatePath
+    });
+    if (params.credentialName) {
+      session.credentialName = params.credentialName;
+    }
+    json(res, 200, {
+      ok: true,
+      data: await toSessionInfo(session)
+    });
+  } catch (err) {
+    json(res, 500, {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function handleGetStorageState(sessionId, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, {
+      ok: false,
+      error: `Session "${sessionId}" not found`
+    });
+    return;
+  }
+  if (isAttached(session)) {
+    json(res, 400, {
+      ok: false,
+      error: "storage-state is not supported in attached mode."
+    });
+    return;
+  }
+  try {
+    const storageState = await session.client.getStorageState();
+    json(res, 200, { ok: true, data: storageState });
+  } catch (err) {
+    json(res, 500, {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function handleToolCall(sessionId, toolName, body, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, {
+      ok: false,
+      error: `Session "${sessionId}" not found`
+    });
+    return;
+  }
+  if (session.lock.controller === "cloud") {
+    json(res, 423, {
+      ok: false,
+      error: "Session is controlled by cloud. Use take-control to force CLI control."
+    });
+    return;
+  }
+  touch(session);
+  if (isAttached(session)) {
+    const args2 = parseJson(body);
+    const fullToolName2 = toolName.startsWith("browser_") ? toolName : `browser_${toolName}`;
+    try {
+      const result = await session.cdpProxy.callByCanaryName(fullToolName2, args2);
+      if (!result.ok) {
+        json(res, 500, { ok: false, error: result.error });
+        return;
+      }
+      json(res, 200, {
+        ok: true,
+        text: result.text,
+        images: result.images
+      });
+    } catch (err) {
+      json(res, 500, {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return;
+  }
+  const { paused, events: drainedEvents } = await checkPauseAndDrainEvents(session);
+  if (paused) {
+    startPauseEnrichment(session);
+    json(res, 423, {
+      ok: false,
+      error: 'User has taken control of the browser. They will resume when ready. Do not retry \u2014 wait for the user to click "Resume Agent" in the browser.',
+      errorCode: USER_PAUSED_ERROR
+    });
+    return;
+  }
+  if (session.userPausePollTimer || session.pauseEnrichedEvents.length > 0) {
+    await stopPauseEnrichment(session);
+  }
+  const userEvents = [
+    ...session.pauseEnrichedEvents,
+    ...drainedEvents
+  ];
+  session.pauseEnrichedEvents = [];
+  const pauseSnapshot = session.pauseResumeSnapshot;
+  session.pauseResumeSnapshot = null;
+  const args = parseJson(body);
+  const fullToolName = toolName.startsWith("browser_") ? toolName : `browser_${toolName}`;
+  try {
+    const result = await dispatchBrowserToolWithTimeout(session.executor, fullToolName, args);
+    await discardCapturedEvents(session);
+    let text;
+    let images;
+    if (typeof result === "string") {
+      text = result;
+    } else {
+      text = result.text ?? "";
+      images = result.images;
+    }
+    if (userEvents.length > 0) {
+      const summary = formatUserActionsSummary(userEvents, pauseSnapshot);
+      if (summary) {
+        text = summary + "\n" + text;
+      }
+    }
+    json(res, 200, { ok: true, text, images });
+  } catch (err) {
+    await discardCapturedEvents(session);
+    json(res, 500, {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function handleGetLock(sessionId, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, { ok: false, error: `Session "${sessionId}" not found` });
+    return;
+  }
+  json(res, 200, { ok: true, data: session.lock });
+}
+async function handleTakeControl(sessionId, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, { ok: false, error: `Session "${sessionId}" not found` });
+    return;
+  }
+  if (isAttached(session)) {
+    json(res, 400, {
+      ok: false,
+      error: "Cloud lock operations are not supported in attached mode."
+    });
+    return;
+  }
+  touch(session);
+  const wasClouded = session.lock.controller === "cloud";
+  session.lock = {
+    controller: "cli",
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cloudPaused: wasClouded
+  };
+  await updateControllerBadge(session.client, "cli");
+  json(res, 200, { ok: true, data: await toSessionInfo(session) });
+}
+async function handleResumeCloud(sessionId, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, { ok: false, error: `Session "${sessionId}" not found` });
+    return;
+  }
+  if (isAttached(session)) {
+    json(res, 400, {
+      ok: false,
+      error: "Cloud lock operations are not supported in attached mode."
+    });
+    return;
+  }
+  if (!session.lock.cloudPaused) {
+    json(res, 409, { ok: false, error: "Cloud is not paused" });
+    return;
+  }
+  touch(session);
+  session.lock = {
+    controller: "cloud",
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cloudPaused: false
+  };
+  await updateControllerBadge(session.client, "cloud");
+  json(res, 200, { ok: true, data: await toSessionInfo(session) });
+}
+async function handleAcquireCloud(sessionId, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, { ok: false, error: `Session "${sessionId}" not found` });
+    return;
+  }
+  if (isAttached(session)) {
+    json(res, 400, {
+      ok: false,
+      error: "Cloud lock operations are not supported in attached mode."
+    });
+    return;
+  }
+  touch(session);
+  session.lock = {
+    controller: "cloud",
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cloudPaused: false
+  };
+  await updateControllerBadge(session.client, "cloud");
+  json(res, 200, { ok: true, data: await toSessionInfo(session) });
+}
+async function handleReleaseCloud(sessionId, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, { ok: false, error: `Session "${sessionId}" not found` });
+    return;
+  }
+  if (isAttached(session)) {
+    json(res, 400, {
+      ok: false,
+      error: "Cloud lock operations are not supported in attached mode."
+    });
+    return;
+  }
+  touch(session);
+  session.lock = {
+    controller: "cli",
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cloudPaused: false
+  };
+  await updateControllerBadge(session.client, "cli");
+  json(res, 200, { ok: true, data: await toSessionInfo(session) });
+}
+async function handleRequest(req, res) {
+  const method = req.method ?? "GET";
+  const { path: segments } = parseRoute(req.url ?? "/");
+  const body = method === "POST" || method === "DELETE" ? await readBody(req) : "";
+  try {
+    if (method === "GET" && segments[0] === "health") {
+      await handleHealth(res);
+      return;
+    }
+    if (method === "POST" && segments[0] === "sessions" && segments.length === 1) {
+      await handleCreateSession(body, res);
+      return;
+    }
+    if (method === "GET" && segments[0] === "sessions" && segments.length === 1) {
+      await handleListSessions(res);
+      return;
+    }
+    if (method === "GET" && segments[0] === "sessions" && segments.length === 2) {
+      await handleGetSession(segments[1], res);
+      return;
+    }
+    if (method === "DELETE" && segments[0] === "sessions" && segments.length === 1) {
+      await handleDeleteAllSessions(res);
+      return;
+    }
+    if (method === "DELETE" && segments[0] === "sessions" && segments.length === 2) {
+      await handleDeleteSession(segments[1], res);
+      return;
+    }
+    if (method === "POST" && segments[0] === "sessions" && segments[2] === "swap-context" && segments.length === 3) {
+      await handleSwapContext(segments[1], body, res);
+      return;
+    }
+    if (method === "GET" && segments[0] === "sessions" && segments[2] === "storage-state" && segments.length === 3) {
+      await handleGetStorageState(segments[1], res);
+      return;
+    }
+    if (method === "GET" && segments[0] === "sessions" && segments[2] === "lock" && segments.length === 3) {
+      await handleGetLock(segments[1], res);
+      return;
+    }
+    if (method === "POST" && segments[0] === "sessions" && segments[2] === "take-control" && segments.length === 3) {
+      await handleTakeControl(segments[1], res);
+      return;
+    }
+    if (method === "POST" && segments[0] === "sessions" && segments[2] === "resume-cloud" && segments.length === 3) {
+      await handleResumeCloud(segments[1], res);
+      return;
+    }
+    if (method === "POST" && segments[0] === "sessions" && segments[2] === "acquire-cloud" && segments.length === 3) {
+      await handleAcquireCloud(segments[1], res);
+      return;
+    }
+    if (method === "POST" && segments[0] === "sessions" && segments[2] === "release-cloud" && segments.length === 3) {
+      await handleReleaseCloud(segments[1], res);
+      return;
+    }
+    if (method === "POST" && segments[0] === "sessions" && segments[2] === "tools" && segments.length === 4) {
+      await handleToolCall(segments[1], segments[3], body, res);
+      return;
+    }
+    json(res, 404, { ok: false, error: "Not found" });
+  } catch (err) {
+    json(res, 500, { ok: false, error: err instanceof Error ? err.message : String(err) });
+  }
+}
+async function writePidfile(port) {
+  await fs2.mkdir(PIDFILE_DIR, { recursive: true, mode: 448 });
+  const state = {
+    pid: process.pid,
+    port,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await fs2.writeFile(PIDFILE_PATH, JSON.stringify(state, null, 2), { mode: 384 });
+}
+async function removePidfile() {
+  try {
+    await fs2.unlink(PIDFILE_PATH);
+  } catch {
+  }
+}
+async function cleanup() {
+  if (idleSweepTimer) {
+    clearInterval(idleSweepTimer);
+    idleSweepTimer = null;
+  }
+  for (const session of sessions.values()) {
+    await teardownSession(session);
+  }
+  sessions.clear();
+  await removePidfile();
+}
+async function startDaemon() {
+  const server = createServer(handleRequest);
+  return new Promise((resolve, reject) => {
+    server.listen(0, "127.0.0.1", async () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = addr.port;
+      await writePidfile(port);
+      resetIdleTimer();
+      idleSweepTimer = setInterval(() => {
+        sweepIdleSessions().catch((err) => {
+          consoleLogger.warn(`[daemon] idle sweep failed: ${err}`);
+        });
+      }, SESSION_IDLE_SWEEP_INTERVAL_MS);
+      idleSweepTimer.unref?.();
+      process.on("SIGINT", async () => {
+        await cleanup();
+        process.exit(0);
+      });
+      process.on("SIGTERM", async () => {
+        await cleanup();
+        process.exit(0);
+      });
+      process.on("exit", () => {
+        removePidfile().catch(() => {
+        });
+      });
+      resolve({ port });
+    });
+    server.on("error", reject);
+  });
+}
+async function runDaemon() {
+  const { Console } = await import("console");
+  global.console = new Console({ stdout: process.stderr, stderr: process.stderr });
+  const { port } = await startDaemon();
+  process.stdout.write(`DAEMON_READY:${port}
+`);
+}
+
+// src/session/index.ts
+function getScreenshotDir() {
+  return path3.join(os3.homedir(), ".canary", "screenshots");
+}
+function cleanupScreenshots() {
+  const dir = getScreenshotDir();
+  if (!fs3.existsSync(dir)) return;
+  for (const file of fs3.readdirSync(dir)) {
+    fs3.unlinkSync(path3.join(dir, file));
+  }
+}
+function cleanupStaleScreenshots() {
+  const dir = getScreenshotDir();
+  if (!fs3.existsSync(dir)) return;
+  const cutoff = Date.now() - 60 * 60 * 1e3;
+  for (const file of fs3.readdirSync(dir)) {
+    const filePath = path3.join(dir, file);
+    try {
+      const stat = fs3.statSync(filePath);
+      if (stat.isFile() && stat.mtimeMs < cutoff) {
+        fs3.unlinkSync(filePath);
+      }
+    } catch {
+    }
+  }
+}
+function formatDuration(since) {
+  const seconds = Math.floor((Date.now() - new Date(since).getTime()) / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${secs}s`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  return `${hours}h ${mins}m`;
+}
+function printSessionTable(sessions2) {
+  if (sessions2.length === 0) {
+    console.log("No active sessions.");
+    return;
+  }
+  const header = ["ID", "NAME", "MODE", "CREDENTIAL", "URL", "UPTIME", "IDLE"];
+  const rows = sessions2.map((s) => [
+    s.id,
+    s.name,
+    s.mode,
+    s.credentialName ?? "(none)",
+    s.url ?? "(none)",
+    formatDuration(s.startedAt),
+    formatDuration(s.lastActivityAt)
+  ]);
+  const widths = header.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => r[i].length))
+  );
+  const pad = (str, width) => str.padEnd(width);
+  console.log(header.map((h, i) => pad(h, widths[i])).join("  "));
+  for (const row of rows) {
+    console.log(row.map((cell, i) => pad(cell, widths[i])).join("  "));
+  }
+}
+function printToolResult(result, jsonMode) {
+  if (jsonMode) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!result.ok) {
+    console.error(`Error: ${result.error}`);
+    process2.exitCode = 1;
+    return;
+  }
+  if (result.text) {
+    console.log(result.text);
+  }
+  if (result.images?.length) {
+    const screenshotDir = getScreenshotDir();
+    fs3.mkdirSync(screenshotDir, { recursive: true });
+    for (const img of result.images) {
+      const ext = img.mimeType === "image/png" ? "png" : "jpg";
+      const filePath = path3.join(screenshotDir, `screenshot-${Date.now()}.${ext}`);
+      fs3.writeFileSync(filePath, Buffer.from(img.data, "base64"));
+      console.log(`Screenshot saved: ${filePath}`);
+    }
+  }
+}
+async function handleStart(argv) {
+  cleanupStaleScreenshots();
+  const headless = hasFlag(argv, "--headless");
+  const name = getArgValue(argv, "--name");
+  const url = getArgValue(argv, "--url");
+  const storageStatePath = getArgValue(argv, "--storage-state");
+  const jsonMode = hasFlag(argv, "--json");
+  const attachRealChrome = hasFlag(argv, "--attach-real-chrome");
+  if (attachRealChrome) {
+    const conflicts = [];
+    if (headless) conflicts.push("--headless");
+    if (storageStatePath) conflicts.push("--storage-state");
+    if (url) conflicts.push("--url");
+    if (argv.includes("--credential")) conflicts.push("--credential");
+    if (argv.includes("--cloud-relay")) conflicts.push("--cloud-relay");
+    if (conflicts.length > 0) {
+      console.error(
+        `Error: --attach-real-chrome cannot be combined with: ${conflicts.join(", ")}`
+      );
+      console.error("Attached mode uses the live browser's profile and tabs.");
+      process2.exitCode = 1;
+      return;
+    }
+    const result2 = await createSession({ attachRealChrome: true, name });
+    if (jsonMode) {
+      console.log(JSON.stringify(result2, null, 2));
+      return;
+    }
+    if (!result2.ok) {
+      console.error(`Error: ${result2.error}`);
+      console.error(
+        "Hint: in your real Chrome, open chrome://inspect/#remote-debugging and approve remote debugging (Chrome 144+)."
+      );
+      process2.exitCode = 1;
+      return;
+    }
+    const session2 = result2.data;
+    console.log(`Session "${session2.id}" attached to your real Chrome (M144+).`);
+    console.log('  Chrome is showing the "controlled by automated test software" banner.');
+    console.log(`  Stop with: canary session stop ${session2.id}`);
+    return;
+  }
+  const credentialIdx = argv.indexOf("--credential");
+  let resolvedCred = null;
+  if (credentialIdx !== -1) {
+    const nextArg = argv[credentialIdx + 1];
+    const credentialArg = nextArg && !nextArg.startsWith("--") ? nextArg : void 0;
+    resolvedCred = await resolveCredential(argv, credentialArg);
+    if (!resolvedCred) {
+      process2.exitCode = 1;
+      return;
+    }
+  }
+  let cloudRelay;
+  if (hasFlag(argv, "--cloud-relay")) {
+    const config = await resolveConfig(argv);
+    cloudRelay = { apiUrl: config.apiUrl, token: config.token };
+  }
+  const result = await createSession({
+    headless,
+    name,
+    url,
+    storageStatePath: resolvedCred?.storageStatePath ?? storageStatePath,
+    credentialName: resolvedCred?.credentialName,
+    cloudRelay
+  });
+  if (jsonMode) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!result.ok) {
+    console.error(`Error: ${result.error}`);
+    process2.exitCode = 1;
+    return;
+  }
+  const session = result.data;
+  console.log(`Session "${session.id}" started (${session.mode})`);
+  if (session.credentialName) {
+    console.log(`  Credential: ${session.credentialName}`);
+  }
+  const displayUrl = url ?? session.url;
+  if (displayUrl) {
+    console.log(`  URL: ${displayUrl}`);
+  }
+  if (cloudRelay) {
+    console.log(`  Cloud relay: connecting...`);
+  }
+  if (!jsonMode) {
+    const settingsDir = findClaudeSettingsDir();
+    if (settingsDir && !hasScreenshotPermission(settingsDir)) {
+      console.log("");
+      console.log("  Tip: Claude needs permission to read screenshots.");
+      console.log("  Run: canary session allow-screenshots");
+    }
+  }
+}
+async function handleList(argv) {
+  const jsonMode = hasFlag(argv, "--json");
+  const result = await listSessions();
+  if (jsonMode) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!result.ok) {
+    console.error(`Error: ${result.error}`);
+    process2.exitCode = 1;
+    return;
+  }
+  printSessionTable(result.data ?? []);
+}
+async function handleStatus(argv) {
+  const sessionId = getArgValue(argv, "--session") || (argv[0] && !argv[0].startsWith("--") ? argv[0] : void 0);
+  const jsonMode = hasFlag(argv, "--json");
+  try {
+    const target = await resolveTargetSession(sessionId);
+    const result = await getSession(target.id);
+    if (jsonMode) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (!result.ok || !result.data) {
+      console.error(`Error: ${result.error}`);
+      process2.exitCode = 1;
+      return;
+    }
+    const s = result.data;
+    console.log(`Session: ${s.id} (${s.name})`);
+    console.log(`  Mode: ${s.mode}`);
+    console.log(`  Credential: ${s.credentialName ?? "(none)"}`);
+    console.log(`  URL: ${s.url ?? "(none)"}`);
+    console.log(`  Controller: ${s.lock.controller}${s.lock.cloudPaused ? " (cloud paused)" : ""}`);
+    if (s.cloudRelay) {
+      console.log(`  Cloud relay: ${s.cloudRelay.connected ? "connected" : "disconnected"}`);
+    }
+    console.log(`  Uptime: ${formatDuration(s.startedAt)}`);
+    console.log(`  Idle: ${formatDuration(s.lastActivityAt)}`);
+    console.log(`  Started: ${s.startedAt}`);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process2.exitCode = 1;
+  }
+}
+async function handleStop(argv) {
+  const jsonMode = hasFlag(argv, "--json");
+  if (hasFlag(argv, "--all")) {
+    const result = await deleteAllSessions();
+    if (result.ok) cleanupScreenshots();
+    if (jsonMode) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (result.ok) {
+      console.log("All sessions stopped.");
+    } else {
+      console.error(`Error: ${result.error}`);
+      process2.exitCode = 1;
+    }
+    return;
+  }
+  const sessionId = getArgValue(argv, "--session") || (argv[0] && !argv[0].startsWith("--") ? argv[0] : void 0);
+  try {
+    const target = await resolveTargetSession(sessionId);
+    const result = await deleteSession(target.id);
+    if (result.ok) {
+      const remaining = await listSessions();
+      if (remaining.ok && (!remaining.data || remaining.data.length === 0)) {
+        cleanupScreenshots();
+      }
+    }
+    if (jsonMode) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (result.ok) {
+      console.log(`Session "${target.id}" stopped.`);
+    } else {
+      console.error(`Error: ${result.error}`);
+      process2.exitCode = 1;
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process2.exitCode = 1;
+  }
+}
+async function handleLoadCredential(argv) {
+  const jsonMode = hasFlag(argv, "--json");
+  const sessionId = getArgValue(argv, "--session") || (argv[0] && !argv[0].startsWith("--") ? argv[0] : void 0);
+  let target;
+  try {
+    target = await resolveTargetSession(sessionId);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process2.exitCode = 1;
+    return;
+  }
+  const credentialIdx = argv.indexOf("--credential");
+  const nextArg = credentialIdx !== -1 ? argv[credentialIdx + 1] : void 0;
+  const credentialArg = nextArg && !nextArg.startsWith("--") ? nextArg : void 0;
+  const storageStatePath = getArgValue(argv, "--storage-state");
+  let resolvedStorageStatePath;
+  let credentialName;
+  if (storageStatePath) {
+    resolvedStorageStatePath = storageStatePath;
+    credentialName = "(local storage state)";
+  } else {
+    const resolvedCred = await resolveCredential(argv, credentialArg);
+    if (!resolvedCred) {
+      process2.exitCode = 1;
+      return;
+    }
+    resolvedStorageStatePath = resolvedCred.storageStatePath;
+    credentialName = resolvedCred.credentialName;
+  }
+  const result = await swapSessionContext(target.id, {
+    storageStatePath: resolvedStorageStatePath,
+    credentialName
+  });
+  if (jsonMode) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!result.ok) {
+    console.error(`Error: ${result.error}`);
+    process2.exitCode = 1;
+    return;
+  }
+  const session = result.data;
+  console.log(`Credential loaded into session "${session.id}".`);
+  if (session.credentialName) {
+    console.log(`  Credential: ${session.credentialName}`);
+  }
+  if (session.url) {
+    console.log(`  URL: ${session.url}`);
+  }
+}
+async function handleSaveCredential(argv) {
+  const jsonMode = hasFlag(argv, "--json");
+  const sessionId = getArgValue(argv, "--session") || (argv[0] && !argv[0].startsWith("--") ? argv[0] : void 0);
+  let target;
+  try {
+    target = await resolveTargetSession(sessionId);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process2.exitCode = 1;
+    return;
+  }
+  const { apiUrl, token } = await resolveConfig(argv);
+  const credentialIdx = argv.indexOf("--credential");
+  const nextArg = credentialIdx !== -1 ? argv[credentialIdx + 1] : void 0;
+  const credentialHint = nextArg && !nextArg.startsWith("--") ? nextArg : void 0;
+  const credential = await selectCredential(apiUrl, token, credentialHint ?? target.credentialName);
+  if (!credential) {
+    console.error("Could not resolve credential. Use --credential <name|id>.");
+    process2.exitCode = 1;
+    return;
+  }
+  const storageResult = await getSessionStorageState(target.id);
+  if (!storageResult.ok || !storageResult.data) {
+    const msg = storageResult.error ?? "Unknown error";
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: false, error: msg }));
+    } else {
+      console.error(`Failed to extract storage state: ${msg}`);
+    }
+    process2.exitCode = 1;
+    return;
+  }
+  const uploadResult = await uploadStorageState({
+    apiUrl,
+    token,
+    propertyId: credential.propertyId,
+    credentialId: credential.id,
+    storageState: storageResult.data
+  });
+  if (jsonMode) {
+    console.log(JSON.stringify(uploadResult));
+    return;
+  }
+  if (!uploadResult.ok) {
+    console.error(`Failed to save: ${uploadResult.error ?? "Unknown error"}`);
+    process2.exitCode = 1;
+    return;
+  }
+  console.log(`Credential "${credential.name}" storage state saved.`);
+}
+function handleAllowScreenshots() {
+  const settingsDir = findClaudeSettingsDir();
+  if (!settingsDir) {
+    console.error(
+      "Error: No .claude/ directory found. Run this inside a project with Claude Code configured."
+    );
+    process2.exitCode = 1;
+    return;
+  }
+  const result = addScreenshotPermission(settingsDir);
+  if (result.alreadyPresent) {
+    console.log("Screenshot read permission already configured.");
+    console.log(`  Pattern: ${getScreenshotReadPattern()}`);
+  } else {
+    console.log("Added screenshot read permission to .claude/settings.local.json:");
+    console.log(`  ${result.added}`);
+  }
+}
+async function handleTakeControl2(argv) {
+  const sessionId = getArgValue(argv, "--session") || (argv[0] && !argv[0].startsWith("--") ? argv[0] : void 0);
+  const jsonMode = hasFlag(argv, "--json");
+  try {
+    const target = await resolveTargetSession(sessionId);
+    const result = await takeControl(target.id);
+    if (jsonMode) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (!result.ok) {
+      console.error(`Error: ${result.error}`);
+      process2.exitCode = 1;
+      return;
+    }
+    const session = result.data;
+    console.log(`CLI now controls session "${session.id}".`);
+    if (session.lock.cloudPaused) {
+      console.log("  Cloud execution paused. Resume with: canary session resume-cloud");
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process2.exitCode = 1;
+  }
+}
+async function handleResumeCloud2(argv) {
+  const sessionId = getArgValue(argv, "--session") || (argv[0] && !argv[0].startsWith("--") ? argv[0] : void 0);
+  const jsonMode = hasFlag(argv, "--json");
+  try {
+    const target = await resolveTargetSession(sessionId);
+    const result = await resumeCloud(target.id);
+    if (jsonMode) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (!result.ok) {
+      console.error(`Error: ${result.error}`);
+      process2.exitCode = 1;
+      return;
+    }
+    console.log(`Cloud execution resumed for session "${result.data.id}".`);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process2.exitCode = 1;
+  }
+}
+async function handleToolCommand(toolName, argv) {
+  const sessionIdOrName = getArgValue(argv, "--session");
+  const jsonMode = hasFlag(argv, "--json");
+  try {
+    const target = await resolveTargetSession(sessionIdOrName);
+    const args = buildToolArgs(toolName, argv);
+    const result = await callTool(target.id, toolName, args);
+    printToolResult(result, jsonMode);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process2.exitCode = 1;
+  }
+}
+function buildToolArgs(toolName, argv) {
+  const args = {};
+  switch (toolName) {
+    case "navigate":
+      args.url = getArgValue(argv, "--url");
+      break;
+    case "snapshot":
+      args.search = getArgValue(argv, "--search");
+      args.expand = getArgValue(argv, "--expand");
+      args.mode = getArgValue(argv, "--mode") ?? "tree";
+      break;
+    case "screenshot":
+      args.fullPage = hasFlag(argv, "--full-page");
+      args.label = getArgValue(argv, "--label");
+      args.returnImage = true;
+      break;
+    case "evaluate":
+      args.function = getArgValue(argv, "--js");
+      break;
+    case "click": {
+      const ref = getArgValue(argv, "--ref");
+      const x = getArgValue(argv, "--x");
+      const y = getArgValue(argv, "--y");
+      if (ref) args.ref = ref;
+      if (x) args.x = parseInt(x, 10);
+      if (y) args.y = parseInt(y, 10);
+      args.element = getArgValue(argv, "--element") ?? "";
+      break;
+    }
+    case "type":
+      args.ref = getArgValue(argv, "--ref");
+      args.text = getArgValue(argv, "--text");
+      args.element = getArgValue(argv, "--element") ?? "";
+      args.submit = hasFlag(argv, "--submit");
+      break;
+    case "fill_form": {
+      const fieldsStr = getArgValue(argv, "--fields");
+      if (fieldsStr) {
+        try {
+          args.fields = JSON.parse(fieldsStr);
+        } catch {
+          console.error("Error: --fields must be valid JSON");
+          process2.exitCode = 1;
+        }
+      }
+      break;
+    }
+    case "select_option":
+      args.ref = getArgValue(argv, "--ref");
+      args.value = getArgValue(argv, "--value");
+      args.element = getArgValue(argv, "--element") ?? "";
+      break;
+    case "press_key":
+      args.key = getArgValue(argv, "--key");
+      break;
+    case "scroll":
+      args.direction = getArgValue(argv, "--direction") ?? "down";
+      {
+        const amount = getArgValue(argv, "--amount");
+        if (amount) args.amount = parseInt(amount, 10);
+      }
+      break;
+    case "hover":
+      args.ref = getArgValue(argv, "--ref");
+      args.element = getArgValue(argv, "--element") ?? "";
+      break;
+    case "tabs": {
+      args.action = getArgValue(argv, "--action") ?? "list";
+      const index = getArgValue(argv, "--index");
+      if (index) args.index = parseInt(index, 10);
+      break;
+    }
+    case "wait_for": {
+      args.text = getArgValue(argv, "--text");
+      const timeout = getArgValue(argv, "--timeout");
+      if (timeout) args.timeout = parseInt(timeout, 10);
+      break;
+    }
+    case "console_messages":
+      args.onlyErrors = hasFlag(argv, "--only-errors");
+      break;
+  }
+  return args;
+}
+var TOOL_ALIASES = {
+  navigate: "navigate",
+  back: "navigate_back",
+  snapshot: "snapshot",
+  screenshot: "screenshot",
+  evaluate: "evaluate",
+  click: "click",
+  type: "type",
+  fill: "fill_form",
+  select: "select_option",
+  press: "press_key",
+  scroll: "scroll",
+  hover: "hover",
+  drag: "drag",
+  tabs: "tabs",
+  wait: "wait_for",
+  console: "console_messages",
+  network: "network_requests"
+};
+function printHelp() {
+  console.log(
+    [
+      "Usage: canary session <subcommand> [options]",
+      "",
+      "Session lifecycle:",
+      "  start [options]     Start a new browser session",
+      "  list                List active sessions",
+      "  status [<id>]       Show session details",
+      "  stop [<id>]         Stop a session (or --all)",
+      "  load-credential     Load a credential into a running session",
+      "  save-credential     Save session login state back to its credential",
+      "  allow-screenshots   Grant Claude auto-read access to session screenshots",
+      "",
+      "Control:",
+      "  take-control [<id>]   Force CLI control (pauses cloud execution)",
+      "  resume-cloud [<id>]   Resume paused cloud execution",
+      "",
+      "Browser actions:",
+      "  navigate --url <url>                Navigate to URL",
+      "  back                                Navigate back",
+      "  snapshot [--search <text>] [--expand <ref>] [--mode tree|screenshot|both]",
+      "  screenshot [--full-page] [--label <text>]",
+      "  evaluate --js <expression>          Evaluate JavaScript",
+      "  click --ref <ref> [--element <desc>]",
+      "  click --x <n> --y <n> [--element <desc>]",
+      "  type --ref <ref> --text <text> [--submit]",
+      `  fill --fields '[{"ref":"e1","value":"test"}]'`,
+      "  select --ref <ref> --value <val> [--element <desc>]",
+      "  press --key <key>                   Press keyboard key",
+      "  scroll --direction <dir> [--amount <n>]",
+      "  hover --ref <ref> [--element <desc>]",
+      "  tabs [--action list|new|close|select] [--index <n>]",
+      "  wait --text <text> [--timeout <ms>]",
+      "  console [--only-errors]             Show console messages",
+      "  network                             Show network requests",
+      "",
+      "Start options:",
+      "  --credential [<name|id>]  Use a credential (interactive if no value)",
+      "  --storage-state <path>    Use a local storage state file",
+      "  --headless                Run browser without visible UI",
+      "  --url <url>               Navigate to URL after launch",
+      "  --name <label>            Name the session",
+      "  --cloud-relay             Connect session to cloud API for remote control",
+      "  --attach-real-chrome      Attach to the user's running Chrome via chrome-devtools-mcp.",
+      "                            Requires Chrome 144+ with remote debugging enabled at",
+      "                            chrome://inspect/#remote-debugging. Uses the live profile \u2014",
+      "                            not compatible with --headless/--credential/--storage-state/--url.",
+      "",
+      "Load-credential options:",
+      "  --credential [<name|id>]  Use a credential (interactive if no value)",
+      "  --storage-state <path>    Use a local storage state file",
+      "",
+      "Save-credential options:",
+      "  --credential [<name|id>]  Target credential (defaults to session's credential)",
+      "",
+      "Common options:",
+      "  --session <id|name>       Target a specific session (when multiple)",
+      "  --json                    Output raw JSON",
+      "  --env <env>               Environment for credential resolution",
+      "  -h, --help                Show this help"
+    ].join("\n")
+  );
+}
+async function runSession(argv) {
+  const [subcommand, ...rest] = argv;
+  if (!subcommand || subcommand === "help" || hasFlag(argv, "-h", "--help")) {
+    printHelp();
+    return;
+  }
+  if (subcommand === "daemon") {
+    await runDaemon();
+    return;
+  }
+  switch (subcommand) {
+    case "start":
+      await handleStart(rest);
+      break;
+    case "list":
+      await handleList(rest);
+      break;
+    case "status":
+      await handleStatus(rest);
+      break;
+    case "stop":
+      await handleStop(rest);
+      break;
+    case "load-credential":
+      await handleLoadCredential(rest);
+      break;
+    case "save-credential":
+      await handleSaveCredential(rest);
+      break;
+    case "allow-screenshots":
+      handleAllowScreenshots();
+      break;
+    case "take-control":
+      await handleTakeControl2(rest);
+      break;
+    case "resume-cloud":
+      await handleResumeCloud2(rest);
+      break;
+    default: {
+      const toolName = TOOL_ALIASES[subcommand];
+      if (toolName) {
+        await handleToolCommand(toolName, rest);
+      } else {
+        console.error(`Unknown session subcommand: ${subcommand}`);
+        printHelp();
+        process2.exitCode = 1;
+      }
+    }
+  }
+}
+export {
+  runSession
+};
+//# sourceMappingURL=session-MYFNZPRP.js.map