@kortix/agent-tunnel 0.1.2 → 0.1.4

package/dist/client-cli.js

@@ -0,0 +1,752 @@
+#!/usr/bin/env node
+import "./chunk-7N7GSU6K.js";
+
+// src/client/cli.ts
+import { writeFileSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+
+// src/client/tunnel-client.ts
+var TunnelClientError = class extends Error {
+  constructor(code, message, requestId, isPermissionRequest = false) {
+    super(message);
+    this.code = code;
+    this.requestId = requestId;
+    this.isPermissionRequest = isPermissionRequest;
+    this.name = "TunnelClientError";
+  }
+};
+var TunnelClient = class {
+  apiUrl;
+  token;
+  explicitTunnelId;
+  cachedTunnelId = null;
+  cacheTimestamp = 0;
+  cacheTtlMs;
+  fs;
+  shell;
+  desktop;
+  constructor(config) {
+    this.apiUrl = config.apiUrl.replace(/\/+$/, "");
+    this.token = config.token;
+    this.explicitTunnelId = config.tunnelId;
+    this.cacheTtlMs = config.cacheTtlMs ?? 1e4;
+    this.fs = new FsNamespace(this);
+    this.shell = new ShellNamespace(this);
+    this.desktop = new DesktopNamespace(this);
+  }
+  async rpc(method, params = {}) {
+    const tunnelId = await this.resolveTunnelId();
+    const res = await fetch(`${this.apiUrl}/rpc/${tunnelId}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.token ? { Authorization: `Bearer ${this.token}` } : {}
+      },
+      body: JSON.stringify({ method, params })
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      if (res.status === 404) this.cachedTunnelId = null;
+      throw new TunnelClientError(
+        data.code ?? -1,
+        data.error ?? `HTTP ${res.status}`,
+        data.requestId,
+        res.status === 403 && !!data.requestId
+      );
+    }
+    return data.result;
+  }
+  async rpcWithPermissionFlow(method, params = {}) {
+    try {
+      return await this.rpc(method, params);
+    } catch (err) {
+      if (err instanceof TunnelClientError && err.isPermissionRequest) {
+        return `Permission required. A permission request (${err.requestId}) has been sent to the user for approval. The user needs to approve this request before you can access their local machine. Please inform the user and try again after they approve.`;
+      }
+      throw err;
+    }
+  }
+  async getConnections() {
+    const res = await fetch(`${this.apiUrl}/connections`, {
+      headers: {
+        ...this.token ? { Authorization: `Bearer ${this.token}` } : {}
+      }
+    });
+    if (!res.ok) {
+      throw new TunnelClientError(-1, `Failed to list connections: HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+  async resolveTunnelId() {
+    if (this.explicitTunnelId) return this.explicitTunnelId;
+    if (this.cachedTunnelId && Date.now() - this.cacheTimestamp < this.cacheTtlMs) {
+      return this.cachedTunnelId;
+    }
+    const res = await fetch(`${this.apiUrl}/connections`, {
+      headers: {
+        ...this.token ? { Authorization: `Bearer ${this.token}` } : {}
+      }
+    });
+    if (res.ok) {
+      const connections = await res.json();
+      const online = connections.find((c) => c.isLive);
+      if (online) {
+        this.cachedTunnelId = online.tunnelId;
+        this.cacheTimestamp = Date.now();
+        return online.tunnelId;
+      }
+      if (connections.length > 0) {
+        this.cachedTunnelId = connections[0].tunnelId;
+        this.cacheTimestamp = Date.now();
+        return connections[0].tunnelId;
+      }
+    }
+    this.cachedTunnelId = null;
+    throw new TunnelClientError(
+      -1,
+      "No tunnel connection found. The user needs to set up Agent Tunnel first:\n1. Create a tunnel connection\n2. Run `npx @kortix/agent-tunnel connect` on their local machine"
+    );
+  }
+};
+var FsNamespace = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  async read(path, encoding = "utf-8") {
+    return await this.client.rpc("fs.read", { path, encoding });
+  }
+  async write(path, content, encoding = "utf-8") {
+    return await this.client.rpc("fs.write", { path, content, encoding });
+  }
+  async list(path, recursive = false) {
+    return await this.client.rpc("fs.list", { path, recursive });
+  }
+  async stat(path) {
+    return await this.client.rpc("fs.stat", { path });
+  }
+  async delete(path) {
+    return await this.client.rpc("fs.delete", { path });
+  }
+};
+var ShellNamespace = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  async exec(command, args2 = [], options) {
+    return await this.client.rpc("shell.exec", {
+      command,
+      args: args2,
+      cwd: options?.cwd,
+      timeout: options?.timeout
+    });
+  }
+};
+var DesktopNamespace = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  async screenshot(params) {
+    return await this.client.rpc("desktop.screenshot", params ?? {});
+  }
+  async click(params) {
+    return this.client.rpc("desktop.mouse.click", params);
+  }
+  async type(text, delay) {
+    return this.client.rpc("desktop.keyboard.type", { text, delay });
+  }
+  async key(keys) {
+    return this.client.rpc("desktop.keyboard.key", { keys });
+  }
+  async mouseMove(x, y) {
+    return this.client.rpc("desktop.mouse.move", { x, y });
+  }
+  async mouseDrag(fromX, fromY, toX, toY, button) {
+    return this.client.rpc("desktop.mouse.drag", { fromX, fromY, toX, toY, button });
+  }
+  async mouseScroll(x, y, deltaX, deltaY) {
+    return this.client.rpc("desktop.mouse.scroll", { x, y, deltaX, deltaY });
+  }
+  async windowList() {
+    return await this.client.rpc("desktop.window.list", {});
+  }
+  async windowFocus(windowId) {
+    return this.client.rpc("desktop.window.focus", { windowId });
+  }
+  async appLaunch(app) {
+    return this.client.rpc("desktop.app.launch", { app });
+  }
+  async appQuit(app) {
+    return this.client.rpc("desktop.app.quit", { app });
+  }
+  async clipboardRead() {
+    return await this.client.rpc("desktop.clipboard.read", {});
+  }
+  async clipboardWrite(text) {
+    return this.client.rpc("desktop.clipboard.write", { text });
+  }
+  async screenInfo() {
+    return await this.client.rpc("desktop.screen.info", {});
+  }
+  async cursorImage(radius) {
+    return await this.client.rpc("desktop.cursor.image", { radius });
+  }
+  async axTree(params) {
+    return await this.client.rpc("desktop.ax.tree", params ?? {});
+  }
+  async axAction(elementId, action, pid) {
+    return await this.client.rpc("desktop.ax.action", { elementId, action, pid });
+  }
+  async axSetValue(elementId, value, pid) {
+    return await this.client.rpc("desktop.ax.set_value", { elementId, value, pid });
+  }
+  async axFocus(elementId, pid) {
+    return await this.client.rpc("desktop.ax.focus", { elementId, pid });
+  }
+  async axSearch(query, params) {
+    return await this.client.rpc("desktop.ax.search", { query, ...params });
+  }
+};
+
+// src/client/cli.ts
+var S6_ENV_DIR = process.env.S6_ENV_DIR || "/run/s6/container_environment";
+function getEnv(key) {
+  try {
+    const val = readFileSync(`${S6_ENV_DIR}/${key}`, "utf-8").trim();
+    if (val) return val;
+  } catch {
+  }
+  return process.env[key];
+}
+var FALLBACK_API_URL = "http://localhost:8008";
+function getApiBase() {
+  const raw = getEnv("TUNNEL_API_URL") || FALLBACK_API_URL;
+  const url = raw.startsWith("http") ? raw : FALLBACK_API_URL;
+  return url.replace(/\/+$/, "").replace(/\/v1\/router\/?$/, "");
+}
+var client = new TunnelClient({
+  apiUrl: `${getApiBase()}/v1/tunnel`,
+  token: getEnv("TUNNEL_TOKEN") || "",
+  tunnelId: getEnv("TUNNEL_ID")
+});
+function out(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function saveImage(base64, format) {
+  const ext = format === "jpeg" || format === "jpg" ? "jpg" : "png";
+  const dir = join(tmpdir(), "tunnel-screenshots");
+  mkdirSync(dir, { recursive: true });
+  const path = join(
+    dir,
+    `screenshot-${randomBytes(4).toString("hex")}.${ext}`
+  );
+  writeFileSync(path, Buffer.from(base64, "base64"));
+  return path;
+}
+function formatAXTree(el, indent = 0) {
+  const pad = "  ".repeat(indent);
+  const parts = [];
+  const label = el.title || el.value || el.description || "(unnamed)";
+  const flags = [];
+  if (!el.enabled) flags.push("disabled");
+  if (el.focused) flags.push("focused");
+  if (el.actions.length > 0) flags.push(`actions: ${el.actions.join(",")}`);
+  const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
+  parts.push(`${pad}[${el.role}] ${label} (id: ${el.id})${flagStr}`);
+  for (const child of el.children) {
+    parts.push(formatAXTree(child, indent + 1));
+  }
+  return parts.join("\n");
+}
+async function rpcSafe(method, params = {}) {
+  try {
+    const result = await client.rpc(method, params);
+    return { result, permissionRequired: false };
+  } catch (err) {
+    if (err instanceof TunnelClientError && err.isPermissionRequest) {
+      return {
+        result: null,
+        permissionRequired: true,
+        requestId: err.requestId || "unknown",
+        message: `Permission required. A permission request (${err.requestId}) has been sent to the user for approval. The user needs to approve this request before you can access their local machine. Please inform the user and try again after they approve.`
+      };
+    }
+    throw err;
+  }
+}
+async function call(method, params = {}) {
+  const r = await rpcSafe(method, params);
+  if (r.permissionRequired) {
+    out({
+      success: false,
+      permissionRequired: true,
+      requestId: r.requestId,
+      message: r.message
+    });
+    return null;
+  }
+  return r.result;
+}
+async function status() {
+  const connections = await client.getConnections();
+  if (connections.length === 0) {
+    return out({
+      success: true,
+      connections: [],
+      message: "No tunnel connections found. The user needs to set up Agent Tunnel first."
+    });
+  }
+  let hasOnline = false;
+  const mapped = connections.map((data) => {
+    if (data.isLive) hasOnline = true;
+    return {
+      name: data.name || "Unnamed",
+      tunnelId: data.tunnelId,
+      status: data.isLive ? "ONLINE" : "OFFLINE",
+      capabilities: data.capabilities || [],
+      machineInfo: data.machineInfo || {}
+    };
+  });
+  out({
+    success: true,
+    connections: mapped,
+    hasOnline,
+    message: hasOnline ? void 0 : "No tunnel is currently online. Ask the user to run `npx @kortix/agent-tunnel connect` on their local machine."
+  });
+}
+async function fsRead(args2) {
+  const result = await call("fs.read", {
+    path: args2.path,
+    encoding: args2.encoding || "utf-8"
+  });
+  if (result === null) return;
+  const data = result;
+  out({
+    success: true,
+    path: data.path || args2.path,
+    size: data.size,
+    content: data.content
+  });
+}
+async function fsWrite(args2) {
+  const result = await call("fs.write", {
+    path: args2.path,
+    content: args2.content,
+    encoding: args2.encoding || "utf-8"
+  });
+  if (result === null) return;
+  const data = result;
+  out({ success: true, path: data.path, size: data.size });
+}
+async function fsList(args2) {
+  const result = await call("fs.list", {
+    path: args2.path,
+    recursive: args2.recursive || false
+  });
+  if (result === null) return;
+  const data = result;
+  out({
+    success: true,
+    path: args2.path,
+    count: data.count,
+    entries: data.entries
+  });
+}
+async function shell(args2) {
+  const result = await call("shell.exec", {
+    command: args2.command,
+    args: args2.args || [],
+    cwd: args2.cwd,
+    timeout: args2.timeout
+  });
+  if (result === null) return;
+  const data = result;
+  out({
+    success: data.exitCode === 0,
+    exitCode: data.exitCode,
+    signal: data.signal,
+    stdout: data.stdout,
+    stderr: data.stderr,
+    stdoutTruncated: data.stdoutTruncated,
+    stderrTruncated: data.stderrTruncated
+  });
+}
+async function screenshot(args2) {
+  const params = {};
+  if (args2.x !== void 0 && args2.y !== void 0 && args2.width !== void 0 && args2.height !== void 0) {
+    params.region = {
+      x: args2.x,
+      y: args2.y,
+      width: args2.width,
+      height: args2.height
+    };
+  }
+  if (args2.windowId !== void 0) params.windowId = args2.windowId;
+  const result = await call("desktop.screenshot", params);
+  if (result === null) return;
+  const data = result;
+  const format = data.format || "png";
+  const sizeKB = Math.round(data.image.length * 0.75 / 1024);
+  const path = saveImage(data.image, format);
+  out({
+    success: true,
+    path,
+    width: data.width,
+    height: data.height,
+    format,
+    sizeKB,
+    message: `Screenshot saved: ${path} (${data.width}x${data.height} ${format.toUpperCase()}, ${sizeKB}KB). Use the Read tool to view.`
+  });
+}
+async function click(args2) {
+  const result = await call("desktop.mouse.click", {
+    x: args2.x,
+    y: args2.y,
+    button: args2.button,
+    clicks: args2.clicks,
+    modifiers: args2.modifiers
+  });
+  if (result === null) return;
+  out({
+    success: true,
+    x: args2.x,
+    y: args2.y,
+    button: args2.button || "left",
+    clicks: args2.clicks || 1
+  });
+}
+async function mouseMove(args2) {
+  const result = await call("desktop.mouse.move", { x: args2.x, y: args2.y });
+  if (result === null) return;
+  out({ success: true, x: args2.x, y: args2.y });
+}
+async function mouseDrag(args2) {
+  const result = await call("desktop.mouse.drag", {
+    fromX: args2.fromX,
+    fromY: args2.fromY,
+    toX: args2.toX,
+    toY: args2.toY,
+    button: args2.button
+  });
+  if (result === null) return;
+  out({
+    success: true,
+    fromX: args2.fromX,
+    fromY: args2.fromY,
+    toX: args2.toX,
+    toY: args2.toY
+  });
+}
+async function mouseScroll(args2) {
+  const result = await call("desktop.mouse.scroll", {
+    x: args2.x,
+    y: args2.y,
+    deltaX: args2.deltaX,
+    deltaY: args2.deltaY
+  });
+  if (result === null) return;
+  out({
+    success: true,
+    x: args2.x,
+    y: args2.y,
+    deltaX: args2.deltaX || 0,
+    deltaY: args2.deltaY || 0
+  });
+}
+async function typeText(args2) {
+  const result = await call("desktop.keyboard.type", {
+    text: args2.text,
+    delay: args2.delay
+  });
+  if (result === null) return;
+  out({ success: true, chars: args2.text.length });
+}
+async function pressKey(args2) {
+  const result = await call("desktop.keyboard.key", { keys: args2.keys });
+  if (result === null) return;
+  out({ success: true, keys: args2.keys });
+}
+async function windowList() {
+  const result = await call("desktop.window.list", {});
+  if (result === null) return;
+  const data = result;
+  out({ success: true, windows: data.windows });
+}
+async function windowFocus(args2) {
+  const result = await call("desktop.window.focus", {
+    windowId: args2.windowId
+  });
+  if (result === null) return;
+  out({ success: true, windowId: args2.windowId });
+}
+async function appLaunch(args2) {
+  const result = await call("desktop.app.launch", { app: args2.app });
+  if (result === null) return;
+  out({ success: true, app: args2.app });
+}
+async function appQuit(args2) {
+  const result = await call("desktop.app.quit", { app: args2.app });
+  if (result === null) return;
+  out({ success: true, app: args2.app });
+}
+async function clipboardRead() {
+  const result = await call("desktop.clipboard.read", {});
+  if (result === null) return;
+  const data = result;
+  out({ success: true, text: data.text || "" });
+}
+async function clipboardWrite(args2) {
+  const result = await call("desktop.clipboard.write", { text: args2.text });
+  if (result === null) return;
+  out({ success: true, chars: args2.text.length });
+}
+async function screenInfo() {
+  const result = await call("desktop.screen.info", {});
+  if (result === null) return;
+  const data = result;
+  out({ success: true, ...data });
+}
+async function cursorImage(args2) {
+  const result = await call("desktop.cursor.image", { radius: args2.radius });
+  if (result === null) return;
+  const data = result;
+  const format = data.format || "png";
+  const sizeKB = Math.round(data.image.length * 0.75 / 1024);
+  const path = saveImage(data.image, format);
+  out({
+    success: true,
+    path,
+    width: data.width,
+    height: data.height,
+    format,
+    sizeKB,
+    message: `Cursor area saved: ${path} (${data.width}x${data.height}). Use the Read tool to view.`
+  });
+}
+async function axTree(args2) {
+  const params = {};
+  if (args2.pid !== void 0) params.pid = args2.pid;
+  if (args2.maxDepth !== void 0) params.maxDepth = args2.maxDepth;
+  if (args2.roles !== void 0) params.roles = args2.roles;
+  const result = await call("desktop.ax.tree", params);
+  if (result === null) return;
+  const data = result;
+  if (!data.root)
+    return out({
+      success: true,
+      tree: null,
+      message: "No accessibility tree available"
+    });
+  out({
+    success: true,
+    elementCount: data.elementCount,
+    tree: formatAXTree(data.root)
+  });
+}
+async function axAction(args2) {
+  const result = await call("desktop.ax.action", {
+    elementId: args2.elementId,
+    action: args2.action,
+    pid: args2.pid
+  });
+  if (result === null) return;
+  const data = result;
+  out({
+    success: data.ok,
+    action: data.action,
+    elementId: data.elementId,
+    role: data.role,
+    title: data.title,
+    stateChanged: data.stateChanged,
+    before: data.before,
+    after: data.after
+  });
+}
+async function axSetValue(args2) {
+  const result = await call("desktop.ax.set_value", {
+    elementId: args2.elementId,
+    value: args2.value,
+    pid: args2.pid
+  });
+  if (result === null) return;
+  const data = result;
+  out({
+    success: data.ok,
+    elementId: data.elementId,
+    requestedValue: data.requestedValue,
+    actualValue: data.actualValue,
+    error: data.error
+  });
+}
+async function axFocus(args2) {
+  const result = await call("desktop.ax.focus", {
+    elementId: args2.elementId,
+    pid: args2.pid
+  });
+  if (result === null) return;
+  const data = result;
+  out({
+    success: data.ok,
+    elementId: data.elementId,
+    role: data.role,
+    title: data.title,
+    before: data.before,
+    after: data.after,
+    error: data.error
+  });
+}
+async function axSearch(args2) {
+  const params = { query: args2.query };
+  if (args2.role !== void 0) params.role = args2.role;
+  if (args2.pid !== void 0) params.pid = args2.pid;
+  if (args2.maxResults !== void 0) params.maxResults = args2.maxResults;
+  const result = await call("desktop.ax.search", params);
+  if (result === null) return;
+  const data = result;
+  if (!data.elements || data.elements.length === 0) {
+    return out({
+      success: true,
+      query: args2.query,
+      elements: [],
+      message: `No elements found matching "${args2.query}"`
+    });
+  }
+  const elements = data.elements.map((el) => ({
+    id: el.id,
+    role: el.role,
+    title: el.title || el.value || el.description || "(unnamed)",
+    bounds: el.bounds,
+    enabled: el.enabled,
+    focused: el.focused,
+    actions: el.actions
+  }));
+  out({ success: true, query: args2.query, count: elements.length, elements });
+}
+var ALL_COMMANDS = [
+  "status",
+  "fs_read",
+  "fs_write",
+  "fs_list",
+  "shell",
+  "screenshot",
+  "click",
+  "mouse_move",
+  "mouse_drag",
+  "mouse_scroll",
+  "type",
+  "key",
+  "window_list",
+  "window_focus",
+  "app_launch",
+  "app_quit",
+  "clipboard_read",
+  "clipboard_write",
+  "screen_info",
+  "cursor_image",
+  "ax_tree",
+  "ax_action",
+  "ax_set_value",
+  "ax_focus",
+  "ax_search"
+];
+var [cmd, rawArgs] = process.argv.slice(2);
+if (!cmd) {
+  console.error(
+    `Usage: agent-tunnel-cli <command> [args as JSON]
+
+Available: ${ALL_COMMANDS.join(" | ")}`
+  );
+  process.exit(1);
+}
+var args = rawArgs ? JSON.parse(rawArgs) : {};
+try {
+  switch (cmd) {
+    case "status":
+      await status();
+      break;
+    case "fs_read":
+      await fsRead(args);
+      break;
+    case "fs_write":
+      await fsWrite(args);
+      break;
+    case "fs_list":
+      await fsList(args);
+      break;
+    case "shell":
+      await shell(args);
+      break;
+    case "screenshot":
+      await screenshot(args);
+      break;
+    case "click":
+      await click(args);
+      break;
+    case "mouse_move":
+      await mouseMove(args);
+      break;
+    case "mouse_drag":
+      await mouseDrag(args);
+      break;
+    case "mouse_scroll":
+      await mouseScroll(args);
+      break;
+    case "type":
+      await typeText(args);
+      break;
+    case "key":
+      await pressKey(args);
+      break;
+    case "window_list":
+      await windowList();
+      break;
+    case "window_focus":
+      await windowFocus(args);
+      break;
+    case "app_launch":
+      await appLaunch(args);
+      break;
+    case "app_quit":
+      await appQuit(args);
+      break;
+    case "clipboard_read":
+      await clipboardRead();
+      break;
+    case "clipboard_write":
+      await clipboardWrite(args);
+      break;
+    case "screen_info":
+      await screenInfo();
+      break;
+    case "cursor_image":
+      await cursorImage(args);
+      break;
+    case "ax_tree":
+      await axTree(args);
+      break;
+    case "ax_action":
+      await axAction(args);
+      break;
+    case "ax_set_value":
+      await axSetValue(args);
+      break;
+    case "ax_focus":
+      await axFocus(args);
+      break;
+    case "ax_search":
+      await axSearch(args);
+      break;
+    default:
+      console.error(
+        `Unknown command: ${cmd}
+
+Available: ${ALL_COMMANDS.join(" | ")}`
+      );
+      process.exit(1);
+  }
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  out({ success: false, error: message });
+  process.exit(1);
+}