anyclaude-sdk 0.1.0

package/dist/queue.d.ts

@@ -0,0 +1,23 @@
+import type { ContentBlockParam } from './types/index.js';
+export type QueuedContent = string | ContentBlockParam[];
+export interface QueuedMessage {
+    content: QueuedContent;
+    /** Epoch ms when enqueued. */
+    at: number;
+}
+export declare class MessageQueue {
+    private items;
+    private listeners;
+    /** Enqueue a user message to be delivered at the next turn boundary. */
+    push(content: QueuedContent): void;
+    /** Remove and return the oldest queued message (FIFO), or undefined if empty. */
+    shift(): QueuedMessage | undefined;
+    peek(): QueuedMessage | undefined;
+    get size(): number;
+    /** Snapshot of pending messages (does not drain). */
+    list(): readonly QueuedMessage[];
+    clear(): void;
+    /** Subscribe to size changes (push/shift/clear). Returns an unsubscribe fn. */
+    onChange(fn: (size: number) => void): () => void;
+    private emit;
+}

package/dist/queue.js

@@ -0,0 +1,43 @@
+export class MessageQueue {
+    constructor() {
+        this.items = [];
+        this.listeners = new Set();
+    }
+    /** Enqueue a user message to be delivered at the next turn boundary. */
+    push(content) {
+        this.items.push({ content, at: Date.now() });
+        this.emit();
+    }
+    /** Remove and return the oldest queued message (FIFO), or undefined if empty. */
+    shift() {
+        const m = this.items.shift();
+        if (m)
+            this.emit();
+        return m;
+    }
+    peek() {
+        return this.items[0];
+    }
+    get size() {
+        return this.items.length;
+    }
+    /** Snapshot of pending messages (does not drain). */
+    list() {
+        return this.items.slice();
+    }
+    clear() {
+        if (!this.items.length)
+            return;
+        this.items = [];
+        this.emit();
+    }
+    /** Subscribe to size changes (push/shift/clear). Returns an unsubscribe fn. */
+    onChange(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    emit() {
+        for (const fn of this.listeners)
+            fn(this.items.length);
+    }
+}

package/dist/sandbox/cloudflare.d.ts

@@ -0,0 +1,48 @@
+import type { CommandExecutor, FileSystem } from '../types/index.js';
+import type { Sandbox } from './types.js';
+interface CfExecResult {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+}
+interface CfFileEntry {
+    name: string;
+    isDir?: boolean;
+    type?: string;
+}
+export interface CloudflareClientLike {
+    exec(command: string, opts?: {
+        cwd?: string;
+    }): Promise<CfExecResult>;
+    readFile?(path: string): Promise<string | {
+        content?: string;
+    }>;
+    writeFile?(path: string, content: string): Promise<unknown>;
+    mkdir?(path: string, opts?: {
+        recursive?: boolean;
+    }): Promise<unknown>;
+    deleteFile?(path: string): Promise<unknown>;
+    listFiles?(path: string): Promise<CfFileEntry[]>;
+}
+export declare class CloudflareSandbox implements Sandbox, FileSystem, CommandExecutor {
+    private readonly client;
+    readonly cwd: string;
+    constructor(client: CloudflareClientLike, cwd?: string);
+    private r;
+    readFile(path: string): Promise<string | null>;
+    readBinary(path: string): Promise<Uint8Array | null>;
+    writeFile(path: string, contents: string): Promise<void>;
+    writeBinary(path: string, data: Uint8Array): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(path: string): Promise<void>;
+    exec(command: string, _timeoutMs?: number, _env?: Record<string, string>): Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+}
+export declare function createCloudflareSandbox(client: CloudflareClientLike, cwd?: string): CloudflareSandbox;
+export {};

package/dist/sandbox/cloudflare.js

@@ -0,0 +1,124 @@
+// Cloudflare Sandbox adapter.
+//
+// Wrap a `@cloudflare/sandbox` instance (Cloudflare Containers):
+//
+//   import { getSandbox } from '@cloudflare/sandbox'
+//   const sbx = getSandbox(env.Sandbox, 'my-session')
+//   const workspace = new CloudflareSandbox(sbx)
+//
+// Methods used:
+//   sbx.exec(command) -> { stdout, stderr, exitCode }
+//   sbx.readFile(path) -> string | { content: string }
+//   sbx.writeFile(path, content)
+//   sbx.mkdir(path, { recursive })
+//   sbx.deleteFile(path)
+//   sbx.listFiles(path)  (optional; falls back to `ls -1Ap` via exec)
+import { resolvePath } from '../util/paths.js';
+import { base64ToBytes, bytesToBase64, shellQuote } from './util.js';
+const encoder = new TextEncoder();
+export class CloudflareSandbox {
+    constructor(client, cwd = '/workspace') {
+        this.client = client;
+        this.cwd = cwd;
+    }
+    r(p) {
+        return resolvePath(this.cwd, p);
+    }
+    async readFile(path) {
+        const abs = this.r(path);
+        if (this.client.readFile) {
+            try {
+                const res = await this.client.readFile(abs);
+                if (typeof res === 'string')
+                    return res;
+                return res?.content ?? null;
+            }
+            catch {
+                return null;
+            }
+        }
+        const res = await this.client.exec(`cat ${shellQuote(abs)}`);
+        return (res.exitCode ?? 0) === 0 ? (res.stdout ?? '') : null;
+    }
+    async readBinary(path) {
+        // No portable native binary read; round-trip through base64 over exec.
+        const abs = this.r(path);
+        const res = await this.client.exec(`base64 ${shellQuote(abs)} | tr -d '\\n'`);
+        if ((res.exitCode ?? 0) !== 0) {
+            // Fall back to a text read if base64 is unavailable.
+            const text = await this.readFile(path);
+            return text === null ? null : encoder.encode(text);
+        }
+        try {
+            return base64ToBytes((res.stdout ?? '').trim());
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeFile(path, contents) {
+        const abs = this.r(path);
+        if (this.client.writeFile) {
+            await this.client.writeFile(abs, contents);
+            return;
+        }
+        await this.client.exec(`mkdir -p ${shellQuote(dir(abs))} && cat > ${shellQuote(abs)} <<'BCS_EOF'\n${contents}\nBCS_EOF`);
+    }
+    async writeBinary(path, data) {
+        const abs = this.r(path);
+        // base64-decode through the shell so arbitrary bytes survive.
+        const b64 = bytesToBase64(data);
+        const res = await this.client.exec(`mkdir -p ${shellQuote(dir(abs))} && printf %s ${shellQuote(b64)} | base64 -d > ${shellQuote(abs)}`);
+        if ((res.exitCode ?? 0) !== 0) {
+            throw new Error(`writeBinary failed: ${res.stderr ?? res.stdout ?? ''}`);
+        }
+    }
+    async deleteFile(path) {
+        const abs = this.r(path);
+        if (this.client.deleteFile) {
+            await this.client.deleteFile(abs);
+            return;
+        }
+        await this.client.exec(`rm -rf ${shellQuote(abs)}`);
+    }
+    async readdir(path) {
+        const abs = this.r(path);
+        if (this.client.listFiles) {
+            try {
+                const entries = await this.client.listFiles(abs);
+                return entries.map((e) => ({ name: e.name, isDir: e.isDir ?? e.type === 'dir' }));
+            }
+            catch {
+                return null;
+            }
+        }
+        const res = await this.client.exec(`ls -1Ap ${shellQuote(abs)}`);
+        if ((res.exitCode ?? 0) !== 0)
+            return null;
+        return (res.stdout ?? '')
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean)
+            .map((name) => name.endsWith('/') ? { name: name.slice(0, -1), isDir: true } : { name, isDir: false });
+    }
+    async mkdir(path) {
+        const abs = this.r(path);
+        if (this.client.mkdir) {
+            await this.client.mkdir(abs, { recursive: true });
+            return;
+        }
+        await this.client.exec(`mkdir -p ${shellQuote(abs)}`);
+    }
+    async exec(command, _timeoutMs, _env) {
+        const res = await this.client.exec(command, { cwd: this.cwd });
+        const out = (res.stdout ?? '') + (res.stderr ? '\n' + res.stderr : '');
+        return { output: out.trimEnd(), exitCode: res.exitCode ?? 0 };
+    }
+}
+function dir(p) {
+    const i = p.lastIndexOf('/');
+    return i <= 0 ? '/' : p.slice(0, i);
+}
+export function createCloudflareSandbox(client, cwd) {
+    return new CloudflareSandbox(client, cwd);
+}

package/dist/sandbox/daytona.d.ts

@@ -0,0 +1,48 @@
+import type { CommandExecutor, FileSystem } from '../types/index.js';
+import type { Sandbox } from './types.js';
+interface DaytonaFileInfo {
+    name: string;
+    isDir?: boolean;
+    isDirectory?: boolean;
+}
+interface DaytonaExecResult {
+    exitCode?: number;
+    result?: string;
+    artifacts?: {
+        stdout?: string;
+    };
+}
+export interface DaytonaClientLike {
+    fs: {
+        uploadFile(content: Uint8Array, destPath: string): Promise<unknown>;
+        downloadFile(path: string): Promise<Uint8Array | ArrayBuffer | string>;
+        listFiles(path: string): Promise<DaytonaFileInfo[]>;
+        deleteFile(path: string): Promise<unknown>;
+        createFolder(path: string, mode?: string): Promise<unknown>;
+    };
+    process: {
+        executeCommand(command: string, cwd?: string, env?: Record<string, string>, timeout?: number): Promise<DaytonaExecResult>;
+    };
+}
+export declare class DaytonaSandbox implements Sandbox, FileSystem, CommandExecutor {
+    private readonly client;
+    readonly cwd: string;
+    constructor(client: DaytonaClientLike, cwd?: string);
+    private r;
+    readBinary(path: string): Promise<Uint8Array | null>;
+    readFile(path: string): Promise<string | null>;
+    writeBinary(path: string, data: Uint8Array): Promise<void>;
+    writeFile(path: string, contents: string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(path: string): Promise<void>;
+    exec(command: string, timeoutMs?: number, env?: Record<string, string>): Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+}
+export declare function createDaytonaSandbox(client: DaytonaClientLike, cwd?: string): DaytonaSandbox;
+export {};

package/dist/sandbox/daytona.js

@@ -0,0 +1,79 @@
+// Daytona sandbox adapter.
+//
+// Wrap a Daytona `Sandbox` (from `@daytonaio/sdk`):
+//
+//   import { Daytona } from '@daytonaio/sdk'
+//   const daytona = new Daytona()
+//   const sbx = await daytona.create()
+//   const workspace = new DaytonaSandbox(sbx)
+//
+// Methods used:
+//   sbx.fs.uploadFile(content: Uint8Array, destPath)   // some SDK versions: (destPath, content)
+//   sbx.fs.downloadFile(path) -> Uint8Array
+//   sbx.fs.listFiles(path) -> FileInfo[] { name, isDir }
+//   sbx.fs.deleteFile(path)
+//   sbx.fs.createFolder(path, mode?)
+//   sbx.process.executeCommand(command, cwd?, env?, timeout?) -> { exitCode, result | artifacts.stdout }
+import { resolvePath } from '../util/paths.js';
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+export class DaytonaSandbox {
+    constructor(client, cwd = '/home/daytona') {
+        this.client = client;
+        this.cwd = cwd;
+    }
+    r(p) {
+        return resolvePath(this.cwd, p);
+    }
+    async readBinary(path) {
+        try {
+            const data = await this.client.fs.downloadFile(this.r(path));
+            if (data instanceof Uint8Array)
+                return data;
+            if (data instanceof ArrayBuffer)
+                return new Uint8Array(data);
+            if (typeof data === 'string')
+                return encoder.encode(data);
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async readFile(path) {
+        const bytes = await this.readBinary(path);
+        return bytes === null ? null : decoder.decode(bytes);
+    }
+    async writeBinary(path, data) {
+        await this.client.fs.uploadFile(data, this.r(path));
+    }
+    async writeFile(path, contents) {
+        await this.writeBinary(path, encoder.encode(contents));
+    }
+    async deleteFile(path) {
+        await this.client.fs.deleteFile(this.r(path));
+    }
+    async readdir(path) {
+        try {
+            const entries = await this.client.fs.listFiles(this.r(path));
+            return entries.map((e) => ({
+                name: e.name,
+                isDir: e.isDir ?? e.isDirectory ?? false,
+            }));
+        }
+        catch {
+            return null;
+        }
+    }
+    async mkdir(path) {
+        await this.client.fs.createFolder(this.r(path), '755');
+    }
+    async exec(command, timeoutMs, env) {
+        const res = await this.client.process.executeCommand(command, this.cwd, env, timeoutMs != null ? Math.ceil(timeoutMs / 1000) : undefined);
+        const out = res.result ?? res.artifacts?.stdout ?? '';
+        return { output: out.trimEnd(), exitCode: res.exitCode ?? 0 };
+    }
+}
+export function createDaytonaSandbox(client, cwd) {
+    return new DaytonaSandbox(client, cwd);
+}

package/dist/sandbox/e2b.d.ts

@@ -0,0 +1,54 @@
+import type { CommandExecutor, FileSystem } from '../types/index.js';
+import type { Sandbox } from './types.js';
+interface E2BEntry {
+    name: string;
+    type?: 'file' | 'dir';
+    isDir?: boolean;
+}
+interface E2BCommandResult {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+}
+export interface E2BClientLike {
+    files: {
+        read(path: string, opts?: {
+            format?: 'text' | 'bytes' | 'blob' | 'stream';
+        }): Promise<unknown>;
+        write(path: string, data: string | Uint8Array): Promise<unknown>;
+        list(path: string): Promise<E2BEntry[]>;
+        remove(path: string): Promise<unknown>;
+        makeDir(path: string): Promise<unknown>;
+    };
+    commands: {
+        run(cmd: string, opts?: {
+            timeoutMs?: number;
+            envs?: Record<string, string>;
+            cwd?: string;
+            background?: false;
+        }): Promise<E2BCommandResult>;
+    };
+}
+export declare class E2BSandbox implements Sandbox, FileSystem, CommandExecutor {
+    private readonly client;
+    readonly cwd: string;
+    constructor(client: E2BClientLike, cwd?: string);
+    private r;
+    readFile(path: string): Promise<string | null>;
+    readBinary(path: string): Promise<Uint8Array | null>;
+    writeFile(path: string, contents: string): Promise<void>;
+    writeBinary(path: string, data: Uint8Array): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(path: string): Promise<void>;
+    exec(command: string, timeoutMs?: number, env?: Record<string, string>): Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+}
+/** Convenience factory mirroring `new E2BSandbox(client, cwd)`. */
+export declare function createE2BSandbox(client: E2BClientLike, cwd?: string): E2BSandbox;
+export {};

package/dist/sandbox/e2b.js

@@ -0,0 +1,87 @@
+// E2B sandbox adapter.
+//
+// Wrap an E2B `Sandbox` (from the `e2b` or `@e2b/code-interpreter` package):
+//
+//   import { Sandbox } from 'e2b'
+//   const sbx = await Sandbox.create()
+//   const workspace = new E2BSandbox(sbx)
+//
+// Methods used (E2B JS SDK):
+//   sbx.files.read(path, { format })   // 'text' -> string, 'bytes' -> Uint8Array
+//   sbx.files.write(path, data)
+//   sbx.files.list(path)               // EntryInfo[] { name, type: 'file'|'dir' }
+//   sbx.files.remove(path)
+//   sbx.files.makeDir(path)
+//   sbx.commands.run(cmd, { timeoutMs, envs, cwd })  // { stdout, stderr, exitCode }
+import { resolvePath } from '../util/paths.js';
+const decoder = new TextDecoder();
+export class E2BSandbox {
+    constructor(client, cwd = '/home/user') {
+        this.client = client;
+        this.cwd = cwd;
+    }
+    r(p) {
+        return resolvePath(this.cwd, p);
+    }
+    async readFile(path) {
+        try {
+            const data = await this.client.files.read(this.r(path), { format: 'text' });
+            return typeof data === 'string' ? data : decoder.decode(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async readBinary(path) {
+        try {
+            const data = await this.client.files.read(this.r(path), { format: 'bytes' });
+            if (data instanceof Uint8Array)
+                return data;
+            if (data instanceof ArrayBuffer)
+                return new Uint8Array(data);
+            if (typeof data === 'string')
+                return new TextEncoder().encode(data);
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeFile(path, contents) {
+        await this.client.files.write(this.r(path), contents);
+    }
+    async writeBinary(path, data) {
+        await this.client.files.write(this.r(path), data);
+    }
+    async deleteFile(path) {
+        await this.client.files.remove(this.r(path));
+    }
+    async readdir(path) {
+        try {
+            const entries = await this.client.files.list(this.r(path));
+            return entries.map((e) => ({
+                name: e.name,
+                isDir: e.isDir ?? e.type === 'dir',
+            }));
+        }
+        catch {
+            return null;
+        }
+    }
+    async mkdir(path) {
+        await this.client.files.makeDir(this.r(path));
+    }
+    async exec(command, timeoutMs = 120_000, env) {
+        const res = await this.client.commands.run(command, {
+            timeoutMs,
+            envs: env,
+            cwd: this.cwd,
+        });
+        const out = (res.stdout ?? '') + (res.stderr ? '\n' + res.stderr : '');
+        return { output: out.trimEnd(), exitCode: res.exitCode ?? 0 };
+    }
+}
+/** Convenience factory mirroring `new E2BSandbox(client, cwd)`. */
+export function createE2BSandbox(client, cwd) {
+    return new E2BSandbox(client, cwd);
+}

package/dist/sandbox/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types.js';
+export { LocalSandbox, createLocalSandbox, detectPlatform, type Platform, type LocalSandboxOptions, } from './local.js';
+export { E2BSandbox, createE2BSandbox, type E2BClientLike } from './e2b.js';
+export { VercelSandbox, createVercelSandbox, type VercelClientLike } from './vercel.js';
+export { DaytonaSandbox, createDaytonaSandbox, type DaytonaClientLike } from './daytona.js';
+export { CloudflareSandbox, createCloudflareSandbox, type CloudflareClientLike, } from './cloudflare.js';
+export { WebContainerWorkspace, type WebContainerLike } from '../workspace/webcontainer.js';
+export { NoopCommandExecutor } from '../workspace/memory.js';

package/dist/sandbox/index.js

@@ -0,0 +1,19 @@
+// Sandbox providers — pluggable backends implementing the `Sandbox`
+// (FileSystem + CommandExecutor) interface.
+//
+// Supported: WebContainer, E2B, Vercel Sandbox, Daytona, Cloudflare Sandbox.
+// Each adapter wraps the provider's client structurally (no hard SDK dependency
+// — install only the provider you use). `composeWorkspace` mixes any FileSystem
+// with any CommandExecutor.
+export * from './types.js';
+export { LocalSandbox, createLocalSandbox, detectPlatform, } from './local.js';
+export { E2BSandbox, createE2BSandbox } from './e2b.js';
+export { VercelSandbox, createVercelSandbox } from './vercel.js';
+export { DaytonaSandbox, createDaytonaSandbox } from './daytona.js';
+export { CloudflareSandbox, createCloudflareSandbox, } from './cloudflare.js';
+// WebContainer lives in workspace/ but is re-exported here so every sandbox
+// provider is reachable from a single import.
+export { WebContainerWorkspace } from '../workspace/webcontainer.js';
+// NoopCommandExecutor (a CommandExecutor that refuses to run anything) pairs
+// with composeWorkspace for file-only agents.
+export { NoopCommandExecutor } from '../workspace/memory.js';

package/dist/sandbox/local.d.ts

@@ -0,0 +1,51 @@
+import type { Sandbox } from './types.js';
+export type Platform = 'windows' | 'mac' | 'linux' | 'unknown';
+/** Detect the host platform from process.platform. */
+export declare function detectPlatform(): Platform;
+export interface LocalSandboxOptions {
+    /** Working directory. Defaults to process.cwd(). */
+    cwd?: string;
+    /** Override the shell binary (default: cmd.exe on Windows, $SHELL or /bin/sh elsewhere). */
+    shell?: string;
+    /** Override shell args; the command string is appended as the final arg. */
+    shellArgs?: string[];
+    /** Extra environment variables merged over process.env. */
+    env?: Record<string, string>;
+}
+/**
+ * A Sandbox backed by the local OS filesystem and shell. Pair with an Anthropic/
+ * OpenAI client and pass to `query()` to run the agent on real files:
+ *
+ *   const workspace = new LocalSandbox({ cwd: '/path/to/project' })
+ *   query({ prompt, workspace, llm })
+ */
+export declare class LocalSandbox implements Sandbox {
+    readonly cwd: string;
+    readonly platform: Platform;
+    private opts;
+    private _fs?;
+    private _path?;
+    private _cp?;
+    constructor(options?: LocalSandboxOptions);
+    private fs;
+    private path;
+    private cp;
+    private resolve;
+    readFile(p: string): Promise<string | null>;
+    readBinary(p: string): Promise<Uint8Array | null>;
+    writeFile(p: string, contents: string): Promise<void>;
+    writeBinary(p: string, data: Uint8Array): Promise<void>;
+    deleteFile(p: string): Promise<void>;
+    readdir(p: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(p: string): Promise<void>;
+    exec(command: string, timeoutMs?: number, env?: Record<string, string>): Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+    /** Pick the shell + args for the detected platform (overridable via options). */
+    private shellFor;
+}
+export declare function createLocalSandbox(options?: LocalSandboxOptions): LocalSandbox;