@miosa/sdk 1.0.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miosa/sdk",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "TypeScript SDK for the MIOSA API — cloud VM desktop infrastructure for AI agents",
   "license": "MIT",
   "author": "MIOSA <hello@miosa.ai>",

package/src/client.ts

@@ -15,6 +15,9 @@ import { CronJobs } from "./resources/cron-jobs.js";
 import { Dashboard } from "./resources/dashboard.js";
 import { Databases } from "./resources/databases.js";
 import { Deployments } from "./resources/deployments.js";
+import { EgressAudit } from "./resources/egressAudit.js";
+import { EgressNetwork } from "./resources/egressNetwork.js";
+import { EgressSecrets } from "./resources/egressSecrets.js";
 import { Email } from "./resources/email.js";
 import { Embeddings } from "./resources/embeddings.js";
 import { ExternalKeys } from "./resources/external-keys.js";
@@ -34,10 +37,13 @@ import { SandboxTemplates } from "./resources/sandbox-templates.js";
 import { Settings } from "./resources/settings.js";
 import { SnapshotsStandalone } from "./resources/snapshots-standalone.js";
 import { Storage } from "./resources/storage.js";
+import { OrgInvites } from "./resources/org-invites.js";
 import { Tenant } from "./resources/tenant.js";
 import { Usage } from "./resources/usage.js";
 import { Volumes } from "./resources/volumes.js";
 import { Webhooks } from "./resources/webhooks.js";
+import { WorkspaceInvites } from "./resources/workspace-invites.js";
+import { WorkspaceMembers } from "./resources/workspace-members.js";
 import type { MiosaClientConfig } from "./types.js";
 
 const DEFAULT_BASE_URL = "https://api.miosa.ai/api/v1";
@@ -58,6 +64,21 @@ const DEFAULT_MAX_RETRIES = 3;
  * ```
  */
 export class Miosa {
+  /** Per-workspace user roster — list, add, update role, remove. */
+  readonly workspaceMembers: WorkspaceMembers;
+
+  /**
+   * Workspace invite flow — create invite, list, revoke, preview, accept.
+   * Sending to an email already in the org adds the user directly.
+   */
+  readonly workspaceInvites: WorkspaceInvites;
+
+  /**
+   * Org invite flow — create invite, list, revoke, preview, accept.
+   * Requires admin/owner role for write operations.
+   */
+  readonly orgInvites: OrgInvites;
+
   /** Current tenant plan, limits, and live usage counters. */
   readonly tenant: Tenant;
 
@@ -183,6 +204,17 @@ export class Miosa {
   /** Admin: fleet-wide snapshot index. */
   readonly snapshotsStandalone: SnapshotsStandalone;
 
+  // ── Egress (security) namespaces ───────────────────────────────────────────
+
+  /** Encrypted secret + OAuth credential vault (`/egress/secrets`). */
+  readonly secrets: EgressSecrets;
+
+  /** Egress allowlist + policies — host-level firewall (`/egress/policies`). */
+  readonly network: EgressNetwork;
+
+  /** Egress audit log — every outbound request, paginated query + tail. */
+  readonly audit: EgressAudit;
+
   private readonly http: HttpClient;
 
   constructor(config: MiosaClientConfig) {
@@ -206,6 +238,9 @@ export class Miosa {
       maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
     });
 
+    this.workspaceMembers = new WorkspaceMembers(this.http);
+    this.workspaceInvites = new WorkspaceInvites(this.http);
+    this.orgInvites = new OrgInvites(this.http);
     this.tenant = new Tenant(this.http);
     this.regions = new Regions(this.http);
     this.settings = new Settings(this.http);
@@ -245,5 +280,9 @@ export class Miosa {
     this.email = new Email(this.http);
     this.builderSessions = new BuilderSessions(this.http);
     this.snapshotsStandalone = new SnapshotsStandalone(this.http);
+    // Egress (security) namespaces
+    this.secrets = new EgressSecrets(this.http);
+    this.network = new EgressNetwork(this.http);
+    this.audit = new EgressAudit(this.http);
   }
 }

package/src/index.ts

@@ -245,6 +245,44 @@ export type {
   ApiKeyCreateParams,
 } from "./resources/api-keys.js";
 
+// Members & Invites
+export { WorkspaceMembers } from "./resources/workspace-members.js";
+export type {
+  WorkspaceRole,
+  WorkspaceMember,
+  WorkspaceMemberRecord,
+  AddWorkspaceMemberParams,
+  UpdateWorkspaceMemberRoleParams,
+  WorkspaceMemberListResponse,
+  WorkspaceMemberRecordResponse,
+  WorkspaceMemberDeleteResponse,
+} from "./resources/workspace-members.js";
+export { WorkspaceInvites } from "./resources/workspace-invites.js";
+export type {
+  WorkspaceInvite,
+  WorkspaceInvitePreview,
+  CreateWorkspaceInviteParams,
+  CreateWorkspaceInviteResponse,
+  WorkspaceInviteCreatedResponse,
+  WorkspaceMemberAddedResponse,
+  WorkspaceInviteListResponse,
+  WorkspaceInviteRevokeResponse,
+  AcceptWorkspaceInviteResponse,
+} from "./resources/workspace-invites.js";
+export { OrgInvites } from "./resources/org-invites.js";
+export type {
+  OrgRole,
+  OrgInvite,
+  OrgInviteCreated,
+  OrgInvitePreview,
+  TenantSummary,
+  CreateOrgInviteParams,
+  OrgInviteCreatedResponse,
+  OrgInviteListResponse,
+  OrgInviteRevokeResponse,
+  AcceptOrgInviteResponse,
+} from "./resources/org-invites.js";
+
 // P2 resources
 export { Tenant } from "./resources/tenant.js";
 export type { TenantPlan } from "./resources/tenant.js";
@@ -369,6 +407,58 @@ export {
   SandboxTags,
 } from "./resources/sandboxes.js";
 
+// Egress (security) — secrets, network, audit
+export {
+  EgressSecrets,
+  OAuthFlow,
+  SandboxSecrets,
+  ComputerSecrets,
+} from "./resources/egressSecrets.js";
+export type {
+  EgressSecretType,
+  EgressSecretScope,
+  EgressSecretData,
+  EgressBindingData,
+  OauthProvider,
+  SecretSetParams,
+  SecretListParams,
+  SecretRotateParams,
+  BindingCreateParams,
+  BindingListParams,
+  OauthConnectParams,
+  OauthStartResult,
+  OauthStatusResult,
+} from "./resources/egressSecrets.js";
+export {
+  EgressNetwork,
+  SandboxNetwork,
+  ComputerNetwork,
+} from "./resources/egressNetwork.js";
+export type {
+  EgressPolicyMode,
+  EgressRuleEffect,
+  EgressPolicyData,
+  EgressAllowlistRule,
+  EgressSuggestion,
+  AllowParams,
+  PolicyCreateParams,
+  PolicyUpdateParams,
+  ModeParams,
+  SuggestionsParams,
+  PolicyListParams,
+  RulesListParams,
+} from "./resources/egressNetwork.js";
+export {
+  EgressAudit,
+  SandboxAudit,
+  ComputerAudit,
+} from "./resources/egressAudit.js";
+export type {
+  EgressAuditEvent,
+  AuditListParams,
+  AuditTailParams,
+} from "./resources/egressAudit.js";
+
 // Error types
 export {
   MiosaError,

package/src/resources/admin.ts

@@ -345,4 +345,15 @@ export class Admin {
       model_id: modelId,
     });
   }
+
+  /** POST /api/v1/admin/impersonate — returns {token, expires_at}. */
+  impersonate(
+    externalUserId: string,
+    options: { ttlSec?: number } = {},
+  ): Promise<{ token: string; expires_at: string }> {
+    return this.http.post("/admin/impersonate", {
+      external_user_id: externalUserId,
+      ttl_sec: options.ttlSec ?? 3600,
+    });
+  }
 }

package/src/resources/api-keys.ts

@@ -113,6 +113,22 @@ export class ApiKeys {
     return unwrap<ApiKeyCreateResult>(data);
   }
 
+  /** POST /api/v1/api-keys/scoped — L2 delegation token bound to one external user. */
+  async createScoped(params: {
+    externalUserId: string;
+    scopes: string[];
+    expiresAt?: string;
+  }): Promise<ApiKeyCreateResult> {
+    const body = stripUndefined({
+      external_user_id: params.externalUserId,
+      scopes: params.scopes,
+      expires_at: params.expiresAt,
+    });
+    return unwrap<ApiKeyCreateResult>(
+      await this.http.post<unknown>("/api-keys/scoped", body),
+    );
+  }
+
   async delete(keyId: string): Promise<void> {
     await this.http.delete<unknown>(`/api-keys/${keyId}`);
   }

package/src/resources/computer.ts

@@ -10,6 +10,9 @@ import { ComputerTerminal } from "./computer-terminal.js";
 import { ComputerVolumes } from "./computer-volumes.js";
 import { CustomDomains } from "./custom_domains.js";
 import { Desktop } from "./desktop.js";
+import { ComputerAudit } from "./egressAudit.js";
+import { ComputerNetwork } from "./egressNetwork.js";
+import { ComputerSecrets } from "./egressSecrets.js";
 import { Events } from "./events.js";
 import { Exec } from "./exec.js";
 import { Files } from "./files.js";
@@ -112,6 +115,15 @@ export class Computer {
   /** Volume attachment — list, attach, detach. */
   readonly volumes: ComputerVolumes;
 
+  /** Encrypted secrets + OAuth credentials scoped to this computer. */
+  readonly secrets: ComputerSecrets;
+
+  /** Egress allowlist + policies scoped to this computer. */
+  readonly network: ComputerNetwork;
+
+  /** Egress audit log + live tail scoped to this computer. */
+  readonly audit: ComputerAudit;
+
   private readonly http: HttpClient;
 
   constructor(http: HttpClient, data: ComputerData) {
@@ -134,6 +146,10 @@ export class Computer {
     this.logs = new ComputerLogs(http, id);
     this.ports = new ComputerPorts(http, id);
     this.volumes = new ComputerVolumes(http, id);
+    // Egress (security) namespaces — pre-scoped to this computer id.
+    this.secrets = new ComputerSecrets(http, id);
+    this.network = new ComputerNetwork(http, id);
+    this.audit = new ComputerAudit(http, id);
   }
 
   get id(): ComputerId {

package/src/resources/egress.test.ts

@@ -0,0 +1,318 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { HttpClient } from "../http.js";
+import { EgressAudit, SandboxAudit } from "./egressAudit.js";
+import { EgressNetwork, SandboxNetwork } from "./egressNetwork.js";
+import { EgressSecrets, OAuthFlow, SandboxSecrets } from "./egressSecrets.js";
+
+const mockGet = vi.fn();
+const mockPost = vi.fn();
+const mockPatch = vi.fn();
+const mockDelete = vi.fn();
+const mockRequest = vi.fn();
+const mockStream = vi.fn();
+const mockGetBinary = vi.fn();
+
+function makeHttp(): HttpClient {
+  const http = {} as HttpClient;
+  http.get = mockGet;
+  http.post = mockPost;
+  http.patch = mockPatch;
+  http.delete = mockDelete;
+  http.request = mockRequest;
+  http.stream = mockStream;
+  http.getBinary = mockGetBinary;
+  return http;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+// ─── client.secrets ──────────────────────────────────────────────────────────
+
+describe("EgressSecrets", () => {
+  it("set() POSTs to /egress/secrets with the right body", async () => {
+    mockPost.mockResolvedValue({
+      data: { id: "sec_1", name: "OPENAI_API_KEY" },
+    });
+
+    const client = new EgressSecrets(makeHttp());
+    const secret = await client.set({
+      name: "OPENAI_API_KEY",
+      value: "sk-abc123",
+      type: "api_key",
+      scope: "user",
+      exposeAsEnv: "OPENAI_API_KEY",
+    });
+
+    expect(mockPost).toHaveBeenCalledWith("/egress/secrets", {
+      name: "OPENAI_API_KEY",
+      value: "sk-abc123",
+      type: "api_key",
+      scope: "user",
+      expose_as_env: "OPENAI_API_KEY",
+    });
+    expect(secret.id).toBe("sec_1");
+  });
+
+  it("list({ scope: 'user' }) GETs /egress/secrets?scope=user", async () => {
+    mockGet.mockResolvedValue({ data: [{ id: "sec_1" }, { id: "sec_2" }] });
+
+    const result = await new EgressSecrets(makeHttp()).list({ scope: "user" });
+
+    expect(mockGet).toHaveBeenCalledWith("/egress/secrets", { scope: "user" });
+    expect(result).toHaveLength(2);
+  });
+
+  it("get() calls /egress/secrets/:id", async () => {
+    mockGet.mockResolvedValue({ data: { id: "sec_1" } });
+    await new EgressSecrets(makeHttp()).get("sec_1");
+    expect(mockGet).toHaveBeenCalledWith("/egress/secrets/sec_1");
+  });
+
+  it("rotate() PATCHes /egress/secrets/:id with new value", async () => {
+    mockPatch.mockResolvedValue({ data: { id: "sec_1" } });
+    await new EgressSecrets(makeHttp()).rotate("sec_1", {
+      newValue: "sk-new",
+      expiresAt: "2027-01-01T00:00:00Z",
+    });
+    expect(mockPatch).toHaveBeenCalledWith("/egress/secrets/sec_1", {
+      value: "sk-new",
+      expires_at: "2027-01-01T00:00:00Z",
+    });
+  });
+
+  it("delete() DELETEs /egress/secrets/:id", async () => {
+    mockDelete.mockResolvedValue(undefined);
+    await new EgressSecrets(makeHttp()).delete("sec_1");
+    expect(mockDelete).toHaveBeenCalledWith("/egress/secrets/sec_1");
+  });
+
+  it("connect() returns an OAuthFlow with authorizeUrl + state", async () => {
+    mockPost.mockResolvedValue({
+      data: {
+        authorize_url: "https://github.com/login/oauth/authorize?state=xyz",
+        state: "xyz",
+      },
+    });
+
+    const flow = await new EgressSecrets(makeHttp()).connect({
+      provider: "github",
+      exposeAsEnv: "GITHUB_TOKEN",
+    });
+
+    expect(mockPost).toHaveBeenCalledWith("/egress/oauth/start", {
+      provider: "github",
+      expose_as_env: "GITHUB_TOKEN",
+    });
+    expect(flow).toBeInstanceOf(OAuthFlow);
+    expect(flow.authorizeUrl).toBe(
+      "https://github.com/login/oauth/authorize?state=xyz",
+    );
+    expect(flow.state).toBe("xyz");
+  });
+
+  it("OAuthFlow.waitForCompletion polls /egress/oauth/status", async () => {
+    mockPost.mockResolvedValue({
+      data: { authorize_url: "https://example.com", state: "xyz" },
+    });
+    mockGet.mockResolvedValueOnce({
+      data: { status: "completed", secret_id: "sec_new" },
+    });
+
+    const flow = await new EgressSecrets(makeHttp()).connect({
+      provider: "github",
+    });
+    const result = await flow.waitForCompletion({
+      timeoutSec: 2,
+      pollIntervalMs: 1,
+    });
+
+    expect(mockGet).toHaveBeenCalledWith("/egress/oauth/status", {
+      state: "xyz",
+    });
+    expect(result.status).toBe("completed");
+  });
+
+  it("createBinding() POSTs to /egress/bindings", async () => {
+    mockPost.mockResolvedValue({ data: { id: "bnd_1" } });
+    await new EgressSecrets(makeHttp()).createBinding({
+      secretId: "sec_1",
+      resourceId: "sbx_1",
+      resourceType: "sandbox",
+      exposeAsEnv: "OPENAI_API_KEY",
+    });
+    expect(mockPost).toHaveBeenCalledWith("/egress/bindings", {
+      secret_id: "sec_1",
+      resource_id: "sbx_1",
+      resource_type: "sandbox",
+      expose_as_env: "OPENAI_API_KEY",
+    });
+  });
+
+  it("providers() GETs /egress/oauth/providers", async () => {
+    mockGet.mockResolvedValue({
+      data: [{ name: "github" }, { name: "slack" }],
+    });
+    const out = await new EgressSecrets(makeHttp()).providers();
+    expect(mockGet).toHaveBeenCalledWith("/egress/oauth/providers");
+    expect(out).toHaveLength(2);
+  });
+});
+
+// ─── client.network ──────────────────────────────────────────────────────────
+
+describe("EgressNetwork", () => {
+  it("allow() POSTs to /egress/allowlist with effect=allow", async () => {
+    mockPost.mockResolvedValue({ data: { id: "rul_1" } });
+    await new EgressNetwork(makeHttp()).allow("api.openai.com", {
+      methods: ["GET", "POST"],
+      pathGlob: "/v1/*",
+    });
+    expect(mockPost).toHaveBeenCalledWith("/egress/allowlist", {
+      host: "api.openai.com",
+      effect: "allow",
+      methods: ["GET", "POST"],
+      path_glob: "/v1/*",
+    });
+  });
+
+  it("deny() POSTs with effect=deny", async () => {
+    mockPost.mockResolvedValue({ data: { id: "rul_2" } });
+    await new EgressNetwork(makeHttp()).deny("169.254.169.254");
+    expect(mockPost).toHaveBeenCalledWith("/egress/allowlist", {
+      host: "169.254.169.254",
+      effect: "deny",
+    });
+  });
+
+  it("lockdown() PATCHes /egress/policies with mode=enforce", async () => {
+    mockPatch.mockResolvedValue({ data: {} });
+    await new EgressNetwork(makeHttp()).lockdown();
+    expect(mockPatch).toHaveBeenCalledWith("/egress/policies", {
+      mode: "enforce",
+    });
+  });
+
+  it("observe() PATCHes /egress/policies with mode=audit_only", async () => {
+    mockPatch.mockResolvedValue({ data: {} });
+    await new EgressNetwork(makeHttp()).observe();
+    expect(mockPatch).toHaveBeenCalledWith("/egress/policies", {
+      mode: "audit_only",
+    });
+  });
+
+  it("suggestions() GETs /egress/audit/suggestions with resource_id", async () => {
+    mockGet.mockResolvedValue({ data: [] });
+    await new EgressNetwork(makeHttp()).suggestions({
+      resourceId: "sbx_1",
+      since: "1d",
+    });
+    expect(mockGet).toHaveBeenCalledWith("/egress/audit/suggestions", {
+      resource_id: "sbx_1",
+      since: "1d",
+    });
+  });
+
+  it("policies() GETs /egress/policies", async () => {
+    mockGet.mockResolvedValue({ data: [{ id: "pol_1" }] });
+    const out = await new EgressNetwork(makeHttp()).policies();
+    expect(mockGet).toHaveBeenCalledWith("/egress/policies", {});
+    expect(out).toHaveLength(1);
+  });
+
+  it("removeRule() DELETEs /egress/allowlist/:id", async () => {
+    mockDelete.mockResolvedValue(undefined);
+    await new EgressNetwork(makeHttp()).removeRule("rul_1");
+    expect(mockDelete).toHaveBeenCalledWith("/egress/allowlist/rul_1");
+  });
+});
+
+// ─── client.audit ────────────────────────────────────────────────────────────
+
+describe("EgressAudit", () => {
+  it("list() GETs /egress/audit", async () => {
+    mockGet.mockResolvedValue({
+      data: [
+        { id: "evt_1", host: "api.openai.com" },
+        { id: "evt_2", host: "github.com" },
+      ],
+    });
+    const out = await new EgressAudit(makeHttp()).list();
+    expect(mockGet).toHaveBeenCalledWith("/egress/audit", {});
+    expect(out).toHaveLength(2);
+  });
+
+  it("list() passes filters as query params", async () => {
+    mockGet.mockResolvedValue({ data: [] });
+    await new EgressAudit(makeHttp()).list({
+      resourceId: "sbx_1",
+      host: "api.openai.com",
+      action: "denied",
+      limit: 50,
+    });
+    expect(mockGet).toHaveBeenCalledWith("/egress/audit", {
+      resource_id: "sbx_1",
+      host: "api.openai.com",
+      action: "denied",
+      limit: 50,
+    });
+  });
+
+  it("get() returns a single event", async () => {
+    mockGet.mockResolvedValue({ data: { id: "evt_1" } });
+    const out = await new EgressAudit(makeHttp()).get("evt_1");
+    expect(mockGet).toHaveBeenCalledWith("/egress/audit/evt_1");
+    expect(out.id).toBe("evt_1");
+  });
+});
+
+// ─── sandbox.* scoped namespaces ─────────────────────────────────────────────
+
+describe("Sandbox-scoped egress", () => {
+  it("sandbox.secrets.set() injects resource_id + resource_type", async () => {
+    mockPost.mockResolvedValue({ data: { id: "sec_1" } });
+    await new SandboxSecrets(makeHttp(), "sbx_abc").set({
+      name: "OPENAI_API_KEY",
+      value: "sk-abc",
+    });
+    expect(mockPost).toHaveBeenCalledWith("/egress/secrets", {
+      name: "OPENAI_API_KEY",
+      value: "sk-abc",
+      type: "api_key",
+      scope: "user",
+      resource_id: "sbx_abc",
+      resource_type: "sandbox",
+    });
+  });
+
+  it("sandbox.audit.list() includes resource_id in query params", async () => {
+    mockGet.mockResolvedValue({ data: [] });
+    await new SandboxAudit(makeHttp(), "sbx_abc").list();
+    expect(mockGet).toHaveBeenCalledWith("/egress/audit", {
+      resource_id: "sbx_abc",
+      resource_type: "sandbox",
+    });
+  });
+
+  it("sandbox.network.allow() scopes the rule to the sandbox", async () => {
+    mockPost.mockResolvedValue({ data: { id: "rul_1" } });
+    await new SandboxNetwork(makeHttp(), "sbx_abc").allow("api.openai.com");
+    expect(mockPost).toHaveBeenCalledWith("/egress/allowlist", {
+      host: "api.openai.com",
+      effect: "allow",
+      resource_id: "sbx_abc",
+      resource_type: "sandbox",
+    });
+  });
+
+  it("sandbox.network.lockdown() scopes the policy patch", async () => {
+    mockPatch.mockResolvedValue({ data: {} });
+    await new SandboxNetwork(makeHttp(), "sbx_abc").lockdown();
+    expect(mockPatch).toHaveBeenCalledWith("/egress/policies", {
+      mode: "enforce",
+      resource_id: "sbx_abc",
+      resource_type: "sandbox",
+    });
+  });
+});