clawaxis 1.0.4 → 1.2.0

package/index.ts

@@ -1,32 +1,25 @@
 import { LOG_PREFIX, PLUGIN_VERSION, loadConfig } from "./src/config.js";
 import { setRuntime } from "./src/runtime.js";
-import { setUtilsConfig } from "./src/utils.js";
 import { clawaxisChannel } from "./src/channel.js";
 import { registerGovernanceHooks } from "./src/governance/hooks.js";
 import { registerTools } from "./src/tools/index.js";
 
 function register(api: any) {
   console.log(`${LOG_PREFIX} ==========================================`);
-  console.log(`${LOG_PREFIX} \uD83E\uDD9E ClawAxis Plugin v${PLUGIN_VERSION}`);
+  console.log(`${LOG_PREFIX} ClawAxis Plugin v${PLUGIN_VERSION} (Unix Socket)`);
   console.log(`${LOG_PREFIX} ==========================================`);
 
   setRuntime(api.runtime);
 
   const config = loadConfig(api.config);
-  if (!config) {
-    console.warn(`${LOG_PREFIX} No channels.clawaxis config found (or missing relayUrl/agentToken). Plugin disabled.`);
-    return;
-  }
-
-  setUtilsConfig(config);
 
-  console.log(`${LOG_PREFIX} \u2713 Config loaded`);
-  if (config.mediaDomain) console.log(`${LOG_PREFIX}   \u2022 Media domain: ${config.mediaDomain}`);
-  if (config.agentName) console.log(`${LOG_PREFIX}   \u2022 Agent name: ${config.agentName}`);
+  if (config.mediaDomain) console.log(`${LOG_PREFIX}   Media domain: ${config.mediaDomain}`);
+  if (config.agentName) console.log(`${LOG_PREFIX}   Agent name: ${config.agentName}`);
+  console.log(`${LOG_PREFIX}   Socket: ${config.socketPath}`);
 
   if (typeof api.registerChannel === "function") {
     api.registerChannel({ plugin: clawaxisChannel });
-    console.log(`${LOG_PREFIX} \u2713 Channel 'clawaxis' registered (WebSocket starts via gateway.startAccount)`);
+    console.log(`${LOG_PREFIX} Channel 'clawaxis' registered (socket starts via gateway.startAccount)`);
   } else {
     console.warn(`${LOG_PREFIX} api.registerChannel not available — channel not registered`);
   }
@@ -34,14 +27,14 @@ function register(api: any) {
   registerGovernanceHooks(api, config);
 
   if (typeof api.registerTool === "function") {
-    registerTools(api, config.agentToken);
-    console.log(`${LOG_PREFIX} \u2705 All 10 tools registered successfully`);
+    registerTools(api);
+    console.log(`${LOG_PREFIX} All 9 tools registered`);
   } else {
     console.warn(`${LOG_PREFIX} api.registerTool not available — tools not registered`);
   }
 
   console.log(`${LOG_PREFIX} ==========================================`);
-  console.log(`${LOG_PREFIX} \u2713 ClawAxis plugin loaded`);
+  console.log(`${LOG_PREFIX} ClawAxis plugin loaded`);
   console.log(`${LOG_PREFIX} ==========================================`);
 }
 

package/openclaw.plugin.json

@@ -1,22 +1,22 @@
 {
   "id": "clawaxis",
   "name": "ClawAxis",
-  "version": "1.0.0",
-  "description": "Real-time bridge between OpenClaw agents and the ClawAxis iOS app. Channel plugin with governance, content management, and document/routine sync.",
+  "version": "2.1.0",
+  "description": "Real-time bridge between OpenClaw agents and the ClawAxis iOS app via the Connect daemon. Channel plugin with governance, content management, and document/routine sync.",
   "channels": ["clawaxis"],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {
-      "relayUrl": {
+      "socketPath": {
         "type": "string",
-        "description": "ClawAxis WebSocket relay endpoint URL",
-        "default": "https://fqwpwypyzcbmdeajlkzt.supabase.co/functions/v1/ws-relay"
+        "description": "Path to the Connect Unix socket",
+        "default": "~/.clawaxis/connect.sock"
       },
-      "agentToken": {
+      "tokenPath": {
         "type": "string",
-        "description": "Agent authentication token (oc_tk_...)",
-        "default": "oc_tk_placeholder_replace_me"
+        "description": "Path to the local auth token file",
+        "default": "~/.clawaxis/local-token"
       },
       "mediaDomain": {
         "type": "string",
@@ -80,8 +80,8 @@
     "required": []
   },
   "uiHints": {
-    "relayUrl": { "label": "Relay URL", "placeholder": "https://your-relay.supabase.co/functions/v1/ws-relay" },
-    "agentToken": { "label": "Agent Token", "sensitive": true, "placeholder": "oc_tk_..." },
+    "socketPath": { "label": "Socket Path", "placeholder": "~/.clawaxis/connect.sock" },
+    "tokenPath": { "label": "Token Path", "placeholder": "~/.clawaxis/local-token" },
     "mediaDomain": { "label": "Media Domain", "placeholder": "pub-xxxxx.r2.dev" },
     "agentName": { "label": "Agent Name" }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawaxis",
-  "version": "1.0.4",
+  "version": "1.2.0",
   "type": "module",
   "main": "index.ts",
   "files": [
@@ -13,7 +13,7 @@
     "openclaw",
     "openclaw-plugin",
     "clawaxis",
-    "websocket",
+    "unix-socket",
     "mobile",
     "channel"
   ],
@@ -29,7 +29,6 @@
     }
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.34.48",
-    "ws": "^8.19.0"
+    "@sinclair/typebox": "^0.34.48"
   }
 }

package/src/channel.ts

@@ -1,6 +1,6 @@
 import { LOG_PREFIX, loadConfig } from "./config.js";
-import { setUtilsConfig, relayFetch } from "./utils.js";
-import { createWebSocketService } from "./websocket.js";
+import { relaySend } from "./socket.js";
+import { createSocketService } from "./socket.js";
 
 export const clawaxisChannel = {
   id: "clawaxis",
@@ -26,25 +26,16 @@ export const clawaxisChannel = {
     deliveryMode: "direct",
     sendText: async () => ({ ok: true }),
     sendMedia: async (ctx: any) => {
-      const result = await relayFetch("POST", "message", {
+      const sent = relaySend({
+        type: "message",
         content: ctx.caption || "[media]",
         message_type: "image",
       });
-      return { ok: !!result };
+      return { ok: sent };
     },
   },
 
   gateway: {
-    /**
-     * OpenClaw calls startAccount when the channel activates.
-     * This is the correct lifecycle hook for channel plugins —
-     * it replaces manual api.registerService() + wsService.start().
-     *
-     * ctx.account.config is pre-scoped to the channel config
-     * (relayUrl/agentToken already at top level).
-     *
-     * Returns a cleanup function that OpenClaw calls on shutdown.
-     */
     startAccount: async (ctx: any) => {
       const accountId = ctx.account?.accountId || "default";
       console.log(`${LOG_PREFIX} gateway.startAccount called for account: ${accountId}`);
@@ -52,26 +43,19 @@ export const clawaxisChannel = {
       const accountConfig = ctx.account?.config || ctx.account || ctx.config;
       const config = loadConfig(accountConfig);
 
-      if (!config) {
-        console.warn(`${LOG_PREFIX} No valid config for account ${accountId}, skipping WebSocket start`);
-        return () => {};
-      }
+      console.log(`${LOG_PREFIX} Config loaded for account ${accountId}`);
+      if (config.mediaDomain) console.log(`${LOG_PREFIX}   Media domain: ${config.mediaDomain}`);
+      if (config.agentName) console.log(`${LOG_PREFIX}   Agent name: ${config.agentName}`);
 
-      setUtilsConfig(config);
+      const socketService = createSocketService(config);
+      await socketService.start();
 
-      console.log(`${LOG_PREFIX} \u2713 Config loaded for account ${accountId}`);
-      if (config.mediaDomain) console.log(`${LOG_PREFIX}   \u2022 Media domain: ${config.mediaDomain}`);
-      if (config.agentName) console.log(`${LOG_PREFIX}   \u2022 Agent name: ${config.agentName}`);
-
-      const wsService = createWebSocketService(config);
-      await wsService.start();
-
-      console.log(`${LOG_PREFIX} \u2713 Account ${accountId} started (WebSocket active)`);
+      console.log(`${LOG_PREFIX} Account ${accountId} started (socket active)`);
 
       return async () => {
         console.log(`${LOG_PREFIX} Stopping account ${accountId}...`);
-        await wsService.stop();
-        console.log(`${LOG_PREFIX} \u2713 Account ${accountId} stopped`);
+        await socketService.stop();
+        console.log(`${LOG_PREFIX} Account ${accountId} stopped`);
       };
     },
   },

package/src/config.ts

@@ -1,14 +1,12 @@
+import path from "node:path";
+import { homedir } from "node:os";
 import type { GovernanceConfig, ClawAxisConfig } from "./types.js";
 
-export const HEARTBEAT_MS = 60000;
-export const PING_MS = 30000;
-export const REAUTH_BUFFER_MS = 5000;
-export const MAX_RECONNECT_DELAY = 60000;
 export const LOG_PREFIX = "\u{1F99E}";
-export const PLUGIN_VERSION = "2.0.0";
+export const PLUGIN_VERSION = "2.1.0";
 
-// Supabase anon key (public by design — RLS enforces security, not key secrecy)
-export const ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImZxd3B3eXB5emNibWRlYWpsa3p0Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA2NDUxOTIsImV4cCI6MjA4NjIyMTE5Mn0.Dc_gve3L8tMXPMqWZQYq-gxCCdPnm7Z5W6A9fg0pLis";
+export const DEFAULT_SOCKET_PATH = path.join(homedir(), ".clawaxis", "connect.sock");
+export const DEFAULT_TOKEN_PATH = path.join(homedir(), ".clawaxis", "local-token");
 
 export const DEFAULT_GOVERNANCE: GovernanceConfig = {
   imageTools: [],
@@ -44,35 +42,37 @@ export const DEFAULT_GOVERNANCE: GovernanceConfig = {
 /**
  * Load and merge config from OpenClaw's config hierarchy.
  *
- * Supports multiple config shapes:
- *   1. Pre-scoped config (from gateway.startAccount ctx.account.config) —
- *      already has relayUrl/agentToken at top level
- *   2. channels.clawaxis.relayUrl (flat structure)
- *   3. channels.clawaxis.accounts.default.relayUrl (accounts structure)
- *   4. plugins.entries.clawaxis-plugin.config — backward compat
- *   5. plugins.entries.clawaxis.config — npm package name
+ * With the Unix socket transport, no secrets are required in plugin config.
+ * Auth is handled via the local token file generated by Connect.
+ *
+ * Config sources (in priority order):
+ *   1. Pre-scoped config (from gateway.startAccount)
+ *   2. channels.clawaxis (flat)
+ *   3. channels.clawaxis.accounts.default
+ *   4. plugins.entries.clawaxis-plugin.config
+ *   5. plugins.entries.clawaxis.config
  */
-export function loadConfig(apiConfig: any): ClawAxisConfig | null {
-  let cfg: any;
+export function loadConfig(apiConfig: any): ClawAxisConfig {
+  let cfg: any = {};
 
-  if (apiConfig?.relayUrl && apiConfig?.agentToken) {
+  if (apiConfig?.socketPath || apiConfig?.governance) {
     cfg = apiConfig;
   } else {
     const channelConfig = apiConfig?.channels?.clawaxis;
 
-    if (channelConfig?.relayUrl && channelConfig?.agentToken) {
-      cfg = channelConfig;
-    } else if (channelConfig?.accounts?.default) {
-      cfg = channelConfig.accounts.default;
+    if (channelConfig && typeof channelConfig === "object") {
+      if (channelConfig.accounts?.default) {
+        cfg = channelConfig.accounts.default;
+      } else {
+        cfg = channelConfig;
+      }
     } else {
       cfg = apiConfig?.plugins?.entries?.["clawaxis-plugin"]?.config
-        ?? apiConfig?.plugins?.entries?.["clawaxis"]?.config;
+        ?? apiConfig?.plugins?.entries?.["clawaxis"]?.config
+        ?? {};
     }
   }
 
-  if (!cfg) return null;
-  if (!cfg.relayUrl || !cfg.agentToken) return null;
-
   const governance: GovernanceConfig = {
     imageTools: cfg.governance?.imageTools || DEFAULT_GOVERNANCE.imageTools,
     contentTools: cfg.governance?.contentTools || DEFAULT_GOVERNANCE.contentTools,
@@ -83,8 +83,8 @@ export function loadConfig(apiConfig: any): ClawAxisConfig | null {
   };
 
   return {
-    relayUrl: cfg.relayUrl,
-    agentToken: cfg.agentToken,
+    socketPath: cfg.socketPath || DEFAULT_SOCKET_PATH,
+    tokenPath: cfg.tokenPath || DEFAULT_TOKEN_PATH,
     mediaDomain: cfg.mediaDomain || null,
     agentName: apiConfig?.agents?.defaults?.name || cfg.agentName || null,
     governance,

package/src/governance/hooks.ts

@@ -72,9 +72,9 @@ export function registerGovernanceHooks(api: any, config: ClawAxisConfig) {
           if (ft) {
             clearTimeout(ft);
             setFlushTimeout(null);
-            flushLogQueue().catch((err) => {
+            try { flushLogQueue(); } catch (err) {
               console.error(`${LOG_PREFIX} Log flush failed:`, err);
-            });
+            }
           }
 
           return context;

package/src/message-handler.ts

@@ -1,27 +1,20 @@
-import WS from "ws";
 import { LOG_PREFIX } from "./config.js";
 import {
   getRuntime,
-  getWs,
   getIsAuthenticated,
   getAuthenticatedAgentId,
-  getLastTokenCount,
-  setLastTokenCount,
-  addSessionTokens,
   hasProcessedMessage,
   markMessageProcessed,
 } from "./runtime.js";
-import { relayFetch, relayLog, getModelName, getSessionTokens } from "./utils.js";
+import { relaySend, socketWrite } from "./socket.js";
+import { relayLog, getModelName, getSessionTokens } from "./utils.js";
 
 export function sendStatusUpdate(messageId: string, status: string): void {
-  const ws = getWs();
-  if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-    ws.send(JSON.stringify({
-      type: "status",
-      message_id: messageId,
-      status,
-    }));
-  }
+  relaySend({
+    type: "status",
+    message_id: messageId,
+    status,
+  });
 }
 
 export async function dispatchSystemMessage(
@@ -61,16 +54,13 @@ export async function dispatchSystemMessage(
     dispatcherOptions: {
       deliver: async (payload: any) => {
         if (payload.text) {
-          const ws = getWs();
-          if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-            ws.send(JSON.stringify({
-              type: "reply",
-              ref_id: refId,
-              content: payload.text,
-              model_used: getModelName(),
-              tokens_used: 0,
-            }));
-          }
+          relaySend({
+            type: "reply",
+            ref_id: refId,
+            content: payload.text,
+            model_used: getModelName(),
+            tokens_used: 0,
+          });
         }
       },
       onError: (err: Error) => {
@@ -82,11 +72,7 @@ export async function dispatchSystemMessage(
 }
 
 export async function handleMessage(msg: any): Promise<void> {
-  const ws = getWs();
-
-  if (ws?.readyState === WS.OPEN) {
-    ws.send(JSON.stringify({ type: "ack", id: msg.id }));
-  }
+  relaySend({ type: "ack", id: msg.id });
 
   if (hasProcessedMessage(msg.id)) {
     console.log(`${LOG_PREFIX} Skipping duplicate message: ${msg.id}`);
@@ -138,7 +124,7 @@ export async function handleMessage(msg: any): Promise<void> {
       return;
     }
 
-    const tokensBefore = getSessionTokens(runtime) || getLastTokenCount();
+    const tokensBefore = getSessionTokens(runtime);
 
     await dispatchReply({
       ctx: ctxPayload,
@@ -149,28 +135,15 @@ export async function handleMessage(msg: any): Promise<void> {
             const tokensAfter = getSessionTokens(runtime);
             const tokensDelta = tokensAfter > tokensBefore ? tokensAfter - tokensBefore : 0;
 
-            if (tokensAfter > 0) setLastTokenCount(tokensAfter);
-            if (tokensDelta > 0) addSessionTokens(tokensDelta);
-
-            const currentWs = getWs();
-            if (currentWs?.readyState === WS.OPEN && getIsAuthenticated()) {
-              currentWs.send(JSON.stringify({
-                type: "reply",
-                ref_id: msg.id,
-                content: payload.text,
-                model_used: getModelName(),
-                tokens_used: tokensDelta || 0,
-                processing_time_ms: Date.now() - (msg.timestamp || new Date(msg.created_at).getTime())
-              }));
-              console.log(`${LOG_PREFIX} \u2713 Reply sent via WebSocket`);
-            } else {
-              await relayFetch("POST", "message", {
-                content: payload.text,
-                model_used: getModelName(),
-                tokens_used: tokensDelta || 0
-              });
-              console.log(`${LOG_PREFIX} \u2713 Reply sent via HTTPS`);
-            }
+            relaySend({
+              type: "reply",
+              ref_id: msg.id,
+              content: payload.text,
+              model_used: getModelName(),
+              tokens_used: tokensDelta || 0,
+              processing_time_ms: Date.now() - (msg.timestamp || new Date(msg.created_at).getTime())
+            });
+            console.log(`${LOG_PREFIX} Reply sent via socket`);
 
             sendStatusUpdate(msg.id, "complete");
           }
@@ -196,10 +169,7 @@ export async function handleMessage(msg: any): Promise<void> {
 }
 
 export async function handleCommand(msg: any): Promise<void> {
-  const ws = getWs();
-  if (ws?.readyState === WS.OPEN) {
-    ws.send(JSON.stringify({ type: "ack", id: msg.id }));
-  }
+  relaySend({ type: "ack", id: msg.id });
 
   console.log(`${LOG_PREFIX} Received command: ${msg.action}`);
 

package/src/runtime.ts

@@ -1,3 +1,4 @@
+import type { Socket } from "node:net";
 import type { MemoryCacheEntry, LogEntry } from "./types.js";
 
 let pluginRuntime: any = null;
@@ -5,54 +6,24 @@ let pluginRuntime: any = null;
 export function getRuntime(): any { return pluginRuntime; }
 export function setRuntime(r: any) { pluginRuntime = r; }
 
-// WebSocket connection state
-let ws: any = null;
-let reconnectAttempts = 0;
-let isAuthenticated = false;
+// Unix socket connection state
+let socket: Socket | null = null;
+let authenticated = false;
 let authenticatedAgentId: string | null = null;
-let pingInterval: NodeJS.Timeout | null = null;
-let heartbeatInterval: NodeJS.Timeout | null = null;
-let running = true;
+let running = false;
 
-export function getWs() { return ws; }
-export function setWs(socket: any) { ws = socket; }
+export function getSocket() { return socket; }
+export function setSocket(s: Socket | null) { socket = s; }
 
-export function getReconnectAttempts() { return reconnectAttempts; }
-export function setReconnectAttempts(n: number) { reconnectAttempts = n; }
-export function incrementReconnectAttempts() { reconnectAttempts++; }
-
-export function getIsAuthenticated() { return isAuthenticated; }
-export function setIsAuthenticated(v: boolean) { isAuthenticated = v; }
+export function getIsAuthenticated() { return authenticated; }
+export function setIsAuthenticated(v: boolean) { authenticated = v; }
 
 export function getAuthenticatedAgentId() { return authenticatedAgentId; }
 export function setAuthenticatedAgentId(id: string | null) { authenticatedAgentId = id; }
 
-export function getPingInterval() { return pingInterval; }
-export function setPingInterval(t: NodeJS.Timeout | null) { pingInterval = t; }
-
-export function getHeartbeatInterval() { return heartbeatInterval; }
-export function setHeartbeatInterval(t: NodeJS.Timeout | null) { heartbeatInterval = t; }
-
 export function isRunning() { return running; }
 export function setRunning(v: boolean) { running = v; }
 
-// Token tracking
-let lastTokenCount = 0;
-let sessionTokensAccumulated = 0;
-let sessionCostAccumulated = 0;
-let lastHeartbeatTokens = 0;
-
-export function getLastTokenCount() { return lastTokenCount; }
-export function setLastTokenCount(n: number) { lastTokenCount = n; }
-
-export function getSessionTokensAccumulated() { return sessionTokensAccumulated; }
-export function addSessionTokens(delta: number) { sessionTokensAccumulated += delta; }
-
-export function getSessionCostAccumulated() { return sessionCostAccumulated; }
-
-export function getLastHeartbeatTokens() { return lastHeartbeatTokens; }
-export function setLastHeartbeatTokens(n: number) { lastHeartbeatTokens = n; }
-
 // Message deduplication with lazy cleanup
 const processedMessageIds = new Set<string>();
 const MESSAGE_ID_HARD_CAP = 2000;