@watasu/sdk 0.1.1 → 0.1.5

package/README.md

@@ -0,0 +1,45 @@
+# Watasu TypeScript SDK
+
+TypeScript SDK for Watasu.
+
+## Install
+
+```bash
+npm install @watasu/sdk
+```
+
+Set `WATASU_API_KEY` before using the SDK.
+
+## Usage
+
+```ts
+import { Sandbox } from '@watasu/sdk'
+
+const sbx = await Sandbox.create()
+await sbx.files.write('/home/user/a.js', 'console.log(2 + 2)')
+const result = await sbx.commands.run('node /home/user/a.js')
+console.log(result.stdout)
+console.log(await sbx.isRunning())
+await sbx.kill()
+```
+
+`Sandbox.create` and `Sandbox.connect` return only after the Watasu API supplies
+a usable data-plane session. The SDK does not poll sandbox readiness.
+
+## Metrics And Snapshots
+
+```ts
+import { Sandbox } from '@watasu/sdk'
+
+const sbx = await Sandbox.create()
+const metrics = await sbx.getMetrics()
+const snapshot = await sbx.createSnapshot({ name: 'ready' })
+const snapshots = await sbx.listSnapshots().nextItems()
+const restored = await sbx.restore({ snapshotId: snapshot.snapshotId })
+await sbx.kill()
+```
+
+Watasu snapshots are backed by sandbox checkpoints. Use the returned
+`snapshotId` when restoring from a checkpoint.
+
+The SDK is ESM-first and ships TypeScript declarations.

package/dist/connectionConfig.d.ts

@@ -3,6 +3,7 @@ export declare const SESSION_OPERATION_REQUEST_TIMEOUT_MS = 150000;
 /** Connection options accepted by Watasu SDK entrypoints. */
 export interface ConnectionOpts {
     apiKey?: string;
+    accessToken?: string;
     domain?: string;
     apiUrl?: string;
     dataPlaneDomain?: string;

package/dist/connectionConfig.js

@@ -11,7 +11,10 @@ export class ConnectionConfig {
     proxy;
     constructor(opts = {}) {
         const env = typeof process !== 'undefined' ? process.env : {};
-        this.apiKey = opts.apiKey ?? env.WATASU_API_KEY;
+        this.apiKey =
+            opts.apiKey ??
+                opts.accessToken ??
+                env.WATASU_API_KEY;
         this.domain = opts.domain ?? env.WATASU_DOMAIN ?? 'watasu.io';
         this.apiUrl =
             opts.apiUrl ?? env.WATASU_API_URL ?? `https://api.${this.domain}/v1`;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { ApiError, AuthenticationError, FileNotFoundError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, TimeoutError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
-export { Sandbox } from './sandbox.js';
-export type { SandboxCreateOpts, SandboxConnectOpts, SandboxInfo } from './sandbox.js';
+export { Sandbox, SnapshotPaginator } from './sandbox.js';
+export type { CreateSnapshotOpts, RestoreSnapshotOpts, SandboxCreateOpts, SandboxConnectOpts, SandboxInfo, SandboxMetrics, SnapshotInfo, } from './sandbox.js';
 export { CommandExitError, CommandHandle, Commands } from './commands.js';
 export type { CommandResult, CommandStartOpts, ProcessInfo } from './commands.js';
 export { FileType, Filesystem } from './filesystem.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 export { ApiError, AuthenticationError, FileNotFoundError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, TimeoutError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
-export { Sandbox } from './sandbox.js';
+export { Sandbox, SnapshotPaginator } from './sandbox.js';
 export { CommandExitError, CommandHandle, Commands } from './commands.js';
 export { FileType, Filesystem } from './filesystem.js';
 export { ProcessSocket, base64DecodeText, base64Encode } from './processSocket.js';

package/dist/sandbox.d.ts

@@ -11,13 +11,7 @@ export interface SandboxCreateOpts extends ConnectionOpts {
     envs?: Record<string, string>;
     secure?: boolean;
     allowInternetAccess?: boolean;
-    templateVersionId?: number | string;
     team?: string;
-    cpu?: number;
-    memoryMb?: number;
-    networkClass?: string;
-    allowPackageRegistryAccess?: boolean;
-    exposedPorts?: unknown[];
     mcp?: unknown;
     volumeMounts?: unknown;
 }
@@ -27,12 +21,52 @@ export interface SandboxConnectOpts extends ConnectionOpts {
 }
 export interface SandboxInfo {
     sandboxId: string;
-    templateVersionId?: number;
+    templateId?: string;
+    name?: string;
     state?: string;
     metadata: Record<string, string>;
     startedAt?: string;
     endAt?: string;
 }
+export interface SandboxMetrics {
+    sandboxId?: string;
+    state?: string;
+    node?: string;
+    backend?: string;
+    cpuCount?: number;
+    memoryMb?: number;
+    raw: Record<string, unknown>;
+}
+export interface SnapshotInfo {
+    snapshotId: string;
+    sandboxId?: string;
+    name?: string;
+    status?: string;
+    sizeBytes?: number;
+    createdAt?: string;
+    expiresAt?: string;
+    raw: Record<string, unknown>;
+}
+export interface CreateSnapshotOpts extends ConnectionOpts {
+    name?: string;
+    metadata?: Record<string, string>;
+    expiresAt?: string;
+    quiesceMode?: string;
+}
+export interface RestoreSnapshotOpts extends ConnectionOpts {
+    checkpointId?: string | number;
+    snapshotId?: string | number;
+    timeout?: number;
+    timeoutMs?: number;
+}
+export declare class SnapshotPaginator {
+    private readonly loadItems;
+    private consumed;
+    hasNext: boolean;
+    nextToken: string | undefined;
+    constructor(loadItems: () => Promise<SnapshotInfo[]>);
+    nextItems(): Promise<SnapshotInfo[]>;
+}
 /** Running Watasu sandbox with ready `files` and `commands` helpers. */
 export declare class Sandbox {
     /** Default template slug used when create is called without a template. */
@@ -48,6 +82,7 @@ export declare class Sandbox {
     };
     private readonly config;
     private readonly control;
+    private readonly envs;
     private dataPlane;
     private sandbox;
     constructor(opts: {
@@ -66,8 +101,20 @@ export declare class Sandbox {
     connect(opts?: SandboxConnectOpts): Promise<this>;
     /** Destroy a sandbox by id. */
     static kill(sandboxId: string, opts?: ConnectionOpts): Promise<boolean>;
+    /** Fetch sandbox metrics by id. */
+    static getMetrics(sandboxId: string, opts?: ConnectionOpts): Promise<SandboxMetrics[]>;
+    /** Deprecated alias for `getInfo`. */
+    static getFullInfo(sandboxId: string, opts?: ConnectionOpts): Promise<SandboxInfo>;
+    /** Create a Watasu checkpoint using snapshot naming. */
+    static createSnapshot(sandboxId: string, opts?: CreateSnapshotOpts): Promise<SnapshotInfo>;
+    /** List checkpoints for one sandbox using snapshot naming. */
+    static listSnapshots(sandboxId: string, opts?: ConnectionOpts): SnapshotPaginator;
+    /** Snapshot deletion is not backed by a Watasu checkpoint delete API yet. */
+    static deleteSnapshot(..._args: unknown[]): never;
     /** Destroy this sandbox. */
     kill(): Promise<boolean>;
+    /** Check if this sandbox is in a runtime-active lifecycle state. */
+    isRunning(opts?: Pick<ConnectionOpts, 'requestTimeoutMs'>): Promise<boolean>;
     /** Set a sandbox's lifetime by id. */
     static setTimeout(sandboxId: string, timeoutMs: number, opts?: ConnectionOpts): Promise<void>;
     /** Set this sandbox's lifetime. */
@@ -76,15 +123,25 @@ export declare class Sandbox {
     static getInfo(sandboxId: string, opts?: ConnectionOpts): Promise<SandboxInfo>;
     /** Fetch the latest control-plane metadata for this sandbox. */
     getInfo(): Promise<SandboxInfo>;
+    /** Fetch latest sandbox metrics. */
+    getMetrics(opts?: ConnectionOpts): Promise<SandboxMetrics[]>;
+    /** Create a Watasu checkpoint using snapshot naming. */
+    createSnapshot(opts?: CreateSnapshotOpts): Promise<SnapshotInfo>;
+    /** Watasu-native alias for `createSnapshot`. */
+    checkpoint(opts?: CreateSnapshotOpts): Promise<SnapshotInfo>;
+    /** List checkpoints for this sandbox using snapshot naming. */
+    listSnapshots(opts?: ConnectionOpts): SnapshotPaginator;
+    /** Restore a checkpoint into a new sandbox and return its control-plane info. */
+    restore(opts?: RestoreSnapshotOpts | string | number): Promise<SandboxInfo>;
     /** List sandboxes visible to the configured API key. */
     static list(opts?: ConnectionOpts & {
         team?: string;
     }): Promise<SandboxInfo[]>;
     /** Return the public hostname for an exposed sandbox port. */
-    getHost(port: number): Promise<string>;
+    getHost(port: number): string;
+    updateNetwork(..._args: unknown[]): never;
     pause(): never;
+    betaPause(): never;
     resume(): never;
-    createSnapshot(): never;
-    checkpoint(): never;
-    restore(): never;
+    private configOptions;
 }

package/dist/sandbox.js

@@ -1,8 +1,24 @@
 import { Commands } from './commands.js';
 import { ConnectionConfig, SESSION_OPERATION_REQUEST_TIMEOUT_MS } from './connectionConfig.js';
 import { DataPlaneClient, ControlClient } from './transport.js';
-import { SandboxError, unsupported } from './errors.js';
+import { NotFoundError, SandboxError, unsupported } from './errors.js';
 import { Filesystem } from './filesystem.js';
+export class SnapshotPaginator {
+    loadItems;
+    consumed = false;
+    hasNext = true;
+    nextToken;
+    constructor(loadItems) {
+        this.loadItems = loadItems;
+    }
+    async nextItems() {
+        if (this.consumed)
+            throw new SandboxError('No more snapshots to fetch');
+        this.consumed = true;
+        this.hasNext = false;
+        return this.loadItems();
+    }
+}
 /** Running Watasu sandbox with ready `files` and `commands` helpers. */
 export class Sandbox {
     /** Default template slug used when create is called without a template. */
@@ -14,17 +30,19 @@ export class Sandbox {
     git = { clone: () => unsupported('sandbox.git') };
     config;
     control;
+    envs;
     dataPlane;
     sandbox;
     constructor(opts) {
         this.sandboxId = String(opts.sandboxId);
         this.config = opts.connectionConfig;
         this.control = opts.control ?? new ControlClient(this.config);
+        this.envs = opts.envs ?? {};
         this.sandbox = opts.sandbox ?? {};
         const dataPlane = dataPlaneFromSession(opts.session, this.config);
         this.dataPlane = dataPlane;
         this.files = new Filesystem(dataPlane);
-        this.commands = new Commands(dataPlane, this.config, opts.envs ?? {});
+        this.commands = new Commands(dataPlane, this.config, this.envs);
     }
     /** Create a sandbox and return it only after the API supplies a data-plane session. */
     static async create(templateOrOpts, opts = {}) {
@@ -39,20 +57,16 @@ export class Sandbox {
         const config = new ConnectionConfig(sandboxOpts);
         const control = new ControlClient(config);
         const sandboxPayload = {
-            template,
-            timeout_seconds: Math.ceil((sandboxOpts.timeoutMs ?? 300_000) / 1000),
+            template_id: template,
+            timeout: Math.ceil((sandboxOpts.timeoutMs ?? 300_000) / 1000),
             metadata: sandboxOpts.metadata ?? {},
+            env_vars: sandboxOpts.envs ?? {},
+            secure: sandboxOpts.secure ?? true,
             allow_internet_access: sandboxOpts.allowInternetAccess ?? true,
         };
-        putIfPresent(sandboxPayload, 'template_version_id', sandboxOpts.templateVersionId);
         putIfPresent(sandboxPayload, 'team', sandboxOpts.team);
-        putIfPresent(sandboxPayload, 'cpu', sandboxOpts.cpu);
-        putIfPresent(sandboxPayload, 'memory_mb', sandboxOpts.memoryMb);
-        putIfPresent(sandboxPayload, 'network_class', sandboxOpts.networkClass);
-        putIfPresent(sandboxPayload, 'allow_package_registry_access', sandboxOpts.allowPackageRegistryAccess);
-        putIfPresent(sandboxPayload, 'exposed_ports', sandboxOpts.exposedPorts);
         const response = await control.post('/sandboxes', {
-            json: { sandbox: sandboxPayload },
+            json: sandboxPayload,
             requestTimeoutMs: sessionOperationRequestTimeout(config, sandboxOpts),
         });
         const sandbox = record(response.sandbox ?? response);
@@ -74,7 +88,7 @@ export class Sandbox {
         const control = new ControlClient(config);
         const info = await control.get(`/sandboxes/${sandboxId}`);
         const response = await control.post(`/sandboxes/${sandboxId}/connect`, {
-            json: { connect: opts.timeoutMs ? { timeout_seconds: Math.ceil(opts.timeoutMs / 1000) } : {} },
+            json: opts.timeoutMs ? { timeout: Math.ceil(opts.timeoutMs / 1000) } : {},
             requestTimeoutMs: sessionOperationRequestTimeout(config, opts),
         });
         return new Sandbox({
@@ -88,14 +102,14 @@ export class Sandbox {
     /** Refresh this sandbox's data-plane session in place. */
     async connect(opts = {}) {
         const response = await this.control.post(`/sandboxes/${this.sandboxId}/connect`, {
-            json: { connect: opts.timeoutMs ? { timeout_seconds: Math.ceil(opts.timeoutMs / 1000) } : {} },
+            json: opts.timeoutMs ? { timeout: Math.ceil(opts.timeoutMs / 1000) } : {},
             requestTimeoutMs: sessionOperationRequestTimeout(this.config, opts),
         });
         this.sandbox = record(response.sandbox ?? this.sandbox);
         const dataPlane = dataPlaneFromSession(response.session, this.config);
         this.dataPlane = dataPlane;
         this.files = new Filesystem(dataPlane);
-        this.commands = new Commands(dataPlane, this.config);
+        this.commands = new Commands(dataPlane, this.config, this.envs);
         return this;
     }
     /** Destroy a sandbox by id. */
@@ -104,22 +118,73 @@ export class Sandbox {
         await control.delete(`/sandboxes/${sandboxId}`);
         return true;
     }
+    /** Fetch sandbox metrics by id. */
+    static async getMetrics(sandboxId, opts = {}) {
+        const control = new ControlClient(new ConnectionConfig(opts));
+        const payload = await control.get(`/sandboxes/${sandboxId}/metrics`, {
+            requestTimeoutMs: opts.requestTimeoutMs,
+        });
+        return metricsList(payload.metrics ?? payload);
+    }
+    /** Deprecated alias for `getInfo`. */
+    static async getFullInfo(sandboxId, opts = {}) {
+        return this.getInfo(sandboxId, opts);
+    }
+    /** Create a Watasu checkpoint using snapshot naming. */
+    static async createSnapshot(sandboxId, opts = {}) {
+        const control = new ControlClient(new ConnectionConfig(opts));
+        const payload = await control.post(`/sandboxes/${sandboxId}/checkpoints`, {
+            json: snapshotPayload(opts),
+            requestTimeoutMs: opts.requestTimeoutMs,
+        });
+        return snapshotInfo(record(payload.sandbox_checkpoint ?? payload.snapshot ?? payload));
+    }
+    /** List checkpoints for one sandbox using snapshot naming. */
+    static listSnapshots(sandboxId, opts = {}) {
+        return new SnapshotPaginator(async () => {
+            const control = new ControlClient(new ConnectionConfig(opts));
+            const payload = await control.get(`/sandboxes/${sandboxId}/checkpoints`, {
+                requestTimeoutMs: opts.requestTimeoutMs,
+            });
+            const snapshots = Array.isArray(payload.sandbox_checkpoints) ? payload.sandbox_checkpoints : [];
+            return snapshots.map((item) => snapshotInfo(record(item)));
+        });
+    }
+    /** Snapshot deletion is not backed by a Watasu checkpoint delete API yet. */
+    static deleteSnapshot(..._args) {
+        unsupported('Sandbox.deleteSnapshot');
+    }
     /** Destroy this sandbox. */
     async kill() {
         await this.control.delete(`/sandboxes/${this.sandboxId}`);
         return true;
     }
+    /** Check if this sandbox is in a runtime-active lifecycle state. */
+    async isRunning(opts = {}) {
+        try {
+            const payload = await this.control.get(`/sandboxes/${this.sandboxId}`, {
+                requestTimeoutMs: opts.requestTimeoutMs,
+            });
+            const item = record(payload.sandbox ?? payload);
+            return ['creating', 'ready', 'checkpointing', 'restoring', 'stopping'].includes(String(item.state ?? ''));
+        }
+        catch (error) {
+            if (error instanceof NotFoundError)
+                return false;
+            throw error;
+        }
+    }
     /** Set a sandbox's lifetime by id. */
     static async setTimeout(sandboxId, timeoutMs, opts = {}) {
         const control = new ControlClient(new ConnectionConfig(opts));
-        await control.patch(`/sandboxes/${sandboxId}`, {
-            json: { sandbox: { timeout_seconds: Math.ceil(timeoutMs / 1000) } },
+        await control.post(`/sandboxes/${sandboxId}/timeout`, {
+            json: { timeout: Math.ceil(timeoutMs / 1000) },
         });
     }
     /** Set this sandbox's lifetime. */
     async setTimeout(timeoutMs) {
-        await this.control.patch(`/sandboxes/${this.sandboxId}`, {
-            json: { sandbox: { timeout_seconds: Math.ceil(timeoutMs / 1000) } },
+        await this.control.post(`/sandboxes/${this.sandboxId}/timeout`, {
+            json: { timeout: Math.ceil(timeoutMs / 1000) },
         });
     }
     /** Fetch control-plane metadata for a sandbox by id. */
@@ -133,6 +198,41 @@ export class Sandbox {
         const payload = await this.control.get(`/sandboxes/${this.sandboxId}`);
         return sandboxInfo(record(payload.sandbox ?? payload));
     }
+    /** Fetch latest sandbox metrics. */
+    async getMetrics(opts = {}) {
+        return Sandbox.getMetrics(this.sandboxId, { ...this.configOptions(), ...opts });
+    }
+    /** Create a Watasu checkpoint using snapshot naming. */
+    async createSnapshot(opts = {}) {
+        return Sandbox.createSnapshot(this.sandboxId, { ...this.configOptions(), ...opts });
+    }
+    /** Watasu-native alias for `createSnapshot`. */
+    async checkpoint(opts = {}) {
+        return this.createSnapshot(opts);
+    }
+    /** List checkpoints for this sandbox using snapshot naming. */
+    listSnapshots(opts = {}) {
+        return Sandbox.listSnapshots(this.sandboxId, { ...this.configOptions(), ...opts });
+    }
+    /** Restore a checkpoint into a new sandbox and return its control-plane info. */
+    async restore(opts = {}) {
+        const restoreOpts = typeof opts === 'string' || typeof opts === 'number'
+            ? { checkpointId: opts }
+            : opts;
+        const checkpointId = restoreOpts.checkpointId ?? restoreOpts.snapshotId;
+        if (checkpointId === undefined)
+            throw new SandboxError('checkpointId or snapshotId is required');
+        const payload = { checkpoint_id: checkpointId };
+        if (restoreOpts.timeout !== undefined)
+            payload.timeout_seconds = restoreOpts.timeout;
+        if (restoreOpts.timeoutMs !== undefined)
+            payload.timeout_seconds = Math.ceil(restoreOpts.timeoutMs / 1000);
+        const response = await this.control.post(`/sandboxes/${this.sandboxId}/restore`, {
+            json: payload,
+            requestTimeoutMs: restoreOpts.requestTimeoutMs,
+        });
+        return sandboxInfo(record(response.sandbox ?? response));
+    }
     /** List sandboxes visible to the configured API key. */
     static async list(opts = {}) {
         const control = new ControlClient(new ConnectionConfig(opts));
@@ -141,22 +241,26 @@ export class Sandbox {
         return sandboxes.map((item) => sandboxInfo(record(item)));
     }
     /** Return the public hostname for an exposed sandbox port. */
-    async getHost(port) {
-        const payload = await this.control.get(`/sandboxes/${this.sandboxId}/ports/${port}`);
-        const portInfo = record(payload.sandbox_port ?? payload.port ?? payload);
-        const value = portInfo.host ?? portInfo.url;
-        if (typeof value === 'string')
-            return hostOnly(value);
-        const routeToken = this.sandbox.route_token;
+    getHost(port) {
+        const routeToken = this.sandbox.route_token ??
+            this.sandbox.routeToken ??
+            routeTokenFromDataPlaneUrl(this.dataPlane.baseUrl, this.config.dataPlaneDomain);
         if (typeof routeToken !== 'string')
             throw new SandboxError('port response did not include host or url');
         return `p${port}-${routeToken}.sandbox.${this.config.dataPlaneDomain}`;
     }
+    updateNetwork(..._args) { unsupported('Sandbox.updateNetwork'); }
     pause() { unsupported('Sandbox.pause'); }
+    betaPause() { unsupported('Sandbox.betaPause'); }
     resume() { unsupported('Sandbox.resume'); }
-    createSnapshot() { unsupported('Sandbox.createSnapshot'); }
-    checkpoint() { unsupported('Sandbox.checkpoint'); }
-    restore() { unsupported('Sandbox.restore'); }
+    configOptions() {
+        return {
+            apiKey: this.config.apiKey,
+            apiUrl: this.config.apiUrl,
+            dataPlaneDomain: this.config.dataPlaneDomain,
+            requestTimeoutMs: this.config.requestTimeoutMs,
+        };
+    }
 }
 function dataPlaneFromSession(session, config) {
     const item = record(session);
@@ -177,13 +281,71 @@ function sessionOperationRequestTimeout(config, opts) {
 function sandboxInfo(payload) {
     return {
         sandboxId: String(payload.id ?? payload.sandbox_id ?? ''),
-        templateVersionId: typeof payload.template_version_id === 'number' ? payload.template_version_id : undefined,
+        templateId: typeof payload.template_id === 'string' ? payload.template_id : templateSlug(payload.template),
+        name: typeof payload.name === 'string' ? payload.name : undefined,
         state: typeof payload.state === 'string' ? payload.state : undefined,
         metadata: recordOfStrings(payload.metadata),
-        startedAt: typeof payload.created_at === 'string' ? payload.created_at : undefined,
-        endAt: typeof payload.deadline_at === 'string' ? payload.deadline_at : undefined,
+        startedAt: typeof payload.started_at === 'string'
+            ? payload.started_at
+            : typeof payload.created_at === 'string' ? payload.created_at : undefined,
+        endAt: typeof payload.end_at === 'string'
+            ? payload.end_at
+            : typeof payload.deadline_at === 'string' ? payload.deadline_at : undefined,
+    };
+}
+function metricsList(value) {
+    if (Array.isArray(value))
+        return value.map((item) => metricsInfo(record(item)));
+    return [metricsInfo(record(value))];
+}
+function metricsInfo(value) {
+    return {
+        sandboxId: stringValue(value.sandbox_id ?? value.sandboxId),
+        state: stringValue(value.state),
+        node: stringValue(value.node),
+        backend: stringValue(value.backend),
+        cpuCount: numberValue(value.cpu_count ?? value.cpuCount),
+        memoryMb: numberValue(value.memory_mb ?? value.memoryMb),
+        raw: value,
     };
 }
+function snapshotPayload(opts) {
+    const payload = {};
+    putIfPresent(payload, 'name', opts.name);
+    putIfPresent(payload, 'metadata', opts.metadata);
+    putIfPresent(payload, 'expires_at', opts.expiresAt);
+    putIfPresent(payload, 'quiesce_mode', opts.quiesceMode);
+    return payload;
+}
+function snapshotInfo(value) {
+    const id = value.snapshot_id ?? value.snapshotId ?? value.checkpoint_id ?? value.checkpointId ?? value.id;
+    if (id === undefined)
+        throw new SandboxError('snapshot response did not include id');
+    return {
+        snapshotId: String(id),
+        sandboxId: stringValue(value.sandbox_id ?? value.sandboxId),
+        name: stringValue(value.name),
+        status: stringValue(value.status),
+        sizeBytes: numberValue(value.size_bytes ?? value.sizeBytes),
+        createdAt: stringValue(value.created_at ?? value.createdAt),
+        expiresAt: stringValue(value.expires_at ?? value.expiresAt),
+        raw: value,
+    };
+}
+function stringValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return String(value);
+    return undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function templateSlug(value) {
+    const template = record(value);
+    return typeof template.slug === 'string' ? template.slug : undefined;
+}
 function putIfPresent(target, key, value) {
     if (value !== undefined && value !== null)
         target[key] = value;
@@ -201,3 +363,11 @@ function hostOnly(value) {
         return new URL(value).host;
     return value.split('/')[0];
 }
+function routeTokenFromDataPlaneUrl(value, dataPlaneDomain) {
+    const host = hostOnly(value);
+    const suffix = `.sandbox.${dataPlaneDomain}`;
+    if (!host.endsWith(suffix))
+        return undefined;
+    const token = host.slice(0, -suffix.length);
+    return token || undefined;
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@watasu/sdk",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "type": "module",
   "license": "MIT OR Apache-2.0",
-  "description": "TypeScript SDK for Watasu sandboxes",
+  "description": "TypeScript SDK for Watasu",
   "publishConfig": {
     "access": "public"
   },
@@ -28,5 +28,10 @@
     "@types/node": "^24.0.3",
     "@types/ws": "^8.18.1",
     "typescript": "^5.7.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/watasuio/sdk.git",
+    "directory": "ts"
   }
 }