@miosa/sdk 1.2.5 → 1.2.7

package/src/resources/desktop.ts

@@ -1,134 +0,0 @@
-import { HttpClient } from "../http.js";
-import type {
-  ClickParams,
-  CursorInfo,
-  DesktopActionResult,
-  DoubleClickParams,
-  DragParams,
-  KeyParams,
-  LaunchParams,
-  ScrollParams,
-  TypeParams,
-  WaitParams,
-  WindowFocusParams,
-  WindowInfo,
-} from "../types.js";
-
-export class Desktop {
-  private readonly http: HttpClient;
-  private readonly computerId: string;
-
-  constructor(http: HttpClient, computerId: string) {
-    this.http = http;
-    this.computerId = computerId;
-  }
-
-  private base(): string {
-    return `/computers/${this.computerId}/desktop`;
-  }
-
-  /** Capture a screenshot of the desktop. Returns raw PNG bytes. */
-  async screenshot(): Promise<Uint8Array> {
-    return this.http.getBinary(`${this.base()}/screenshot`);
-  }
-
-  /** Click at the given coordinates. */
-  async click(
-    x: number,
-    y: number,
-    button: ClickParams["button"] = "left",
-  ): Promise<DesktopActionResult> {
-    return this.http.post<DesktopActionResult>(`${this.base()}/click`, {
-      x,
-      y,
-      button,
-    });
-  }
-
-  /** Double-click at the given coordinates. */
-  async doubleClick(x: number, y: number): Promise<DesktopActionResult> {
-    const params: DoubleClickParams = { x, y };
-    return this.http.post<DesktopActionResult>(
-      `${this.base()}/double-click`,
-      params,
-    );
-  }
-
-  /** Type text into the currently focused element. */
-  async type(text: string, delay?: number): Promise<DesktopActionResult> {
-    const params: TypeParams = { text, ...(delay !== undefined && { delay }) };
-    return this.http.post<DesktopActionResult>(`${this.base()}/type`, params);
-  }
-
-  /** Send a key or key combination (e.g. "Enter", "ctrl+c"). */
-  async key(key: string): Promise<DesktopActionResult> {
-    const params: KeyParams = { key };
-    return this.http.post<DesktopActionResult>(`${this.base()}/key`, params);
-  }
-
-  /** Scroll in a direction at an optional position. */
-  async scroll(
-    direction: ScrollParams["direction"],
-    clicks: number = 3,
-    x?: number,
-    y?: number,
-  ): Promise<DesktopActionResult> {
-    const params: ScrollParams = {
-      direction,
-      clicks,
-      ...(x !== undefined && { x }),
-      ...(y !== undefined && { y }),
-    };
-    return this.http.post<DesktopActionResult>(`${this.base()}/scroll`, params);
-  }
-
-  /** Click and drag from one coordinate to another. */
-  async drag(
-    fromX: number,
-    fromY: number,
-    toX: number,
-    toY: number,
-  ): Promise<DesktopActionResult> {
-    const params: DragParams = {
-      from_x: fromX,
-      from_y: fromY,
-      to_x: toX,
-      to_y: toY,
-    };
-    return this.http.post<DesktopActionResult>(`${this.base()}/drag`, params);
-  }
-
-  /** Wait for the given number of seconds. */
-  async wait(seconds: number): Promise<DesktopActionResult> {
-    const params: WaitParams = { seconds };
-    return this.http.post<DesktopActionResult>(`${this.base()}/wait`, params);
-  }
-
-  /** List all open windows on the desktop. */
-  async windows(): Promise<WindowInfo[]> {
-    const result = await this.http.get<{ windows: WindowInfo[] }>(
-      `${this.base()}/windows`,
-    );
-    return result.windows;
-  }
-
-  /** Get the current cursor position. */
-  async cursor(): Promise<CursorInfo> {
-    return this.http.get<CursorInfo>(`${this.base()}/cursor`);
-  }
-
-  /** Bring the given window into focus. */
-  async focusWindow(windowId: string): Promise<DesktopActionResult> {
-    const params: WindowFocusParams = { window_id: windowId };
-    return this.http.post<DesktopActionResult>(
-      `${this.base()}/window/focus`,
-      params,
-    );
-  }
-
-  /** Launch an application by name. */
-  async launch(appName: string): Promise<DesktopActionResult> {
-    const params: LaunchParams = { app_name: appName };
-    return this.http.post<DesktopActionResult>(`${this.base()}/launch`, params);
-  }
-}

package/src/resources/devices.test.ts

@@ -1,92 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { HttpClient } from "../http.js";
-import { Devices } from "./devices.js";
-
-const mockGet = vi.fn();
-
-function makeHttp(): HttpClient {
-  const http = {} as HttpClient;
-  http.get = mockGet;
-  return http;
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("Devices", () => {
-  it("returns the static agent device catalog", () => {
-    const catalog = new Devices(makeHttp()).catalog();
-
-    expect(catalog.map((device) => device.kind)).toEqual(
-      expect.arrayContaining([
-        "sandbox_worker",
-        "computer",
-        "local_device",
-        "docker_deploy_host",
-      ]),
-    );
-    expect(catalog.find((device) => device.kind === "sandbox_worker")
-      ?.primaryCommands).toEqual(
-      expect.arrayContaining([
-        expect.stringContaining("sandboxes.create"),
-        expect.stringContaining("sandbox.exec"),
-      ]),
-    );
-  });
-
-  it("normalizes sandboxes and computers into one device list", async () => {
-    mockGet
-      .mockResolvedValueOnce({
-        data: [
-          {
-            id: "sbx_123",
-            name: "builder",
-            state: "running",
-            ready: true,
-            persistent: true,
-            preview_url: "https://3000-sbx_123.sandbox.miosa.app",
-          },
-        ],
-      })
-      .mockResolvedValueOnce({
-        data: [
-          {
-            id: "cmp_123",
-            name: "desktop",
-            status: "running",
-            region: "us-nyc",
-          },
-        ],
-      });
-
-    const result = await new Devices(makeHttp()).list();
-
-    expect(mockGet).toHaveBeenNthCalledWith(1, "/sandboxes");
-    expect(mockGet).toHaveBeenNthCalledWith(2, "/computers");
-    expect(result.errors).toEqual([]);
-    expect(result.devices).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ id: "sbx_123", kind: "sandbox_worker" }),
-        expect.objectContaining({ id: "cmp_123", kind: "computer" }),
-      ]),
-    );
-  });
-
-  it("returns partial device inventory when one backing endpoint fails", async () => {
-    mockGet
-      .mockResolvedValueOnce({
-        data: [{ id: "sbx_123", state: "running" }],
-      })
-      .mockRejectedValueOnce(new Error("HTTP 502"));
-
-    const result = await new Devices(makeHttp()).list();
-
-    expect(result.devices).toEqual([
-      expect.objectContaining({ id: "sbx_123", kind: "sandbox_worker" }),
-    ]);
-    expect(result.errors).toEqual([
-      expect.objectContaining({ source: "computers", retryable: true }),
-    ]);
-  });
-});

package/src/resources/devices.ts

@@ -1,291 +0,0 @@
-import { HttpClient } from "../http.js";
-
-export type DeviceKind =
-  | "sandbox_worker"
-  | "computer"
-  | "local_device"
-  | "docker_deploy_host";
-
-export type DeviceSource = "sandboxes" | "computers";
-
-export interface DeviceCatalogEntry {
-  kind: DeviceKind;
-  label: string;
-  purpose: string;
-  lifecycle: string;
-  persistence: string;
-  primaryCommands: string[];
-  useWhen: string[];
-  avoidWhen: string[];
-}
-
-export interface DeviceRecord {
-  id: string;
-  kind: DeviceKind;
-  source: DeviceSource;
-  name?: string;
-  state?: string;
-  ready?: boolean;
-  persistent?: boolean;
-  alwaysOn?: boolean;
-  region?: string;
-  template?: string;
-  previewUrl?: string;
-  timeoutRemainingMs?: number;
-}
-
-export interface DeviceListError {
-  source: DeviceSource;
-  message: string;
-  retryable: boolean;
-}
-
-export interface DeviceListParams {
-  kind?: "all" | "sandbox_worker" | "sandbox" | "computer";
-}
-
-export interface DeviceListResponse {
-  devices: DeviceRecord[];
-  errors: DeviceListError[];
-}
-
-const DEVICE_CATALOG: DeviceCatalogEntry[] = [
-  {
-    kind: "sandbox_worker",
-    label: "Sandbox Worker",
-    purpose:
-      "Isolated Linux workspace for agents to create files, run code, preview apps, snapshot, fork, and publish.",
-    lifecycle:
-      "Persistent by default; use stop/resume/snapshot/fork where the account backend supports saved state.",
-    persistence:
-      "Use one-hour timeouts for interactive builds and checkpoint before long pauses.",
-    primaryCommands: [
-      "miosa.sandboxes.create({ templateId: 'nextjs', timeoutSec: 3600 })",
-      "sandbox.exec.run('codex ...', { cwd: '/workspace' })",
-      "sandbox.files.write('/workspace/app/page.jsx', source)",
-      "miosa.deployments.publishFromSandbox(...)",
-    ],
-    useWhen: [
-      "Coding agents should build inside the remote filesystem.",
-      "You need command execution, file writes, package installs, previews, artifacts, or app publish.",
-      "You want virtual-device behavior without a GUI desktop.",
-    ],
-    avoidWhen: [
-      "The workflow requires full browser/desktop control.",
-      "The app is ready for production; publish it to a deployment runtime.",
-    ],
-  },
-  {
-    kind: "computer",
-    label: "Computer",
-    purpose:
-      "Durable VM/desktop device for browser automation, CUA sessions, SSH, tunnels, and persistent agent control.",
-    lifecycle:
-      "Managed as a Computer with desktop/browser and operator-style control surfaces.",
-    persistence:
-      "Use checkpoints, volumes, tunnels, and agent sessions for long-lived desktop workflows.",
-    primaryCommands: [
-      "miosa.computers.create({ name: 'browser-agent' })",
-      "computer.exec.run('npm test')",
-      "computer.desktop.open()",
-    ],
-    useWhen: [
-      "The agent needs Chromium or a full desktop.",
-      "The workflow logs into dashboards, fills forms, clicks buttons, or captures screenshots.",
-      "A human and agent share the same persistent machine state.",
-    ],
-    avoidWhen: [
-      "Simple code generation/build/test work fits a cheaper sandbox worker.",
-      "You only need durable app hosting.",
-    ],
-  },
-  {
-    kind: "local_device",
-    label: "Local Device",
-    purpose:
-      "Developer-owned machine connected through CLI/MCP for local discovery and private tooling.",
-    lifecycle: "Not hosted by MIOSA; the user owns uptime and state.",
-    persistence:
-      "State is local machine state. Do not assume cloud resume semantics.",
-    primaryCommands: ["miosa mcp install", "miosa doctor --json"],
-    useWhen: [
-      "The agent needs local repository discovery before cloud execution.",
-      "The user intentionally wants local private tools.",
-    ],
-    avoidWhen: [
-      "Customer code must stay isolated in MIOSA-hosted infrastructure.",
-      "The workflow needs reproducible shared cloud state.",
-    ],
-  },
-  {
-    kind: "docker_deploy_host",
-    label: "Docker Deploy Host",
-    purpose:
-      "Workspace appliance VM that runs Docker containers for durable apps published from sandboxes.",
-    lifecycle:
-      "Always-on deployment capacity; not an interactive coding workspace.",
-    persistence:
-      "Versioned releases and routing are durable; edits happen in sandboxes before publish.",
-    primaryCommands: [
-      "miosa sandbox publish <id> --docker-deploy",
-      "miosa deploy --docker-deploy",
-    ],
-    useWhen: [
-      "You need many small apps, APIs, funnels, or client sites in one workspace appliance.",
-      "You want stable public URLs backed by Docker containers.",
-    ],
-    avoidWhen: [
-      "Interactive agent work is still happening.",
-      "The app needs the standard MIOSA Deploy runtime.",
-    ],
-  },
-];
-
-export class Devices {
-  private readonly http: HttpClient;
-
-  constructor(http: HttpClient) {
-    this.http = http;
-  }
-
-  /**
-   * Return the static device catalog used by orchestration apps to choose the
-   * right MIOSA execution surface before creating resources.
-   */
-  catalog(): DeviceCatalogEntry[] {
-    return DEVICE_CATALOG.map((entry) => ({ ...entry }));
-  }
-
-  /**
-   * List hosted devices by normalizing existing sandboxes and computers.
-   * Partial backend failures are returned in `errors` so orchestration UIs can
-   * still show usable inventory instead of failing the whole page.
-   */
-  async list(params: DeviceListParams = {}): Promise<DeviceListResponse> {
-    const kind = normalizeKind(params.kind ?? "all");
-    const devices: DeviceRecord[] = [];
-    const errors: DeviceListError[] = [];
-
-    if (kind === "all" || kind === "sandbox_worker") {
-      try {
-        const sandboxes = await this.http.get<unknown>("/sandboxes");
-        devices.push(...unwrapList(sandboxes, ["sandboxes"]).map(normalizeSandbox));
-      } catch (err) {
-        errors.push(toListError("sandboxes", err));
-      }
-    }
-
-    if (kind === "all" || kind === "computer") {
-      try {
-        const computers = await this.http.get<unknown>("/computers");
-        devices.push(...unwrapList(computers, ["computers"]).map(normalizeComputer));
-      } catch (err) {
-        errors.push(toListError("computers", err));
-      }
-    }
-
-    return { devices, errors };
-  }
-}
-
-function normalizeKind(
-  kind: NonNullable<DeviceListParams["kind"]>,
-): "all" | "sandbox_worker" | "computer" {
-  if (kind === "all") return "all";
-  if (kind === "sandbox" || kind === "sandbox_worker") {
-    return "sandbox_worker";
-  }
-  if (kind === "computer") return "computer";
-  throw new Error(`Unsupported device kind: ${kind}`);
-}
-
-function normalizeSandbox(row: Record<string, unknown>): DeviceRecord {
-  return compactRecord({
-    id: stringField(row, "id"),
-    kind: "sandbox_worker",
-    source: "sandboxes",
-    name: optionalString(row, "name"),
-    state: optionalString(row, "state") ?? optionalString(row, "status"),
-    ready: optionalBoolean(row, "ready"),
-    persistent: optionalBoolean(row, "persistent"),
-    alwaysOn: optionalBoolean(row, "always_on"),
-    template:
-      optionalString(row, "template_id") ?? optionalString(row, "template"),
-    previewUrl: optionalString(row, "preview_url"),
-    timeoutRemainingMs: optionalNumber(row, "timeout_remaining_ms"),
-  });
-}
-
-function normalizeComputer(row: Record<string, unknown>): DeviceRecord {
-  return compactRecord({
-    id: stringField(row, "id"),
-    kind: "computer",
-    source: "computers",
-    name: optionalString(row, "name"),
-    state: optionalString(row, "status") ?? optionalString(row, "state"),
-    ready: optionalBoolean(row, "ready"),
-    region: optionalString(row, "region"),
-    template:
-      optionalString(row, "template_type") ?? optionalString(row, "template"),
-  });
-}
-
-function compactRecord(record: Record<string, unknown>): DeviceRecord {
-  return Object.fromEntries(
-    Object.entries(record).filter(([, value]) => value !== undefined),
-  ) as unknown as DeviceRecord;
-}
-
-function unwrapList(payload: unknown, keys: string[]): Record<string, unknown>[] {
-  const value = isRecord(payload) && "data" in payload ? payload.data : payload;
-  if (Array.isArray(value)) return value.filter(isRecord);
-  if (isRecord(value)) {
-    for (const key of keys) {
-      const nested = value[key];
-      if (Array.isArray(nested)) return nested.filter(isRecord);
-    }
-  }
-  return [];
-}
-
-function toListError(source: DeviceSource, err: unknown): DeviceListError {
-  const message = err instanceof Error ? err.message : String(err);
-  return {
-    source,
-    message,
-    retryable: /fetch failed|ECONNRESET|HTTP 502|other side closed|socket hang up|bad gateway/i.test(
-      message,
-    ),
-  };
-}
-
-function stringField(row: Record<string, unknown>, key: string): string {
-  const value = row[key];
-  return typeof value === "string" ? value : String(value ?? "");
-}
-
-function optionalString(
-  row: Record<string, unknown>,
-  key: string,
-): string | undefined {
-  const value = row[key];
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
-function optionalBoolean(
-  row: Record<string, unknown>,
-  key: string,
-): boolean | undefined {
-  return typeof row[key] === "boolean" ? row[key] : undefined;
-}
-
-function optionalNumber(
-  row: Record<string, unknown>,
-  key: string,
-): number | undefined {
-  return typeof row[key] === "number" ? row[key] : undefined;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}