@kortix/agent-tunnel 0.1.3 → 0.12.7

package/src/shared/types.ts

@@ -46,14 +46,7 @@ export const TunnelErrorCode = {
 
 export type TunnelErrorCodeValue = (typeof TunnelErrorCode)[keyof typeof TunnelErrorCode];
 
-export type TunnelCapability =
-  | 'filesystem'
-  | 'shell'
-  | 'network'
-  | 'apps'
-  | 'hardware'
-  | 'desktop'
-  | 'gpu';
+export type TunnelCapability = 'filesystem' | 'shell' | 'desktop';
 
 export const TunnelMethods = {
   'fs.read': 'filesystem',
@@ -62,34 +55,49 @@ export const TunnelMethods = {
   'fs.stat': 'filesystem',
   'fs.delete': 'filesystem',
   'shell.exec': 'shell',
-  'desktop.screenshot': 'desktop',
-  'desktop.mouse.click': 'desktop',
-  'desktop.mouse.move': 'desktop',
-  'desktop.mouse.drag': 'desktop',
-  'desktop.mouse.scroll': 'desktop',
-  'desktop.mouse.position': 'desktop',
-  'desktop.keyboard.type': 'desktop',
-  'desktop.keyboard.key': 'desktop',
-  'desktop.window.list': 'desktop',
-  'desktop.window.focus': 'desktop',
-  'desktop.window.resize': 'desktop',
-  'desktop.window.close': 'desktop',
-  'desktop.window.minimize': 'desktop',
-  'desktop.app.launch': 'desktop',
-  'desktop.app.quit': 'desktop',
-  'desktop.app.list': 'desktop',
-  'desktop.clipboard.read': 'desktop',
-  'desktop.clipboard.write': 'desktop',
-  'desktop.screen.info': 'desktop',
-  'desktop.cursor.image': 'desktop',
-  'desktop.ax.tree': 'desktop',
-  'desktop.ax.action': 'desktop',
-  'desktop.ax.set_value': 'desktop',
-  'desktop.ax.focus': 'desktop',
-  'desktop.ax.search': 'desktop',
-  'net.request': 'network',
-  'net.port_forward.start': 'network',
-  'net.port_forward.stop': 'network',
+  'desktop.cua.ensure': 'desktop',
+  'desktop.cua.start_daemon': 'desktop',
+  'desktop.cua.status': 'desktop',
+  'desktop.cua.version': 'desktop',
+  'desktop.cua.list_tools': 'desktop',
+  'desktop.cua.describe': 'desktop',
+  'desktop.cua.call': 'desktop',
+  'desktop.cua.bring_to_front': 'desktop',
+  'desktop.cua.check_for_update': 'desktop',
+  'desktop.cua.check_permissions': 'desktop',
+  'desktop.cua.click': 'desktop',
+  'desktop.cua.double_click': 'desktop',
+  'desktop.cua.drag': 'desktop',
+  'desktop.cua.end_session': 'desktop',
+  'desktop.cua.get_accessibility_tree': 'desktop',
+  'desktop.cua.get_agent_cursor_state': 'desktop',
+  'desktop.cua.get_config': 'desktop',
+  'desktop.cua.get_cursor_position': 'desktop',
+  'desktop.cua.get_recording_state': 'desktop',
+  'desktop.cua.get_screen_size': 'desktop',
+  'desktop.cua.get_window_state': 'desktop',
+  'desktop.cua.hotkey': 'desktop',
+  'desktop.cua.kill_app': 'desktop',
+  'desktop.cua.launch_app': 'desktop',
+  'desktop.cua.list_apps': 'desktop',
+  'desktop.cua.list_windows': 'desktop',
+  'desktop.cua.move_cursor': 'desktop',
+  'desktop.cua.page': 'desktop',
+  'desktop.cua.press_key': 'desktop',
+  'desktop.cua.replay_trajectory': 'desktop',
+  'desktop.cua.right_click': 'desktop',
+  'desktop.cua.scroll': 'desktop',
+  'desktop.cua.set_agent_cursor_enabled': 'desktop',
+  'desktop.cua.set_agent_cursor_motion': 'desktop',
+  'desktop.cua.set_agent_cursor_style': 'desktop',
+  'desktop.cua.set_config': 'desktop',
+  'desktop.cua.set_value': 'desktop',
+  'desktop.cua.start_recording': 'desktop',
+  'desktop.cua.install_ffmpeg': 'desktop',
+  'desktop.cua.start_session': 'desktop',
+  'desktop.cua.stop_recording': 'desktop',
+  'desktop.cua.type_text': 'desktop',
+  'desktop.cua.zoom': 'desktop',
   'tunnel.ping': null,
   'tunnel.pong': null,
   'tunnel.permission.revoked': null,
@@ -138,11 +146,21 @@ export interface AgentInfo {
 
 export interface TunnelRelayEvents {
   'agent:connect': { tunnelId: string; metadata?: Record<string, unknown> };
-  'agent:disconnect': { tunnelId: string };
+  'agent:disconnect': { tunnelId: string; metadata?: Record<string, unknown> };
   'agent:timeout': { tunnelId: string };
   'rpc:request': { tunnelId: string; method: string; requestId: string };
-  'rpc:response': { tunnelId: string; method: string; requestId: string; durationMs: number };
-  'rpc:error': { tunnelId: string; method: string; requestId: string; error: Error };
+  'rpc:response': {
+    tunnelId: string;
+    method: string;
+    requestId: string;
+    durationMs: number;
+  };
+  'rpc:error': {
+    tunnelId: string;
+    method: string;
+    requestId: string;
+    error: Error;
+  };
   'connection:replaced': { tunnelId: string };
   'message:pong': { tunnelId: string; params?: Record<string, unknown> };
   'message:raw': { tunnelId: string; message: unknown };
@@ -162,6 +180,9 @@ export interface HeartbeatConfig {
 export interface TunnelAuthMessage {
   type: 'auth';
   token: string;
+  /** RPC capability handlers registered in this exact agent process. */
+  capabilities?: TunnelCapability[];
+  agentVersion?: string;
 }
 
 /** Result returned by onAuthenticate hook on success. */
@@ -179,12 +200,20 @@ export interface TunnelServerConfig {
    * Return { signingKey, metadata } to accept, or null to reject.
    * If not provided, all connections are rejected.
    */
-  onAuthenticate?: (tunnelId: string, token: string) => Promise<AuthResult | null>;
+  onAuthenticate?: (
+    tunnelId: string,
+    token: string,
+    auth: TunnelAuthMessage,
+  ) => Promise<AuthResult | null>;
   /**
    * Called before relaying an RPC to the agent.
    * Return false to deny. If not provided, all RPCs are allowed.
    */
-  onAuthorizeRPC?: (tunnelId: string, method: string, params: Record<string, unknown>) => Promise<boolean>;
+  onAuthorizeRPC?: (
+    tunnelId: string,
+    method: string,
+    params: Record<string, unknown>,
+  ) => Promise<boolean>;
   /**
    * Called before handling HTTP requests to relay routes (/connections, /rpc).
    * Return false to deny. If not provided, routes are open.

package/dist/agent/index.d.ts

@@ -1,140 +0,0 @@
-interface TunnelConfig {
-    token: string;
-    tunnelId: string;
-    apiUrl: string;
-    wsPath: string;
-    maxFileSize: number;
-    allowedPaths: string[];
-    allowedCommands: string[];
-    blockedCommands: string[];
-    blockedPaths: string[];
-    workingDir: string;
-    shellTimeout: number;
-    shellMaxTimeout: number;
-    shellMaxOutputSize: number;
-    shellEnvPassthrough: string[];
-}
-declare function loadConfig(overrides?: Partial<TunnelConfig>): TunnelConfig;
-
-/**
- * Capability Registry — extensible registry for tunnel capabilities.
- *
- * Each capability (filesystem, shell, network, etc.) registers its
- * RPC method handlers here. The TunnelAgent dispatches incoming
- * JSON-RPC requests to the matching handler.
- */
-type RpcHandler = (params: Record<string, unknown>) => Promise<unknown>;
-interface Capability {
-    name: string;
-    methods: Map<string, RpcHandler>;
-}
-declare class CapabilityRegistry {
-    private capabilities;
-    register(capability: Capability): void;
-    unregister(name: string): void;
-    getHandler(method: string): RpcHandler | null;
-    getCapabilityNames(): string[];
-    has(name: string): boolean;
-}
-
-declare class TunnelAgent {
-    private ws;
-    private registry;
-    private permissionGuard;
-    private config;
-    private reconnectAttempts;
-    private maxReconnectDelay;
-    private baseReconnectDelay;
-    private reconnectTimer;
-    private isShuttingDown;
-    private uptime;
-    private uptimeInterval;
-    private signingKey;
-    private lastNonce;
-    private responseNonce;
-    constructor(config: TunnelConfig, registry: CapabilityRegistry);
-    connect(): void;
-    disconnect(): void;
-    isConnected(): boolean;
-    private setupWsHandlers;
-    private handleMessage;
-    /**
-     * Verify HMAC signature on incoming messages (excluding pings).
-     */
-    private verifyIncomingSignature;
-    private handleRpcRequest;
-    /** Send HMAC-signed RPC result. */
-    private sendSignedResult;
-    /** Send HMAC-signed RPC error. */
-    private sendSignedError;
-    private sendSigned;
-    private send;
-    private sendPong;
-    private scheduleReconnect;
-    private buildWsUrl;
-}
-
-/**
- * Filesystem Capability — handles fs.read, fs.write, fs.list, fs.stat, fs.delete.
- *
- * All operations go through local-side path validation (defense in depth)
- * even though the server already validates permissions.
- */
-
-declare function createFilesystemCapability(config: TunnelConfig): Capability;
-
-/**
- * Shell Capability — handles shell.exec for running commands on the local machine.
- *
- * Security:
- *   - Commands are executed as array args (no shell interpolation)
- *   - First arg (executable) is validated against allowedCommands / blockedCommands
- *   - Working directory is validated against allowedPaths / blockedPaths
- *   - Timeout enforcement
- */
-
-declare function createShellCapability(config: TunnelConfig): Capability;
-
-declare function createDesktopCapability(): Capability;
-
-/**
- * Permission Guard — local-side permission enforcement (defense in depth).
- *
- * Even though the server validates permissions before relaying RPCs,
- * the local agent also checks permissions as a second layer of defense.
- * This prevents a compromised server from bypassing permission controls.
- *
- * After the initial permission sync, unknown permissionIds are denied.
- * Before sync, unknown IDs are also denied (fail-closed).
- */
-interface LocalPermission {
-    permissionId: string;
-    capability: string;
-    scope: Record<string, unknown>;
-    expiresAt?: string;
-}
-declare class PermissionGuard {
-    private permissions;
-    private hasSynced;
-    /** Bulk-load permissions from server sync notification. */
-    syncPermissions(permissions: LocalPermission[]): void;
-    addPermission(permission: LocalPermission): void;
-    revokePermission(permissionId: string): void;
-    checkPermission(permissionId: string | undefined): boolean;
-    clear(): void;
-}
-
-declare function validateCommand(command: string, allowedCommands: string[], blockedCommands: string[]): void;
-
-/**
- * Path Validator — defense-in-depth path traversal prevention.
- *
- * Validates that requested paths:
- *   1. Are absolute
- *   2. Resolve to an absolute path (follows symlinks)
- *   3. Fall within allowed directories
- *   4. Don't hit blocked paths (configurable)
- */
-declare function validatePath(path: string, allowedPaths: string[], blockedPaths?: string[]): void;
-
-export { type Capability, CapabilityRegistry, type LocalPermission, PermissionGuard, type RpcHandler, TunnelAgent, type TunnelConfig, createDesktopCapability, createFilesystemCapability, createShellCapability, loadConfig, validateCommand, validatePath };

package/dist/agent/index.js

@@ -1,21 +0,0 @@
-import { TunnelAgent } from "./agent";
-import { loadConfig } from "./config";
-import { CapabilityRegistry } from "./capabilities/index";
-import { createFilesystemCapability } from "./capabilities/filesystem";
-import { createShellCapability } from "./capabilities/shell";
-import { createDesktopCapability } from "./capabilities/desktop";
-import { PermissionGuard } from "./security/permission-guard";
-import { validateCommand } from "./security/command-validator";
-import { validatePath } from "./security/path-validator";
-export {
-  CapabilityRegistry,
-  PermissionGuard,
-  TunnelAgent,
-  createDesktopCapability,
-  createFilesystemCapability,
-  createShellCapability,
-  loadConfig,
-  validateCommand,
-  validatePath
-};
-//# sourceMappingURL=index.js.map

package/dist/agent/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/agent/index.ts"],"sourcesContent":["export { TunnelAgent } from './agent';\nexport { loadConfig, type TunnelConfig } from './config';\nexport { CapabilityRegistry } from './capabilities/index';\nexport type { Capability, RpcHandler } from './capabilities/index';\nexport { createFilesystemCapability } from './capabilities/filesystem';\nexport { createShellCapability } from './capabilities/shell';\nexport { createDesktopCapability } from './capabilities/desktop';\nexport { PermissionGuard } from './security/permission-guard';\nexport type { LocalPermission } from './security/permission-guard';\nexport { validateCommand } from './security/command-validator';\nexport { validatePath } from './security/path-validator';\n"],"mappings":"AAAA,SAAS,mBAAmB;AAC5B,SAAS,kBAAqC;AAC9C,SAAS,0BAA0B;AAEnC,SAAS,kCAAkC;AAC3C,SAAS,6BAA6B;AACtC,SAAS,+BAA+B;AACxC,SAAS,uBAAuB;AAEhC,SAAS,uBAAuB;AAChC,SAAS,oBAAoB;","names":[]}

package/dist/chunk-7N7GSU6K.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-export {
-  __require,
-  __esm,
-  __export,
-  __toCommonJS
-};

package/dist/client/index.d.ts

@@ -1,183 +0,0 @@
-interface TunnelClientConfig {
-    apiUrl: string;
-    token: string;
-    tunnelId?: string;
-    cacheTtlMs?: number;
-}
-declare class TunnelClientError extends Error {
-    readonly code: number;
-    readonly requestId?: string | undefined;
-    readonly isPermissionRequest: boolean;
-    constructor(code: number, message: string, requestId?: string | undefined, isPermissionRequest?: boolean);
-}
-declare class TunnelClient {
-    private apiUrl;
-    private token;
-    private explicitTunnelId;
-    private cachedTunnelId;
-    private cacheTimestamp;
-    private cacheTtlMs;
-    readonly fs: FsNamespace;
-    readonly shell: ShellNamespace;
-    readonly desktop: DesktopNamespace;
-    constructor(config: TunnelClientConfig);
-    rpc(method: string, params?: Record<string, unknown>): Promise<unknown>;
-    rpcWithPermissionFlow(method: string, params?: Record<string, unknown>): Promise<unknown>;
-    getConnections(): Promise<Array<Record<string, unknown>>>;
-    resolveTunnelId(): Promise<string>;
-}
-declare class FsNamespace {
-    private client;
-    constructor(client: TunnelClient);
-    read(path: string, encoding?: string): Promise<{
-        content: string;
-        size: number;
-        path: string;
-    }>;
-    write(path: string, content: string, encoding?: string): Promise<{
-        path: string;
-        size: number;
-    }>;
-    list(path: string, recursive?: boolean): Promise<{
-        entries: Array<{
-            name: string;
-            path: string;
-            isDirectory: boolean;
-            isFile: boolean;
-        }>;
-        count: number;
-    }>;
-    stat(path: string): Promise<Record<string, unknown>>;
-    delete(path: string): Promise<Record<string, unknown>>;
-}
-declare class ShellNamespace {
-    private client;
-    constructor(client: TunnelClient);
-    exec(command: string, args?: string[], options?: {
-        cwd?: string;
-        timeout?: number;
-    }): Promise<{
-        exitCode: number | null;
-        signal: string | null;
-        stdout: string;
-        stderr: string;
-        stdoutTruncated: boolean;
-        stderrTruncated: boolean;
-    }>;
-}
-declare class DesktopNamespace {
-    private client;
-    constructor(client: TunnelClient);
-    screenshot(params?: {
-        region?: {
-            x: number;
-            y: number;
-            width: number;
-            height: number;
-        };
-        windowId?: number;
-    }): Promise<{
-        image: string;
-        width: number;
-        height: number;
-        format?: string;
-    }>;
-    click(params: {
-        x: number;
-        y: number;
-        button?: string;
-        clicks?: number;
-        modifiers?: string[];
-    }): Promise<unknown>;
-    type(text: string, delay?: number): Promise<unknown>;
-    key(keys: string[]): Promise<unknown>;
-    mouseMove(x: number, y: number): Promise<unknown>;
-    mouseDrag(fromX: number, fromY: number, toX: number, toY: number, button?: string): Promise<unknown>;
-    mouseScroll(x: number, y: number, deltaX?: number, deltaY?: number): Promise<unknown>;
-    windowList(): Promise<{
-        windows: Array<{
-            id: number;
-            app: string;
-            title: string;
-            bounds: {
-                x: number;
-                y: number;
-                width: number;
-                height: number;
-            };
-            minimized: boolean;
-        }>;
-    }>;
-    windowFocus(windowId: number): Promise<unknown>;
-    appLaunch(app: string): Promise<unknown>;
-    appQuit(app: string): Promise<unknown>;
-    clipboardRead(): Promise<{
-        text: string;
-    }>;
-    clipboardWrite(text: string): Promise<unknown>;
-    screenInfo(): Promise<{
-        width: number;
-        height: number;
-        scaleFactor: number;
-    }>;
-    cursorImage(radius?: number): Promise<{
-        image: string;
-        width: number;
-        height: number;
-        format?: string;
-    }>;
-    axTree(params?: {
-        pid?: number;
-        maxDepth?: number;
-        roles?: string[];
-    }): Promise<{
-        root: AXElement;
-        elementCount: number;
-    }>;
-    axAction(elementId: string, action: string, pid?: number): Promise<Record<string, unknown>>;
-    axSetValue(elementId: string, value: string, pid?: number): Promise<Record<string, unknown>>;
-    axFocus(elementId: string, pid?: number): Promise<Record<string, unknown>>;
-    axSearch(query: string, params?: {
-        role?: string;
-        pid?: number;
-        maxResults?: number;
-    }): Promise<{
-        elements: AXElement[];
-    }>;
-}
-interface AXElement {
-    id: string;
-    role: string;
-    title: string;
-    value: string;
-    description: string;
-    bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    children: AXElement[];
-    actions: string[];
-    enabled: boolean;
-    focused: boolean;
-}
-
-interface TunnelToolParameter {
-    type: string;
-    description: string;
-    required?: boolean;
-    items?: {
-        type: string;
-    };
-    enum?: string[];
-}
-interface TunnelToolDefinition {
-    name: string;
-    description: string;
-    parameters: Record<string, TunnelToolParameter>;
-    execute: (args: Record<string, unknown>) => Promise<string>;
-}
-declare function createTunnelTools(client: TunnelClient): TunnelToolDefinition[];
-
-export { type AXElement, TunnelClient, type TunnelClientConfig, TunnelClientError, type TunnelToolDefinition, type TunnelToolParameter, createTunnelTools };

package/dist/client/index.js

@@ -1,8 +0,0 @@
-import { TunnelClient, TunnelClientError } from "./tunnel-client";
-import { createTunnelTools } from "./tools";
-export {
-  TunnelClient,
-  TunnelClientError,
-  createTunnelTools
-};
-//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/client/index.ts"],"sourcesContent":["export { TunnelClient, TunnelClientError } from './tunnel-client';\nexport type { TunnelClientConfig, AXElement } from './tunnel-client';\nexport { createTunnelTools } from './tools';\nexport type { TunnelToolDefinition, TunnelToolParameter } from './tools';\n// CLI entrypoint: src/client/cli.ts (run via `bun run cli.ts <command> [json]`)\n"],"mappings":"AAAA,SAAS,cAAc,yBAAyB;AAEhD,SAAS,yBAAyB;","names":[]}

package/dist/index.d.ts

@@ -1,7 +0,0 @@
-export { deriveSigningKey, generateToken, hashToken, signMessage, timingSafeStringEqual, verifyMessageSignature } from './shared/index.js';
-export { A as AgentInfo, a as AuthResult, H as HeartbeatConfig, J as JsonRpcError, b as JsonRpcErrorResponse, c as JsonRpcMessage, d as JsonRpcNotification, e as JsonRpcRequest, f as JsonRpcResponse, g as JsonRpcSuccessResponse, P as PendingRPC, R as RelayRpcOptions, S as SignedJsonRpcNotification, h as SignedJsonRpcRequest, T as TunnelAuthMessage, i as TunnelCapability, j as TunnelErrorCode, k as TunnelErrorCodeValue, l as TunnelMethod, m as TunnelMethods, n as TunnelRelayConfig, o as TunnelRelayEvents, p as TunnelRpcParams, q as TunnelServerConfig } from './types-Dpwrd8Ai.js';
-export { HeartbeatManager, TunnelRelay, TunnelRelayError, TunnelServer, WsHandlerOptions, WsHandlers, createTunnelRouter, createWsHandlers, startTunnelServer } from './server/index.js';
-export { AXElement, TunnelClient, TunnelClientConfig, TunnelClientError, TunnelToolDefinition, TunnelToolParameter, createTunnelTools } from './client/index.js';
-export { Capability, CapabilityRegistry, LocalPermission, PermissionGuard, RpcHandler, TunnelAgent, TunnelConfig, createDesktopCapability, createFilesystemCapability, createShellCapability, loadConfig, validateCommand, validatePath } from './agent/index.js';
-import 'events';
-import 'hono';

package/dist/index.js

@@ -1,55 +0,0 @@
-import {
-  deriveSigningKey,
-  signMessage,
-  verifyMessageSignature,
-  generateToken,
-  hashToken,
-  timingSafeStringEqual,
-  TunnelErrorCode,
-  TunnelMethods
-} from "./shared";
-import { TunnelRelay, TunnelRelayError } from "./server";
-import { HeartbeatManager } from "./server";
-import { createWsHandlers } from "./server";
-import { createTunnelRouter } from "./server";
-import { startTunnelServer } from "./server";
-import { TunnelClient, TunnelClientError } from "./client";
-import { createTunnelTools } from "./client";
-import { TunnelAgent } from "./agent";
-import { loadConfig } from "./agent";
-import { CapabilityRegistry } from "./agent";
-import { createFilesystemCapability } from "./agent";
-import { createShellCapability } from "./agent";
-import { createDesktopCapability } from "./agent";
-import { PermissionGuard } from "./agent";
-import { validateCommand } from "./agent";
-import { validatePath } from "./agent";
-export {
-  CapabilityRegistry,
-  HeartbeatManager,
-  PermissionGuard,
-  TunnelAgent,
-  TunnelClient,
-  TunnelClientError,
-  TunnelErrorCode,
-  TunnelMethods,
-  TunnelRelay,
-  TunnelRelayError,
-  createDesktopCapability,
-  createFilesystemCapability,
-  createShellCapability,
-  createTunnelRouter,
-  createTunnelTools,
-  createWsHandlers,
-  deriveSigningKey,
-  generateToken,
-  hashToken,
-  loadConfig,
-  signMessage,
-  startTunnelServer,
-  timingSafeStringEqual,
-  validateCommand,
-  validatePath,
-  verifyMessageSignature
-};
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// ─── Shared: Types + Crypto ─────────────────────────────────────────────────\nexport {\n  deriveSigningKey,\n  signMessage,\n  verifyMessageSignature,\n  generateToken,\n  hashToken,\n  timingSafeStringEqual,\n  TunnelErrorCode,\n  TunnelMethods,\n} from './shared';\n\nexport type {\n  JsonRpcRequest,\n  JsonRpcSuccessResponse,\n  JsonRpcErrorResponse,\n  JsonRpcError,\n  JsonRpcResponse,\n  JsonRpcNotification,\n  JsonRpcMessage,\n  SignedJsonRpcRequest,\n  SignedJsonRpcNotification,\n  PendingRPC,\n  TunnelRpcParams,\n  RelayRpcOptions,\n  AgentInfo,\n  TunnelRelayEvents,\n  TunnelRelayConfig,\n  HeartbeatConfig,\n  TunnelServerConfig,\n  TunnelAuthMessage,\n  AuthResult,\n  TunnelCapability,\n  TunnelMethod,\n  TunnelErrorCodeValue,\n} from './shared';\n\n// ─── Server: Relay ──────────────────────────────────────────────────────────\nexport { TunnelRelay, TunnelRelayError } from './server';\nexport { HeartbeatManager } from './server';\nexport { createWsHandlers } from './server';\nexport type { WsHandlers, WsHandlerOptions } from './server';\nexport { createTunnelRouter } from './server';\nexport { startTunnelServer } from './server';\nexport type { TunnelServer } from './server';\n\n// ─── Client: SDK ────────────────────────────────────────────────────────────\nexport { TunnelClient, TunnelClientError } from './client';\nexport type { TunnelClientConfig, AXElement } from './client';\nexport { createTunnelTools } from './client';\nexport type { TunnelToolDefinition, TunnelToolParameter } from './client';\n\n// ─── Agent: Local Machine ───────────────────────────────────────────────────\nexport { TunnelAgent } from './agent';\nexport { loadConfig, type TunnelConfig } from './agent';\nexport { CapabilityRegistry } from './agent';\nexport type { Capability, RpcHandler } from './agent';\nexport { createFilesystemCapability } from './agent';\nexport { createShellCapability } from './agent';\nexport { createDesktopCapability } from './agent';\nexport { PermissionGuard } from './agent';\nexport type { LocalPermission } from './agent';\nexport { validateCommand } from './agent';\nexport { validatePath } from './agent';\n"],"mappings":"AACA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AA4BP,SAAS,aAAa,wBAAwB;AAC9C,SAAS,wBAAwB;AACjC,SAAS,wBAAwB;AAEjC,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAIlC,SAAS,cAAc,yBAAyB;AAEhD,SAAS,yBAAyB;AAIlC,SAAS,mBAAmB;AAC5B,SAAS,kBAAqC;AAC9C,SAAS,0BAA0B;AAEnC,SAAS,kCAAkC;AAC3C,SAAS,6BAA6B;AACtC,SAAS,+BAA+B;AACxC,SAAS,uBAAuB;AAEhC,SAAS,uBAAuB;AAChC,SAAS,oBAAoB;","names":[]}