@elizaos/plugin-computeruse 2.0.3-beta.2 → 2.0.3-beta.4

package/dist/platform/process-list.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Cross-platform process listing.
+ *
+ * The WS6 scene-builder joins running processes with windows to produce the
+ * `apps[]` field of a Scene. The contract is intentionally minimal — pid,
+ * executable/display name, and a best-effort foreground flag if cheap to
+ * obtain. Anything richer (memory, cpu, parent pid) is out of scope here
+ * because the scene-builder runs every active-poll frame and must stay
+ * cheap.
+ *
+ * Per-OS source:
+ *   - Linux  : `/proc/<pid>/comm` and `/proc/<pid>/status`. Pure FS read,
+ *              no shell out. ~5ms for 300 processes.
+ *   - macOS  : `ps -axo pid=,comm=` — built-in BSD ps.
+ *   - Windows: PowerShell `Get-Process | Select Id, ProcessName`.
+ *   - Android: returns `[]` in this JS helper; the `UsageStatsManager`
+ *              integration is owned by WS8's native side. We expose the
+ *              function shape so the scene-builder doesn't have to branch.
+ *
+ * Failure semantics:
+ *   - A single un-readable process is skipped, not propagated.
+ *   - A complete enumeration failure returns `[]` and the scene-builder logs
+ *     once per platform-mode at warn.
+ */
+export interface ProcessInfo {
+    pid: number;
+    name: string;
+}
+export declare function listProcesses(): ProcessInfo[];
+export declare function parsePsOutput(text: string): ProcessInfo[];
+export declare function parseWindowsProcessJson(text: string): ProcessInfo[];
+//# sourceMappingURL=process-list.d.ts.map

package/dist/platform/process-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-list.d.ts","sourceRoot":"","sources":["../../src/platform/process-list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,aAAa,IAAI,WAAW,EAAE,CAM7C;AAmDD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAkBzD;AAmBD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAmBnE"}

package/dist/platform/ps-host.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Warm PowerShell host (Windows-only) — eliminates the cold-spawn tax.
+ *
+ * On Windows, every capability that shells out to `powershell.exe`
+ * (screen capture, clipboard, window/display enumeration) pays the cost of
+ * starting a fresh process. On Defender-heavy hosts real-time AV scans each new
+ * process image, which measured **~10-12s per cold `powershell.exe` spawn** on a
+ * build box (see #9581). The CUA scene pipeline grabs the screen — and several
+ * dirty regions — every turn, so that tax compounds.
+ *
+ * This module keeps ONE long-lived `powershell.exe` alive and feeds it commands
+ * over stdin, reading results back over stdout. The first call pays the cold
+ * spawn once; every call after that runs in the already-warm process
+ * (sub-second). It is a pure latency optimization: callers wrap their existing
+ * one-shot PowerShell invocation and fall back to it transparently whenever the
+ * host is unavailable, disabled, or errors — so behavior is unchanged, only
+ * faster.
+ *
+ * The loop runs from a temp `.ps1` via `powershell -File` (NOT `-Command -`,
+ * which would consume stdin to build the program and starve the loop's own
+ * `ReadLine`). `-File` reads the program from disk, leaving stdin free for the
+ * loop to read request lines.
+ *
+ * Protocol (host side is a tiny ReadLine server loop, see `SERVER_LOOP`):
+ *   - JS writes ONE line per request: `<token> <base64-utf8-script>\n`.
+ *     base64 guarantees the payload is single-line and escaping-free.
+ *   - The host decodes the script, runs it in a child scope (`& {…}` via a
+ *     fresh ScriptBlock, so request state never leaks), then writes the script's
+ *     stdout followed by the bare `<token>` (no newline). On a terminating
+ *     error it writes `PSHOSTERR:<message>` before the token.
+ *   - JS accumulates stdout until it sees `<token>`; everything before it is the
+ *     response. A `PSHOSTERR:` prefix is surfaced as a rejection so the caller
+ *     falls back to its one-shot path.
+ *
+ * Requests are serialized through a single promise chain — one in flight at a
+ * time over the one pipe. That is fine: each request is now sub-second, so even
+ * a handful of dirty-region captures per turn complete far faster than a single
+ * cold spawn used to.
+ *
+ * Disable entirely with `COMPUTERUSE_PS_HOST=0`.
+ */
+/**
+ * Whether the warm host is usable on this platform / configuration. Callers
+ * should check this before attempting {@link runPsHost} and skip straight to
+ * their one-shot path when false.
+ */
+export declare function psHostAvailable(): boolean;
+/** Tear the host down (test cleanup / unrecoverable state). */
+export declare function shutdownPsHost(): void;
+/**
+ * Run a PowerShell script in the warm host and resolve with its stdout (UTF-8).
+ * Serialized against other in-flight requests. Rejects (so the caller can fall
+ * back to a one-shot spawn) on host-start failure, script error, timeout, or
+ * unexpected host exit.
+ *
+ * @param script    PowerShell source. Runs in a child scope; assemblies
+ *                  `System.Windows.Forms` + `System.Drawing` are preloaded.
+ * @param timeoutMs Per-request budget.
+ */
+export declare function runPsHost(script: string, timeoutMs: number): Promise<string>;
+/**
+ * Best-effort pre-warm: pay the one-time cold spawn during service init instead
+ * of on the first capture/clipboard call. Never rejects — if the host can't
+ * start, callers transparently fall back to one-shot spawns.
+ */
+export declare function warmPsHost(): Promise<void>;
+/**
+ * Owner-initiated dispose (service stop). Unlike {@link shutdownPsHost} (which
+ * leaves the host respawnable for the next call — used by the timeout path),
+ * this latches spawning OFF so an in-flight fire-and-forget warm continuation
+ * cannot resurrect a powershell.exe after the service has stopped. A later
+ * {@link warmPsHost} re-enables it.
+ */
+export declare function disposePsHost(): void;
+/** Test-only: reset failure latch so a fresh attempt can be made. */
+export declare function __resetPsHostFailures(): void;
+//# sourceMappingURL=ps-host.d.ts.map

package/dist/platform/ps-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-host.d.ts","sourceRoot":"","sources":["../../src/platform/ps-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAkEH;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAKzC;AAiCD,+DAA+D;AAC/D,wBAAgB,cAAc,IAAI,IAAI,CAsBrC;AAsGD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ5E;AAED;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAS1C;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAGpC;AAED,qEAAqE;AACrE,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C"}

package/dist/platform/screenshot-errors.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Structured screenshot error contract (issue #9105, M3.5).
+ *
+ * Capture can fail for several distinct reasons, and a caller (the CUA Brain,
+ * the GET_SCREEN op, the approval/telemetry layer) wants to react differently
+ * to each: a missing OS permission needs a "grant access" prompt; a missing CLI
+ * tool needs an "install scrot/ImageMagick" hint; an empty buffer or a timeout
+ * is a transient retry. Before this contract, those were indistinguishable —
+ * callers had to regex the human-readable message.
+ *
+ * This module adds a machine-readable {@link ScreenshotErrorCode} **additively**:
+ * `tagScreenshotError` annotates the *existing* thrown error object with a code
+ * rather than replacing it, so a `PermissionDeniedError` keeps its identity
+ * (`isPermissionDeniedError` stays true) while also gaining a
+ * `screenshotErrorCode` of `"permission_denied"`. No existing caller breaks; new
+ * callers can switch on the code.
+ */
+export type ScreenshotErrorCode = 
+/** An OS privacy permission (Screen Recording / Accessibility) is denied. */
+"permission_denied"
+/** No screenshot CLI tool is installed (e.g. Linux without scrot/import). */
+ | "tool_missing"
+/** The capture tool ran but produced an empty/zero-byte image. */
+ | "empty_output"
+/** The capture command exceeded its timeout. */
+ | "timeout"
+/** Any other capture failure. */
+ | "capture_failed";
+/** An `Error` carrying a machine-readable {@link ScreenshotErrorCode}. */
+export interface ScreenshotError extends Error {
+    readonly screenshotErrorCode: ScreenshotErrorCode;
+    /** The capture operation that failed (e.g. `screenshot_capture`). */
+    readonly operation: string;
+    /** Underlying error message, when this wraps a lower-level failure. */
+    readonly details?: string;
+}
+export declare function isScreenshotError(value: unknown): value is ScreenshotError;
+export declare function createScreenshotError(code: ScreenshotErrorCode, operation: string, message: string, details?: string): ScreenshotError;
+/**
+ * Map any thrown value to a {@link ScreenshotErrorCode} by inspecting its type
+ * and message. Permission denials win first (they are typed); the rest are
+ * recognized from the well-known message shapes the capture functions throw.
+ * Pure — exported so the mapping has a single, testable source of truth.
+ */
+export declare function classifyScreenshotErrorCode(error: unknown): ScreenshotErrorCode;
+/**
+ * Annotate `error` with a {@link ScreenshotErrorCode} and return it. Additive:
+ * an `Error` (including a `PermissionDeniedError`) is mutated in place so its
+ * identity and existing fields are preserved; a non-`Error` value is wrapped in
+ * a fresh {@link ScreenshotError}. Idempotent — an already-tagged error is
+ * returned unchanged.
+ */
+export declare function tagScreenshotError(error: unknown, operation: string): ScreenshotError;
+//# sourceMappingURL=screenshot-errors.d.ts.map

package/dist/platform/screenshot-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenshot-errors.d.ts","sourceRoot":"","sources":["../../src/platform/screenshot-errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,MAAM,MAAM,mBAAmB;AAC7B,6EAA6E;AAC3E,mBAAmB;AACrB,6EAA6E;GAC3E,cAAc;AAChB,kEAAkE;GAChE,cAAc;AAChB,gDAAgD;GAC9C,SAAS;AACX,iCAAiC;GAC/B,gBAAgB,CAAC;AAErB,0EAA0E;AAC1E,MAAM,WAAW,eAAgB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;IAClD,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAQD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAO1E;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,mBAAmB,EACzB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,eAAe,CAOjB;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,GACb,mBAAmB,CAuBrB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAChB,eAAe,CAWjB"}

package/dist/platform/screenshot-quality.d.ts

@@ -0,0 +1,11 @@
+export interface ScreenshotQuality {
+    width: number;
+    height: number;
+    sampledPixels: number;
+    colorBuckets: number;
+    dominantRatio: number;
+}
+export declare function analyzePngScreenshot(buffer: Buffer): ScreenshotQuality;
+export declare function screenshotQualityIssues(label: string, quality: ScreenshotQuality): string[];
+export declare function assertScreenshotBase64NotBlank(screenshot: string | undefined, label: string, minBytes?: number): void;
+//# sourceMappingURL=screenshot-quality.d.ts.map

package/dist/platform/screenshot-quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenshot-quality.d.ts","sourceRoot":"","sources":["../../src/platform/screenshot-quality.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AAoDD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CA8EtE;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,iBAAiB,GACzB,MAAM,EAAE,CAeV;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,KAAK,EAAE,MAAM,EACb,QAAQ,SAAM,GACb,IAAI,CAoBN"}

package/dist/platform/screenshot.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cross-platform screenshot capture.
+ *
+ * Ported from:
+ * - coasty-ai/open-computer-use screenshot.ts (Apache 2.0)
+ * - eliza sandbox-routes.ts captureScreenshot()
+ *
+ * Uses native CLI tools — no Electron dependency.
+ * Full logical resolution is preserved (critical for accurate coordinate mapping).
+ */
+import type { ScreenRegion } from "../types.js";
+/**
+ * Capture a screenshot of the entire screen (or a region) and return as a Buffer (PNG).
+ */
+export declare function captureScreenshot(region?: ScreenRegion): Buffer;
+//# sourceMappingURL=screenshot.d.ts.map

package/dist/platform/screenshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenshot.d.ts","sourceRoot":"","sources":["../../src/platform/screenshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiBhD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAoD/D"}

package/dist/platform/security.d.ts

@@ -0,0 +1,20 @@
+export interface PathValidationResult {
+    allowed: boolean;
+    reason?: string;
+}
+export interface CommandRiskResult {
+    blocked: boolean;
+    reason?: string;
+}
+export declare function validateFilePath(filePath: string, operation: "read" | "write" | "delete"): PathValidationResult;
+export type SafeFileTargetResult = PathValidationResult & {
+    resolvedPath?: string;
+};
+/**
+ * Resolve and re-validate file paths after lstat/realpath to reduce TOCTOU /
+ * symlink escapes (GHSA-qmf5-p9x5-9xr5).
+ */
+export declare function resolveSafeFileTarget(filePath: string, operation: "read" | "write" | "delete"): Promise<SafeFileTargetResult>;
+export declare function sanitizeChildEnv(): Record<string, string | undefined>;
+export declare function checkDangerousCommand(command: string): CommandRiskResult;
+//# sourceMappingURL=security.d.ts.map

package/dist/platform/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../src/platform/security.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA+LD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GACrC,oBAAoB,CA8FtB;AAED,MAAM,MAAM,oBAAoB,GAAG,oBAAoB,GAAG;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAQF;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GACrC,OAAO,CAAC,oBAAoB,CAAC,CAuE/B;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAerE;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAkBxE"}

package/dist/platform/terminal.d.ts

@@ -0,0 +1,38 @@
+import type { TerminalActionResult } from "../types.js";
+export type TerminalSession = {
+    id: string;
+    cwd: string;
+    createdAt: string;
+    lastOutput?: string;
+};
+export declare function connectTerminal(arg?: string | {
+    cwd?: string;
+}): TerminalActionResult;
+export declare function executeTerminal(params: {
+    command: string;
+    timeoutSeconds?: number;
+    sessionId?: string;
+    cwd?: string;
+}): Promise<TerminalActionResult>;
+export declare function readTerminal(arg?: string | {
+    session_id?: string;
+    sessionId?: string;
+}): TerminalActionResult;
+export declare function typeTerminal(arg: string | {
+    text: string;
+    session_id?: string;
+    sessionId?: string;
+}): TerminalActionResult;
+export declare function clearTerminal(arg?: string | {
+    session_id?: string;
+    sessionId?: string;
+}): TerminalActionResult;
+export declare function closeTerminal(arg?: string | {
+    session_id?: string;
+    sessionId?: string;
+}): TerminalActionResult;
+export declare function closeAllTerminalSessions(): void;
+export declare function listTerminalSessions(): TerminalSession[];
+/** Alias of executeTerminal — upstream calls it execute_command. */
+export declare const executeCommand: typeof executeTerminal;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/platform/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/platform/terminal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AA2BF,wBAAgB,eAAe,CAC7B,GAAG,CAAC,EAAE,MAAM,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9B,oBAAoB,CAgBtB;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAwFhC;AAED,wBAAgB,YAAY,CAC1B,GAAG,CAAC,EAAE,MAAM,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACzD,oBAAoB,CAatB;AAED,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACtE,oBAAoB,CAUtB;AAED,wBAAgB,aAAa,CAC3B,GAAG,CAAC,EAAE,MAAM,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACzD,oBAAoB,CAStB;AAED,wBAAgB,aAAa,CAC3B,GAAG,CAAC,EAAE,MAAM,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACzD,oBAAoB,CAetB;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAgB,oBAAoB,IAAI,eAAe,EAAE,CAExD;AAED,oEAAoE;AACpE,eAAO,MAAM,cAAc,wBAAkB,CAAC"}

package/dist/platform/wayland-portal.d.ts

@@ -0,0 +1,25 @@
+export interface WaylandPortalCaptureOptions {
+    readonly interactive?: boolean;
+    readonly timeoutMs?: number;
+}
+export interface PortalScreenshotResponse {
+    readonly responseCode: number;
+    readonly uri?: string;
+}
+interface WaylandSessionEnv {
+    readonly WAYLAND_DISPLAY?: string;
+    readonly XDG_SESSION_TYPE?: string;
+}
+export declare function isWaylandSession(env?: WaylandSessionEnv): boolean;
+export declare function canUseWaylandScreenshotPortal(): boolean;
+export declare function captureWaylandPortalScreenshot(tmpFile: string, options?: WaylandPortalCaptureOptions): void;
+export declare function parsePortalRequestHandle(output: string): string | null;
+export declare function parsePortalScreenshotResponse(output: string, handle?: string): PortalScreenshotResponse | null;
+export declare function portalFileUriToPath(uri: string): string;
+export declare const WAYLAND_PORTAL_DBUS_TARGET: {
+    readonly busName: "org.freedesktop.portal.Desktop";
+    readonly objectPath: "/org/freedesktop/portal/desktop";
+    readonly method: "org.freedesktop.portal.Screenshot.Screenshot";
+};
+export {};
+//# sourceMappingURL=wayland-portal.d.ts.map

package/dist/platform/wayland-portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wayland-portal.d.ts","sourceRoot":"","sources":["../../src/platform/wayland-portal.ts"],"names":[],"mappings":"AAyGA,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,iBAAiB;IACzB,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAOjE;AAED,wBAAgB,6BAA6B,IAAI,OAAO,CAIvD;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,2BAAgC,GACxC,IAAI,CAyCN;AAoBD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEtE;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd,wBAAwB,GAAG,IAAI,CAajC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOvD;AAED,eAAO,MAAM,0BAA0B;;;;CAI7B,CAAC"}

package/dist/platform/windows-list.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Cross-platform window listing and management.
+ *
+ * Ported from:
+ * - coasty-ai/open-computer-use local-executor.ts window handlers (Apache 2.0)
+ * - eliza sandbox-routes.ts listWindows()
+ */
+import type { ScreenRegion, ScreenSize, WindowInfo } from "../types.js";
+export declare function findWindowsByQuery(query: string, windows?: WindowInfo[]): WindowInfo[];
+export declare function resolveWindowMatch(queryOrId: string, windows?: WindowInfo[]): WindowInfo | null;
+export declare function listWindows(): WindowInfo[];
+/**
+ * The currently-focused / frontmost window (#9170 M12 — cua
+ * `get_current_window_id`). Best-effort per-OS query; returns `null` when no
+ * window is focused or the platform query is unavailable.
+ */
+export declare function getActiveWindow(): WindowInfo | null;
+/**
+ * Windows belonging to a given application name (#9170 M12 — cua
+ * `get_application_windows`). Pure filter over `listWindows()`; case-insensitive
+ * substring match on the window's `app` (with a `title` fallback).
+ */
+export declare function getApplicationWindows(appName: string): WindowInfo[];
+/**
+ * Set a window's position AND size in one call (#9170 M12 — cua set window
+ * size+position). Position is required; width/height optional (position-only
+ * when omitted).
+ */
+export declare function resizeWindow(windowId: string, x: number, y: number, width?: number, height?: number): {
+    success: true;
+    message: string;
+};
+/**
+ * Read a window's bounds — position AND size — in OS-global logical pixels
+ * (#9170 M12 — cua `get_window_size` / `get_window_position`). When `windowId`
+ * is omitted, reads the currently-focused/foreground window. Returns
+ * `{ x, y, width, height }`.
+ *
+ * Windows: `GetWindowRect` via the window's `MainWindowHandle`. macOS: AppleScript
+ * `position`/`size` of the matched process window. Linux: `xdotool
+ * getwindowgeometry --shell`.
+ */
+export declare function getWindowBounds(windowId?: string): ScreenRegion;
+export declare function focusWindow(windowId: string): void;
+export declare function switchWindow(windowQuery: string): void;
+export declare function arrangeWindows(arrangement?: string): {
+    success: true;
+    message: string;
+};
+export declare function moveWindow(windowId: string, x?: number, y?: number): {
+    success: true;
+    message: string;
+};
+export declare function minimizeWindow(windowId: string): void;
+export declare function maximizeWindow(windowId: string): void;
+export declare function restoreWindow(windowId: string): void;
+export declare function closeWindow(windowId: string): void;
+export declare const list_windows: typeof listWindows;
+export declare const focus_window: typeof focusWindow;
+export declare const switch_to_window: typeof switchWindow;
+export declare const arrange_windows: typeof arrangeWindows;
+export declare const move_window: typeof moveWindow;
+export declare const minimize_window: typeof minimizeWindow;
+export declare const maximize_window: typeof maximizeWindow;
+export declare const restore_window: typeof restoreWindow;
+export declare const close_window: typeof closeWindow;
+/**
+ * PowerShell command that reads the primary screen bounds on Windows.
+ *
+ * `Add-Type -AssemblyName System.Windows.Forms` MUST run before
+ * `[System.Windows.Forms.Screen]` is referenced — on a clean PowerShell session
+ * the type is otherwise unresolved (`TypeNotFound`) and the screen size silently
+ * falls back to a hard-coded default. Exported so a cross-platform unit test can
+ * guard against the assembly-load regression without spawning PowerShell.
+ */
+export declare const WINDOWS_PRIMARY_SCREEN_SIZE_COMMAND: string;
+export declare function getScreenSize(): ScreenSize;
+//# sourceMappingURL=windows-list.d.ts.map

package/dist/platform/windows-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"windows-list.d.ts","sourceRoot":"","sources":["../../src/platform/windows-list.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0BxE,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,UAAU,EAAkB,GACpC,UAAU,EAAE,CAUd;AAoBD,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,UAAU,EAAkB,GACpC,UAAU,GAAG,IAAI,CAEnB;AAmDD,wBAAgB,WAAW,IAAI,UAAU,EAAE,CAa1C;AA4FD;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,UAAU,GAAG,IAAI,CAuDnD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CAQnE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,CAAC,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAapC;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAiF/D;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAqClD;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAEtD;AAoFD,wBAAgB,cAAc,CAAC,WAAW,SAAS,GAAG;IACpD,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAuDA;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,CAAC,CAAC,EAAE,MAAM,EACV,CAAC,CAAC,EAAE,MAAM,GACT;IACD,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CASA;AAID,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CA0BrD;AAID,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CA8BrD;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAqCpD;AAID,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAuBlD;AAED,eAAO,MAAM,YAAY,oBAAc,CAAC;AACxC,eAAO,MAAM,YAAY,oBAAc,CAAC;AACxC,eAAO,MAAM,gBAAgB,qBAAe,CAAC;AAC7C,eAAO,MAAM,eAAe,uBAAiB,CAAC;AAC9C,eAAO,MAAM,WAAW,mBAAa,CAAC;AACtC,eAAO,MAAM,eAAe,uBAAiB,CAAC;AAC9C,eAAO,MAAM,eAAe,uBAAiB,CAAC;AAC9C,eAAO,MAAM,cAAc,sBAAgB,CAAC;AAC5C,eAAO,MAAM,YAAY,oBAAc,CAAC;AAIxC;;;;;;;;GAQG;AACH,eAAO,MAAM,mCAAmC,QAEmC,CAAC;AAEpF,wBAAgB,aAAa,IAAI,UAAU,CA+H1C"}

package/dist/providers/computer-state.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ComputerStateProvider — injects current computer state into the LLM context.
+ *
+ * Provides platform info, screen dimensions, available capabilities,
+ * and a summary of recent actions so the agent has continuity.
+ */
+import type { Provider } from "@elizaos/core";
+export declare const computerStateProvider: Provider;
+//# sourceMappingURL=computer-state.d.ts.map

package/dist/providers/computer-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computer-state.d.ts","sourceRoot":"","sources":["../../src/providers/computer-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAIvB,eAAO,MAAM,qBAAqB,EAAE,QA4GnC,CAAC"}

package/dist/providers/scene.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `scene` provider — surfaces the latest Scene from the computeruse service's
+ * SceneBuilder into the agent prompt and provider data.
+ *
+ * Contract:
+ *   - On every turn, we run `onAgentTurn()` to refresh the scene before
+ *     reading it. WS7 (Brain) re-reads via `service.getCurrentScene()` for
+ *     deeper introspection.
+ *   - The provider text is a token-efficient JSON fence built by
+ *     `serializeSceneForPrompt`. We never emit raw pixels.
+ *   - The provider data is the FULL Scene so downstream pieces can crop /
+ *     correlate / filter without re-serializing.
+ *
+ * Cache:
+ *   - `cacheStable: false` — the Scene is by definition turn-specific.
+ *   - `cacheScope: "turn"` — re-use within a single turn so multiple
+ *     consumers don't double-tick the builder.
+ */
+import type { Provider } from "@elizaos/core";
+export declare const sceneProvider: Provider;
+//# sourceMappingURL=scene.d.ts.map

package/dist/providers/scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../src/providers/scene.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAIvB,eAAO,MAAM,aAAa,EAAE,QA0C3B,CAAC"}

package/dist/register-routes.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register-routes.d.ts.map

package/dist/register-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-routes.d.ts","sourceRoot":"","sources":["../src/register-routes.ts"],"names":[],"mappings":""}