@miosa/sdk 1.2.4 → 1.2.6

package/src/resources/integrations.ts

@@ -1,183 +0,0 @@
-/**
- * Integrations — OAuth account-level connections (GitHub, Slack, Linear, Discord).
- */
-
-import type { HttpClient } from "../http.js";
-
-// ── Resource shapes ──────────────────────────────────────────────────────────
-
-export interface IntegrationData {
-  id?: string;
-  provider?: string;
-  status?: string;
-  connected_at?: string;
-  [key: string]: unknown;
-}
-
-export interface IntegrationCatalogEntry {
-  provider?: string;
-  name?: string;
-  description?: string;
-  [key: string]: unknown;
-}
-
-export interface GithubRepo {
-  id?: number;
-  name?: string;
-  full_name?: string;
-  private?: boolean;
-  [key: string]: unknown;
-}
-
-export interface GithubSshKey {
-  id?: number;
-  title?: string;
-  key?: string;
-  [key: string]: unknown;
-}
-
-// ── Request payloads ─────────────────────────────────────────────────────────
-
-export interface SlackSendTestParams {
-  message?: string;
-  channel?: string;
-  [key: string]: unknown;
-}
-
-export interface DiscordSendTestParams {
-  message?: string;
-  channel_id?: string;
-  [key: string]: unknown;
-}
-
-export interface LinearCreateIssueParams {
-  title?: string;
-  description?: string;
-  team_id?: string;
-  [key: string]: unknown;
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-function unwrap<T>(payload: unknown): T {
-  if (payload && typeof payload === "object") {
-    const p = payload as Record<string, unknown>;
-    for (const k of ["data", "integrations", "catalog", "items"]) {
-      if (k in p) return p[k] as T;
-    }
-  }
-  return payload as T;
-}
-
-function listItems<T>(payload: unknown): T[] {
-  const result = unwrap<T[] | unknown>(payload);
-  if (Array.isArray(result)) return result;
-  return [];
-}
-
-function stripUndefined(
-  input: Record<string, unknown>,
-): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(input).filter(([, v]) => v !== undefined),
-  );
-}
-
-// ── Main resource ─────────────────────────────────────────────────────────────
-
-export class Integrations {
-  constructor(private readonly http: HttpClient) {}
-
-  /** List active OAuth integrations for the tenant. */
-  async list(): Promise<IntegrationData[]> {
-    const data = await this.http.get<unknown>("/integrations");
-    return listItems<IntegrationData>(data);
-  }
-
-  /** List available providers in the integration catalog. */
-  async catalog(): Promise<IntegrationCatalogEntry[]> {
-    const data = await this.http.get<unknown>("/integrations/catalog");
-    return listItems<IntegrationCatalogEntry>(data);
-  }
-
-  /** Begin the OAuth flow for a provider — returns an authorize URL. */
-  async start(provider: string): Promise<Record<string, unknown>> {
-    const data = await this.http.get<unknown>(
-      `/integrations/${provider}/start`,
-    );
-    return unwrap<Record<string, unknown>>(data);
-  }
-
-  /** Force-refresh the access token for a provider. */
-  async refresh(provider: string): Promise<Record<string, unknown>> {
-    const data = await this.http.post<unknown>(
-      `/integrations/${provider}/refresh`,
-    );
-    return unwrap<Record<string, unknown>>(data);
-  }
-
-  /** Disconnect (revoke) an integration. */
-  async disconnect(provider: string): Promise<void> {
-    await this.http.delete<unknown>(`/integrations/${provider}`);
-  }
-
-  // ── GitHub-specific capabilities ───────────────────────────────────────────
-
-  /** List GitHub repositories accessible to this integration. */
-  async githubRepos(): Promise<GithubRepo[]> {
-    const data = await this.http.get<unknown>("/integrations/github/repos");
-    return listItems<GithubRepo>(data);
-  }
-
-  /** List configured GitHub deploy keys. */
-  async githubSshKeys(): Promise<GithubSshKey[]> {
-    const data = await this.http.get<unknown>("/integrations/github/ssh-keys");
-    return listItems<GithubSshKey>(data);
-  }
-
-  // ── Test hooks ─────────────────────────────────────────────────────────────
-
-  /** Send a test message to the connected Slack channel. */
-  async slackSendTest(
-    params: SlackSendTestParams = {},
-  ): Promise<Record<string, unknown>> {
-    const body = stripUndefined(params as Record<string, unknown>);
-    const data = await this.http.post<unknown>(
-      "/integrations/slack/send-test",
-      body,
-    );
-    return unwrap<Record<string, unknown>>(data);
-  }
-
-  /** Send a test message to the connected Discord channel. */
-  async discordSendTest(
-    params: DiscordSendTestParams = {},
-  ): Promise<Record<string, unknown>> {
-    const body = stripUndefined(params as Record<string, unknown>);
-    const data = await this.http.post<unknown>(
-      "/integrations/discord/send-test",
-      body,
-    );
-    return unwrap<Record<string, unknown>>(data);
-  }
-
-  // ── Linear dedicated controller ────────────────────────────────────────────
-
-  /** Begin Linear OAuth — Linear has provider-specific error shapes. */
-  async linearStart(): Promise<Record<string, unknown>> {
-    const data = await this.http.get<unknown>("/integrations/linear/start");
-    return unwrap<Record<string, unknown>>(data);
-  }
-
-  /** Create a Linear issue via the connected workspace. */
-  async linearCreateIssue(
-    params: LinearCreateIssueParams = {},
-  ): Promise<Record<string, unknown>> {
-    const body = stripUndefined(params as Record<string, unknown>);
-    const data = await this.http.post<unknown>(
-      "/integrations/linear/create-issue",
-      body,
-    );
-    return unwrap<Record<string, unknown>>(data);
-  }
-}

package/src/resources/mcp.ts

@@ -1,70 +0,0 @@
-/**
- * Mcp — Model Context Protocol streamable-HTTP transport.
- *
- * Clients (Claude Code, Cursor, Gemini CLI, Copilot) point at /api/v1/mcp
- * with a msk_* Bearer token and discover the MIOSA tool-belt.
- */
-
-import type { HttpClient } from "../http.js";
-
-// ── Request payloads ─────────────────────────────────────────────────────────
-
-export interface McpDispatchParams {
-  method?: string;
-  params?: Record<string, unknown>;
-  [key: string]: unknown;
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-function unwrap<T>(payload: unknown): T {
-  if (payload && typeof payload === "object") {
-    const p = payload as Record<string, unknown>;
-    for (const k of ["data", "mcp", "result", "items"]) {
-      if (k in p) return p[k] as T;
-    }
-  }
-  return payload as T;
-}
-
-function stripUndefined(
-  input: Record<string, unknown>,
-): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(input).filter(([, v]) => v !== undefined),
-  );
-}
-
-// ── Main resource ─────────────────────────────────────────────────────────────
-
-export class Mcp {
-  constructor(private readonly http: HttpClient) {}
-
-  /** Send a JSON-RPC request to the MCP endpoint. */
-  async dispatch(
-    params: McpDispatchParams = {},
-  ): Promise<Record<string, unknown>> {
-    const body = stripUndefined(params as Record<string, unknown>);
-    const data = await this.http.post<unknown>(
-      "/mcp",
-      Object.keys(body).length > 0 ? body : undefined,
-    );
-    return unwrap<Record<string, unknown>>(data);
-  }
-
-  /**
-   * Open the MCP listen channel (GET).
-   *
-   * Returns whatever the server returns. For true SSE streaming, use
-   * `http.stream("/mcp")` directly.
-   */
-  async listen(): Promise<unknown> {
-    const data = await this.http.get<unknown>("/mcp");
-    return unwrap(data);
-  }
-
-  /** Close (terminate) the MCP session. */
-  async close(): Promise<void> {
-    await this.http.delete<unknown>("/mcp");
-  }
-}

package/src/resources/models.ts

@@ -1,45 +0,0 @@
-/**
- * Models — list available LLMs across providers.
- *
- * Routes: GET /intelligence/models
- * Requires an mki_* intelligence key or JWT.
- */
-
-import type { HttpClient } from "../http.js";
-
-function unwrap(data: unknown): unknown[] {
-  if (Array.isArray(data)) return data;
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    for (const k of ["data", "models", "items"]) {
-      if (Array.isArray(d[k])) return d[k] as unknown[];
-    }
-  }
-  return [];
-}
-
-export class Models {
-  constructor(private readonly http: HttpClient) {}
-
-  /** List all models available to the calling tenant (OpenAI-compatible shape). */
-  async list(
-    filters: Record<string, string | number | boolean | undefined> = {},
-  ): Promise<Record<string, unknown>[]> {
-    const query = Object.fromEntries(
-      Object.entries(filters).filter(([, v]) => v !== undefined),
-    ) as Record<string, string | number | boolean | undefined>;
-    const data = await this.http.get<unknown>("/intelligence/models", query);
-    return unwrap(data) as Record<string, unknown>[];
-  }
-
-  /**
-   * Get a single model by id.
-   *
-   * The platform router does not expose a per-model GET; this filters
-   * the list payload client-side.
-   */
-  async get(modelId: string): Promise<Record<string, unknown>> {
-    const all = await this.list();
-    return all.find((m) => (m as Record<string, unknown>).id === modelId) ?? {};
-  }
-}

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`,
-    );
-  }
-}