@miosa/sdk 1.2.4 → 1.2.6

package/src/resources/community.ts

@@ -1,103 +0,0 @@
-/**
- * Community — public template + agent catalog with install + rate.
- *
- * Routes: /community/*
- * Requires JWT.
- */
-
-import type { HttpClient } from "../http.js";
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    for (const k of ["data", "templates", "agents", "items"]) {
-      if (k in d) return d[k] as Record<string, unknown>;
-    }
-  }
-  return data as Record<string, unknown>;
-}
-
-function unwrapList(data: unknown): Record<string, unknown>[] {
-  if (Array.isArray(data)) return data as Record<string, unknown>[];
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    for (const k of ["data", "templates", "agents", "items"]) {
-      if (Array.isArray(d[k])) return d[k] as Record<string, unknown>[];
-    }
-  }
-  return [];
-}
-
-export class Community {
-  constructor(private readonly http: HttpClient) {}
-
-  // ── Agents ────────────────────────────────────────────────────────────
-
-  async listAgents(
-    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>;
-    return unwrapList(await this.http.get<unknown>("/community/agents", query));
-  }
-
-  async getAgent(agentId: string): Promise<Record<string, unknown>> {
-    return unwrap(await this.http.get<unknown>(`/community/agents/${agentId}`));
-  }
-
-  // ── Templates ─────────────────────────────────────────────────────────
-
-  async listTemplates(
-    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>;
-    return unwrapList(
-      await this.http.get<unknown>("/community/templates", query),
-    );
-  }
-
-  async getTemplate(templateId: string): Promise<Record<string, unknown>> {
-    return unwrap(
-      await this.http.get<unknown>(`/community/templates/${templateId}`),
-    );
-  }
-
-  /** Install a community template into the caller's tenant. */
-  async installTemplate(
-    templateId: string,
-    opts: Record<string, unknown> = {},
-  ): Promise<Record<string, unknown>> {
-    const body = Object.fromEntries(
-      Object.entries(opts).filter(([, v]) => v !== undefined),
-    );
-    return unwrap(
-      await this.http.post<unknown>(
-        `/community/templates/${templateId}/install`,
-        body,
-      ),
-    );
-  }
-
-  /** Rate a community template (1–5). */
-  async rateTemplate(
-    templateId: string,
-    rating: number,
-    opts: Record<string, unknown> = {},
-  ): Promise<Record<string, unknown>> {
-    const body = {
-      rating,
-      ...Object.fromEntries(
-        Object.entries(opts).filter(([, v]) => v !== undefined),
-      ),
-    };
-    return unwrap(
-      await this.http.post<unknown>(
-        `/community/templates/${templateId}/rate`,
-        body,
-      ),
-    );
-  }
-}

package/src/resources/completions.ts

@@ -1,104 +0,0 @@
-/**
- * Completions — OpenAI-compatible chat / text completion endpoints.
- *
- * Routes: POST /intelligence/completions, POST /intelligence/chat/completions
- * Requires an mki_* intelligence key. Supports stream=true via SSE.
- */
-
-import type { HttpClient } from "../http.js";
-
-interface CompletionBase {
-  model: string;
-  prompt?: string | string[];
-  [key: string]: unknown;
-}
-
-export interface CompletionCreateParams extends CompletionBase {
-  stream?: false;
-}
-
-export interface CompletionCreateStreamParams extends CompletionBase {
-  stream: true;
-}
-
-interface ChatBase {
-  model: string;
-  messages: Record<string, unknown>[];
-  [key: string]: unknown;
-}
-
-export interface ChatCompletionCreateParams extends ChatBase {
-  stream?: false;
-}
-
-export interface ChatCompletionCreateStreamParams extends ChatBase {
-  stream: true;
-}
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    // Preserve OpenAI envelope (choices array present)
-    if (Array.isArray(d.choices)) return d;
-    if ("data" in d) return d.data as Record<string, unknown>;
-  }
-  return data as Record<string, unknown>;
-}
-
-function buildBody(params: Record<string, unknown>): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(params).filter(([, v]) => v !== undefined),
-  );
-}
-
-export class Completions {
-  constructor(private readonly http: HttpClient) {}
-
-  /** Create a text completion (POST /intelligence/completions). */
-  async create(
-    params: CompletionCreateParams,
-  ): Promise<Record<string, unknown>>;
-  create(
-    params: CompletionCreateStreamParams,
-  ): AsyncIterableIterator<Record<string, unknown>>;
-  create(
-    params: CompletionCreateParams | CompletionCreateStreamParams,
-  ):
-    | Promise<Record<string, unknown>>
-    | AsyncIterableIterator<Record<string, unknown>> {
-    const body = buildBody(params);
-    if (params.stream === true) {
-      return this.http.stream<Record<string, unknown>>(
-        "/intelligence/completions",
-        { method: "POST", body },
-      );
-    }
-    return this.http
-      .post<unknown>("/intelligence/completions", body)
-      .then(unwrap);
-  }
-
-  /** Create a chat completion (POST /intelligence/chat/completions). */
-  async chat(
-    params: ChatCompletionCreateParams,
-  ): Promise<Record<string, unknown>>;
-  chat(
-    params: ChatCompletionCreateStreamParams,
-  ): AsyncIterableIterator<Record<string, unknown>>;
-  chat(
-    params: ChatCompletionCreateParams | ChatCompletionCreateStreamParams,
-  ):
-    | Promise<Record<string, unknown>>
-    | AsyncIterableIterator<Record<string, unknown>> {
-    const body = buildBody(params);
-    if (params.stream === true) {
-      return this.http.stream<Record<string, unknown>>(
-        "/intelligence/chat/completions",
-        { method: "POST", body },
-      );
-    }
-    return this.http
-      .post<unknown>("/intelligence/chat/completions", body)
-      .then(unwrap);
-  }
-}

package/src/resources/computer-auto-stop.ts

@@ -1,43 +0,0 @@
-/**
- * ComputerAutoStop — read/update idle-timeout config.
- *
- * Routes:
- *   GET   /computers/:id/auto-stop
- *   PATCH /computers/:id/auto-stop
- */
-
-import type { HttpClient } from "../http.js";
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    if ("data" in d && Object.keys(d).length <= 2) {
-      return d.data as Record<string, unknown>;
-    }
-  }
-  return (data ?? {}) as Record<string, unknown>;
-}
-
-export class ComputerAutoStop {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly computerId: string,
-  ) {}
-
-  /** Return the current auto-stop configuration. */
-  async get(): Promise<Record<string, unknown>> {
-    return unwrap(
-      await this.http.get<unknown>(`/computers/${this.computerId}/auto-stop`),
-    );
-  }
-
-  /** Set the idle timeout in seconds (0 disables auto-stop). */
-  async update(seconds: number): Promise<Record<string, unknown>> {
-    return unwrap(
-      await this.http.patch<unknown>(
-        `/computers/${this.computerId}/auto-stop`,
-        { seconds },
-      ),
-    );
-  }
-}

package/src/resources/computer-env.ts

@@ -1,76 +0,0 @@
-/**
- * ComputerEnv — encrypted env var CRUD scoped to one Computer.
- *
- * Routes:
- *   GET    /computers/:id/env           → list
- *   POST   /computers/:id/env           → create (single)
- *   PATCH  /computers/:id/env/:name     → update value
- *   DELETE /computers/:id/env/:name     → remove
- *
- * bulkSet falls back to N individual POSTs (no bulk endpoint yet).
- */
-
-import type { HttpClient } from "../http.js";
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    if ("data" in d && Object.keys(d).length <= 2) {
-      return d.data as Record<string, unknown>;
-    }
-  }
-  return (data ?? {}) as Record<string, unknown>;
-}
-
-function unwrapList(data: unknown): Record<string, unknown>[] {
-  if (Array.isArray(data)) return data as Record<string, unknown>[];
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    for (const k of ["data", "env", "items"]) {
-      if (Array.isArray(d[k])) return d[k] as Record<string, unknown>[];
-    }
-  }
-  return [];
-}
-
-export class ComputerEnv {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly computerId: string,
-  ) {}
-
-  private base(): string {
-    return `/computers/${this.computerId}/env`;
-  }
-
-  /** List all env vars (values may be masked depending on server policy). */
-  async list(): Promise<Record<string, unknown>[]> {
-    return unwrapList(await this.http.get<unknown>(this.base()));
-  }
-
-  /** Create a new env var. Use update() to change an existing one. */
-  async set(name: string, value: string): Promise<Record<string, unknown>> {
-    return unwrap(await this.http.post<unknown>(this.base(), { name, value }));
-  }
-
-  /** Patch the value of an existing env var by name. */
-  async update(name: string, value: string): Promise<Record<string, unknown>> {
-    return unwrap(
-      await this.http.patch<unknown>(`${this.base()}/${name}`, { value }),
-    );
-  }
-
-  /** Remove an env var by name. */
-  async delete(name: string): Promise<void> {
-    await this.http.delete(`${this.base()}/${name}`);
-  }
-
-  /** Convenience: create one env var per entry. */
-  async bulkSet(
-    env: Record<string, string>,
-  ): Promise<Record<string, unknown>[]> {
-    return Promise.all(
-      Object.entries(env).map(([name, value]) => this.set(name, value)),
-    );
-  }
-}

package/src/resources/computer-logs.ts

@@ -1,50 +0,0 @@
-/**
- * ComputerLogs — read + stream VM logs.
- *
- * Routes:
- *   GET /computers/:id/logs         — JSON snapshot (last N lines)
- *   GET /computers/:id/logs/stream  — text/event-stream of new lines (SSE)
- */
-
-import type { HttpClient } from "../http.js";
-
-export interface ComputerLogsGetParams {
-  lines?: number;
-  since?: string;
-}
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    if ("data" in d && Object.keys(d).length <= 2) {
-      return d.data as Record<string, unknown>;
-    }
-  }
-  return (data ?? {}) as Record<string, unknown>;
-}
-
-export class ComputerLogs {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly computerId: string,
-  ) {}
-
-  /** Fetch the most recent log snapshot. */
-  async get(
-    params: ComputerLogsGetParams = {},
-  ): Promise<Record<string, unknown>> {
-    const query = Object.fromEntries(
-      Object.entries(params).filter(([, v]) => v !== undefined),
-    ) as Record<string, string | number | boolean | undefined>;
-    return unwrap(
-      await this.http.get<unknown>(`/computers/${this.computerId}/logs`, query),
-    );
-  }
-
-  /** Stream live log events as SSE dicts `{type, data, id}`. */
-  stream(): AsyncIterableIterator<Record<string, unknown>> {
-    return this.http.stream<Record<string, unknown>>(
-      `/computers/${this.computerId}/logs/stream`,
-    );
-  }
-}

package/src/resources/computer-osa.ts

@@ -1,76 +0,0 @@
-/**
- * ComputerOsa — task dispatch to the in-VM OSA agent.
- *
- * Routes:
- *   POST   /computers/:id/osa/task
- *   DELETE /computers/:id/osa/task
- *   GET    /computers/:id/osa/status
- *   POST   /computers/:id/osa/configure
- */
-
-import type { HttpClient } from "../http.js";
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    if ("data" in d && Object.keys(d).length <= 2) {
-      return d.data as Record<string, unknown>;
-    }
-  }
-  return (data ?? {}) as Record<string, unknown>;
-}
-
-export class ComputerOsa {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly computerId: string,
-  ) {}
-
-  /** Submit a free-form task to the in-VM OSA agent. */
-  async submitTask(
-    task: string,
-    params: Record<string, unknown> = {},
-  ): Promise<Record<string, unknown>> {
-    const body = {
-      task,
-      ...Object.fromEntries(
-        Object.entries(params).filter(([, v]) => v !== undefined),
-      ),
-    };
-    return unwrap(
-      await this.http.post<unknown>(
-        `/computers/${this.computerId}/osa/task`,
-        body,
-      ),
-    );
-  }
-
-  /** Cancel the currently-running OSA task, if any. */
-  async cancelTask(): Promise<Record<string, unknown>> {
-    return unwrap(
-      await this.http.delete<unknown>(`/computers/${this.computerId}/osa/task`),
-    );
-  }
-
-  /** Return OSA's current task / configuration / health snapshot. */
-  async status(): Promise<Record<string, unknown>> {
-    return unwrap(
-      await this.http.get<unknown>(`/computers/${this.computerId}/osa/status`),
-    );
-  }
-
-  /** Update OSA runtime configuration (model, tools, secrets, etc.). */
-  async configure(
-    config: Record<string, unknown>,
-  ): Promise<Record<string, unknown>> {
-    const body = Object.fromEntries(
-      Object.entries(config).filter(([, v]) => v !== undefined),
-    );
-    return unwrap(
-      await this.http.post<unknown>(
-        `/computers/${this.computerId}/osa/configure`,
-        body,
-      ),
-    );
-  }
-}

package/src/resources/computer-ports.ts

@@ -1,91 +0,0 @@
-/**
- * ComputerPorts — per-port visibility control.
- *
- * Routes:
- *   GET    /computers/:id/ports        — list
- *   POST   /computers/:id/ports        — create
- *   PATCH  /computers/:id/ports/:port  — update
- *   DELETE /computers/:id/ports/:port  — delete
- *
- * The backend does not expose a single-port GET; get() filters the list
- * response client-side for ergonomics.
- */
-
-import type { HttpClient } from "../http.js";
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    if ("data" in d && Object.keys(d).length <= 2) {
-      return d.data as Record<string, unknown>;
-    }
-  }
-  return (data ?? {}) as Record<string, unknown>;
-}
-
-function unwrapList(data: unknown): Record<string, unknown>[] {
-  if (Array.isArray(data)) return data as Record<string, unknown>[];
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    for (const k of ["data", "ports", "items"]) {
-      if (Array.isArray(d[k])) return d[k] as Record<string, unknown>[];
-    }
-  }
-  return [];
-}
-
-export class ComputerPorts {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly computerId: string,
-  ) {}
-
-  private base(): string {
-    return `/computers/${this.computerId}/ports`;
-  }
-
-  async list(): Promise<Record<string, unknown>[]> {
-    return unwrapList(await this.http.get<unknown>(this.base()));
-  }
-
-  /** Return the port record for port, or null if not exposed. */
-  async get(port: number): Promise<Record<string, unknown> | null> {
-    const all = await this.list();
-    return (
-      all.find((r) => Number((r as Record<string, unknown>).port) === port) ??
-      null
-    );
-  }
-
-  /** Expose port with the given visibility options. */
-  async create(
-    port: number,
-    opts: Record<string, unknown> = {},
-  ): Promise<Record<string, unknown>> {
-    const body = {
-      port,
-      ...Object.fromEntries(
-        Object.entries(opts).filter(([, v]) => v !== undefined),
-      ),
-    };
-    return unwrap(await this.http.post<unknown>(this.base(), body));
-  }
-
-  /** Patch visibility / auth options for port. */
-  async update(
-    port: number,
-    opts: Record<string, unknown>,
-  ): Promise<Record<string, unknown>> {
-    const body = Object.fromEntries(
-      Object.entries(opts).filter(([, v]) => v !== undefined),
-    );
-    return unwrap(
-      await this.http.patch<unknown>(`${this.base()}/${port}`, body),
-    );
-  }
-
-  /** Stop exposing port. */
-  async delete(port: number): Promise<void> {
-    await this.http.delete(`${this.base()}/${port}`);
-  }
-}

package/src/resources/computer-terminal.ts

@@ -1,61 +0,0 @@
-/**
- * ComputerTerminal — PTY session management for a Computer.
- *
- * Routes:
- *   POST /computers/:id/terminal
- *   POST /computers/:id/pty/:sessionId/resize
- */
-
-import type { HttpClient } from "../http.js";
-
-export interface TerminalCreateParams {
-  cols?: number;
-  rows?: number;
-  shell?: string;
-  cwd?: string;
-  env?: Record<string, string>;
-}
-
-export class ComputerTerminal {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly computerId: string,
-  ) {}
-
-  /** Open a new PTY session. Returns the server payload (session id, etc.). */
-  async create(
-    params: TerminalCreateParams = {},
-  ): Promise<Record<string, unknown>> {
-    const body = Object.fromEntries(
-      Object.entries(params).filter(([, v]) => v !== undefined),
-    );
-    const raw = await this.http.post<unknown>(
-      `/computers/${this.computerId}/terminal`,
-      body,
-    );
-    return unwrap(raw);
-  }
-
-  /** Resize an existing PTY session. */
-  async resize(
-    sessionId: string,
-    cols: number,
-    rows: number,
-  ): Promise<Record<string, unknown>> {
-    const raw = await this.http.post<unknown>(
-      `/computers/${this.computerId}/pty/${sessionId}/resize`,
-      { cols, rows },
-    );
-    return unwrap(raw);
-  }
-}
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    if ("data" in d && Object.keys(d).length <= 2) {
-      return d.data as Record<string, unknown>;
-    }
-  }
-  return (data ?? {}) as Record<string, unknown>;
-}

package/src/resources/computer-volumes.ts

@@ -1,64 +0,0 @@
-/**
- * ComputerVolumes — per-computer volume attachment.
- *
- * Routes:
- *   GET    /computers/:id/volumes          — list attachments
- *   POST   /computers/:id/volumes          — attach a volume
- *   DELETE /computers/:id/volumes/:aid     — detach an attachment
- */
-
-import type { HttpClient } from "../http.js";
-
-function unwrap(data: unknown): Record<string, unknown> {
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    if ("data" in d && Object.keys(d).length <= 2) {
-      return d.data as Record<string, unknown>;
-    }
-  }
-  return (data ?? {}) as Record<string, unknown>;
-}
-
-function unwrapList(data: unknown): Record<string, unknown>[] {
-  if (Array.isArray(data)) return data as Record<string, unknown>[];
-  if (data && typeof data === "object") {
-    const d = data as Record<string, unknown>;
-    for (const k of ["data", "attachments", "volumes", "items"]) {
-      if (Array.isArray(d[k])) return d[k] as Record<string, unknown>[];
-    }
-  }
-  return [];
-}
-
-export class ComputerVolumes {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly computerId: string,
-  ) {}
-
-  private base(): string {
-    return `/computers/${this.computerId}/volumes`;
-  }
-
-  async list(): Promise<Record<string, unknown>[]> {
-    return unwrapList(await this.http.get<unknown>(this.base()));
-  }
-
-  /** Attach volumeId at mountPath inside the VM. */
-  async attach(
-    volumeId: string,
-    mountPath: string,
-  ): Promise<Record<string, unknown>> {
-    return unwrap(
-      await this.http.post<unknown>(this.base(), {
-        volume_id: volumeId,
-        mount_path: mountPath,
-      }),
-    );
-  }
-
-  /** Detach an existing attachment by attachment id. */
-  async detach(attachmentId: string): Promise<void> {
-    await this.http.delete(`${this.base()}/${attachmentId}`);
-  }
-}