anyclaw 0.2.0

package/dist/adapters.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gateway Adapters
+ *
+ * Protocol translators for different claw gateway types.
+ * Each adapter knows how to send a message and parse the SSE stream
+ * from a specific type of local AI agent.
+ */
+export interface ChannelEvent {
+    type: "content" | "tool_call" | "tool_result" | "error";
+    data: Record<string, unknown>;
+}
+export interface GatewayAdapter {
+    name: string;
+    send(gatewayUrl: string, message: string, onEvent: (event: ChannelEvent) => void, signal?: AbortSignal): Promise<string>;
+}
+/**
+ * PaeanClaw / ZeroClaw adapter
+ * Both expose POST /api/chat with SSE response.
+ */
+export declare const clawAdapter: GatewayAdapter;
+/**
+ * OpenAI-compatible adapter
+ * For any endpoint that speaks POST /v1/chat/completions with SSE.
+ */
+export declare const openaiAdapter: GatewayAdapter;
+export declare function getAdapter(type: string): GatewayAdapter;

package/dist/adapters.js

@@ -0,0 +1,125 @@
+/**
+ * Gateway Adapters
+ *
+ * Protocol translators for different claw gateway types.
+ * Each adapter knows how to send a message and parse the SSE stream
+ * from a specific type of local AI agent.
+ */
+async function readSSEStream(body, handler) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            handler(line);
+        }
+    }
+}
+/**
+ * PaeanClaw / ZeroClaw adapter
+ * Both expose POST /api/chat with SSE response.
+ */
+export const clawAdapter = {
+    name: "claw",
+    async send(gatewayUrl, message, onEvent, signal) {
+        const url = `${gatewayUrl.replace(/\/$/, "")}/api/chat`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ message }),
+            signal,
+        });
+        if (!res.ok || !res.body) {
+            throw new Error(`Gateway error: HTTP ${res.status}`);
+        }
+        let fullContent = "";
+        await readSSEStream(res.body, (line) => {
+            if (!line.startsWith("data: "))
+                return;
+            try {
+                const event = JSON.parse(line.slice(6));
+                switch (event.type) {
+                    case "content":
+                        fullContent += event.text || "";
+                        onEvent({ type: "content", data: { text: event.text, partial: true } });
+                        break;
+                    case "tool_call":
+                        onEvent({ type: "tool_call", data: { name: event.name, id: event.name } });
+                        break;
+                    case "tool_result":
+                        onEvent({ type: "tool_result", data: { name: event.name, status: "completed" } });
+                        break;
+                    case "done":
+                        onEvent({ type: "content", data: { text: event.content || fullContent, partial: false } });
+                        break;
+                    case "error":
+                        onEvent({ type: "error", data: { error: event.error } });
+                        break;
+                }
+            }
+            catch {
+                // skip malformed lines
+            }
+        });
+        return fullContent;
+    },
+};
+/**
+ * OpenAI-compatible adapter
+ * For any endpoint that speaks POST /v1/chat/completions with SSE.
+ */
+export const openaiAdapter = {
+    name: "openai",
+    async send(gatewayUrl, message, onEvent, signal) {
+        const url = `${gatewayUrl.replace(/\/$/, "")}/v1/chat/completions`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: "default",
+                messages: [{ role: "user", content: message }],
+                stream: true,
+            }),
+            signal,
+        });
+        if (!res.ok || !res.body) {
+            throw new Error(`Gateway error: HTTP ${res.status}`);
+        }
+        let fullContent = "";
+        await readSSEStream(res.body, (line) => {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data: ") || trimmed === "data: [DONE]")
+                return;
+            try {
+                const chunk = JSON.parse(trimmed.slice(6));
+                const delta = chunk.choices?.[0]?.delta;
+                if (delta?.content) {
+                    fullContent += delta.content;
+                    onEvent({ type: "content", data: { text: delta.content, partial: true } });
+                }
+            }
+            catch {
+                // skip
+            }
+        });
+        return fullContent;
+    },
+};
+export function getAdapter(type) {
+    switch (type) {
+        case "claw":
+        case "paeanclaw":
+        case "zeroclaw":
+            return clawAdapter;
+        case "openai":
+            return openaiAdapter;
+        default:
+            return clawAdapter;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * AnyClaw CLI
+ *
+ * Multi-command toolkit for local AI agent gateways.
+ *
+ * Usage:
+ *   anyclaw                     Show help
+ *   anyclaw bridge [options]    Connect local gateway to AnyClaw relay
+ *   anyclaw install [variant]   Install a claw variant (paeanclaw, zeroclaw, etc.)
+ *   anyclaw status              Check locally running agent gateways
+ *   anyclaw version             Show version
+ */
+declare const VERSION = "0.2.0";
+declare const BANNER = "\n  \u2584\u2580\u2588 \u2588\u2584\u2591\u2588 \u2588\u2584\u2588 \u2588\u2580\u2580 \u2588\u2591\u2591 \u2584\u2580\u2588 \u2588\u2591\u2588\u2591\u2588\n  \u2588\u2580\u2588 \u2588\u2591\u2580\u2588 \u2591\u2588\u2591 \u2588\u2584\u2584 \u2588\u2584\u2584 \u2588\u2580\u2588 \u2580\u2584\u2580\u2584\u2580\n";
+declare function printHelp(): void;
+declare function main(): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * AnyClaw CLI
+ *
+ * Multi-command toolkit for local AI agent gateways.
+ *
+ * Usage:
+ *   anyclaw                     Show help
+ *   anyclaw bridge [options]    Connect local gateway to AnyClaw relay
+ *   anyclaw install [variant]   Install a claw variant (paeanclaw, zeroclaw, etc.)
+ *   anyclaw status              Check locally running agent gateways
+ *   anyclaw version             Show version
+ */
+const VERSION = "0.2.0";
+const BANNER = `
+  ▄▀█ █▄░█ █▄█ █▀▀ █░░ ▄▀█ █░█░█
+  █▀█ █░▀█ ░█░ █▄▄ █▄▄ █▀█ ▀▄▀▄▀
+`;
+function printHelp() {
+    console.log(BANNER);
+    console.log(`  AnyClaw CLI v${VERSION}`);
+    console.log(`  https://anyclaw.sh\n`);
+    console.log(`  Usage:`);
+    console.log(`    anyclaw <command> [options]\n`);
+    console.log(`  Commands:`);
+    console.log(`    bridge    Connect a local AI agent gateway to the AnyClaw relay`);
+    console.log(`    install   Install a claw variant (paeanclaw, zeroclaw, openclaw, nanoclaw)`);
+    console.log(`    status    Check locally running agent gateways`);
+    console.log(`    version   Show version info`);
+    console.log(`    help      Show this help message\n`);
+    console.log(`  Examples:`);
+    console.log(`    anyclaw bridge -g http://localhost:3007 -k ck_g_abc123`);
+    console.log(`    anyclaw install paeanclaw`);
+    console.log(`    anyclaw status\n`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0] || "help";
+    // Backward compat: if invoked as `anyclaw-bridge` (old bin name),
+    // or if first arg looks like a bridge flag, route to bridge
+    const invokedAs = process.argv[1]?.endsWith("anyclaw-bridge") ?? false;
+    const bridgeFlags = ["-g", "--gateway", "-k", "--key", "-t", "--type", "-s", "--service"];
+    const looksLikeBridge = invokedAs || bridgeFlags.includes(command);
+    if (looksLikeBridge) {
+        const { runBridge } = await import("./commands/bridge.js");
+        return runBridge(looksLikeBridge && !invokedAs ? args : args);
+    }
+    switch (command) {
+        case "bridge": {
+            const { runBridge } = await import("./commands/bridge.js");
+            return runBridge(args.slice(1));
+        }
+        case "install": {
+            const { runInstall } = await import("./commands/install.js");
+            return runInstall(args.slice(1));
+        }
+        case "status": {
+            const { runStatus } = await import("./commands/status.js");
+            return runStatus();
+        }
+        case "version":
+        case "--version":
+        case "-v":
+            console.log(`anyclaw v${VERSION}`);
+            break;
+        case "help":
+        case "--help":
+        case "-h":
+        default:
+            printHelp();
+            break;
+    }
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/commands/bridge.d.ts

@@ -0,0 +1 @@
+export declare function runBridge(args: string[]): Promise<void>;

package/dist/commands/bridge.js

@@ -0,0 +1,157 @@
+/**
+ * Bridge Command
+ *
+ * Connects a local AI agent gateway to the AnyClaw relay service.
+ * Polls for incoming messages, forwards them to the local gateway,
+ * and streams responses back through the relay.
+ */
+import { getAdapter } from "../adapters.js";
+import { pollRequests, claimRequest, pushEvents, completeRequest, } from "../relay.js";
+function parseArgs(args) {
+    const config = {
+        gatewayUrl: "http://localhost:3007",
+        gatewayType: "claw",
+        clawKey: "",
+        serviceUrl: "http://localhost:4777",
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case "--gateway":
+            case "-g":
+                config.gatewayUrl = args[++i];
+                break;
+            case "--type":
+            case "-t":
+                config.gatewayType = args[++i];
+                break;
+            case "--key":
+            case "-k":
+                config.clawKey = args[++i];
+                break;
+            case "--service":
+            case "-s":
+                config.serviceUrl = args[++i];
+                break;
+            case "--help":
+            case "-h":
+                printHelp();
+                process.exit(0);
+        }
+    }
+    config.clawKey = config.clawKey || process.env.CLAW_KEY || "";
+    config.serviceUrl =
+        config.serviceUrl || process.env.ANYCLAW_SERVICE_URL || "http://localhost:4777";
+    config.gatewayUrl =
+        config.gatewayUrl || process.env.GATEWAY_URL || "http://localhost:3007";
+    return config;
+}
+function printHelp() {
+    console.log(`
+  AnyClaw Bridge — connects your local AI agent to the AnyClaw relay
+
+  Usage:
+    anyclaw bridge --gateway <url> --key <clawkey> [options]
+
+  Options:
+    -g, --gateway <url>     Local agent gateway URL (default: http://localhost:3007)
+    -t, --type <type>       Gateway type: claw, paeanclaw, zeroclaw, openai (default: claw)
+    -k, --key <key>         ClawKey for relay authentication
+    -s, --service <url>     AnyClaw service URL (default: http://localhost:4777)
+    -h, --help              Show this help
+
+  Environment:
+    CLAW_KEY                ClawKey (alternative to --key)
+    ANYCLAW_SERVICE_URL     Service URL (alternative to --service)
+    GATEWAY_URL             Gateway URL (alternative to --gateway)
+
+  Examples:
+    anyclaw bridge -g http://localhost:3007 -k ck_g_abc123
+    anyclaw bridge -g http://localhost:42617 -t zeroclaw -k ck_p_xyz789
+`);
+}
+const MIN_POLL_MS = 500;
+const MAX_POLL_MS = 5000;
+const BACKOFF_FACTOR = 1.5;
+async function processRequest(relay, gatewayUrl, gatewayType, requestId, message) {
+    const claimed = await claimRequest(relay, requestId);
+    if (!claimed) {
+        console.log(`  [skip] Could not claim ${requestId}`);
+        return;
+    }
+    console.log(`  [run]  ${message.slice(0, 60)}${message.length > 60 ? "..." : ""}`);
+    const adapter = getAdapter(gatewayType);
+    const eventBatch = [];
+    const flush = async () => {
+        if (eventBatch.length === 0)
+            return;
+        const batch = eventBatch.splice(0);
+        await pushEvents(relay, requestId, batch);
+    };
+    try {
+        const fullContent = await adapter.send(gatewayUrl, message, (event) => {
+            eventBatch.push(event);
+            if (eventBatch.length >= 5 ||
+                event.type === "tool_call" ||
+                event.type === "tool_result") {
+                flush();
+            }
+        });
+        await flush();
+        await completeRequest(relay, requestId, { content: fullContent });
+        console.log(`  [done] ${requestId}`);
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        console.error(`  [err]  ${requestId}: ${errorMsg}`);
+        await flush();
+        await completeRequest(relay, requestId, { error: errorMsg });
+    }
+}
+export async function runBridge(args) {
+    const config = parseArgs(args);
+    if (!config.clawKey) {
+        console.error("Error: ClawKey is required. Use --key or set CLAW_KEY env var.");
+        console.error("Run with --help for usage.");
+        process.exit(1);
+    }
+    console.log(`\n  ▄▀█ █▄░█ █▄█ █▀▀ █░░ ▄▀█ █░█░█`);
+    console.log(`  █▀█ █░▀█ ░█░ █▄▄ █▄▄ █▀█ ▀▄▀▄▀`);
+    console.log(`\n  AnyClaw Bridge v0.2.0`);
+    console.log(`  Gateway:  ${config.gatewayUrl} (${config.gatewayType})`);
+    console.log(`  Service:  ${config.serviceUrl}`);
+    console.log(`  Key:      ${config.clawKey.slice(0, 8)}...`);
+    console.log(`\n  Waiting for messages from anyclaw.sh / anyclaw.dev ...\n`);
+    const relay = {
+        serviceUrl: config.serviceUrl,
+        clawKey: config.clawKey,
+    };
+    let pollInterval = MIN_POLL_MS;
+    let running = true;
+    process.on("SIGINT", () => {
+        console.log("\n  Bridge stopped.");
+        running = false;
+        process.exit(0);
+    });
+    while (running) {
+        try {
+            const pending = await pollRequests(relay);
+            if (pending.length > 0) {
+                pollInterval = MIN_POLL_MS;
+                for (const req of pending) {
+                    await processRequest(relay, config.gatewayUrl, config.gatewayType, req.requestId, req.message);
+                }
+            }
+            else {
+                pollInterval = Math.min(pollInterval * BACKOFF_FACTOR, MAX_POLL_MS);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes("ECONNREFUSED")) {
+                console.error(`  [poll] ${msg}`);
+            }
+            pollInterval = MAX_POLL_MS;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+}

package/dist/commands/install.d.ts

@@ -0,0 +1 @@
+export declare function runInstall(args: string[]): Promise<void>;

package/dist/commands/install.js

@@ -0,0 +1,111 @@
+/**
+ * Install Command
+ *
+ * Helps users install various claw variants: paeanclaw, zeroclaw, openclaw, nanoclaw.
+ * Detects available runtimes and suggests the best install method.
+ */
+import { execSync } from "child_process";
+const C = "\x1b[36m";
+const G = "\x1b[32m";
+const Y = "\x1b[33m";
+const R = "\x1b[31m";
+const B = "\x1b[1m";
+const D = "\x1b[0m";
+function has(cmd) {
+    try {
+        execSync(`command -v ${cmd}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function run(cmd) {
+    try {
+        execSync(cmd, { stdio: "inherit" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const VARIANTS = {
+    paeanclaw: {
+        name: "PaeanClaw",
+        description: "Ultra-minimal local AI agent runtime (~365 lines). MCP tools, web PWA, Telegram.",
+        methods: [
+            { runtime: "bun", command: "bun install -g --no-optional paeanclaw", check: () => has("bun") },
+            { runtime: "npm", command: "npm install -g paeanclaw", check: () => has("npm") },
+        ],
+    },
+    zeroclaw: {
+        name: "ZeroClaw",
+        description: "Rust-based AI agent runtime. Extremely low resource usage (<5MB RAM).",
+        methods: [
+            { runtime: "cargo", command: "cargo install zeroclaw", check: () => has("cargo") },
+            { runtime: "npm", command: "npm install -g zeroclaw", check: () => has("npm") },
+        ],
+    },
+    openclaw: {
+        name: "OpenClaw",
+        description: "Full-featured Python AI agent. 60+ tools, 16+ platforms, voice mode.",
+        methods: [
+            { runtime: "pip", command: "pip install openclaw", check: () => has("pip") || has("pip3") },
+            { runtime: "pipx", command: "pipx install openclaw", check: () => has("pipx") },
+        ],
+    },
+    nanoclaw: {
+        name: "NanoClaw",
+        description: "Container-isolated AI agent. Docker/Apple Container sandboxing.",
+        methods: [
+            { runtime: "docker", command: "docker pull nanoclaw/nanoclaw", check: () => has("docker") },
+            { runtime: "npm", command: "npm install -g nanoclaw", check: () => has("npm") },
+        ],
+    },
+};
+function printVariants() {
+    console.log(`\n  ${B}Available claw variants:${D}\n`);
+    for (const [key, v] of Object.entries(VARIANTS)) {
+        const runtimes = v.methods
+            .filter((m) => m.check())
+            .map((m) => m.runtime);
+        const available = runtimes.length > 0
+            ? `${G}available${D} (${runtimes.join(", ")})`
+            : `${Y}missing runtime${D}`;
+        console.log(`  ${C}${key.padEnd(12)}${D} ${v.name} — ${v.description}`);
+        console.log(`${"".padEnd(15)}${available}`);
+    }
+    console.log(`\n  Usage: ${B}anyclaw install <variant>${D}\n`);
+}
+export async function runInstall(args) {
+    const variant = args[0]?.toLowerCase();
+    if (!variant || variant === "--help" || variant === "-h") {
+        printVariants();
+        return;
+    }
+    const v = VARIANTS[variant];
+    if (!v) {
+        console.error(`${R}Unknown variant: ${variant}${D}`);
+        printVariants();
+        process.exit(1);
+    }
+    console.log(`\n  ${B}Installing ${v.name}${D}`);
+    console.log(`  ${v.description}\n`);
+    const method = v.methods.find((m) => m.check());
+    if (!method) {
+        const needed = v.methods.map((m) => m.runtime).join(" or ");
+        console.error(`${R}No compatible runtime found.${D} Install one of: ${needed}`);
+        process.exit(1);
+    }
+    console.log(`  ${C}▸${D} Using ${method.runtime}: ${B}${method.command}${D}\n`);
+    const ok = run(method.command);
+    if (ok) {
+        console.log(`\n  ${G}✓${D} ${v.name} installed successfully.`);
+        console.log(`  Run ${C}anyclaw status${D} to verify.\n`);
+    }
+    else {
+        console.error(`\n  ${R}✗${D} Installation failed. Try running the command manually:`);
+        console.error(`    ${method.command}\n`);
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function runStatus(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,79 @@
+/**
+ * Status Command
+ *
+ * Checks locally running AI agent gateways by probing common ports
+ * and checking for installed claw binaries.
+ */
+import { execSync } from "child_process";
+const C = "\x1b[36m";
+const G = "\x1b[32m";
+const Y = "\x1b[33m";
+const R = "\x1b[31m";
+const B = "\x1b[1m";
+const D = "\x1b[0m";
+const TARGETS = [
+    { name: "PaeanClaw", port: 3007, type: "claw", healthPath: "/" },
+    { name: "ZeroClaw", port: 42617, type: "claw", healthPath: "/" },
+    { name: "OpenAI-compat (LM Studio)", port: 1234, type: "openai", healthPath: "/v1/models" },
+    { name: "OpenAI-compat (vLLM)", port: 8080, type: "openai", healthPath: "/v1/models" },
+    { name: "Ollama", port: 11434, type: "openai", healthPath: "/v1/models" },
+];
+function has(cmd) {
+    try {
+        return execSync(`command -v ${cmd}`, { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function probe(port, path) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        const res = await fetch(`http://localhost:${port}${path}`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        return res.ok || res.status < 500;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runStatus() {
+    console.log(`\n  ${B}AnyClaw Status${D}\n`);
+    // Check installed binaries
+    console.log(`  ${B}Installed:${D}`);
+    const bins = [
+        { cmd: "paeanclaw", label: "PaeanClaw" },
+        { cmd: "zeroclaw", label: "ZeroClaw" },
+        { cmd: "openclaw", label: "OpenClaw" },
+        { cmd: "nanoclaw", label: "NanoClaw" },
+    ];
+    let anyInstalled = false;
+    for (const b of bins) {
+        const location = has(b.cmd);
+        if (location) {
+            console.log(`    ${G}●${D} ${b.label.padEnd(14)} ${C}${location}${D}`);
+            anyInstalled = true;
+        }
+    }
+    if (!anyInstalled) {
+        console.log(`    ${Y}(none found)${D}  Run ${C}anyclaw install${D} to get started.`);
+    }
+    // Probe ports
+    console.log(`\n  ${B}Running Gateways:${D}`);
+    let anyRunning = false;
+    for (const target of TARGETS) {
+        const running = await probe(target.port, target.healthPath);
+        if (running) {
+            console.log(`    ${G}●${D} ${target.name.padEnd(28)} ${C}:${target.port}${D}  (${target.type})`);
+            anyRunning = true;
+        }
+    }
+    if (!anyRunning) {
+        console.log(`    ${R}●${D} No running gateways detected.`);
+        console.log(`      Start a gateway, e.g.: ${C}paeanclaw${D} or ${C}zeroclaw${D}`);
+    }
+    console.log("");
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * AnyClaw Bridge
+ *
+ * Standalone sidecar that connects ANY local AI agent gateway
+ * to the AnyClaw relay service. Zero modification to the agent required.
+ *
+ * Usage:
+ *   anyclaw-bridge --gateway http://localhost:3007 --key ck_g_xxx
+ *   anyclaw-bridge --gateway http://localhost:42617 --type zeroclaw --key ck_p_xxx
+ *   anyclaw-bridge --gateway http://localhost:8080 --type openai --key ck_g_xxx
+ */
+import { getAdapter } from "./adapters.js";
+import { pollRequests, claimRequest, pushEvents, completeRequest, } from "./relay.js";
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = {
+        gatewayUrl: "http://localhost:3007",
+        gatewayType: "claw",
+        clawKey: "",
+        serviceUrl: "http://localhost:4777",
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case "--gateway":
+            case "-g":
+                config.gatewayUrl = args[++i];
+                break;
+            case "--type":
+            case "-t":
+                config.gatewayType = args[++i];
+                break;
+            case "--key":
+            case "-k":
+                config.clawKey = args[++i];
+                break;
+            case "--service":
+            case "-s":
+                config.serviceUrl = args[++i];
+                break;
+            case "--help":
+            case "-h":
+                printHelp();
+                process.exit(0);
+        }
+    }
+    config.clawKey = config.clawKey || process.env.CLAW_KEY || "";
+    config.serviceUrl =
+        config.serviceUrl || process.env.ANYCLAW_SERVICE_URL || "http://localhost:4777";
+    config.gatewayUrl =
+        config.gatewayUrl || process.env.GATEWAY_URL || "http://localhost:3007";
+    return config;
+}
+function printHelp() {
+    console.log(`
+  AnyClaw Bridge — connects your local AI agent to the AnyClaw relay
+
+  Usage:
+    anyclaw-bridge --gateway <url> --key <clawkey> [options]
+
+  Options:
+    -g, --gateway <url>     Local agent gateway URL (default: http://localhost:3007)
+    -t, --type <type>       Gateway type: claw, paeanclaw, zeroclaw, openai (default: claw)
+    -k, --key <key>         ClawKey for relay authentication
+    -s, --service <url>     AnyClaw service URL (default: http://localhost:4777)
+    -h, --help              Show this help
+
+  Environment:
+    CLAW_KEY                ClawKey (alternative to --key)
+    ANYCLAW_SERVICE_URL     Service URL (alternative to --service)
+    GATEWAY_URL             Gateway URL (alternative to --gateway)
+
+  Examples:
+    anyclaw-bridge -g http://localhost:3007 -k ck_g_abc123
+    anyclaw-bridge -g http://localhost:42617 -t zeroclaw -k ck_p_xyz789
+`);
+}
+// ── Bridge Loop ────────────────────────────────────────
+const MIN_POLL_MS = 500;
+const MAX_POLL_MS = 5000;
+const BACKOFF_FACTOR = 1.5;
+async function processRequest(relay, gatewayUrl, gatewayType, requestId, message) {
+    const claimed = await claimRequest(relay, requestId);
+    if (!claimed) {
+        console.log(`  [skip] Could not claim ${requestId}`);
+        return;
+    }
+    console.log(`  [run]  ${message.slice(0, 60)}${message.length > 60 ? "..." : ""}`);
+    const adapter = getAdapter(gatewayType);
+    const eventBatch = [];
+    const flush = async () => {
+        if (eventBatch.length === 0)
+            return;
+        const batch = eventBatch.splice(0);
+        await pushEvents(relay, requestId, batch);
+    };
+    try {
+        const fullContent = await adapter.send(gatewayUrl, message, (event) => {
+            eventBatch.push(event);
+            if (eventBatch.length >= 5 ||
+                event.type === "tool_call" ||
+                event.type === "tool_result") {
+                flush();
+            }
+        });
+        await flush();
+        await completeRequest(relay, requestId, { content: fullContent });
+        console.log(`  [done] ${requestId}`);
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        console.error(`  [err]  ${requestId}: ${errorMsg}`);
+        await flush();
+        await completeRequest(relay, requestId, { error: errorMsg });
+    }
+}
+async function main() {
+    const config = parseArgs();
+    if (!config.clawKey) {
+        console.error("Error: ClawKey is required. Use --key or set CLAW_KEY env var.");
+        console.error("Run with --help for usage.");
+        process.exit(1);
+    }
+    console.log(`\n  ▄▀█ █▄░█ █▄█ █▀▀ █░░ ▄▀█ █░█░█`);
+    console.log(`  █▀█ █░▀█ ░█░ █▄▄ █▄▄ █▀█ ▀▄▀▄▀`);
+    console.log(`\n  AnyClaw Bridge v0.1.0`);
+    console.log(`  Gateway:  ${config.gatewayUrl} (${config.gatewayType})`);
+    console.log(`  Service:  ${config.serviceUrl}`);
+    console.log(`  Key:      ${config.clawKey.slice(0, 8)}...`);
+    console.log(`\n  Waiting for messages from anyclaw.sh / anyclaw.dev ...\n`);
+    const relay = {
+        serviceUrl: config.serviceUrl,
+        clawKey: config.clawKey,
+    };
+    let pollInterval = MIN_POLL_MS;
+    let running = true;
+    process.on("SIGINT", () => {
+        console.log("\n  Bridge stopped.");
+        running = false;
+        process.exit(0);
+    });
+    while (running) {
+        try {
+            const pending = await pollRequests(relay);
+            if (pending.length > 0) {
+                pollInterval = MIN_POLL_MS;
+                for (const req of pending) {
+                    await processRequest(relay, config.gatewayUrl, config.gatewayType, req.requestId, req.message);
+                }
+            }
+            else {
+                pollInterval = Math.min(pollInterval * BACKOFF_FACTOR, MAX_POLL_MS);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes("ECONNREFUSED")) {
+                console.error(`  [poll] ${msg}`);
+            }
+            pollInterval = MAX_POLL_MS;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/relay.d.ts

@@ -0,0 +1,15 @@
+export interface RelayConfig {
+    serviceUrl: string;
+    clawKey: string;
+}
+export interface PendingRequest {
+    requestId: string;
+    message: string;
+}
+export declare function pollRequests(config: RelayConfig): Promise<PendingRequest[]>;
+export declare function claimRequest(config: RelayConfig, requestId: string): Promise<boolean>;
+export declare function pushEvents(config: RelayConfig, requestId: string, events: unknown[]): Promise<void>;
+export declare function completeRequest(config: RelayConfig, requestId: string, result: {
+    content?: string;
+    error?: string;
+}): Promise<void>;

package/dist/relay.js

@@ -0,0 +1,49 @@
+/**
+ * Relay Client
+ *
+ * Communicates with the AnyClaw Service (or zero-api) relay.
+ * Polls for incoming messages, claims them, pushes events, completes.
+ */
+import crypto from "crypto";
+const SESSION_ID = crypto.randomBytes(8).toString("hex");
+async function relayFetch(config, path, options = {}) {
+    return fetch(`${config.serviceUrl.replace(/\/$/, "")}${path}`, {
+        headers: {
+            "Content-Type": "application/json",
+            "X-Claw-Key": config.clawKey,
+            ...options.headers,
+        },
+        ...options,
+    });
+}
+export async function pollRequests(config) {
+    const res = await relayFetch(config, "/claw/channel/poll", {
+        method: "POST",
+        body: JSON.stringify({ sessionId: SESSION_ID }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(`Poll failed: ${body.error || res.status}`);
+    }
+    const data = (await res.json());
+    return data.requests || [];
+}
+export async function claimRequest(config, requestId) {
+    const res = await relayFetch(config, `/claw/channel/claim/${requestId}`, {
+        method: "POST",
+        body: JSON.stringify({ sessionId: SESSION_ID }),
+    });
+    return res.ok;
+}
+export async function pushEvents(config, requestId, events) {
+    await relayFetch(config, `/claw/channel/events/${requestId}`, {
+        method: "POST",
+        body: JSON.stringify({ sessionId: SESSION_ID, events }),
+    });
+}
+export async function completeRequest(config, requestId, result) {
+    await relayFetch(config, `/claw/channel/complete/${requestId}`, {
+        method: "POST",
+        body: JSON.stringify({ sessionId: SESSION_ID, ...result }),
+    });
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "anyclaw",
+  "version": "0.2.0",
+  "description": "AnyClaw CLI — bridge, install, and manage local AI agent gateways",
+  "type": "module",
+  "bin": {
+    "anyclaw": "dist/cli.js",
+    "anyclaw-bridge": "dist/cli.js"
+  },
+  "main": "./dist/cli.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/cli.js",
+    "dev": "tsc && node dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "anyclaw",
+    "ai",
+    "agent",
+    "bridge",
+    "relay",
+    "mcp",
+    "paeanclaw",
+    "zeroclaw",
+    "openclaw",
+    "nanoclaw",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paean-ai/anyclaw.git",
+    "directory": "bridge"
+  },
+  "homepage": "https://anyclaw.sh",
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}