clawaxis 1.0.3 → 1.2.0

package/src/socket.ts

@@ -0,0 +1,271 @@
+import net from "node:net";
+import fs from "node:fs";
+import readline from "node:readline";
+import crypto from "node:crypto";
+import { LOG_PREFIX, PLUGIN_VERSION } from "./config.js";
+import {
+  getSocket,
+  setSocket,
+  getIsAuthenticated,
+  setIsAuthenticated,
+  setAuthenticatedAgentId,
+  isRunning,
+  setRunning,
+} from "./runtime.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";
+
+const RECONNECT_DELAY_MS = 1000;
+
+let _config: ClawAxisConfig | null = null;
+
+type PendingRequest = {
+  resolve: (data: any) => void;
+  reject: (err: Error) => void;
+  timer: NodeJS.Timeout;
+};
+
+const pendingRequests = new Map<string, PendingRequest>();
+
+function generateId(): string {
+  return `msg_${crypto.randomBytes(8).toString("hex")}`;
+}
+
+/**
+ * Write a newline-delimited JSON message to the socket.
+ */
+export function socketWrite(obj: Record<string, any>): boolean {
+  const sock = getSocket();
+  if (!sock || sock.destroyed || !getIsAuthenticated()) return false;
+  sock.write(JSON.stringify(obj) + "\n");
+  return true;
+}
+
+/**
+ * Send an outbound message wrapped in a relay envelope.
+ * Returns true if the message was written to the socket.
+ */
+export function relaySend(envelope: Record<string, any>): boolean {
+  return socketWrite({ type: "relay", id: generateId(), envelope });
+}
+
+/**
+ * Send a request to Connect and wait for the response.
+ * Used for RPC-style calls (e.g., memory_search).
+ */
+export function socketRequest(
+  method: string,
+  params?: Record<string, any>,
+  timeoutMs = 10000,
+): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const id = `req_${crypto.randomBytes(8).toString("hex")}`;
+
+    const timer = setTimeout(() => {
+      pendingRequests.delete(id);
+      reject(new Error(`Request ${method} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    pendingRequests.set(id, { resolve, reject, timer });
+
+    const written = socketWrite({ type: "request", id, method, params });
+    if (!written) {
+      clearTimeout(timer);
+      pendingRequests.delete(id);
+      reject(new Error("Socket not connected"));
+    }
+  });
+}
+
+function readToken(tokenPath: string): string | null {
+  try {
+    return fs.readFileSync(tokenPath, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+
+function connect() {
+  if (!_config || !isRunning()) return;
+
+  const { socketPath, tokenPath } = _config;
+
+  if (!fs.existsSync(socketPath)) {
+    console.warn(`${LOG_PREFIX} Socket not found at ${socketPath}, retrying in ${RECONNECT_DELAY_MS}ms...`);
+    scheduleReconnect();
+    return;
+  }
+
+  const token = readToken(tokenPath);
+  if (!token) {
+    console.warn(`${LOG_PREFIX} Token file not found at ${tokenPath}, retrying in ${RECONNECT_DELAY_MS}ms...`);
+    scheduleReconnect();
+    return;
+  }
+
+  console.log(`${LOG_PREFIX} [Socket] Connecting to ${socketPath}...`);
+
+  const sock = net.createConnection({ path: socketPath });
+  const rl = readline.createInterface({ input: sock });
+
+  sock.on("connect", () => {
+    console.log(`${LOG_PREFIX} [Socket] Connected, authenticating...`);
+    setSocket(sock);
+    sock.write(JSON.stringify({
+      type: "auth",
+      token,
+      plugin_version: PLUGIN_VERSION,
+      protocol_version: 1,
+    }) + "\n");
+  });
+
+  rl.on("line", async (line: string) => {
+    try {
+      const msg = JSON.parse(line);
+      await handleSocketMessage(msg);
+    } catch (err) {
+      console.error(`${LOG_PREFIX} [Socket] Failed to parse:`, err);
+    }
+  });
+
+  sock.on("close", () => {
+    console.log(`${LOG_PREFIX} [Socket] Disconnected`);
+    cleanup();
+    scheduleReconnect();
+  });
+
+  sock.on("error", (err: Error) => {
+    console.error(`${LOG_PREFIX} [Socket] Error:`, err.message);
+  });
+}
+
+function cleanup() {
+  setIsAuthenticated(false);
+  setAuthenticatedAgentId(null);
+
+  for (const [id, req] of pendingRequests) {
+    clearTimeout(req.timer);
+    req.reject(new Error("Socket disconnected"));
+    pendingRequests.delete(id);
+  }
+}
+
+function scheduleReconnect() {
+  if (!isRunning()) return;
+  setTimeout(() => {
+    if (isRunning()) connect();
+  }, RECONNECT_DELAY_MS);
+}
+
+async function handleSocketMessage(msg: any) {
+  switch (msg.type) {
+    case "auth_ok":
+      console.log(`${LOG_PREFIX} [Socket] Authenticated (connect v${msg.connect_version}, device=${msg.device_state})`);
+      setIsAuthenticated(true);
+      setAuthenticatedAgentId(msg.agent_id || null);
+      break;
+
+    case "auth_error":
+      console.error(`${LOG_PREFIX} [Socket] Auth failed: ${msg.reason}`);
+      setIsAuthenticated(false);
+      if (msg.reason === "already_connected") {
+        console.warn(`${LOG_PREFIX} [Socket] Another plugin instance is connected, will retry...`);
+      } else {
+        setRunning(false);
+      }
+      getSocket()?.destroy();
+      break;
+
+    case "relay": {
+      const envelope = msg.envelope;
+      if (!envelope) break;
+      await routeInboundEnvelope(envelope);
+      break;
+    }
+
+    case "relay_ack":
+      if (!msg.forwarded && !msg.queued) {
+        console.warn(`${LOG_PREFIX} [Socket] Relay not forwarded: ${msg.id}`);
+      }
+      break;
+
+    case "response": {
+      const pending = pendingRequests.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        pendingRequests.delete(msg.id);
+        if (msg.ok) {
+          pending.resolve(msg.data);
+        } else {
+          pending.reject(new Error(msg.error || "Request failed"));
+        }
+      }
+      break;
+    }
+
+    case "pong":
+      break;
+
+    default:
+      console.warn(`${LOG_PREFIX} [Socket] Unknown message type: ${msg.type}`);
+  }
+}
+
+async function routeInboundEnvelope(envelope: any) {
+  switch (envelope.type) {
+    case "message":
+      await handleMessage(envelope);
+      break;
+    case "command":
+      await handleCommand(envelope);
+      break;
+    case "sync":
+    case "heartbeat_ack":
+      if (envelope.pending_docs?.length > 0) await processPendingDocs(envelope.pending_docs);
+      if (envelope.pending_routines?.length > 0) await processPendingRoutines(envelope.pending_routines);
+      break;
+    case "doc_deleted":
+      await processDocDeletion(envelope);
+      break;
+    case "content_ack":
+      console.log(`${LOG_PREFIX} Content ${envelope.action}: ${envelope.content_id}`);
+      break;
+    case "routine_ack":
+      console.log(`${LOG_PREFIX} Routine ${envelope.action}: ${envelope.routine_id}`);
+      break;
+    case "error":
+      console.warn(`${LOG_PREFIX} Server error: ${envelope.reason} — ${envelope.detail || ""}`);
+      break;
+    default:
+      console.warn(`${LOG_PREFIX} Unknown envelope type: ${envelope.type}`);
+  }
+}
+
+export function createSocketService(cfg: ClawAxisConfig) {
+  _config = cfg;
+  let started = false;
+
+  return {
+    id: "clawaxis-socket",
+
+    async start() {
+      if (started) return;
+      started = true;
+      console.log(`${LOG_PREFIX} Starting Unix socket connection...`);
+      setRunning(true);
+      connect();
+    },
+
+    async stop() {
+      console.log(`${LOG_PREFIX} Shutting down socket...`);
+      started = false;
+      setRunning(false);
+      cleanup();
+      const sock = getSocket();
+      sock?.destroy();
+      setSocket(null);
+    },
+  };
+}

package/src/sync/documents.ts

@@ -1,10 +1,10 @@
 import path from "node:path";
 import fs from "node:fs";
 import { homedir } from "node:os";
-import WS from "ws";
 import { LOG_PREFIX } from "../config.js";
-import { getRuntime, getWs, getIsAuthenticated } from "../runtime.js";
-import { relayFetch, relayLog } from "../utils.js";
+import { getRuntime } from "../runtime.js";
+import { relayLog } from "../utils.js";
+import { relaySend } from "../socket.js";
 import { dispatchSystemMessage } from "../message-handler.js";
 
 export function resolveDocPath(doc: any): { dir: string; filePath: string } {
@@ -31,8 +31,18 @@ export async function processPendingDocs(docs: any[]): Promise<void> {
       }
 
       const isUpdate = (doc.version && doc.version > 1) || !!doc.agent_skill_path;
-      const { dir, filePath } = doc.agent_skill_path
-        ? { dir: path.dirname(doc.agent_skill_path), filePath: doc.agent_skill_path }
+
+      let resolvedSkillPath = doc.agent_skill_path;
+      if (resolvedSkillPath && !fs.existsSync(path.dirname(resolvedSkillPath))) {
+        const runtime = getRuntime();
+        const workspaceDir = runtime?.config?.workspace?.dir
+          || path.join(homedir(), ".openclaw", "workspace");
+        const relative = resolvedSkillPath.replace(/^.*?\.openclaw\/workspace\//, "");
+        resolvedSkillPath = path.join(workspaceDir, relative);
+      }
+
+      const { dir, filePath } = resolvedSkillPath
+        ? { dir: path.dirname(resolvedSkillPath), filePath: resolvedSkillPath }
         : resolveDocPath(doc);
 
       fs.mkdirSync(dir, { recursive: true });
@@ -52,7 +62,7 @@ export async function processPendingDocs(docs: any[]): Promise<void> {
       const fileContent = `${frontmatter}\n\n# ${doc.name}\n\n${doc.content}`;
       fs.writeFileSync(filePath, fileContent, "utf8");
 
-      console.log(`${LOG_PREFIX} \u2713 ${isUpdate ? "Updated" : "Wrote"} document: ${filePath}`);
+      console.log(`${LOG_PREFIX} ${isUpdate ? "Updated" : "Wrote"} document: ${filePath}`);
 
       const docMeta = [
         doc.doc_type ? `Type: ${doc.doc_type}` : null,
@@ -67,19 +77,11 @@ export async function processPendingDocs(docs: any[]): Promise<void> {
 
       await dispatchSystemMessage(messageContent, `doc-sync-${doc.id}`, `doc-sync-${doc.id}`);
 
-      const ws = getWs();
-      if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-        ws.send(JSON.stringify({
-          type: "doc_synced",
-          doc_id: doc.id,
-          agent_skill_path: filePath
-        }));
-      } else {
-        await relayFetch("POST", "doc-synced", {
-          document_id: doc.id,
-          agent_skill_path: filePath
-        });
-      }
+      relaySend({
+        type: "doc_synced",
+        doc_id: doc.id,
+        agent_skill_path: filePath,
+      });
 
       await relayLog(
         "system",
@@ -102,16 +104,25 @@ export async function processPendingDocs(docs: any[]): Promise<void> {
 
 export async function processDocDeletion(doc: { id: string; name: string; agent_skill_path?: string }): Promise<void> {
   try {
-    if (doc.agent_skill_path) {
+    let deletePath = doc.agent_skill_path;
+    if (deletePath && !fs.existsSync(deletePath)) {
+      const runtime = getRuntime();
+      const workspaceDir = runtime?.config?.workspace?.dir
+        || path.join(homedir(), ".openclaw", "workspace");
+      const relative = deletePath.replace(/^.*?\.openclaw\/workspace\//, "");
+      deletePath = path.join(workspaceDir, relative);
+    }
+
+    if (deletePath) {
       try {
-        fs.unlinkSync(doc.agent_skill_path);
-        console.log(`${LOG_PREFIX} \u2713 Deleted document file: ${doc.agent_skill_path}`);
+        fs.unlinkSync(deletePath);
+        console.log(`${LOG_PREFIX} Deleted document file: ${deletePath}`);
       } catch (fsErr: any) {
-        console.warn(`${LOG_PREFIX} Could not delete file ${doc.agent_skill_path}:`, fsErr.message);
+        console.warn(`${LOG_PREFIX} Could not delete file ${deletePath}:`, fsErr.message);
       }
     }
 
-    const messageContent = `[DOC_DELETED] The user deleted document "${doc.name}"${doc.agent_skill_path ? ` (was at: ${doc.agent_skill_path})` : ""}. The file has been removed from your workspace. Memory search will no longer return results from this document.`;
+    const messageContent = `[DOC_DELETED] The user deleted document "${doc.name}"${deletePath ? ` (was at: ${deletePath})` : ""}. The file has been removed from your workspace. Memory search will no longer return results from this document.`;
     await dispatchSystemMessage(messageContent, `doc-delete-${doc.id}`, `doc-delete-${doc.id}`);
 
     await relayLog(

package/src/sync/routines.ts

@@ -1,7 +1,6 @@
-import WS from "ws";
 import { LOG_PREFIX } from "../config.js";
-import { getWs, getIsAuthenticated } from "../runtime.js";
 import { relayLog } from "../utils.js";
+import { relaySend } from "../socket.js";
 import { dispatchSystemMessage } from "../message-handler.js";
 
 export async function processPendingRoutines(routines: any[]): Promise<void> {
@@ -28,13 +27,10 @@ export async function processPendingRoutines(routines: any[]): Promise<void> {
 
       await dispatchSystemMessage(messageContent, `routine-sync-${routine.id}`, `routine-sync-${routine.id}`);
 
-      const ws = getWs();
-      if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-        ws.send(JSON.stringify({
-          type: "routine_synced",
-          routine_id: routine.id
-        }));
-      }
+      relaySend({
+        type: "routine_synced",
+        routine_id: routine.id,
+      });
 
       await relayLog(
         "system",

package/src/tools/content.ts

@@ -1,7 +1,7 @@
 import { Type } from "@sinclair/typebox";
 import { LOG_PREFIX } from "../config.js";
-import { relayFetch } from "../utils.js";
-import { toolOk, toolFail, wsSendOrHttp } from "./helpers.js";
+import { toolOk, toolFail, socketSend } from "./helpers.js";
+import { socketRequest } from "../socket.js";
 
 export function registerContentTools(api: any) {
   api.registerTool({
@@ -17,15 +17,12 @@ export function registerContentTools(api: any) {
       word_count: Type.Optional(Type.Number({ description: "Word count. Shown in blog/report/email card headers. Always provide for long-form content." })),
       prompt_used: Type.Optional(Type.String({ description: "The prompt that generated this content. Shown in Generation Info section." })),
       model_used: Type.Optional(Type.String({ description: "Model ID (e.g. 'anthropic/claude-sonnet-4-5'). Shown in Generation Info section." })),
-      media: Type.Optional(Type.Any({ description: "Media object: {images: [{url: string, alt?: string}], videos: [{url: string, alt?: string}]}. Use permanent URLs only (upload via clawaxis_upload_media first). Required for twitter, instagram, facebook, tiktok, youtube." })),
+      media: Type.Optional(Type.Any({ description: "Media object: {images: [{url: string, alt?: string}], videos: [{url: string, alt?: string}]}. Use permanent URLs only. Required for twitter, instagram, facebook, tiktok, youtube." })),
     }),
     async execute(_id: string, params: any) {
-      console.log(`${LOG_PREFIX} Sending content via WebSocket/HTTP...`);
-      const result = await wsSendOrHttp(
-        { type: "content", action: "create", ...params },
-        "POST", "content", params,
-      );
-      return result ? toolOk("Content posted to ClawAxis app", { result }) : toolFail("Failed to post content");
+      console.log(`${LOG_PREFIX} Sending content via socket...`);
+      const sent = socketSend({ type: "content", action: "create", ...params });
+      return sent ? toolOk("Content posted to ClawAxis app") : toolFail("Socket not connected");
     },
   });
 
@@ -36,11 +33,12 @@ export function registerContentTools(api: any) {
       content_id: Type.Optional(Type.String({ description: "UUID of specific content item to fetch. If omitted, returns recent content list." })),
     }),
     async execute(_id: string, params: any) {
-      const path = params.content_id ? `content?id=${params.content_id}` : "content";
-      const result = await relayFetch("GET", path, null);
-      return result
-        ? toolOk(JSON.stringify(result, null, 2), { result })
-        : toolFail("Failed to retrieve content");
+      try {
+        const result = await socketRequest("get_content", params);
+        return toolOk(JSON.stringify(result, null, 2), { result });
+      } catch (err: any) {
+        return toolFail(`Failed to retrieve content: ${err.message}`);
+      }
     },
   });
 
@@ -54,11 +52,8 @@ export function registerContentTools(api: any) {
       media: Type.Optional(Type.Any({ description: "Updated media: {images: [{url: string, alt?: string}], videos: [{url: string, alt?: string}]}. Omit to keep existing." })),
     }),
     async execute(_id: string, params: any) {
-      const result = await wsSendOrHttp(
-        { type: "content", action: "update", content_id: params.content_id, body: params.body, title: params.title, media: params.media },
-        "POST", "content-update", params,
-      );
-      return result ? toolOk("Content updated successfully", { result }) : toolFail("Failed to update content");
+      const sent = socketSend({ type: "content", action: "update", ...params });
+      return sent ? toolOk("Content updated successfully") : toolFail("Socket not connected");
     },
   });
 }

package/src/tools/helpers.ts

@@ -1,6 +1,4 @@
-import WS from "ws";
-import { getWs, getIsAuthenticated } from "../runtime.js";
-import { relayFetch } from "../utils.js";
+import { relaySend } from "../socket.js";
 
 export interface ToolResult {
   content: Array<{ type: "text"; text: string }>;
@@ -22,19 +20,9 @@ export function toolFail(message: string, extra?: Record<string, any>): ToolResu
 }
 
 /**
- * Send a payload over WebSocket if connected, otherwise fall back to HTTP.
- * Returns the result (truthy on WS success, parsed JSON on HTTP, null on failure).
+ * Send a message envelope through the Unix socket to Connect.
+ * Returns true if the message was written to the socket.
  */
-export async function wsSendOrHttp(
-  wsPayload: Record<string, any>,
-  httpMethod: string,
-  httpPath: string,
-  httpBody?: any,
-): Promise<any> {
-  const ws = getWs();
-  if (ws?.readyState === WS.OPEN && getIsAuthenticated()) {
-    (ws as any).send(JSON.stringify(wsPayload));
-    return true;
-  }
-  return relayFetch(httpMethod, httpPath, httpBody ?? wsPayload);
+export function socketSend(envelope: Record<string, any>): boolean {
+  return relaySend(envelope);
 }

package/src/tools/index.ts

@@ -2,15 +2,12 @@ import { registerContentTools } from "./content.js";
 import { registerLoggingTools } from "./logging.js";
 import { registerSyncTools } from "./sync.js";
 import { registerRoutineTools } from "./routines.js";
-import { registerMediaTools } from "./media.js";
-import { registerMemoryTools, setMemoryAgentToken } from "./memory.js";
+import { registerMemoryTools } from "./memory.js";
 
-export function registerTools(api: any, agentToken: string) {
-  setMemoryAgentToken(agentToken);
+export function registerTools(api: any) {
   registerContentTools(api);
   registerLoggingTools(api);
   registerSyncTools(api);
   registerRoutineTools(api);
-  registerMediaTools(api);
   registerMemoryTools(api);
 }

package/src/tools/memory.ts

@@ -1,14 +1,9 @@
 import { Type } from "@sinclair/typebox";
-import { ANON_KEY, LOG_PREFIX } from "../config.js";
+import { LOG_PREFIX } from "../config.js";
 import { getAuthenticatedAgentId } from "../runtime.js";
+import { socketRequest } from "../socket.js";
 import { toolOk, toolFail } from "./helpers.js";
 
-let _agentToken = "";
-
-export function setMemoryAgentToken(token: string) {
-  _agentToken = token;
-}
-
 export function registerMemoryTools(api: any) {
   api.registerTool({
     name: "clawaxis_memory_search",
@@ -20,56 +15,31 @@ export function registerMemoryTools(api: any) {
     }),
     async execute(_id: string, params: any) {
       try {
-        const agent_id = getAuthenticatedAgentId() || "520bc407-81db-4ce3-85d5-d19bd437da0f";
+        const agent_id = getAuthenticatedAgentId();
+        console.log(`${LOG_PREFIX} [Memory Search] Requesting via socket...`);
 
-        const memoryApiUrl = "https://fqwpwypyzcbmdeajlkzt.supabase.co/functions/v1/memory-search";
-        const requestBody = {
+        const result = await socketRequest("memory_search", {
           query: params.query,
-          agent_id: agent_id,
+          agent_id,
           match_count: params.match_count || 10,
-          match_threshold: params.match_threshold || 0.5
-        };
-
-        console.log(`${LOG_PREFIX} [Memory Search] Calling: ${memoryApiUrl}`);
-
-        const res = await fetch(memoryApiUrl, {
-          method: "POST",
-          headers: {
-            "Authorization": `Bearer ${ANON_KEY}`,
-            "apikey": ANON_KEY,
-            "x-agent-token": _agentToken,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify(requestBody)
+          match_threshold: params.match_threshold || 0.5,
         });
 
-        console.log(`${LOG_PREFIX} [Memory Search] Response status: ${res.status}`);
+        const results = result?.results || [];
+        console.log(`${LOG_PREFIX} [Memory Search] Result count: ${results.length}`);
 
-        if (!res.ok) {
-          const errorText = await res.text();
-          console.log(`${LOG_PREFIX} [Memory Search] Error response:`, errorText);
-          return toolFail(`Memory search failed: ${res.status} ${errorText}`, { error: errorText });
-        }
-
-        const result = await res.json();
-        console.log(`${LOG_PREFIX} [Memory Search] Result count: ${result?.results?.length || 0}`);
-
-        if (result?.results && result.results.length > 0) {
-          const snippets = result.results.map((r: any, i: number) =>
+        if (results.length > 0) {
+          const snippets = results.map((r: any, i: number) =>
             `[Result ${i + 1}] (Similarity: ${r.similarity?.toFixed(3)})\n${r.content}\n`
           ).join("\n---\n\n");
 
-          return toolOk(`Found ${result.results.length} memories:\n\n${snippets}`, {
-            count: result.results.length,
-            results: result.results,
+          return toolOk(`Found ${results.length} memories:\n\n${snippets}`, {
+            count: results.length,
+            results,
           });
         }
 
-        return toolOk(`No memories found. Raw response: ${JSON.stringify(result).substring(0, 500)}`, {
-          count: 0,
-          results: [],
-          raw: result,
-        });
+        return toolOk("No memories found.", { count: 0, results: [] });
       } catch (err: any) {
         return toolFail(`Memory search error: ${err.message}`, { error: err.message });
       }

package/src/tools/routines.ts

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { toolOk, toolFail, wsSendOrHttp } from "./helpers.js";
+import { toolOk, toolFail, socketSend } from "./helpers.js";
 
 export function registerRoutineTools(api: any) {
   api.registerTool({
@@ -18,11 +18,8 @@ export function registerRoutineTools(api: any) {
       status: Type.Optional(Type.String({ description: "Must be: active, paused, or disabled. Default: active." })),
     }),
     async execute(_id: string, params: any) {
-      const result = await wsSendOrHttp(
-        { type: "routine_created", ...params },
-        "POST", "routine-created", params,
-      );
-      return result ? toolOk("Routine registered in app", { result }) : toolFail("Failed to register routine");
+      const sent = socketSend({ type: "routine_created", ...params });
+      return sent ? toolOk("Routine registered in app") : toolFail("Socket not connected");
     },
   });
 
@@ -42,13 +39,8 @@ export function registerRoutineTools(api: any) {
       status: Type.Optional(Type.String({ description: "active, paused, or disabled" })),
     }),
     async execute(_id: string, params: any) {
-      const result = await wsSendOrHttp(
-        { type: "routine_update", ...params },
-        "POST", "routine-update", params,
-      );
-      return result?.ok
-        ? toolOk("Routine updated in app", { result })
-        : toolFail("Failed to update routine", { result });
+      const sent = socketSend({ type: "routine_update", ...params });
+      return sent ? toolOk("Routine updated in app") : toolFail("Socket not connected");
     },
   });
 }

package/src/tools/sync.ts

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { toolOk, toolFail, wsSendOrHttp } from "./helpers.js";
+import { toolOk, toolFail, socketSend } from "./helpers.js";
 
 export function registerSyncTools(api: any) {
   api.registerTool({
@@ -10,11 +10,8 @@ export function registerSyncTools(api: any) {
       agent_skill_path: Type.Optional(Type.String({ description: "Path where the document was saved in agent skills" })),
     }),
     async execute(_id: string, params: any) {
-      const result = await wsSendOrHttp(
-        { type: "doc_synced", ...params },
-        "POST", "doc-synced", params,
-      );
-      return result ? toolOk("Document sync confirmed", { result }) : toolFail("Failed to confirm document sync");
+      const sent = socketSend({ type: "doc_synced", ...params });
+      return sent ? toolOk("Document sync confirmed") : toolFail("Socket not connected");
     },
   });
 
@@ -26,11 +23,8 @@ export function registerSyncTools(api: any) {
       openclaw_cron_id: Type.Optional(Type.String({ description: "OpenClaw cron job ID that was created" })),
     }),
     async execute(_id: string, params: any) {
-      const result = await wsSendOrHttp(
-        { type: "routine_synced", ...params },
-        "POST", "routine-synced", params,
-      );
-      return result ? toolOk("Routine sync confirmed", { result }) : toolFail("Failed to confirm routine sync");
+      const sent = socketSend({ type: "routine_synced", ...params });
+      return sent ? toolOk("Routine sync confirmed") : toolFail("Socket not connected");
     },
   });
 }