@beeuni/agent-tunnel 0.0.0-stage → 0.1.1

package/dist/client-cli.js

@@ -0,0 +1,511 @@
+#!/usr/bin/env node
+
+// src/client/cli.ts
+import { readFileSync } from "fs";
+import { open } from "node:fs/promises";
+import { createHash } from "node:crypto";
+
+// src/client/tunnel-client.ts
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47)
+    end -= 1;
+  return value.slice(0, end);
+}
+
+class TunnelClientError extends Error {
+  code;
+  requestId;
+  isPermissionRequest;
+  constructor(code, message, requestId, isPermissionRequest = false) {
+    super(message);
+    this.code = code;
+    this.requestId = requestId;
+    this.isPermissionRequest = isPermissionRequest;
+    this.name = "TunnelClientError";
+  }
+}
+
+class TunnelClient {
+  apiUrl;
+  token;
+  explicitTunnelId;
+  cachedTunnelId = null;
+  cacheTimestamp = 0;
+  cacheTtlMs;
+  fs;
+  shell;
+  cua;
+  constructor(config) {
+    const apiUrl = new URL(config.apiUrl);
+    const loopback = apiUrl.hostname === "localhost" || apiUrl.hostname === "127.0.0.1" || apiUrl.hostname === "[::1]" || apiUrl.hostname === "::1";
+    if (apiUrl.protocol !== "https:" && !(apiUrl.protocol === "http:" && loopback)) {
+      throw new Error("Remote tunnel API URLs must use https");
+    }
+    this.apiUrl = trimTrailingSlashes(apiUrl.toString());
+    this.token = config.token;
+    this.explicitTunnelId = config.tunnelId;
+    this.cacheTtlMs = config.cacheTtlMs ?? 1e4;
+    this.fs = new FsNamespace(this);
+    this.shell = new ShellNamespace(this);
+    this.cua = new CuaNamespace(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 })
+    });
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      if (!res.ok) {
+        throw new TunnelClientError(-1, `HTTP ${res.status} ${res.statusText}`, undefined, false);
+      }
+      throw new Error(`Failed to parse response for ${method}: unexpected non-JSON body`);
+    }
+    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}`);
+    }
+    try {
+      return await res.json();
+    } catch {
+      throw new Error(`Failed to parse connections response: unexpected non-JSON body`);
+    }
+  }
+  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);
+      const chosen = online ?? connections[0];
+      if (chosen) {
+        this.cachedTunnelId = chosen.tunnelId;
+        this.cacheTimestamp = Date.now();
+        return chosen.tunnelId;
+      }
+    }
+    this.cachedTunnelId = null;
+    throw new TunnelClientError(-1, `No tunnel connection found. The user needs to set up Agent Tunnel first:
+` + `1. Create a tunnel connection
+` + "2. Connect the local machine from the Beeuni desktop app or run the tunnel connect command");
+  }
+}
+
+class FsNamespace {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  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 });
+  }
+}
+
+class ShellNamespace {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async exec(command, args = [], options) {
+    return await this.client.rpc("shell.exec", {
+      command,
+      args,
+      cwd: options?.cwd,
+      timeout: options?.timeout
+    });
+  }
+}
+
+class CuaNamespace {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async ensure() {
+    return await this.client.rpc("desktop.cua.ensure", {});
+  }
+  async startDaemon() {
+    return await this.client.rpc("desktop.cua.start_daemon", {});
+  }
+  async status() {
+    return await this.client.rpc("desktop.cua.status", {});
+  }
+  async version() {
+    return await this.client.rpc("desktop.cua.version", {});
+  }
+  async listTools() {
+    return await this.client.rpc("desktop.cua.list_tools", {});
+  }
+  async describe(tool) {
+    return await this.client.rpc("desktop.cua.describe", { tool });
+  }
+  async call(tool, args = {}) {
+    return this.client.rpc("desktop.cua.call", { tool, args });
+  }
+  async listApps() {
+    return this.client.rpc("desktop.cua.list_apps", {});
+  }
+  async listWindows(params) {
+    return this.client.rpc("desktop.cua.list_windows", params ?? {});
+  }
+  async getWindowState(params) {
+    return this.client.rpc("desktop.cua.get_window_state", params);
+  }
+  async click(params) {
+    return this.client.rpc("desktop.cua.click", params);
+  }
+  async typeText(params) {
+    return this.client.rpc("desktop.cua.type_text", params);
+  }
+  async hotkey(params) {
+    return this.client.rpc("desktop.cua.hotkey", params);
+  }
+}
+
+// src/client/cli.ts
+var S6_ENV_DIR = process.env.S6_ENV_DIR || "/run/s6/container_environment";
+var FALLBACK_API_URL = "http://localhost:8008";
+var ALL_COMMANDS = [
+  "status",
+  "fs_read",
+  "fs_write",
+  "fs_upload",
+  "fs_list",
+  "shell",
+  "cua_ensure",
+  "cua_start_daemon",
+  "cua_status",
+  "cua_version",
+  "cua_list_tools",
+  "cua_describe",
+  "cua_call",
+  "cua_list_apps",
+  "cua_list_windows",
+  "cua_get_window_state",
+  "cua_click",
+  "cua_type_text",
+  "cua_hotkey"
+];
+function getEnv(key) {
+  try {
+    const value = readFileSync(`${S6_ENV_DIR}/${key}`, "utf-8").trim();
+    if (value)
+      return value;
+  } catch {}
+  return process.env[key];
+}
+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 fail(message) {
+  out({ success: false, error: message });
+  process.exitCode = 1;
+}
+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.`
+      };
+    }
+    throw err;
+  }
+}
+async function call(method, params = {}) {
+  const response = await rpcSafe(method, params);
+  if (response.permissionRequired) {
+    out({
+      success: false,
+      permissionRequired: true,
+      requestId: response.requestId,
+      message: response.message
+    });
+    return null;
+  }
+  return response.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 ? undefined : "No tunnel is currently online. Ask the user to run `npx --yes @beeuni/agent-tunnel@latest connect` on their local machine."
+  });
+}
+async function fsRead(args) {
+  const result = await call("fs.read", {
+    path: args.path,
+    encoding: args.encoding || "utf-8"
+  });
+  if (result === null)
+    return;
+  const data = result;
+  out({ success: true, path: data.path || args.path, size: data.size, content: data.content });
+}
+async function fsWrite(args) {
+  const result = await call("fs.write", {
+    path: args.path,
+    content: args.content,
+    sha256: args.sha256,
+    encoding: args.encoding || "utf-8"
+  });
+  if (result === null)
+    return;
+  const data = result;
+  out({ success: true, path: data.path, size: data.size, sha256: data.sha256 });
+}
+async function fsUpload(args) {
+  if (typeof args.source !== "string" || !args.source)
+    return fail("source is required");
+  if (typeof args.path !== "string" || !args.path)
+    return fail("path is required");
+  const handle = await open(args.source, "r");
+  let bytes;
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile())
+      return fail("source must be a regular file");
+    if (stats.size > 3 * 1024 * 1024)
+      return fail("source exceeds the 3 MiB upload limit");
+    bytes = await handle.readFile();
+    if (bytes.length > 3 * 1024 * 1024)
+      return fail("source exceeds the 3 MiB upload limit");
+  } finally {
+    await handle.close();
+  }
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  const result = await call("fs.write", { path: args.path, content: bytes.toString("base64"), encoding: "base64", sha256 });
+  if (result === null) {
+    process.exitCode = 1;
+    return;
+  }
+  const data = result;
+  if (data.sha256 !== sha256 || data.size !== bytes.length) {
+    return fail("Destination verification failed. Update the connected agent if its response has no sha256. The file may have been written.");
+  }
+  out({ success: true, path: data.path, size: data.size, sha256 });
+}
+async function fsList(args) {
+  const result = await call("fs.list", {
+    path: args.path,
+    recursive: args.recursive || false
+  });
+  if (result === null)
+    return;
+  const data = result;
+  out({ success: true, path: args.path, count: data.count, entries: data.entries });
+}
+async function shell(args) {
+  const result = await call("shell.exec", {
+    command: args.command,
+    args: args.args || [],
+    cwd: args.cwd,
+    timeout: args.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 cuaRpc(method, args = {}) {
+  const result = await call(method, args);
+  if (result === null)
+    return;
+  out({ success: true, result });
+}
+async function cuaCall(args) {
+  const tool = args.tool;
+  if (!tool)
+    return fail("tool is required");
+  const result = await call("desktop.cua.call", {
+    tool,
+    args: args.args || {}
+  });
+  if (result === null)
+    return;
+  out({ success: true, tool, result });
+}
+async function cuaDescribe(args) {
+  const tool = args.tool;
+  if (!tool)
+    return fail("tool is required");
+  await cuaRpc("desktop.cua.describe", { tool });
+}
+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 = {};
+try {
+  args = rawArgs ? JSON.parse(rawArgs) : {};
+} catch (err) {
+  fail(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+}
+try {
+  switch (cmd) {
+    case "status":
+      await status();
+      break;
+    case "fs_read":
+      await fsRead(args);
+      break;
+    case "fs_write":
+      await fsWrite(args);
+      break;
+    case "fs_upload":
+      await fsUpload(args);
+      break;
+    case "fs_list":
+      await fsList(args);
+      break;
+    case "shell":
+      await shell(args);
+      break;
+    case "cua_ensure":
+      await cuaRpc("desktop.cua.ensure");
+      break;
+    case "cua_start_daemon":
+      await cuaRpc("desktop.cua.start_daemon");
+      break;
+    case "cua_status":
+      await cuaRpc("desktop.cua.status");
+      break;
+    case "cua_version":
+      await cuaRpc("desktop.cua.version");
+      break;
+    case "cua_list_tools":
+      await cuaRpc("desktop.cua.list_tools");
+      break;
+    case "cua_describe":
+      await cuaDescribe(args);
+      break;
+    case "cua_call":
+      await cuaCall(args);
+      break;
+    case "cua_list_apps":
+      await cuaRpc("desktop.cua.list_apps", args);
+      break;
+    case "cua_list_windows":
+      await cuaRpc("desktop.cua.list_windows", args);
+      break;
+    case "cua_get_window_state":
+      await cuaRpc("desktop.cua.get_window_state", args);
+      break;
+    case "cua_click":
+      await cuaRpc("desktop.cua.click", args);
+      break;
+    case "cua_type_text":
+      await cuaRpc("desktop.cua.type_text", args);
+      break;
+    case "cua_hotkey":
+      await cuaRpc("desktop.cua.hotkey", 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);
+}

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "@beeuni/agent-tunnel",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "description": "Tunnel relay between cloud AI agents and local machines — server relay, local agent, client SDK, JSON-RPC, HMAC signing",
+  "bin": {
+    "agent-tunnel": "dist/agent-cli.js",
+    "agent-tunnel-cli": "dist/client-cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "dependencies": {
+    "hono": "^4.13.7",
+    "ws": "^8.18.0"
+  },
+  "keywords": [
+    "tunnel",
+    "relay",
+    "websocket",
+    "json-rpc",
+    "hmac",
+    "agent",
+    "sdk"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}