anyclaude-sdk 0.1.0

package/dist/workspace/memory.js

@@ -0,0 +1,97 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/**
+ * A pure in-memory FileSystem. Useful for tests and environments without a
+ * WebContainer. Does not implement CommandExecutor — pair it with a custom
+ * executor or `NoopCommandExecutor` if bash is not needed.
+ */
+export class MemoryFileSystem {
+    constructor() {
+        this.files = new Map();
+        this.dirs = new Set(['/']);
+    }
+    norm(path) {
+        const isAbs = path.startsWith('/');
+        const out = [];
+        for (const seg of path.split('/')) {
+            if (seg === '' || seg === '.')
+                continue;
+            if (seg === '..')
+                out.pop();
+            else
+                out.push(seg);
+        }
+        return (isAbs ? '/' : '') + out.join('/');
+    }
+    async readFile(path) {
+        const data = this.files.get(this.norm(path));
+        return data ? decoder.decode(data) : null;
+    }
+    async readBinary(path) {
+        return this.files.get(this.norm(path)) ?? null;
+    }
+    async writeFile(path, contents) {
+        await this.writeBinary(path, encoder.encode(contents));
+    }
+    async writeBinary(path, data) {
+        const p = this.norm(path);
+        this.files.set(p, data);
+        let dir = p.slice(0, p.lastIndexOf('/')) || '/';
+        while (dir && !this.dirs.has(dir)) {
+            this.dirs.add(dir);
+            dir = dir.slice(0, dir.lastIndexOf('/')) || '/';
+        }
+    }
+    async deleteFile(path) {
+        const p = this.norm(path);
+        this.files.delete(p);
+        for (const f of [...this.files.keys()]) {
+            if (f.startsWith(p + '/'))
+                this.files.delete(f);
+        }
+        this.dirs.delete(p);
+    }
+    async readdir(path) {
+        const p = this.norm(path);
+        if (!this.dirs.has(p) && p !== '/') {
+            // allow listing a dir that only exists implicitly via files
+            const hasChildren = [...this.files.keys(), ...this.dirs].some((k) => k.startsWith(p + '/'));
+            if (!hasChildren)
+                return null;
+        }
+        const prefix = p === '/' ? '/' : p + '/';
+        const names = new Map();
+        for (const f of this.files.keys()) {
+            if (f.startsWith(prefix)) {
+                const rest = f.slice(prefix.length);
+                const slash = rest.indexOf('/');
+                if (slash === -1)
+                    names.set(rest, false);
+                else
+                    names.set(rest.slice(0, slash), true);
+            }
+        }
+        for (const d of this.dirs) {
+            if (d.startsWith(prefix) && d !== p) {
+                const rest = d.slice(prefix.length);
+                const name = rest.split('/')[0];
+                if (name)
+                    names.set(name, true);
+            }
+        }
+        return [...names].map(([name, isDir]) => ({ name, isDir }));
+    }
+    async mkdir(path) {
+        let dir = this.norm(path);
+        while (dir && !this.dirs.has(dir)) {
+            this.dirs.add(dir);
+            dir = dir.slice(0, dir.lastIndexOf('/')) || '/';
+        }
+    }
+}
+/** A CommandExecutor that refuses to run anything — for FS-only workspaces. */
+export class NoopCommandExecutor {
+    async exec() {
+        return { output: 'bash is not available in this workspace', exitCode: 127 };
+    }
+}

package/dist/workspace/webcontainer.d.ts

@@ -0,0 +1,65 @@
+import type { CommandExecutor, FileSystem } from '../types/index.js';
+export interface WebContainerLike {
+    fs: {
+        readFile(path: string): Promise<Uint8Array>;
+        readFile(path: string, encoding: 'utf-8'): Promise<string>;
+        writeFile(path: string, data: string | Uint8Array): Promise<void>;
+        readdir(path: string, options?: {
+            withFileTypes?: boolean;
+        }): Promise<string[] | Array<{
+            name: string;
+            isDirectory(): boolean;
+        }>>;
+        mkdir(path: string, options?: {
+            recursive?: boolean;
+        }): Promise<void>;
+        rm(path: string, options?: {
+            recursive?: boolean;
+            force?: boolean;
+        }): Promise<void>;
+    };
+    spawn(command: string, args?: string[], options?: {
+        env?: Record<string, string>;
+        cwd?: string;
+    }): Promise<WebContainerProcess>;
+    workdir?: string;
+}
+export interface WebContainerProcess {
+    output: ReadableStream<string>;
+    exit: Promise<number>;
+    kill(): void;
+}
+/**
+ * Wraps a booted WebContainer instance, exposing the `FileSystem` and
+ * `CommandExecutor` interfaces the agent loop and tools depend on.
+ *
+ * All paths are resolved relative to `cwd` (default: the container workdir or
+ * "/home/projects" — the standard WebContainer mount point) when not absolute.
+ */
+export declare class WebContainerWorkspace implements FileSystem, CommandExecutor {
+    readonly wc: WebContainerLike;
+    readonly cwd: string;
+    constructor(wc: WebContainerLike, cwd?: string);
+    /** Resolve a possibly-relative path against the workspace cwd. */
+    resolve(path: string): string;
+    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>;
+    private ensureParent;
+    exec(command: string, timeoutMs?: number, env?: Record<string, string>): Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+}
+/**
+ * jsh is a constrained shell. Strip constructs it doesn't support so commands
+ * authored for a real bash shell still run (mirrors the spec's bash notes).
+ */
+export declare function sanitizeCommand(command: string): string;

package/dist/workspace/webcontainer.js

@@ -0,0 +1,156 @@
+const textDecoder = new TextDecoder();
+/**
+ * Wraps a booted WebContainer instance, exposing the `FileSystem` and
+ * `CommandExecutor` interfaces the agent loop and tools depend on.
+ *
+ * All paths are resolved relative to `cwd` (default: the container workdir or
+ * "/home/projects" — the standard WebContainer mount point) when not absolute.
+ */
+export class WebContainerWorkspace {
+    constructor(wc, cwd) {
+        this.wc = wc;
+        this.cwd = cwd ?? wc.workdir ?? '/home/projects';
+    }
+    /** Resolve a possibly-relative path against the workspace cwd. */
+    resolve(path) {
+        if (path.startsWith('/'))
+            return normalize(path);
+        const base = this.cwd.endsWith('/') ? this.cwd.slice(0, -1) : this.cwd;
+        return normalize(`${base}/${path}`);
+    }
+    // ---- FileSystem ----
+    async readFile(path) {
+        try {
+            return await this.wc.fs.readFile(this.resolve(path), 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    async readBinary(path) {
+        try {
+            return await this.wc.fs.readFile(this.resolve(path));
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeFile(path, contents) {
+        const resolved = this.resolve(path);
+        await this.ensureParent(resolved);
+        await this.wc.fs.writeFile(resolved, contents);
+    }
+    async writeBinary(path, data) {
+        const resolved = this.resolve(path);
+        await this.ensureParent(resolved);
+        await this.wc.fs.writeFile(resolved, data);
+    }
+    async deleteFile(path) {
+        await this.wc.fs.rm(this.resolve(path), { recursive: true, force: true });
+    }
+    async readdir(path) {
+        try {
+            const entries = await this.wc.fs.readdir(this.resolve(path), {
+                withFileTypes: true,
+            });
+            return entries.map((e) => ({
+                name: e.name,
+                isDir: e.isDirectory(),
+            }));
+        }
+        catch {
+            return null;
+        }
+    }
+    async mkdir(path) {
+        await this.wc.fs.mkdir(this.resolve(path), { recursive: true });
+    }
+    async ensureParent(resolvedPath) {
+        const idx = resolvedPath.lastIndexOf('/');
+        if (idx <= 0)
+            return;
+        const parent = resolvedPath.slice(0, idx);
+        try {
+            await this.wc.fs.mkdir(parent, { recursive: true });
+        }
+        catch {
+            // best-effort; writeFile will surface a real error if it matters
+        }
+    }
+    // ---- CommandExecutor ----
+    async exec(command, timeoutMs = 120_000, env) {
+        const sanitized = sanitizeCommand(command);
+        const proc = await this.wc.spawn('jsh', ['-c', sanitized], {
+            env,
+            cwd: this.cwd,
+        });
+        let output = '';
+        const reader = proc.output.getReader();
+        const collect = (async () => {
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                output += typeof value === 'string' ? value : textDecoder.decode(value);
+            }
+        })();
+        let timedOut = false;
+        let timer;
+        const timeout = new Promise((res) => {
+            timer = setTimeout(() => {
+                timedOut = true;
+                try {
+                    proc.kill();
+                }
+                catch {
+                    /* ignore */
+                }
+                res(124);
+            }, timeoutMs);
+        });
+        const exitCode = await Promise.race([proc.exit, timeout]);
+        if (timer)
+            clearTimeout(timer);
+        try {
+            await collect;
+        }
+        catch {
+            /* stream may close on kill */
+        }
+        reader.releaseLock?.();
+        if (timedOut) {
+            output += `\n[command timed out after ${timeoutMs}ms]`;
+        }
+        return { output: output.trimEnd(), exitCode };
+    }
+}
+/**
+ * jsh is a constrained shell. Strip constructs it doesn't support so commands
+ * authored for a real bash shell still run (mirrors the spec's bash notes).
+ */
+export function sanitizeCommand(command) {
+    return command
+        .replace(/\s*2>&1/g, '')
+        .replace(/\s*>\s*\/dev\/null(\s+2>&1)?/g, '')
+        .replace(/\s*2>\s*\/dev\/null/g, '')
+        .trim();
+}
+/** Collapse `.`/`..` segments and duplicate slashes in an absolute path. */
+function normalize(path) {
+    const isAbs = path.startsWith('/');
+    const out = [];
+    for (const seg of path.split('/')) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..') {
+            if (out.length && out[out.length - 1] !== '..')
+                out.pop();
+            else if (!isAbs)
+                out.push('..');
+        }
+        else {
+            out.push(seg);
+        }
+    }
+    return (isAbs ? '/' : '') + out.join('/');
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "anyclaude-sdk",
+  "version": "0.1.0",
+  "description": "Standalone, browser-compatible SDK providing Claude Code agent capabilities (tools, tool loop, multi-turn, MCP, sub-agents, sessions) against any OpenAI/Anthropic-compatible LLM endpoint. Runs in the browser (WebContainer), Node, and Bun — no backend required.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
+    "./query": { "types": "./dist/query.d.ts", "import": "./dist/query.js" },
+    "./workspace": { "types": "./dist/workspace/index.d.ts", "import": "./dist/workspace/index.js" },
+    "./sandbox": { "types": "./dist/sandbox/index.d.ts", "import": "./dist/sandbox/index.js" },
+    "./fs": { "types": "./dist/fs/index.d.ts", "import": "./dist/fs/index.js" },
+    "./llm": { "types": "./dist/llm/index.d.ts", "import": "./dist/llm/index.js" },
+    "./tools": { "types": "./dist/tools/index.d.ts", "import": "./dist/tools/index.js" },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "agent",
+    "agent-sdk",
+    "ai-agent",
+    "tool-use",
+    "webcontainer",
+    "browser",
+    "bun",
+    "llm",
+    "openai",
+    "anthropic",
+    "mcp"
+  ],
+  "license": "MIT",
+  "author": "Hans Ade <anye.happiness@swisslinkedu.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pipilot-dev/anyclaude-sdk.git"
+  },
+  "homepage": "https://github.com/pipilot-dev/anyclaude-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/pipilot-dev/anyclaude-sdk/issues"
+  },
+  "peerDependencies": {
+    "@cloudflare/sandbox": "*",
+    "@daytonaio/sdk": "*",
+    "@vercel/sandbox": "*",
+    "@webcontainer/api": ">=1.1.0",
+    "dexie": ">=3.2.0",
+    "e2b": "*"
+  },
+  "peerDependenciesMeta": {
+    "@webcontainer/api": { "optional": true },
+    "dexie": { "optional": true },
+    "e2b": { "optional": true },
+    "@vercel/sandbox": { "optional": true },
+    "@daytonaio/sdk": { "optional": true },
+    "@cloudflare/sandbox": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "comlink": "^4.4.2",
+    "dexie": "^4.4.4",
+    "typescript": "^5.4.0"
+  }
+}