multiclaws 0.4.41 → 0.4.43

package/dist/infra/gateway-client.d.ts

@@ -1,27 +1,27 @@
-export type GatewayConfig = {
-    port: number;
-    token: string;
-};
-export type InvokeToolResult = {
-    ok: boolean;
-    result?: unknown;
-    error?: {
-        type?: string;
-        message?: string;
-    };
-};
-/**
- * Call the local OpenClaw gateway's /tools/invoke endpoint.
- * Requires the tool to be allowed by gateway policy.
- *
- * Timeout is enforced via AbortController on the fetch call.
- * Circuit breaker tracks error rates per tool to fail fast on persistent failures.
- * p-retry handles transient errors with up to 2 retries.
- */
-export declare function invokeGatewayTool(params: {
-    gateway: GatewayConfig;
-    tool: string;
-    args?: Record<string, unknown>;
-    sessionKey?: string;
-    timeoutMs?: number;
-}): Promise<unknown>;
+export type GatewayConfig = {
+    port: number;
+    token: string;
+};
+export type InvokeToolResult = {
+    ok: boolean;
+    result?: unknown;
+    error?: {
+        type?: string;
+        message?: string;
+    };
+};
+/**
+ * Call the local OpenClaw gateway's /tools/invoke endpoint.
+ * Requires the tool to be allowed by gateway policy.
+ *
+ * Timeout is enforced via AbortController on the fetch call.
+ * Circuit breaker tracks error rates per tool to fail fast on persistent failures.
+ * p-retry handles transient errors with up to 2 retries.
+ */
+export declare function invokeGatewayTool(params: {
+    gateway: GatewayConfig;
+    tool: string;
+    args?: Record<string, unknown>;
+    sessionKey?: string;
+    timeoutMs?: number;
+}): Promise<unknown>;

package/dist/infra/gateway-client.js

@@ -1,136 +1,136 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.invokeGatewayTool = invokeGatewayTool;
-const opossum_1 = __importDefault(require("opossum"));
-class NonRetryableError extends Error {
-}
-const breakerCache = new Map();
-let pRetryModulePromise = null;
-async function loadPRetry() {
-    if (!pRetryModulePromise) {
-        pRetryModulePromise = Promise.resolve().then(() => __importStar(require("p-retry")));
-    }
-    return await pRetryModulePromise;
-}
-function getBreaker(key, timeoutMs) {
-    const existing = breakerCache.get(key);
-    if (existing) {
-        return existing;
-    }
-    const breaker = new opossum_1.default((operation) => operation(), {
-        timeout: false, // timeout handled by AbortController in the operation
-        errorThresholdPercentage: 50,
-        resetTimeout: 10_000,
-        volumeThreshold: 5,
-    });
-    breakerCache.set(key, breaker);
-    return breaker;
-}
-async function executeResilient(params) {
-    const pRetryModule = await loadPRetry();
-    const pRetry = pRetryModule.default;
-    const AbortError = pRetryModule.AbortError;
-    const breaker = getBreaker(params.key, params.timeoutMs);
-    return (await pRetry(async () => {
-        try {
-            return (await breaker.fire(params.operation));
-        }
-        catch (error) {
-            if (error instanceof NonRetryableError && AbortError) {
-                throw new AbortError(error.message);
-            }
-            throw error;
-        }
-    }, {
-        retries: 2,
-        factor: 2,
-        minTimeout: 150,
-        maxTimeout: 1200,
-        randomize: true,
-    }));
-}
-/**
- * Call the local OpenClaw gateway's /tools/invoke endpoint.
- * Requires the tool to be allowed by gateway policy.
- *
- * Timeout is enforced via AbortController on the fetch call.
- * Circuit breaker tracks error rates per tool to fail fast on persistent failures.
- * p-retry handles transient errors with up to 2 retries.
- */
-async function invokeGatewayTool(params) {
-    const url = `http://localhost:${params.gateway.port}/tools/invoke`;
-    const timeoutMs = params.timeoutMs ?? 8_000;
-    const key = `${params.gateway.port}:${params.tool}`;
-    return await executeResilient({
-        key,
-        timeoutMs,
-        operation: async () => {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), timeoutMs);
-            try {
-                const response = await fetch(url, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${params.gateway.token}`,
-                    },
-                    body: JSON.stringify({
-                        tool: params.tool,
-                        action: "json",
-                        args: params.args ?? {},
-                        sessionKey: params.sessionKey ?? "main",
-                    }),
-                    signal: controller.signal,
-                });
-                const json = (await response.json());
-                if (!response.ok || !json.ok) {
-                    const msg = json.error?.message ?? `HTTP ${response.status}`;
-                    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-                        throw new NonRetryableError(`invokeGatewayTool(${params.tool}) failed: ${msg}`);
-                    }
-                    throw new Error(`invokeGatewayTool(${params.tool}) failed: ${msg}`);
-                }
-                return json.result;
-            }
-            finally {
-                clearTimeout(timer);
-            }
-        },
-    });
-}
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeGatewayTool = invokeGatewayTool;
+const opossum_1 = __importDefault(require("opossum"));
+class NonRetryableError extends Error {
+}
+const breakerCache = new Map();
+let pRetryModulePromise = null;
+async function loadPRetry() {
+    if (!pRetryModulePromise) {
+        pRetryModulePromise = Promise.resolve().then(() => __importStar(require("p-retry")));
+    }
+    return await pRetryModulePromise;
+}
+function getBreaker(key, timeoutMs) {
+    const existing = breakerCache.get(key);
+    if (existing) {
+        return existing;
+    }
+    const breaker = new opossum_1.default((operation) => operation(), {
+        timeout: false, // timeout handled by AbortController in the operation
+        errorThresholdPercentage: 50,
+        resetTimeout: 10_000,
+        volumeThreshold: 5,
+    });
+    breakerCache.set(key, breaker);
+    return breaker;
+}
+async function executeResilient(params) {
+    const pRetryModule = await loadPRetry();
+    const pRetry = pRetryModule.default;
+    const AbortError = pRetryModule.AbortError;
+    const breaker = getBreaker(params.key, params.timeoutMs);
+    return (await pRetry(async () => {
+        try {
+            return (await breaker.fire(params.operation));
+        }
+        catch (error) {
+            if (error instanceof NonRetryableError && AbortError) {
+                throw new AbortError(error.message);
+            }
+            throw error;
+        }
+    }, {
+        retries: 2,
+        factor: 2,
+        minTimeout: 150,
+        maxTimeout: 1200,
+        randomize: true,
+    }));
+}
+/**
+ * Call the local OpenClaw gateway's /tools/invoke endpoint.
+ * Requires the tool to be allowed by gateway policy.
+ *
+ * Timeout is enforced via AbortController on the fetch call.
+ * Circuit breaker tracks error rates per tool to fail fast on persistent failures.
+ * p-retry handles transient errors with up to 2 retries.
+ */
+async function invokeGatewayTool(params) {
+    const url = `http://localhost:${params.gateway.port}/tools/invoke`;
+    const timeoutMs = params.timeoutMs ?? 8_000;
+    const key = `${params.gateway.port}:${params.tool}`;
+    return await executeResilient({
+        key,
+        timeoutMs,
+        operation: async () => {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(url, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${params.gateway.token}`,
+                    },
+                    body: JSON.stringify({
+                        tool: params.tool,
+                        action: "json",
+                        args: params.args ?? {},
+                        sessionKey: params.sessionKey ?? "main",
+                    }),
+                    signal: controller.signal,
+                });
+                const json = (await response.json());
+                if (!response.ok || !json.ok) {
+                    const msg = json.error?.message ?? `HTTP ${response.status}`;
+                    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                        throw new NonRetryableError(`invokeGatewayTool(${params.tool}) failed: ${msg}`);
+                    }
+                    throw new Error(`invokeGatewayTool(${params.tool}) failed: ${msg}`);
+                }
+                return json.result;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    });
+}

package/dist/infra/json-store.d.ts

@@ -1,4 +1,4 @@
-export declare function ensureJsonFile(filePath: string, fallback: unknown): Promise<void>;
-export declare function readJsonWithFallback<T>(filePath: string, fallback: T): Promise<T>;
-export declare function writeJsonAtomically(filePath: string, value: unknown): Promise<void>;
-export declare function withJsonLock<T>(filePath: string, fallback: unknown, fn: () => Promise<T>): Promise<T>;
+export declare function ensureJsonFile(filePath: string, fallback: unknown): Promise<void>;
+export declare function readJsonWithFallback<T>(filePath: string, fallback: T): Promise<T>;
+export declare function writeJsonAtomically(filePath: string, value: unknown): Promise<void>;
+export declare function withJsonLock<T>(filePath: string, fallback: unknown, fn: () => Promise<T>): Promise<T>;

package/dist/infra/json-store.js

@@ -1,57 +1,57 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureJsonFile = ensureJsonFile;
-exports.readJsonWithFallback = readJsonWithFallback;
-exports.writeJsonAtomically = writeJsonAtomically;
-exports.withJsonLock = withJsonLock;
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const node_path_1 = __importDefault(require("node:path"));
-const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
-const LOCK_OPTIONS = {
-    retries: {
-        retries: 10,
-        factor: 1.5,
-        minTimeout: 50,
-        maxTimeout: 1_000,
-        randomize: true,
-    },
-    stale: 10_000,
-};
-async function ensureJsonFile(filePath, fallback) {
-    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
-    try {
-        await promises_1.default.access(filePath);
-    }
-    catch {
-        await writeJsonAtomically(filePath, fallback);
-    }
-}
-async function readJsonWithFallback(filePath, fallback) {
-    try {
-        const content = await promises_1.default.readFile(filePath, "utf8");
-        return JSON.parse(content);
-    }
-    catch {
-        return fallback;
-    }
-}
-async function writeJsonAtomically(filePath, value) {
-    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
-    const tmp = `${filePath}.${process.pid}.${Date.now()}.${node_crypto_1.default.randomUUID()}.tmp`;
-    await promises_1.default.writeFile(tmp, JSON.stringify(value, null, 2), "utf8");
-    await promises_1.default.rename(tmp, filePath);
-}
-async function withJsonLock(filePath, fallback, fn) {
-    await ensureJsonFile(filePath, fallback);
-    const release = await proper_lockfile_1.default.lock(filePath, LOCK_OPTIONS);
-    try {
-        return await fn();
-    }
-    finally {
-        await release();
-    }
-}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureJsonFile = ensureJsonFile;
+exports.readJsonWithFallback = readJsonWithFallback;
+exports.writeJsonAtomically = writeJsonAtomically;
+exports.withJsonLock = withJsonLock;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_path_1 = __importDefault(require("node:path"));
+const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
+const LOCK_OPTIONS = {
+    retries: {
+        retries: 10,
+        factor: 1.5,
+        minTimeout: 50,
+        maxTimeout: 1_000,
+        randomize: true,
+    },
+    stale: 10_000,
+};
+async function ensureJsonFile(filePath, fallback) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    try {
+        await promises_1.default.access(filePath);
+    }
+    catch {
+        await writeJsonAtomically(filePath, fallback);
+    }
+}
+async function readJsonWithFallback(filePath, fallback) {
+    try {
+        const content = await promises_1.default.readFile(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeJsonAtomically(filePath, value) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.${process.pid}.${Date.now()}.${node_crypto_1.default.randomUUID()}.tmp`;
+    await promises_1.default.writeFile(tmp, JSON.stringify(value, null, 2), "utf8");
+    await promises_1.default.rename(tmp, filePath);
+}
+async function withJsonLock(filePath, fallback, fn) {
+    await ensureJsonFile(filePath, fallback);
+    const release = await proper_lockfile_1.default.lock(filePath, LOCK_OPTIONS);
+    try {
+        return await fn();
+    }
+    finally {
+        await release();
+    }
+}

package/dist/infra/logger.d.ts

@@ -1,14 +1,14 @@
-export type BasicLogger = {
-    info: (message: string) => void;
-    warn: (message: string) => void;
-    error: (message: string) => void;
-    debug?: (message: string) => void;
-};
-export declare const noopLogger: BasicLogger;
-/**
- * Creates a structured logger that delegates to OpenClaw's base logger.
- * Only outputs via baseLogger to avoid duplicate stdout writes.
- */
-export declare function createStructuredLogger(baseLogger: BasicLogger, _name?: string): {
-    logger: BasicLogger;
-};
+export type BasicLogger = {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    debug?: (message: string) => void;
+};
+export declare const noopLogger: BasicLogger;
+/**
+ * Creates a structured logger that delegates to OpenClaw's base logger.
+ * Only outputs via baseLogger to avoid duplicate stdout writes.
+ */
+export declare function createStructuredLogger(baseLogger: BasicLogger, _name?: string): {
+    logger: BasicLogger;
+};

package/dist/infra/logger.js

@@ -1,25 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noopLogger = void 0;
-exports.createStructuredLogger = createStructuredLogger;
-exports.noopLogger = {
-    info: () => { },
-    warn: () => { },
-    error: () => { },
-    debug: () => { },
-};
-/**
- * Creates a structured logger that delegates to OpenClaw's base logger.
- * Only outputs via baseLogger to avoid duplicate stdout writes.
- */
-function createStructuredLogger(baseLogger, _name = "multiclaws") {
-    const bridge = {
-        info: (message) => baseLogger.info(message),
-        warn: (message) => baseLogger.warn(message),
-        error: (message) => baseLogger.error(message),
-        debug: (message) => baseLogger.debug?.(message),
-    };
-    return {
-        logger: bridge,
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noopLogger = void 0;
+exports.createStructuredLogger = createStructuredLogger;
+exports.noopLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+};
+/**
+ * Creates a structured logger that delegates to OpenClaw's base logger.
+ * Only outputs via baseLogger to avoid duplicate stdout writes.
+ */
+function createStructuredLogger(baseLogger, _name = "multiclaws") {
+    const bridge = {
+        info: (message) => baseLogger.info(message),
+        warn: (message) => baseLogger.warn(message),
+        error: (message) => baseLogger.error(message),
+        debug: (message) => baseLogger.debug?.(message),
+    };
+    return {
+        logger: bridge,
+    };
+}

package/dist/infra/rate-limiter.d.ts

@@ -1,19 +1,19 @@
-/**
- * Simple sliding-window rate limiter keyed by peer ID.
- * Returns true if the request should be allowed, false if rate-limited.
- * Periodically prunes empty/stale keys to prevent unbounded memory growth.
- */
-export declare class RateLimiter {
-    private readonly windowMs;
-    private readonly maxRequests;
-    private readonly windows;
-    private pruneTimer;
-    constructor(opts?: {
-        windowMs?: number;
-        maxRequests?: number;
-    });
-    allow(key: string): boolean;
-    reset(key: string): void;
-    destroy(): void;
-    private pruneStaleKeys;
-}
+/**
+ * Simple sliding-window rate limiter keyed by peer ID.
+ * Returns true if the request should be allowed, false if rate-limited.
+ * Periodically prunes empty/stale keys to prevent unbounded memory growth.
+ */
+export declare class RateLimiter {
+    private readonly windowMs;
+    private readonly maxRequests;
+    private readonly windows;
+    private pruneTimer;
+    constructor(opts?: {
+        windowMs?: number;
+        maxRequests?: number;
+    });
+    allow(key: string): boolean;
+    reset(key: string): void;
+    destroy(): void;
+    private pruneStaleKeys;
+}