@canaryai/cli 0.2.8 → 0.2.9

package/dist/session-RNLKFS2Z.js

@@ -0,0 +1,751 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  downloadStorageState,
+  fetchList
+} from "./chunk-QLFSJG5O.js";
+import {
+  callTool,
+  createSession,
+  deleteAllSessions,
+  deleteSession,
+  getSession,
+  listSessions,
+  resolveTargetSession
+} from "./chunk-C2PGZRYK.js";
+import {
+  getArgValue,
+  hasFlag,
+  resolveConfig
+} from "./chunk-PWWQGYFG.js";
+import {
+  BrowserToolExecutor,
+  PlaywrightClient,
+  dispatchBrowserTool
+} from "./chunk-XGO62PO2.js";
+import "./chunk-XAA5VQ5N.js";
+import {
+  consoleLogger
+} from "./chunk-P5Z2Y5VV.js";
+import "./chunk-VKVL7WBN.js";
+
+// src/session/index.ts
+import process3 from "process";
+
+// src/session/credentials.ts
+import process2 from "process";
+async function resolveCredential(argv, credentialArg) {
+  const { apiUrl, token } = await resolveConfig(argv);
+  const credentials = await fetchList(
+    apiUrl,
+    token,
+    "/org/credentials",
+    "credentials"
+  );
+  if (credentials.length === 0) {
+    console.error("No credentials found for this organization.");
+    return null;
+  }
+  let credential;
+  if (!credentialArg) {
+    console.log("Select a credential:");
+    for (let i = 0; i < credentials.length; i++) {
+      const c = credentials[i];
+      const propLabel = c.propertyName ? ` (${c.propertyName})` : "";
+      console.log(`  ${i + 1}. ${c.name}${propLabel}`);
+    }
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: process2.stdin, output: process2.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question("> ", (ans) => {
+        rl.close();
+        resolve(ans.trim());
+      });
+    });
+    const idx = parseInt(answer, 10) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= credentials.length) {
+      console.error("Invalid selection.");
+      return null;
+    }
+    credential = credentials[idx];
+  } else {
+    credential = credentials.find(
+      (c) => c.id === credentialArg || c.name.toLowerCase() === credentialArg.toLowerCase()
+    );
+    if (!credential) {
+      console.error(`Credential "${credentialArg}" not found.`);
+      console.error("Available credentials:");
+      for (const c of credentials) {
+        console.error(`  - ${c.name} (${c.id})`);
+      }
+      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 fs from "fs/promises";
+import path from "path";
+import os from "os";
+var PIDFILE_DIR = path.join(os.homedir(), ".config", "canary-cli");
+var PIDFILE_PATH = path.join(PIDFILE_DIR, "daemon.json");
+var IDLE_TIMEOUT_MS = 6e4;
+var sessions = /* @__PURE__ */ new Map();
+var nextId = 1;
+var idleTimer = null;
+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) {
+  try {
+    return await session.client.getCurrentUrl();
+  } catch {
+    return void 0;
+  }
+}
+async function toSessionInfo(s) {
+  return {
+    id: s.id,
+    name: s.name,
+    mode: s.mode,
+    credentialName: s.credentialName,
+    url: await getSessionUrl(s),
+    startedAt: s.startedAt
+  };
+}
+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 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;
+  const mode = params.headless ? "headless" : "headed";
+  try {
+    const client = new PlaywrightClient({ logger: consoleLogger });
+    await client.connect({
+      browserMode: mode,
+      storageStatePath: params.storageStatePath
+    });
+    if (params.url) {
+      await client.navigate(params.url);
+    }
+    const executor = new BrowserToolExecutor(client, {
+      autoSnapshotAfterAction: true,
+      includeScreenshotWithSnapshot: true,
+      clickValidation: true,
+      logger: consoleLogger
+    });
+    const session = {
+      id,
+      name,
+      mode,
+      credentialName: params.credentialName,
+      client,
+      executor,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    sessions.set(id, session);
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    const result = {
+      ok: true,
+      data: await toSessionInfo(session)
+    };
+    json(res, 201, result);
+  } 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 handleDeleteSession(sessionId, res) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    json(res, 404, { ok: false, error: `Session "${sessionId}" not found` });
+    return;
+  }
+  try {
+    await session.client.disconnect();
+  } catch {
+  }
+  sessions.delete(sessionId);
+  json(res, 200, { ok: true });
+  resetIdleTimer();
+}
+async function handleDeleteAllSessions(res) {
+  for (const session of sessions.values()) {
+    try {
+      await session.client.disconnect();
+    } catch {
+    }
+  }
+  sessions.clear();
+  json(res, 200, { ok: true });
+  resetIdleTimer();
+}
+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;
+  }
+  const args = parseJson(body);
+  const fullToolName = toolName.startsWith("browser_") ? toolName : `browser_${toolName}`;
+  try {
+    const result = await dispatchBrowserTool(session.executor, fullToolName, args);
+    if (typeof result === "string") {
+      json(res, 200, { ok: true, text: result });
+    } else {
+      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)
+    });
+  }
+}
+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] === "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 fs.mkdir(PIDFILE_DIR, { recursive: true, mode: 448 });
+  const state = {
+    pid: process.pid,
+    port,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await fs.writeFile(PIDFILE_PATH, JSON.stringify(state, null, 2), { mode: 384 });
+}
+async function removePidfile() {
+  try {
+    await fs.unlink(PIDFILE_PATH);
+  } catch {
+  }
+}
+async function cleanup() {
+  for (const session of sessions.values()) {
+    try {
+      await session.client.disconnect();
+    } catch {
+    }
+  }
+  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();
+      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 { port } = await startDaemon();
+  process.stdout.write(`DAEMON_READY:${port}
+`);
+}
+
+// src/session/index.ts
+function formatUptime(startedAt) {
+  const seconds = Math.floor((Date.now() - new Date(startedAt).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"];
+  const rows = sessions2.map((s) => [
+    s.id,
+    s.name,
+    s.mode,
+    s.credentialName ?? "(none)",
+    s.url ?? "(none)",
+    formatUptime(s.startedAt)
+  ]);
+  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}`);
+    process3.exitCode = 1;
+    return;
+  }
+  if (result.text) {
+    console.log(result.text);
+  }
+  if (result.images?.length) {
+    console.log(`[${result.images.length} image(s) captured]`);
+  }
+}
+async function handleStart(argv) {
+  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 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) {
+      process3.exitCode = 1;
+      return;
+    }
+  }
+  const result = await createSession({
+    headless,
+    name,
+    url,
+    storageStatePath: resolvedCred?.storageStatePath ?? storageStatePath,
+    credentialName: resolvedCred?.credentialName
+  });
+  if (jsonMode) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!result.ok) {
+    console.error(`Error: ${result.error}`);
+    process3.exitCode = 1;
+    return;
+  }
+  const session = result.data;
+  console.log(`Session "${session.id}" started (${session.mode})`);
+  if (session.credentialName) {
+    console.log(`  Credential: ${session.credentialName}`);
+  }
+  if (session.url) {
+    console.log(`  URL: ${session.url}`);
+  }
+}
+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}`);
+    process3.exitCode = 1;
+    return;
+  }
+  printSessionTable(result.data ?? []);
+}
+async function handleStatus(argv) {
+  const sessionId = 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}`);
+      process3.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(`  Uptime: ${formatUptime(s.startedAt)}`);
+    console.log(`  Started: ${s.startedAt}`);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process3.exitCode = 1;
+  }
+}
+async function handleStop(argv) {
+  const jsonMode = hasFlag(argv, "--json");
+  if (hasFlag(argv, "--all")) {
+    const result = await deleteAllSessions();
+    if (jsonMode) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (result.ok) {
+      console.log("All sessions stopped.");
+    } else {
+      console.error(`Error: ${result.error}`);
+      process3.exitCode = 1;
+    }
+    return;
+  }
+  const sessionId = argv[0] && !argv[0].startsWith("--") ? argv[0] : void 0;
+  try {
+    const target = await resolveTargetSession(sessionId);
+    const result = await deleteSession(target.id);
+    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}`);
+      process3.exitCode = 1;
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process3.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));
+    process3.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.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");
+          process3.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)",
+      "",
+      "Browser actions:",
+      "  navigate --url <url>                Navigate to URL",
+      "  back                                Navigate back",
+      "  snapshot [--search <text>] [--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",
+      "",
+      "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;
+    default: {
+      const toolName = TOOL_ALIASES[subcommand];
+      if (toolName) {
+        await handleToolCommand(toolName, rest);
+      } else {
+        console.error(`Unknown session subcommand: ${subcommand}`);
+        printHelp();
+        process3.exitCode = 1;
+      }
+    }
+  }
+}
+export {
+  runSession
+};
+//# sourceMappingURL=session-RNLKFS2Z.js.map