@kortix/agent-tunnel 0.1.2 → 0.1.3

package/dist/chunk-7N7GSU6K.js

@@ -0,0 +1,34 @@
+#!/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

@@ -0,0 +1,183 @@
+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

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

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"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":[]}