clawaxis 1.0.3 → 1.2.0

package/src/types.ts

@@ -56,8 +56,8 @@ export interface LogEntry {
 }
 
 export interface ClawAxisConfig {
-  relayUrl: string;
-  agentToken: string;
+  socketPath: string;
+  tokenPath: string;
   mediaDomain: string | null;
   agentName: string | null;
   governance: GovernanceConfig;

package/src/utils.ts

@@ -1,71 +1,12 @@
-import WS from "ws";
-import { LOG_PREFIX, ANON_KEY } from "./config.js";
+import { LOG_PREFIX } from "./config.js";
 import {
   getRuntime,
-  getWs,
   getIsAuthenticated,
   getLogQueue,
   getFlushTimeout,
   setFlushTimeout,
 } from "./runtime.js";
-import type { ClawAxisConfig } from "./types.js";
-
-let _config: ClawAxisConfig | null = null;
-
-export function setUtilsConfig(cfg: ClawAxisConfig) {
-  _config = cfg;
-}
-
-function getRelayUrl(): string {
-  return _config?.relayUrl ?? "";
-}
-
-function getAgentToken(): string {
-  return _config?.agentToken ?? "";
-}
-
-function getGovernance() {
-  return _config?.governance;
-}
-
-export async function relayFetch(method: string, path: string, body?: any) {
-  const base = getRelayUrl();
-  const url = path ? `${base}/${path}` : base;
-  const opts: RequestInit = {
-    method,
-    headers: {
-      "Authorization": `Bearer ${ANON_KEY}`,
-      "apikey": ANON_KEY,
-      "x-agent-token": getAgentToken(),
-      "Content-Type": "application/json",
-    },
-  };
-  if (body) opts.body = JSON.stringify(body);
-
-  try {
-    const res = await fetch(url, opts);
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-
-      if (res.status === 401) {
-        console.error(`${LOG_PREFIX} Relay ${method} ${path || ""}: 401 Unauthorized — check agentToken`);
-      } else if (res.status === 429) {
-        const retryAfter = res.headers.get("retry-after");
-        console.warn(`${LOG_PREFIX} Relay ${method} ${path || ""}: 429 Rate limited${retryAfter ? ` (retry-after: ${retryAfter}s)` : ""}`);
-      } else if (res.status >= 500) {
-        console.error(`${LOG_PREFIX} Relay ${method} ${path || ""}: ${res.status} Server error — ${text.substring(0, 200)}`);
-      } else {
-        console.error(`${LOG_PREFIX} Relay ${method} ${path || ""} failed: ${res.status}`);
-      }
-
-      return null;
-    }
-    return await res.json();
-  } catch (err: any) {
-    console.error(`${LOG_PREFIX} Relay ${method} ${path || ""} error:`, err.message);
-    return null;
-  }
-}
+import { relaySend } from "./socket.js";
 
 export async function relayLog(
   action: string,
@@ -73,56 +14,42 @@ export async function relayLog(
   level: "info" | "success" | "warning" | "error" = "info",
   metadata?: Record<string, any>
 ): Promise<void> {
-  const governance = getGovernance();
-  if (!governance?.logging.enabled) return;
-
   const logQueue = getLogQueue();
   logQueue.push({ action, detail, level, metadata: metadata || {} });
 
   const existing = getFlushTimeout();
   if (existing) clearTimeout(existing);
 
-  setFlushTimeout(setTimeout(async () => {
-    await flushLogQueue();
-  }, governance.logging.debounceMs));
+  setFlushTimeout(setTimeout(() => {
+    flushLogQueue();
+  }, 100));
 }
 
-export async function flushLogQueue(): Promise<void> {
+export function flushLogQueue(): void {
   const logQueue = getLogQueue();
   if (logQueue.length === 0) return;
 
   const batch = [...logQueue];
   logQueue.length = 0;
 
-  const ws = getWs();
-  if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-    const entries = batch.map(log => {
-      const { tokens_used, cost, duration_ms, ...extraMetadata } = log.metadata || {};
-      return {
-        action: log.action,
-        detail: log.detail,
-        level: log.level || "info",
-        timestamp: new Date().toISOString(),
-        tokens_used: tokens_used || 0,
-        cost: cost || 0,
-        duration_ms: duration_ms || null,
-        metadata: Object.keys(extraMetadata).length > 0 ? extraMetadata : undefined,
-      };
-    });
-
-    (ws as any).send(JSON.stringify({
-      type: "log",
-      entries: entries.slice(0, 10)
-    }));
-  } else {
-    for (const log of batch) {
-      try {
-        await relayFetch("POST", "log", log);
-      } catch (err) {
-        console.error(`${LOG_PREFIX} Failed to log:`, log.action, err);
-      }
-    }
-  }
+  const entries = batch.map(log => {
+    const { tokens_used, cost, duration_ms, ...extraMetadata } = log.metadata || {};
+    return {
+      action: log.action,
+      detail: log.detail,
+      level: log.level || "info",
+      timestamp: new Date().toISOString(),
+      tokens_used: tokens_used || 0,
+      cost: cost || 0,
+      duration_ms: duration_ms || null,
+      metadata: Object.keys(extraMetadata).length > 0 ? extraMetadata : undefined,
+    };
+  });
+
+  relaySend({
+    type: "log",
+    entries: entries.slice(0, 10),
+  });
 }
 
 export function getModelName(): string {

package/src/tools/media.ts

@@ -1,21 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { relayFetch } from "../utils.js";
-import { toolOk, toolFail } from "./helpers.js";
-
-export function registerMediaTools(api: any) {
-  api.registerTool({
-    name: "clawaxis_upload_media",
-    description: "Upload an image to permanent R2 storage from a temporary URL. Returns a permanent public URL for use in content.",
-    parameters: Type.Object({
-      image_url: Type.String({ description: "The temporary image URL to upload to permanent storage" }),
-      filename: Type.Optional(Type.String({ description: "Custom filename without extension. Defaults to timestamp." })),
-      folder: Type.Optional(Type.String({ description: "Subfolder in bucket. Defaults to agent ID." })),
-    }),
-    async execute(_id: string, params: any) {
-      const result = await relayFetch("POST", "media-upload", params);
-      return result?.ok
-        ? toolOk(`Image uploaded successfully: ${result.url}`, result)
-        : toolFail("Failed to upload image", { result });
-    },
-  });
-}

package/src/websocket.ts

@@ -1,294 +0,0 @@
-import { setTimeout as sleep } from "node:timers/promises";
-import WS from "ws";
-import {
-  LOG_PREFIX,
-  PLUGIN_VERSION,
-  HEARTBEAT_MS,
-  PING_MS,
-  REAUTH_BUFFER_MS,
-  MAX_RECONNECT_DELAY,
-} from "./config.js";
-import {
-  getRuntime,
-  getWs,
-  setWs,
-  getIsAuthenticated,
-  setIsAuthenticated,
-  getAuthenticatedAgentId,
-  setAuthenticatedAgentId,
-  getReconnectAttempts,
-  setReconnectAttempts,
-  incrementReconnectAttempts,
-  getPingInterval,
-  setPingInterval,
-  getHeartbeatInterval,
-  setHeartbeatInterval,
-  isRunning,
-  setRunning,
-  getSessionTokensAccumulated,
-  getSessionCostAccumulated,
-  getLastHeartbeatTokens,
-  setLastHeartbeatTokens,
-  getFlushTimeout,
-  setFlushTimeout,
-} from "./runtime.js";
-import { relayLog, flushLogQueue, getModelName } from "./utils.js";
-import { handleMessage, handleCommand } from "./message-handler.js";
-import { processPendingDocs, processDocDeletion } from "./sync/documents.js";
-import { processPendingRoutines } from "./sync/routines.js";
-import type { ClawAxisConfig } from "./types.js";
-
-let _config: ClawAxisConfig | null = null;
-
-function getAgentToken(): string {
-  return _config?.agentToken ?? "";
-}
-
-function getRelayUrl(): string {
-  return _config?.relayUrl ?? "";
-}
-
-function sendAuth() {
-  const ws = getWs();
-  if (!ws || ws.readyState !== WS.OPEN) return;
-
-  const authMsg = {
-    type: "auth",
-    token: getAgentToken(),
-    plugin_version: PLUGIN_VERSION,
-    openclaw_version: getRuntime()?.version || "unknown",
-    host_os: process.platform
-  };
-
-  console.log(`${LOG_PREFIX} Sending auth...`);
-  ws.send(JSON.stringify(authMsg));
-}
-
-function cleanup() {
-  setIsAuthenticated(false);
-  setAuthenticatedAgentId(null);
-
-  const ping = getPingInterval();
-  if (ping) {
-    clearInterval(ping);
-    setPingInterval(null);
-  }
-}
-
-function startKeepalive() {
-  const existing = getPingInterval();
-  if (existing) clearInterval(existing);
-
-  setPingInterval(setInterval(() => {
-    const ws = getWs();
-    if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-      ws.send(JSON.stringify({ type: "ping" }));
-    }
-  }, PING_MS));
-}
-
-function startHeartbeat() {
-  const existing = getHeartbeatInterval();
-  if (existing) clearInterval(existing);
-
-  setHeartbeatInterval(setInterval(async () => {
-    const ws = getWs();
-    if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-      const uptime = process.uptime();
-      const sessionTokens = getSessionTokensAccumulated();
-      const tokensDelta = sessionTokens - getLastHeartbeatTokens();
-
-      ws.send(JSON.stringify({
-        type: "heartbeat",
-        status: "online",
-        model: getModelName(),
-        openclaw_version: getRuntime()?.version || "unknown",
-        uptime_seconds: Math.floor(uptime),
-        tokens_used_session: sessionTokens,
-        cost_session: getSessionCostAccumulated(),
-        tokens_delta: tokensDelta > 0 ? tokensDelta : 0,
-      }));
-
-      setLastHeartbeatTokens(sessionTokens);
-    }
-  }, HEARTBEAT_MS));
-}
-
-function scheduleReconnect() {
-  if (!isRunning()) return;
-
-  const base = Math.min(1000 * Math.pow(2, getReconnectAttempts()), MAX_RECONNECT_DELAY);
-  const jitter = base * 0.3 * (Math.random() * 2 - 1);
-  const delay = Math.max(0, Math.round(base + jitter));
-  incrementReconnectAttempts();
-
-  console.log(`${LOG_PREFIX} Reconnecting in ${delay}ms (attempt ${getReconnectAttempts()})...`);
-
-  setTimeout(() => {
-    if (isRunning()) connectWebSocket();
-  }, delay);
-}
-
-// ─── WebSocket message router ────────────────────────────
-
-async function handleWebSocketMessage(msg: any) {
-  console.log(`${LOG_PREFIX} [WS] Received: ${msg.type}`);
-
-  switch (msg.type) {
-    case "auth_ok":
-      await handleAuthOk(msg);
-      break;
-    case "auth_error":
-      await handleAuthError(msg);
-      break;
-    case "message":
-      await handleMessage(msg);
-      break;
-    case "command":
-      await handleCommand(msg);
-      break;
-    case "sync":
-    case "heartbeat_ack":
-      await handleSync(msg);
-      break;
-    case "content_ack":
-      console.log(`${LOG_PREFIX} Content ${msg.action}: ${msg.content_id}`);
-      break;
-    case "doc_deleted":
-      await processDocDeletion(msg);
-      break;
-    case "routine_ack":
-      console.log(`${LOG_PREFIX} Routine ${msg.action}: ${msg.routine_id}`);
-      break;
-    case "error":
-      console.warn(`${LOG_PREFIX} Server error: ${msg.reason} \u2014 ${msg.detail || ""}`);
-      break;
-    case "reauth":
-      await handleReauth(msg);
-      break;
-    case "pong":
-      break;
-    default:
-      console.warn(`${LOG_PREFIX} Unknown message type: ${msg.type}`);
-  }
-}
-
-async function handleAuthOk(msg: any) {
-  console.log(`${LOG_PREFIX} \u2713 Authenticated`);
-  setIsAuthenticated(true);
-  setAuthenticatedAgentId(msg.agent_id || null);
-  if (msg.agent_id) console.log(`${LOG_PREFIX} Agent ID: ${msg.agent_id}`);
-  startKeepalive();
-}
-
-async function handleAuthError(msg: any) {
-  console.error(`${LOG_PREFIX} \u274C Auth failed: ${msg.reason}`);
-  setIsAuthenticated(false);
-  setRunning(false);
-  getWs()?.close();
-  await relayLog("error", `Authentication failed: ${msg.reason}`, "error", { reason: msg.reason });
-}
-
-async function handleSync(msg: any) {
-  console.log(`${LOG_PREFIX} Sync received: ${msg.pending_docs?.length || 0} docs, ${msg.pending_routines?.length || 0} routines`);
-  if (msg.pending_docs?.length > 0) await processPendingDocs(msg.pending_docs);
-  if (msg.pending_routines?.length > 0) await processPendingRoutines(msg.pending_routines);
-}
-
-async function handleReauth(msg: any) {
-  console.log(`${LOG_PREFIX} Re-auth requested (deadline: ${msg.deadline_ms}ms)`);
-  setTimeout(() => {
-    const ws = getWs();
-    if (ws?.readyState === WS.OPEN) sendAuth();
-  }, Math.max(100, msg.deadline_ms - REAUTH_BUFFER_MS));
-}
-
-// ─── Connection ──────────────────────────────────────────
-
-function connectWebSocket() {
-  const wsUrl = getRelayUrl().replace(/^https?:/, "wss:").replace(/\/agent-relay$/, "/ws-relay");
-
-  console.log(`${LOG_PREFIX} [WS] Connecting to: ${wsUrl}`);
-
-  try {
-    const socket = new WS(wsUrl);
-    setWs(socket as any);
-
-    socket.on("open", () => {
-      console.log(`${LOG_PREFIX} [WS] \u2713 Connection opened`);
-      setReconnectAttempts(0);
-      sendAuth();
-    });
-
-    socket.on("message", async (data: WS.RawData) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        await handleWebSocketMessage(msg);
-      } catch (err) {
-        console.error(`${LOG_PREFIX} [WS] Failed to parse message:`, err);
-      }
-    });
-
-    socket.on("close", (code: number, reason: Buffer) => {
-      console.log(`${LOG_PREFIX} [WS] Closed (code ${code}, reason: ${reason.toString() || "none"}), reconnecting...`);
-      cleanup();
-      scheduleReconnect();
-    });
-
-    socket.on("error", (err: Error) => {
-      console.error(`${LOG_PREFIX} [WS] Socket error:`, err.message);
-    });
-
-  } catch (err: any) {
-    console.error(`${LOG_PREFIX} [WS] Failed to create WebSocket:`, err.message);
-    scheduleReconnect();
-  }
-}
-
-// ─── Service factory ─────────────────────────────────────
-
-export function createWebSocketService(cfg: ClawAxisConfig) {
-  _config = cfg;
-  let started = false;
-
-  return {
-    id: "clawaxis-ws",
-
-    async start() {
-      if (started) return;
-      started = true;
-      console.log(`${LOG_PREFIX} \uD83C\uDF10 Starting WebSocket connection...`);
-      setRunning(true);
-      connectWebSocket();
-      startHeartbeat();
-    },
-
-    async stop() {
-      console.log(`${LOG_PREFIX} Shutting down WebSocket...`);
-      started = false;
-      setRunning(false);
-
-      const ws = getWs();
-      if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-        (ws as any).send(JSON.stringify({ type: "heartbeat", status: "offline" }));
-        await sleep(100);
-      }
-
-      const ft = getFlushTimeout();
-      if (ft) {
-        clearTimeout(ft);
-        setFlushTimeout(null);
-        await flushLogQueue();
-      }
-
-      const hb = getHeartbeatInterval();
-      if (hb) {
-        clearInterval(hb);
-        setHeartbeatInterval(null);
-      }
-
-      cleanup();
-      (ws as any)?.close();
-    },
-  };
-}