@sealant/sdk 0.3.1 → 0.4.0

package/README.md

@@ -1,18 +1,18 @@
 # @sealant/sdk
 
-The fluent public SDK for Sealant — **create a sandbox, run a harness, replay the record.**
+The fluent public SDK for Sealant — **create a workspace, run a harness, replay the record.**
 
 ```ts
 import { Sealant, opencode } from "@sealant/sdk";
 
 const sealant = new Sealant({ baseUrl: "http://localhost:8080" });
 
-const sandbox = await sealant.sandboxes.create({
+const workspace = await sealant.workspaces.create({
   repository: "github.com/acme/billing-service",
   harness: opencode(),
 });
 
-const run = await sandbox.harness.run("Round invoice totals once, after applying the discount.");
+const run = await workspace.harness.run("Round invoice totals once, after applying the discount.");
 
 await run.record.replay();
 ```
@@ -31,11 +31,11 @@ await run.record.replay();
 
 ## Connected-account credentials
 
-Attach the caller's connected Claude / Codex / GitHub accounts to a sandbox so the harness
+Attach the caller's connected Claude / Codex / GitHub accounts to a workspace so the harness
 authenticates as that identity instead of running unauthenticated:
 
 ```ts
-const sandbox = await sealant.sandboxes.create({
+const workspace = await sealant.workspaces.create({
   repository: "github.com/acme/billing-service",
   harness: claudeCode(),
   credentials: { claude: true, github: "bot-account" },
@@ -50,12 +50,12 @@ and injects them at launch.
 
 ## Status
 
-The core loop is real: `sandboxes.create()`/`get()`/`list()`, `ready()`, blocking `harness.run()`
+The core loop is real: `workspaces.create()`/`get()`/`list()`, `ready()`, blocking `harness.run()`
 and non-blocking `harness.start()` (run execution happens server-side; the SDK is a thin HTTP
 client), `runs.get()`, and the record read surface — `replay()`, `timeline()`, `scrollback()`,
 `commands()`, `transcript()`, `stream()` (poll-backed), `loss()`, `summary()`, plus captured
 `changes` (files + diff) settled by `run()`/`wait()`.
 
 Still typed stubs pending their read models / endpoints: `artifacts.get()` and the time-travel folds
-`fileTreeAt()`/`processTreeAt()` (Phase 1), and `harness.session()` + sandbox lifecycle
+`fileTreeAt()`/`processTreeAt()` (Phase 1), and `harness.session()` + workspace lifecycle
 `stop()`/`restart()`/`expire()` (Phase 3).

package/dist/client.d.ts

@@ -1,16 +1,16 @@
-import type { CreateOptions, ListOptions, Run, Sandbox, SealantConfig } from "./types.js";
+import type { CreateOptions, ListOptions, Run, Workspace, SealantConfig } from "./types.js";
 export declare class Sealant {
     #private;
     constructor(config: SealantConfig);
     /** The configured control-plane base URL. */
     get baseUrl(): string;
-    /** Sandbox lifecycle: create, fetch, and list live environments. */
-    readonly sandboxes: {
-        create: (options: CreateOptions) => Promise<Sandbox>;
-        get: (id: string) => Promise<Sandbox>;
-        list: (options?: ListOptions | undefined) => Promise<readonly Sandbox[]>;
+    /** Workspace lifecycle: create, fetch, and list live environments. */
+    readonly workspaces: {
+        create: (options: CreateOptions) => Promise<Workspace>;
+        get: (id: string) => Promise<Workspace>;
+        list: (options?: ListOptions | undefined) => Promise<readonly Workspace[]>;
     };
-    /** Runs by id — so a record can be replayed long after its sandbox is gone. */
+    /** Runs by id — so a record can be replayed long after its workspace is gone. */
     readonly runs: {
         get: (runId: string) => Promise<Run>;
     };

package/dist/client.js

@@ -10,16 +10,16 @@
  * stable surface and reject with `SealantNotImplementedError` so callers can compile and wire
  * against the final shape today.
  */
-import { createSandboxOp, getRunOp, getSandboxOp, listSandboxesOp } from "./effect/operations.js";
+import { createWorkspaceOp, getRunOp, getWorkspaceOp, listWorkspacesOp, } from "./effect/operations.js";
 import { runHarness, startHarness } from "./effect/run-harness.js";
 import { makeSdkRuntime } from "./effect/runtime.js";
 import { SealantError } from "./errors.js";
 import { makeRun } from "./facade/run.js";
-import { makeSandbox, registerHarnessExecutors } from "./facade/sandbox.js";
-import { buildCreateSandboxRequest } from "./internal/blueprint.js";
+import { makeWorkspace, registerHarnessExecutors } from "./facade/workspace.js";
+import { buildCreateWorkspaceRequest } from "./internal/blueprint.js";
 import { resolveInternalConfig } from "./internal/config.js";
-// Wire the run-execution implementations into the Sandbox facade (the injection point exists to
-// break the sandbox <-> run-harness import cycle; the client is the composition root).
+// Wire the run-execution implementations into the Workspace facade (the injection point exists to
+// break the workspace <-> run-harness import cycle; the client is the composition root).
 registerHarnessExecutors({ run: runHarness, start: startHarness });
 export class Sealant {
     #config;
@@ -38,19 +38,19 @@ export class Sealant {
     get baseUrl() {
         return this.#config.baseUrl;
     }
-    /** Sandbox lifecycle: create, fetch, and list live environments. */
-    sandboxes = {
+    /** Workspace lifecycle: create, fetch, and list live environments. */
+    workspaces = {
         create: async (options) => {
-            const { payload } = buildCreateSandboxRequest(options, this.#ctx.config);
-            const created = await this.#runtime.run(createSandboxOp(payload));
-            const sandbox = makeSandbox(this.#ctx, {
-                id: created.sandboxId,
+            const { payload } = buildCreateWorkspaceRequest(options, this.#ctx.config);
+            const created = await this.#runtime.run(createWorkspaceOp(payload));
+            const workspace = makeWorkspace(this.#ctx, {
+                id: created.workspaceId,
                 name: created.name,
                 status: created.status,
                 harness: options.harness,
             });
             if (options.wait === false) {
-                return sandbox;
+                return workspace;
             }
             // Pump provisioning events to onEvent (best-effort) while we wait for ready. Never let an
             // event-stream hiccup fail create().
@@ -58,7 +58,7 @@ export class Sealant {
                 const onEvent = options.onEvent;
                 void (async () => {
                     try {
-                        for await (const event of sandbox.events()) {
+                        for await (const event of workspace.events()) {
                             onEvent(event);
                         }
                     }
@@ -67,30 +67,30 @@ export class Sealant {
                     }
                 })();
             }
-            return sandbox.ready();
+            return workspace.ready();
         },
         get: async (id) => {
-            const details = await this.#runtime.run(getSandboxOp(id));
-            return makeSandbox(this.#ctx, {
-                id: details.sandboxId,
+            const details = await this.#runtime.run(getWorkspaceOp(id));
+            return makeWorkspace(this.#ctx, {
+                id: details.workspaceId,
                 name: details.name,
                 status: details.status,
             });
         },
         list: async (options) => {
-            const response = await this.#runtime.run(listSandboxesOp({
+            const response = await this.#runtime.run(listWorkspacesOp({
                 ownerUserId: this.#ctx.config.hostLocal.ownerUserId,
                 ...(options?.status === undefined ? {} : { status: options.status }),
                 ...(options?.limit === undefined ? {} : { limit: String(options.limit) }),
             }));
-            return response.items.map((item) => makeSandbox(this.#ctx, {
-                id: item.sandboxId,
+            return response.items.map((item) => makeWorkspace(this.#ctx, {
+                id: item.workspaceId,
                 name: item.name,
                 status: item.status,
             }));
         },
     };
-    /** Runs by id — so a record can be replayed long after its sandbox is gone. */
+    /** Runs by id — so a record can be replayed long after its workspace is gone. */
     runs = {
         get: async (runId) => {
             const wire = await this.#runtime.run(getRunOp(runId));