@miosa/sdk 1.2.5 → 1.2.7

package/src/resources/network_policy.ts

@@ -1,73 +0,0 @@
-import { HttpClient } from "../http.js";
-import type { NetworkPolicyData, NetworkPolicySetParams } from "../types.js";
-
-/**
- * Manage egress network policy for a computer.
- *
- * A policy is a list of rules evaluated top-to-bottom, with a `default_effect`
- * applied when no rule matches.
- *
- * Example — block IMDS and allow everything else:
- * ```ts
- * await computer.networkPolicy.set({
- *   default_effect: "allow",
- *   rules: [
- *     { effect: "deny", destination: "169.254.169.254/32" },
- *     { effect: "deny", destination: "metadata.google.internal" },
- *   ],
- * });
- * ```
- *
- * Example — allowlist mode (deny all by default, allow only example.com):
- * ```ts
- * await computer.networkPolicy.set({
- *   default_effect: "deny",
- *   rules: [
- *     { effect: "allow", destination: "example.com", ports: "443", protocol: "tcp" },
- *   ],
- * });
- * ```
- */
-export class NetworkPolicy {
-  private readonly http: HttpClient;
-  private readonly computerId: string;
-
-  constructor(http: HttpClient, computerId: string) {
-    this.http = http;
-    this.computerId = computerId;
-  }
-
-  /**
-   * Get the current network policy.
-   * Returns an empty allow-all policy if none is set.
-   */
-  async get(): Promise<NetworkPolicyData> {
-    const response = await this.http.get<{ data: NetworkPolicyData }>(
-      `/computers/${this.computerId}/network-policy`,
-    );
-    return response.data;
-  }
-
-  /**
-   * Set (create or replace) the network policy.
-   * Triggers immediate nftables update on the host — running VMs pick up
-   * the new rules without a restart.
-   */
-  async set(params: NetworkPolicySetParams): Promise<NetworkPolicyData> {
-    const response = await this.http.put<{ data: NetworkPolicyData }>(
-      `/computers/${this.computerId}/network-policy`,
-      params,
-    );
-    return response.data;
-  }
-
-  /**
-   * Reset to the default policy (allow all egress).
-   * Idempotent — safe to call even if no policy was set.
-   */
-  async reset(): Promise<void> {
-    await this.http.delete<unknown>(
-      `/computers/${this.computerId}/network-policy`,
-    );
-  }
-}

package/src/resources/open-computers/agents.ts

@@ -1,91 +0,0 @@
-import { HttpClient } from "../../http.js";
-import type {
-  AgentDispatchParams,
-  AgentEvent,
-  AgentSessionListResponse,
-  HostId,
-  OcAgentSessionData,
-} from "./types.js";
-
-/**
- * Agents resource — dispatch Optimal AI agent sessions that execute on a
- * remote OpenComputers host via the OSA/WS tunnel.
- *
- * ```ts
- * const session = await client.openComputers.agents.dispatch(hostId, {
- *   task: "Run the test suite and report failures",
- * });
- *
- * for await (const event of client.openComputers.agents.events(hostId, session.id)) {
- *   console.log(event.type, event.data);
- *   if (event.type === "session_completed" || event.type === "done") break;
- * }
- * ```
- */
-export class Agents {
-  private readonly http: HttpClient;
-
-  constructor(http: HttpClient) {
-    this.http = http;
-  }
-
-  private base(hostId: string): string {
-    return `/opencomputers/hosts/${hostId}/agent`;
-  }
-
-  /**
-   * Dispatch a new agent session on the host.
-   */
-  async dispatch(
-    hostId: HostId | string,
-    params: AgentDispatchParams,
-  ): Promise<OcAgentSessionData> {
-    return this.http.post<OcAgentSessionData>(
-      `${this.base(hostId)}/dispatch`,
-      params,
-    );
-  }
-
-  /**
-   * List all agent sessions for a host.
-   */
-  async list(hostId: HostId | string): Promise<AgentSessionListResponse> {
-    return this.http.get<AgentSessionListResponse>(
-      `${this.base(hostId)}/sessions`,
-    );
-  }
-
-  /**
-   * Fetch the current state of a specific agent session.
-   */
-  async get(
-    hostId: HostId | string,
-    sessionId: string,
-  ): Promise<OcAgentSessionData> {
-    return this.http.get<OcAgentSessionData>(
-      `${this.base(hostId)}/sessions/${sessionId}`,
-    );
-  }
-
-  /**
-   * Stream live events from an agent session.
-   *
-   * Yields `AgentEvent` objects. Break on `type === "done"` or
-   * `type === "session_completed"`.
-   */
-  events(
-    hostId: HostId | string,
-    sessionId: string,
-  ): AsyncIterableIterator<AgentEvent> {
-    return this.http.stream<AgentEvent>(
-      `${this.base(hostId)}/sessions/${sessionId}/events`,
-    );
-  }
-
-  /**
-   * Cancel a running or pending agent session.
-   */
-  async cancel(hostId: HostId | string, sessionId: string): Promise<void> {
-    return this.http.delete<void>(`${this.base(hostId)}/sessions/${sessionId}`);
-  }
-}

package/src/resources/open-computers/apps.ts

@@ -1,102 +0,0 @@
-import { HttpClient } from "../../http.js";
-import type {
-  AppCatalogEntry,
-  AppInstallData,
-  AppInstallEvent,
-  HostId,
-} from "./types.js";
-
-/**
- * Apps resource — one-click install of common dev services on a remote host.
- *
- * ```ts
- * const catalog = await client.openComputers.apps.catalog();
- * const install = await client.openComputers.apps.install(hostId, "postgres");
- *
- * for await (const evt of client.openComputers.apps.installEvents(hostId, install.id)) {
- *   console.log(evt.type, evt.data);
- *   if (evt.type === "installed" || evt.type === "failed") break;
- * }
- * ```
- */
-export class Apps {
-  private readonly http: HttpClient;
-
-  constructor(http: HttpClient) {
-    this.http = http;
-  }
-
-  /**
-   * List all available apps in the MIOSA app library.
-   */
-  async catalog(): Promise<AppCatalogEntry[]> {
-    const result = await this.http.get<{ data: AppCatalogEntry[] }>(
-      "/opencomputers/apps",
-    );
-    return result.data;
-  }
-
-  /**
-   * List apps installed on a specific host.
-   */
-  async listInstalled(hostId: HostId | string): Promise<AppInstallData[]> {
-    const result = await this.http.get<{ data: AppInstallData[] }>(
-      `/opencomputers/hosts/${hostId}/apps`,
-    );
-    return result.data;
-  }
-
-  /**
-   * Install an app on a host by app catalog ID.
-   */
-  async install(
-    hostId: HostId | string,
-    appId: string,
-  ): Promise<AppInstallData> {
-    return this.http.post<AppInstallData>(
-      `/opencomputers/hosts/${hostId}/apps/${appId}/install`,
-    );
-  }
-
-  /**
-   * Get the current state of an install operation.
-   */
-  async getInstall(
-    hostId: HostId | string,
-    installId: string,
-  ): Promise<AppInstallData> {
-    return this.http.get<AppInstallData>(
-      `/opencomputers/hosts/${hostId}/apps/installs/${installId}`,
-    );
-  }
-
-  /**
-   * Stream install progress events.
-   */
-  installEvents(
-    hostId: HostId | string,
-    installId: string,
-  ): AsyncIterableIterator<AppInstallEvent> {
-    return this.http.stream<AppInstallEvent>(
-      `/opencomputers/hosts/${hostId}/apps/installs/${installId}/events`,
-    );
-  }
-
-  /**
-   * Uninstall an app from a host.
-   */
-  async uninstall(hostId: HostId | string, appId: string): Promise<void> {
-    return this.http.delete<void>(
-      `/opencomputers/hosts/${hostId}/apps/${appId}`,
-    );
-  }
-
-  /**
-   * Start a previously installed app (e.g. start the postgres service).
-   */
-  async startApp(hostId: HostId | string, appId: string): Promise<void> {
-    return this.http.post<void>(
-      `/opencomputers/hosts/${hostId}/apps/${appId}/start`,
-    );
-  }
-}

package/src/resources/open-computers/clusters.ts

@@ -1,88 +0,0 @@
-import { HttpClient } from "../../http.js";
-import type {
-  ClusterCreateParams,
-  ClusterData,
-  ClusterEvent,
-  ClusterId,
-  ClusterListResponse,
-} from "./types.js";
-
-/**
- * Clusters resource — manage multi-host LLM inference clusters (exo / MLX
- * Distributed). Hosts must be Apple Silicon.
- *
- * Once a cluster is active it exposes an OpenAI-compatible endpoint at:
- *   `POST /inference/{slug}/v1/chat/completions`
- *
- * Point any OpenAI client at `https://api.miosa.ai/inference/{slug}/v1` with
- * your `msk_*` Bearer token.
- *
- * ```ts
- * const cluster = await client.openComputers.clusters.create({
- *   name: "llama-cluster",
- *   model: "llama3:70b",
- *   host_ids: [hostA.id, hostB.id],
- * });
- * console.log(cluster.inference_url); // OpenAI-compatible base URL
- * ```
- */
-export class Clusters {
-  private readonly http: HttpClient;
-
-  constructor(http: HttpClient) {
-    this.http = http;
-  }
-
-  private base(): string {
-    return "/opencomputers/clusters";
-  }
-
-  /**
-   * List all inference clusters for the tenant.
-   */
-  async list(): Promise<ClusterListResponse> {
-    return this.http.get<ClusterListResponse>(this.base());
-  }
-
-  /**
-   * Create and provision a new inference cluster.
-   */
-  async create(params: ClusterCreateParams): Promise<ClusterData> {
-    return this.http.post<ClusterData>(this.base(), params);
-  }
-
-  /**
-   * Fetch a single cluster.
-   */
-  async get(id: ClusterId | string): Promise<ClusterData> {
-    return this.http.get<ClusterData>(`${this.base()}/${id}`);
-  }
-
-  /**
-   * Start a stopped cluster.
-   */
-  async start(id: ClusterId | string): Promise<ClusterData> {
-    return this.http.post<ClusterData>(`${this.base()}/${id}/start`);
-  }
-
-  /**
-   * Stop a running cluster (preserves configuration).
-   */
-  async stop(id: ClusterId | string): Promise<ClusterData> {
-    return this.http.post<ClusterData>(`${this.base()}/${id}/stop`);
-  }
-
-  /**
-   * Permanently delete a cluster.
-   */
-  async delete(id: ClusterId | string): Promise<void> {
-    return this.http.delete<void>(`${this.base()}/${id}`);
-  }
-
-  /**
-   * Stream cluster provisioning / health events.
-   */
-  events(id: ClusterId | string): AsyncIterableIterator<ClusterEvent> {
-    return this.http.stream<ClusterEvent>(`${this.base()}/${id}/events`);
-  }
-}

package/src/resources/open-computers/desktop.ts

@@ -1,34 +0,0 @@
-import { HttpClient } from "../../http.js";
-import type { HostId, WsTicket } from "./types.js";
-
-/**
- * Desktop resource — issue WebSocket tickets for KasmVNC desktop streaming on
- * a remote OpenComputers host.
- *
- * The ticket is consumed by a WebSocket upgrade at the URL in `ws_url`. Connect
- * a KasmVNC-compatible client (or an iframe pointing at the VNC web client) to
- * drive the desktop.
- *
- * ```ts
- * const { ws_url } = await client.openComputers.desktop.ticket(hostId);
- * // Open ws_url in an iframe or VNC client
- * ```
- */
-export class Desktop {
-  private readonly http: HttpClient;
-
-  constructor(http: HttpClient) {
-    this.http = http;
-  }
-
-  /**
-   * Issue a short-lived WebSocket ticket for a desktop streaming session.
-   *
-   * The ticket expires quickly — open the WebSocket immediately after receiving it.
-   */
-  async ticket(hostId: HostId | string): Promise<WsTicket> {
-    return this.http.post<WsTicket>(
-      `/opencomputers/hosts/${hostId}/desktop/ticket`,
-    );
-  }
-}

package/src/resources/open-computers/files.ts

@@ -1,97 +0,0 @@
-import { HttpClient } from "../../http.js";
-import type { FsEntry, FsListResponse, FsStat, HostId } from "./types.js";
-
-/**
- * Files resource — direct file-system access on a remote OpenComputers host.
- *
- * Operations are proxied through the OSA daemon running on the host.
- *
- * ```ts
- * const entries = await client.openComputers.files.list(hostId, "/home/user");
- * const bytes = await client.openComputers.files.download(hostId, "/home/user/report.pdf");
- * await client.openComputers.files.upload(hostId, "/tmp/data.json", new TextEncoder().encode("{}"));
- * ```
- */
-export class OcFiles {
-  private readonly http: HttpClient;
-
-  constructor(http: HttpClient) {
-    this.http = http;
-  }
-
-  private base(hostId: string): string {
-    return `/opencomputers/hosts/${hostId}/fs`;
-  }
-
-  /**
-   * List directory entries at `path`.
-   */
-  async list(hostId: HostId | string, path: string): Promise<FsListResponse> {
-    return this.http.get<FsListResponse>(this.base(hostId), { path });
-  }
-
-  /**
-   * Stat a path (does not follow symlinks).
-   */
-  async stat(hostId: HostId | string, path: string): Promise<FsStat> {
-    return this.http.get<FsStat>(`${this.base(hostId)}/stat`, { path });
-  }
-
-  /**
-   * Download a file from the host. Returns raw bytes.
-   */
-  async download(hostId: HostId | string, path: string): Promise<Uint8Array> {
-    const url = `${this.base(hostId)}/download?path=${encodeURIComponent(path)}`;
-    return this.http.getBinary(url);
-  }
-
-  /**
-   * Upload content to `remotePath` on the host.
-   *
-   * @param content    - `Blob`, `Uint8Array`, or UTF-8 string.
-   * @param remotePath - Absolute destination path on the host.
-   * @param filename   - Optional filename hint; defaults to `remotePath` basename.
-   */
-  async upload(
-    hostId: HostId | string,
-    remotePath: string,
-    content: Blob | Uint8Array | string,
-    filename?: string,
-  ): Promise<FsEntry> {
-    const fd = new FormData();
-    const name = filename ?? remotePath.split("/").pop() ?? "file";
-
-    if (typeof content === "string") {
-      fd.append("file", new Blob([content]), name);
-    } else if (content instanceof Uint8Array) {
-      fd.append("file", new Blob([content.buffer as ArrayBuffer]), name);
-    } else {
-      fd.append("file", content, name);
-    }
-    fd.append("path", remotePath);
-
-    return this.http.postFormData<FsEntry>(`${this.base(hostId)}/upload`, fd);
-  }
-
-  /**
-   * Delete a file or directory.
-   *
-   * @param recursive - When `true`, delete non-empty directories recursively.
-   */
-  async delete(
-    hostId: HostId | string,
-    path: string,
-    recursive = false,
-  ): Promise<void> {
-    return this.http.delete<void>(
-      `${this.base(hostId)}?path=${encodeURIComponent(path)}&recursive=${recursive}`,
-    );
-  }
-
-  /**
-   * Create a directory (and any missing parents).
-   */
-  async mkdir(hostId: HostId | string, path: string): Promise<void> {
-    return this.http.post<void>(`${this.base(hostId)}/mkdir`, { path });
-  }
-}

package/src/resources/open-computers/hosts.ts

@@ -1,85 +0,0 @@
-import { HttpClient } from "../../http.js";
-import type {
-  HostCreateParams,
-  HostData,
-  HostEvent,
-  HostId,
-  HostListResponse,
-  HostUpdateParams,
-} from "./types.js";
-
-/**
- * Hosts resource — manage BYOC (Bring Your Own Computer) hosts registered
- * under your tenant.
- *
- * ```ts
- * const host = await client.openComputers.hosts.create({ name: "my-mac" });
- * console.log(host.host_key); // store this — shown only once
- * ```
- */
-export class Hosts {
-  private readonly http: HttpClient;
-
-  constructor(http: HttpClient) {
-    this.http = http;
-  }
-
-  private base(): string {
-    return "/opencomputers/hosts";
-  }
-
-  /**
-   * List all hosts registered for the tenant.
-   */
-  async list(): Promise<HostListResponse> {
-    return this.http.get<HostListResponse>(this.base());
-  }
-
-  /**
-   * Register a new host. The returned `host_key` is shown **once** — store it
-   * immediately and install it on the target machine.
-   */
-  async create(params: HostCreateParams): Promise<HostData> {
-    return this.http.post<HostData>(this.base(), params);
-  }
-
-  /**
-   * Fetch a single host by ID.
-   */
-  async get(id: HostId | string): Promise<HostData> {
-    return this.http.get<HostData>(`${this.base()}/${id}`);
-  }
-
-  /**
-   * Update host metadata (name / labels).
-   */
-  async update(
-    id: HostId | string,
-    params: HostUpdateParams,
-  ): Promise<HostData> {
-    return this.http.patch<HostData>(`${this.base()}/${id}`, params);
-  }
-
-  /**
-   * Revoke a host. Permanently removes the registration; the host key is
-   * invalidated and the host will disconnect on next heartbeat.
-   */
-  async revoke(id: HostId | string): Promise<void> {
-    return this.http.delete<void>(`${this.base()}/${id}`);
-  }
-
-  /**
-   * Stream host state-change events (connect / disconnect / error) as an
-   * `AsyncIterable`.
-   *
-   * ```ts
-   * for await (const event of client.openComputers.hosts.events()) {
-   *   console.log(event.type, event.host_id);
-   *   if (shouldStop) break;
-   * }
-   * ```
-   */
-  events(): AsyncIterableIterator<HostEvent> {
-    return this.http.stream<HostEvent>("/opencomputers/hosts/events");
-  }
-}

package/src/resources/open-computers/index.ts

@@ -1,98 +0,0 @@
-import { HttpClient } from "../../http.js";
-import { Agents } from "./agents.js";
-import { Apps } from "./apps.js";
-import { Clusters } from "./clusters.js";
-import { Desktop } from "./desktop.js";
-import { OcFiles } from "./files.js";
-import { Hosts } from "./hosts.js";
-import { Jobs } from "./jobs.js";
-import { Secrets } from "./secrets.js";
-import { Terminal } from "./terminal.js";
-import { Tunnels } from "./tunnels.js";
-import { OcWorkspaces } from "./workspaces.js";
-
-export * from "./types.js";
-export { Agents } from "./agents.js";
-export { Apps } from "./apps.js";
-export { Clusters } from "./clusters.js";
-export { Desktop } from "./desktop.js";
-export { OcFiles } from "./files.js";
-export { Hosts } from "./hosts.js";
-export { Jobs } from "./jobs.js";
-export { Secrets } from "./secrets.js";
-export { Terminal } from "./terminal.js";
-export { Tunnels } from "./tunnels.js";
-export { OcWorkspaces } from "./workspaces.js";
-
-/**
- * OpenComputers namespace — BYOC (Bring Your Own Computer) host management.
- *
- * Register your own machines (Mac, Linux, Windows) with MIOSA and use them
- * just like cloud computers: run jobs, manage files, open terminals, expose
- * ports, dispatch AI agents, and run LLM inference clusters.
- *
- * Access via `client.openComputers`:
- *
- * ```ts
- * const miosa = new Miosa({ apiKey: "msk_u_..." });
- *
- * // Register a host — save host_key immediately, shown only once
- * const host = await miosa.openComputers.hosts.create({ name: "my-mac" });
- *
- * // Run a command
- * const job = await miosa.openComputers.jobs.run(host.id, { command: "npm test" });
- *
- * // Stream output
- * for await (const event of miosa.openComputers.jobs.stream(host.id, job.id)) {
- *   process.stdout.write(String(event.data ?? ""));
- *   if (event.type === "done") break;
- * }
- *
- * // Expose a port
- * const tunnel = await miosa.openComputers.tunnels.create(host.id, { target_port: 3000 });
- * console.log(tunnel.public_url);
- *
- * // Dispatch an AI agent
- * const session = await miosa.openComputers.agents.dispatch(host.id, {
- *   task: "Run tests and fix failing ones",
- * });
- * ```
- */
-export class OpenComputers {
-  /** Host registration and lifecycle. */
-  readonly hosts: Hosts;
-  /** Command execution on remote hosts. */
-  readonly jobs: Jobs;
-  /** File system access on remote hosts. */
-  readonly files: OcFiles;
-  /** Interactive terminal session tickets. */
-  readonly terminal: Terminal;
-  /** Desktop streaming session tickets. */
-  readonly desktop: Desktop;
-  /** HTTP tunnel management (expose host ports publicly). */
-  readonly tunnels: Tunnels;
-  /** AI agent dispatch and session management. */
-  readonly agents: Agents;
-  /** Multi-host LLM inference clusters. */
-  readonly clusters: Clusters;
-  /** App library — one-click installs on hosts. */
-  readonly apps: Apps;
-  /** Git-backed workspace environments. */
-  readonly workspaces: OcWorkspaces;
-  /** Encrypted per-host / per-tenant secrets. */
-  readonly secrets: Secrets;
-
-  constructor(http: HttpClient) {
-    this.hosts = new Hosts(http);
-    this.jobs = new Jobs(http);
-    this.files = new OcFiles(http);
-    this.terminal = new Terminal(http);
-    this.desktop = new Desktop(http);
-    this.tunnels = new Tunnels(http);
-    this.agents = new Agents(http);
-    this.clusters = new Clusters(http);
-    this.apps = new Apps(http);
-    this.workspaces = new OcWorkspaces(http);
-    this.secrets = new Secrets(http);
-  }
-}