@daytonaio/sdk 0.21.9 → 0.22.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daytonaio/sdk",
-  "version": "0.21.9",
+  "version": "0.22.0-alpha.0",
   "description": "TypeScript SDK for Daytona",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
@@ -15,9 +15,10 @@
   },
   "homepage": "https://www.daytona.io/docs",
   "config": {
-    "docsDir": "../../apps/docs/src/content/docs/typescript-sdk"
+    "docsDir": "../../apps/docs/content/sdk-typescript"
   },
   "scripts": {
+    "build": "tsc && tsc -p tsconfig.esm.json",
     "docs": "bash -O extglob -c 'rm -rf $npm_package_config_docsDir/!(index.mdx)' && typedoc && rm -f $npm_package_config_docsDir/readme.mdx"
   },
   "keywords": [],
@@ -36,12 +37,9 @@
     "form-data": "^4.0.0",
     "shell-quote": "^1.8.2",
     "tar": "^6.2.0",
-    "typedoc": "0.27.9",
-    "typedoc-plugin-markdown": "4.4.2",
-    "typedoc-plugin-merge-modules": "6.1.0",
     "untildify": "^5.0.0",
     "uuid": "^11.0.3",
-    "@daytonaio/api-client": "0.21.8"
+    "@daytonaio/api-client": "0.22.0-alpha.0"
   },
   "packageManager": "yarn@4.6.0",
   "type": "commonjs"

package/src/ComputerUse.d.ts

@@ -0,0 +1,408 @@
+import { ToolboxApi, MousePosition, MouseMoveResponse, MouseClickResponse, MouseDragResponse, MouseScrollResponse, KeyboardTypeResponse, KeyboardPressResponse, KeyboardHotkeyResponse, ScreenshotResponse, RegionScreenshotResponse, CompressedScreenshotResponse, DisplayInfoResponse, WindowsResponse } from '@daytonaio/api-client';
+/**
+ * Interface for region coordinates used in screenshot operations
+ */
+export interface ScreenshotRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Interface for screenshot compression options
+ */
+export interface ScreenshotOptions {
+    showCursor?: boolean;
+    format?: string;
+    quality?: number;
+    scale?: number;
+}
+/**
+ * Mouse operations for computer use functionality
+ */
+export declare class Mouse {
+    private readonly sandboxId;
+    private readonly toolboxApi;
+    constructor(sandboxId: string, toolboxApi: ToolboxApi);
+    /**
+     * Gets the current mouse cursor position
+     *
+     * @returns {Promise<MousePosition>} Current mouse position with x and y coordinates
+     *
+     * @example
+     * ```typescript
+     * const position = await sandbox.computerUse.mouse.getPosition();
+     * console.log(`Mouse is at: ${position.x}, ${position.y}`);
+     * ```
+     */
+    getPosition(): Promise<MousePosition>;
+    /**
+     * Moves the mouse cursor to the specified coordinates
+     *
+     * @param {number} x - The x coordinate to move to
+     * @param {number} y - The y coordinate to move to
+     * @returns {Promise<MouseMoveResponse>} Move operation result
+     *
+     * @example
+     * ```typescript
+     * const result = await sandbox.computerUse.mouse.move(100, 200);
+     * console.log(`Mouse moved to: ${result.actual_x}, ${result.actual_y}`);
+     * ```
+     */
+    move(x: number, y: number): Promise<MouseMoveResponse>;
+    /**
+     * Clicks the mouse at the specified coordinates
+     *
+     * @param {number} x - The x coordinate to click at
+     * @param {number} y - The y coordinate to click at
+     * @param {string} [button='left'] - The mouse button to click ('left', 'right', 'middle')
+     * @param {boolean} [double=false] - Whether to perform a double-click
+     * @returns {Promise<MouseClickResponse>} Click operation result
+     *
+     * @example
+     * ```typescript
+     * // Single left click
+     * const result = await sandbox.computerUse.mouse.click(100, 200);
+     *
+     * // Double click
+     * const doubleClick = await sandbox.computerUse.mouse.click(100, 200, 'left', true);
+     *
+     * // Right click
+     * const rightClick = await sandbox.computerUse.mouse.click(100, 200, 'right');
+     * ```
+     */
+    click(x: number, y: number, button?: string, double?: boolean): Promise<MouseClickResponse>;
+    /**
+     * Drags the mouse from start coordinates to end coordinates
+     *
+     * @param {number} startX - The starting x coordinate
+     * @param {number} startY - The starting y coordinate
+     * @param {number} endX - The ending x coordinate
+     * @param {number} endY - The ending y coordinate
+     * @param {string} [button='left'] - The mouse button to use for dragging
+     * @returns {Promise<MouseDragResponse>} Drag operation result
+     *
+     * @example
+     * ```typescript
+     * const result = await sandbox.computerUse.mouse.drag(50, 50, 150, 150);
+     * console.log(`Dragged from ${result.from.x},${result.from.y} to ${result.to.x},${result.to.y}`);
+     * ```
+     */
+    drag(startX: number, startY: number, endX: number, endY: number, button?: string): Promise<MouseDragResponse>;
+    /**
+     * Scrolls the mouse wheel at the specified coordinates
+     *
+     * @param {number} x - The x coordinate to scroll at
+     * @param {number} y - The y coordinate to scroll at
+     * @param {'up' | 'down'} direction - The direction to scroll
+     * @param {number} [amount=1] - The amount to scroll
+     * @returns {Promise<MouseScrollResponse>} Scroll operation result
+     *
+     * @example
+     * ```typescript
+     * // Scroll up
+     * const scrollUp = await sandbox.computerUse.mouse.scroll(100, 200, 'up', 3);
+     *
+     * // Scroll down
+     * const scrollDown = await sandbox.computerUse.mouse.scroll(100, 200, 'down', 5);
+     * ```
+     */
+    scroll(x: number, y: number, direction: 'up' | 'down', amount?: number): Promise<MouseScrollResponse>;
+}
+/**
+ * Keyboard operations for computer use functionality
+ */
+export declare class Keyboard {
+    private readonly sandboxId;
+    private readonly toolboxApi;
+    constructor(sandboxId: string, toolboxApi: ToolboxApi);
+    /**
+     * Types the specified text
+     *
+     * @param {string} text - The text to type
+     * @param {number} [delay=0] - Delay between characters in milliseconds
+     * @returns {Promise<KeyboardTypeResponse>} Type operation result
+     *
+     * @example
+     * ```typescript
+     * const result = await sandbox.computerUse.keyboard.type('Hello, World!');
+     * console.log(`Typed: ${result.typed}`);
+     *
+     * // With delay between characters
+     * const slowType = await sandbox.computerUse.keyboard.type('Slow typing', 100);
+     * ```
+     */
+    type(text: string, delay?: number): Promise<KeyboardTypeResponse>;
+    /**
+     * Presses a key with optional modifiers
+     *
+     * @param {string} key - The key to press (e.g., 'Enter', 'Escape', 'Tab', 'a', 'A')
+     * @param {string[]} [modifiers=[]] - Modifier keys ('ctrl', 'alt', 'meta', 'shift')
+     * @returns {Promise<KeyboardPressResponse>} Press operation result
+     *
+     * @example
+     * ```typescript
+     * // Press Enter
+     * const enter = await sandbox.computerUse.keyboard.press('Return');
+     *
+     * // Press Ctrl+C
+     * const copy = await sandbox.computerUse.keyboard.press('c', ['ctrl']);
+     *
+     * // Press Ctrl+Shift+T
+     * const newTab = await sandbox.computerUse.keyboard.press('t', ['ctrl', 'shift']);
+     * ```
+     */
+    press(key: string, modifiers?: string[]): Promise<KeyboardPressResponse>;
+    /**
+     * Presses a hotkey combination
+     *
+     * @param {string} keys - The hotkey combination (e.g., 'ctrl+c', 'alt+tab', 'cmd+shift+t')
+     * @returns {Promise<KeyboardHotkeyResponse>} Hotkey operation result
+     *
+     * @example
+     * ```typescript
+     * // Copy
+     * const copy = await sandbox.computerUse.keyboard.hotkey('ctrl+c');
+     *
+     * // Paste
+     * const paste = await sandbox.computerUse.keyboard.hotkey('ctrl+v');
+     *
+     * // Alt+Tab
+     * const altTab = await sandbox.computerUse.keyboard.hotkey('alt+tab');
+     * ```
+     */
+    hotkey(keys: string): Promise<KeyboardHotkeyResponse>;
+}
+/**
+ * Screenshot operations for computer use functionality
+ */
+export declare class Screenshot {
+    private readonly sandboxId;
+    private readonly toolboxApi;
+    constructor(sandboxId: string, toolboxApi: ToolboxApi);
+    /**
+     * Takes a screenshot of the entire screen
+     *
+     * @param {boolean} [showCursor=false] - Whether to show the cursor in the screenshot
+     * @returns {Promise<ScreenshotResponse>} Screenshot data with base64 encoded image
+     *
+     * @example
+     * ```typescript
+     * const screenshot = await sandbox.computerUse.screenshot.takeFullScreen();
+     * console.log(`Screenshot size: ${screenshot.width}x${screenshot.height}`);
+     *
+     * // With cursor visible
+     * const withCursor = await sandbox.computerUse.screenshot.takeFullScreen(true);
+     * ```
+     */
+    takeFullScreen(showCursor?: boolean): Promise<ScreenshotResponse>;
+    /**
+     * Takes a screenshot of a specific region
+     *
+     * @param {ScreenshotRegion} region - The region to capture
+     * @param {boolean} [showCursor=false] - Whether to show the cursor in the screenshot
+     * @returns {Promise<RegionScreenshotResponse>} Screenshot data with base64 encoded image
+     *
+     * @example
+     * ```typescript
+     * const region = { x: 100, y: 100, width: 300, height: 200 };
+     * const screenshot = await sandbox.computerUse.screenshot.takeRegion(region);
+     * console.log(`Captured region: ${screenshot.region.width}x${screenshot.region.height}`);
+     * ```
+     */
+    takeRegion(region: ScreenshotRegion, showCursor?: boolean): Promise<RegionScreenshotResponse>;
+    /**
+     * Takes a compressed screenshot of the entire screen
+     *
+     * @param {ScreenshotOptions} [options={}] - Compression and display options
+     * @returns {Promise<CompressedScreenshotResponse>} Compressed screenshot data
+     *
+     * @example
+     * ```typescript
+     * // Default compression
+     * const screenshot = await sandbox.computerUse.screenshot.takeCompressed();
+     *
+     * // High quality JPEG
+     * const jpeg = await sandbox.computerUse.screenshot.takeCompressed({
+     *   format: 'jpeg',
+     *   quality: 95,
+     *   showCursor: true
+     * });
+     *
+     * // Scaled down PNG
+     * const scaled = await sandbox.computerUse.screenshot.takeCompressed({
+     *   format: 'png',
+     *   scale: 0.5
+     * });
+     * ```
+     */
+    takeCompressed(options?: ScreenshotOptions): Promise<CompressedScreenshotResponse>;
+    /**
+     * Takes a compressed screenshot of a specific region
+     *
+     * @param {ScreenshotRegion} region - The region to capture
+     * @param {ScreenshotOptions} [options={}] - Compression and display options
+     * @returns {Promise<CompressedScreenshotResponse>} Compressed screenshot data
+     *
+     * @example
+     * ```typescript
+     * const region = { x: 0, y: 0, width: 800, height: 600 };
+     * const screenshot = await sandbox.computerUse.screenshot.takeCompressedRegion(region, {
+     *   format: 'webp',
+     *   quality: 80,
+     *   showCursor: true
+     * });
+     * console.log(`Compressed size: ${screenshot.size_bytes} bytes`);
+     * ```
+     */
+    takeCompressedRegion(region: ScreenshotRegion, options?: ScreenshotOptions): Promise<CompressedScreenshotResponse>;
+}
+/**
+ * Display operations for computer use functionality
+ */
+export declare class Display {
+    private readonly sandboxId;
+    private readonly toolboxApi;
+    constructor(sandboxId: string, toolboxApi: ToolboxApi);
+    /**
+     * Gets information about the displays
+     *
+     * @returns {Promise<DisplayInfoResponse>} Display information including primary display and all available displays
+     *
+     * @example
+     * ```typescript
+     * const info = await sandbox.computerUse.display.getInfo();
+     * console.log(`Primary display: ${info.primary_display.width}x${info.primary_display.height}`);
+     * console.log(`Total displays: ${info.total_displays}`);
+     * info.displays.forEach((display, index) => {
+     *   console.log(`Display ${index}: ${display.width}x${display.height} at ${display.x},${display.y}`);
+     * });
+     * ```
+     */
+    getInfo(): Promise<DisplayInfoResponse>;
+    /**
+     * Gets the list of open windows
+     *
+     * @returns {Promise<WindowsResponse>} List of open windows with their IDs and titles
+     *
+     * @example
+     * ```typescript
+     * const windows = await sandbox.computerUse.display.getWindows();
+     * console.log(`Found ${windows.count} open windows:`);
+     * windows.windows.forEach(window => {
+     *   console.log(`- ${window.title} (ID: ${window.id})`);
+     * });
+     * ```
+     */
+    getWindows(): Promise<WindowsResponse>;
+}
+/**
+ * Computer Use functionality for interacting with the desktop environment.
+ *
+ * Provides access to mouse, keyboard, screenshot, and display operations
+ * for automating desktop interactions within a sandbox.
+ *
+ * @property {Mouse} mouse - Mouse operations interface
+ * @property {Keyboard} keyboard - Keyboard operations interface
+ * @property {Screenshot} screenshot - Screenshot operations interface
+ * @property {Display} display - Display operations interface
+ *
+ * @class
+ */
+export declare class ComputerUse {
+    private readonly sandboxId;
+    private readonly toolboxApi;
+    readonly mouse: Mouse;
+    readonly keyboard: Keyboard;
+    readonly screenshot: Screenshot;
+    readonly display: Display;
+    constructor(sandboxId: string, toolboxApi: ToolboxApi);
+    /**
+     * Starts all computer use processes (Xvfb, xfce4, x11vnc, novnc)
+     *
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * await sandbox.computerUse.start();
+     * console.log('Computer use processes started');
+     * ```
+     */
+    start(): Promise<void>;
+    /**
+     * Stops all computer use processes
+     *
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * await sandbox.computerUse.stop();
+     * console.log('Computer use processes stopped');
+     * ```
+     */
+    stop(): Promise<void>;
+    /**
+     * Gets the status of all computer use processes
+     *
+     * @returns {Promise<void>} Status information about all VNC desktop processes
+     *
+     * @example
+     * ```typescript
+     * const status = await sandbox.computerUse.getStatus();
+     * console.log('Computer use status:', status);
+     * ```
+     */
+    getStatus(): Promise<void>;
+    /**
+     * Gets the status of a specific VNC process
+     *
+     * @param {string} processName - Name of the process to check
+     * @returns {Promise<void>} Status information about the specific process
+     *
+     * @example
+     * ```typescript
+     * const xvfbStatus = await sandbox.computerUse.getProcessStatus('xvfb');
+     * const noVncStatus = await sandbox.computerUse.getProcessStatus('novnc');
+     * ```
+     */
+    getProcessStatus(processName: string): Promise<void>;
+    /**
+     * Restarts a specific VNC process
+     *
+     * @param {string} processName - Name of the process to restart
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * await sandbox.computerUse.restartProcess('xfce4');
+     * console.log('XFCE4 process restarted');
+     * ```
+     */
+    restartProcess(processName: string): Promise<void>;
+    /**
+     * Gets logs for a specific VNC process
+     *
+     * @param {string} processName - Name of the process to get logs for
+     * @returns {Promise<void>} Process logs
+     *
+     * @example
+     * ```typescript
+     * const logs = await sandbox.computerUse.getProcessLogs('novnc');
+     * console.log('NoVNC logs:', logs);
+     * ```
+     */
+    getProcessLogs(processName: string): Promise<void>;
+    /**
+     * Gets error logs for a specific VNC process
+     *
+     * @param {string} processName - Name of the process to get error logs for
+     * @returns {Promise<void>} Process error logs
+     *
+     * @example
+     * ```typescript
+     * const errors = await sandbox.computerUse.getProcessErrors('x11vnc');
+     * console.log('X11VNC errors:', errors);
+     * ```
+     */
+    getProcessErrors(processName: string): Promise<void>;
+}