clawaxis 1.0.0

package/src/message-handler.ts

@@ -0,0 +1,212 @@
+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";
+
+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,
+    }));
+  }
+}
+
+export async function dispatchSystemMessage(
+  content: string,
+  messageSid: string,
+  refId: string,
+): Promise<void> {
+  const runtime = getRuntime();
+  if (!runtime) return;
+
+  const runtimeConfig = runtime.config?.loadConfig?.() ?? {};
+  const dispatchReply = runtime.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher;
+  if (!dispatchReply) return;
+
+  await dispatchReply({
+    ctx: {
+      Body: content,
+      RawBody: content,
+      CommandBody: content,
+      From: "clawaxis:system",
+      To: "clawaxis:agent",
+      SessionKey: "agent:main:clawaxis:main",
+      AccountId: "default",
+      ChatType: "direct",
+      SenderName: "ClawAxis App",
+      SenderId: "clawaxis-system",
+      Provider: "clawaxis",
+      Surface: "clawaxis",
+      MessageSid: messageSid,
+      Timestamp: Date.now(),
+      OriginatingChannel: "clawaxis",
+      OriginatingTo: "clawaxis:agent",
+      MessageType: "text",
+      RefId: null,
+    },
+    cfg: runtimeConfig,
+    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,
+            }));
+          }
+        }
+      },
+      onError: (err: Error) => {
+        console.error(`${LOG_PREFIX} System dispatch error (${messageSid}): ${err.message}`);
+      },
+    },
+    replyOptions: {},
+  });
+}
+
+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 }));
+  }
+
+  if (hasProcessedMessage(msg.id)) {
+    console.log(`${LOG_PREFIX} Skipping duplicate message: ${msg.id}`);
+    return;
+  }
+  markMessageProcessed(msg.id);
+
+  sendStatusUpdate(msg.id, "processing");
+
+  try {
+    console.log(`${LOG_PREFIX} Processing message: ${msg.content.substring(0, 50)}...`);
+    console.log(`${LOG_PREFIX} Message type: ${msg.message_type || "text"}, ref_id: ${msg.ref_id || "none"}`);
+
+    const runtime = getRuntime();
+    if (!runtime) {
+      console.error(`${LOG_PREFIX} Plugin runtime not available`);
+      sendStatusUpdate(msg.id, "error");
+      return;
+    }
+
+    const runtimeConfig = runtime.config?.loadConfig?.() ?? {};
+    const sessionId = getAuthenticatedAgentId() || "default";
+
+    const ctxPayload = {
+      Body: msg.content,
+      RawBody: msg.content,
+      CommandBody: msg.content,
+      From: "clawaxis:user",
+      To: "clawaxis:agent",
+      SessionKey: `agent:main:clawaxis:${sessionId}`,
+      AccountId: "default",
+      ChatType: "direct",
+      SenderName: "Dashboard User",
+      SenderId: "clawaxis-user",
+      Provider: "clawaxis",
+      Surface: "clawaxis",
+      MessageSid: msg.id,
+      Timestamp: Date.now(),
+      OriginatingChannel: "clawaxis",
+      OriginatingTo: "clawaxis:agent",
+      MessageType: msg.message_type || "text",
+      RefId: msg.ref_id || null,
+    };
+
+    const dispatchReply = runtime.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher;
+    if (!dispatchReply) {
+      console.error(`${LOG_PREFIX} Dispatch function not available`);
+      sendStatusUpdate(msg.id, "error");
+      return;
+    }
+
+    const tokensBefore = getSessionTokens(runtime) || getLastTokenCount();
+
+    await dispatchReply({
+      ctx: ctxPayload,
+      cfg: runtimeConfig,
+      dispatcherOptions: {
+        deliver: async (payload: any) => {
+          if (payload.text) {
+            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`);
+            }
+
+            sendStatusUpdate(msg.id, "complete");
+          }
+        },
+        onError: (err: Error) => {
+          console.error(`${LOG_PREFIX} Dispatch error: ${err.message}`);
+          sendStatusUpdate(msg.id, "error");
+        },
+      },
+      replyOptions: {},
+    });
+
+  } catch (err: any) {
+    console.error(`${LOG_PREFIX} Failed to process message:`, err);
+    sendStatusUpdate(msg.id, "error");
+    await relayLog(
+      "error",
+      `Message processing failed: ${err.message}`,
+      "error",
+      { message_id: msg.id, error: err.message }
+    );
+  }
+}
+
+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 }));
+  }
+
+  console.log(`${LOG_PREFIX} Received command: ${msg.action}`);
+
+  await relayLog(
+    "system",
+    `Command received: ${msg.action}`,
+    "info",
+    { command_id: msg.id, action: msg.action, payload: msg.payload }
+  );
+}

package/src/runtime.ts

@@ -0,0 +1,91 @@
+import type { MemoryCacheEntry, LogEntry } from "./types.js";
+
+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;
+let authenticatedAgentId: string | null = null;
+let pingInterval: NodeJS.Timeout | null = null;
+let heartbeatInterval: NodeJS.Timeout | null = null;
+let running = true;
+
+export function getWs() { return ws; }
+export function setWs(socket: any) { ws = socket; }
+
+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 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;
+const CLEANUP_EVERY_N = 50;
+let messagesSinceCleanup = 0;
+
+export function hasProcessedMessage(id: string): boolean {
+  return processedMessageIds.has(id);
+}
+
+export function markMessageProcessed(id: string): void {
+  processedMessageIds.add(id);
+  messagesSinceCleanup++;
+
+  if (messagesSinceCleanup >= CLEANUP_EVERY_N && processedMessageIds.size > MESSAGE_ID_HARD_CAP) {
+    messagesSinceCleanup = 0;
+    const excess = processedMessageIds.size - MESSAGE_ID_HARD_CAP;
+    const iter = processedMessageIds.values();
+    for (let i = 0; i < excess; i++) {
+      processedMessageIds.delete(iter.next().value!);
+    }
+  }
+}
+
+// Logging queue
+const logQueue: LogEntry[] = [];
+let flushTimeout: NodeJS.Timeout | null = null;
+
+export function getLogQueue() { return logQueue; }
+export function getFlushTimeout() { return flushTimeout; }
+export function setFlushTimeout(t: NodeJS.Timeout | null) { flushTimeout = t; }
+
+// Memory search cache
+const memoryCache = new Map<string, MemoryCacheEntry>();
+
+export function getMemoryCache() { return memoryCache; }

package/src/sync/documents.ts

@@ -0,0 +1,127 @@
+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 { dispatchSystemMessage } from "../message-handler.js";
+
+export function resolveDocPath(doc: any): { dir: string; filePath: string } {
+  const category = doc.category || "general";
+  const slug = doc.name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  const runtime = getRuntime();
+  const workspaceDir = runtime?.config?.workspace?.dir
+    || path.join(homedir(), ".openclaw", "workspace");
+  const dir = path.join(workspaceDir, "memory", "docs", category);
+  const filePath = path.join(dir, `${slug}.md`);
+  return { dir, filePath };
+}
+
+export async function processPendingDocs(docs: any[]): Promise<void> {
+  if (!docs || docs.length === 0) return;
+
+  console.log(`${LOG_PREFIX} Processing ${docs.length} pending document(s)...`);
+
+  for (const doc of docs) {
+    try {
+      if (!doc.content && !doc.storage_path) {
+        console.warn(`${LOG_PREFIX} Document ${doc.id} has no content or storage_path, skipping`);
+        continue;
+      }
+
+      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 }
+        : resolveDocPath(doc);
+
+      fs.mkdirSync(dir, { recursive: true });
+
+      const frontmatter = [
+        `---`,
+        `title: "${doc.name}"`,
+        doc.doc_type ? `type: ${doc.doc_type}` : null,
+        doc.category ? `category: ${doc.category}` : null,
+        doc.tags?.length ? `tags: [${doc.tags.join(", ")}]` : null,
+        doc.description ? `description: "${doc.description}"` : null,
+        `version: ${doc.version || 1}`,
+        `synced: ${new Date().toISOString()}`,
+        `---`,
+      ].filter(Boolean).join("\n");
+
+      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}`);
+
+      const docMeta = [
+        doc.doc_type ? `Type: ${doc.doc_type}` : null,
+        doc.category ? `Category: ${doc.category}` : null,
+        doc.tags?.length ? `Tags: ${doc.tags.join(", ")}` : null,
+        doc.description ? `Description: ${doc.description}` : null,
+      ].filter(Boolean).join(" | ");
+
+      const messageContent = isUpdate
+        ? `[DOC_UPDATED] The user updated document "${doc.name}" (v${doc.version || 1}). ${docMeta ? docMeta + ". " : ""}File updated at: ${filePath}. Read it with the read tool if you need to review the changes. Confirm sync by calling clawaxis_confirm_doc_sync with document_id: ${doc.id}.`
+        : `[DOC_UPLOADED] The user uploaded a new document: "${doc.name}". ${docMeta ? docMeta + ". " : ""}Saved to: ${filePath}. This file is now searchable via memory_search. Read it with the read tool if you want to review. Confirm sync by calling clawaxis_confirm_doc_sync with document_id: ${doc.id}.`;
+
+      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
+        });
+      }
+
+      await relayLog(
+        "system",
+        `Document ${isUpdate ? "updated" : "synced"}: ${doc.name}`,
+        "info",
+        { document_id: doc.id, path: filePath, version: doc.version }
+      );
+
+    } catch (err: any) {
+      console.error(`${LOG_PREFIX} Failed to sync document ${doc.id}:`, err);
+      await relayLog(
+        "error",
+        `Document sync failed: ${doc.name}`,
+        "error",
+        { document_id: doc.id, error: err.message }
+      );
+    }
+  }
+}
+
+export async function processDocDeletion(doc: { id: string; name: string; agent_skill_path?: string }): Promise<void> {
+  try {
+    if (doc.agent_skill_path) {
+      try {
+        fs.unlinkSync(doc.agent_skill_path);
+        console.log(`${LOG_PREFIX} \u2713 Deleted document file: ${doc.agent_skill_path}`);
+      } catch (fsErr: any) {
+        console.warn(`${LOG_PREFIX} Could not delete file ${doc.agent_skill_path}:`, 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.`;
+    await dispatchSystemMessage(messageContent, `doc-delete-${doc.id}`, `doc-delete-${doc.id}`);
+
+    await relayLog(
+      "system",
+      `Document deleted: ${doc.name}`,
+      "info",
+      { document_id: doc.id }
+    );
+
+  } catch (err: any) {
+    console.error(`${LOG_PREFIX} Failed to process document deletion ${doc.id}:`, err);
+  }
+}

package/src/sync/routines.ts

@@ -0,0 +1,56 @@
+import WS from "ws";
+import { LOG_PREFIX } from "../config.js";
+import { getWs, getIsAuthenticated } from "../runtime.js";
+import { relayLog } from "../utils.js";
+import { dispatchSystemMessage } from "../message-handler.js";
+
+export async function processPendingRoutines(routines: any[]): Promise<void> {
+  if (!routines || routines.length === 0) return;
+
+  console.log(`${LOG_PREFIX} Processing ${routines.length} pending routine(s)...`);
+
+  for (const routine of routines) {
+    try {
+      const isUpdate = !!routine.openclaw_cron_id;
+
+      const scheduleInfo = [
+        routine.cron_expression ? `Cron: ${routine.cron_expression}` : null,
+        routine.frequency ? `Frequency: ${routine.frequency}` : null,
+        routine.timezone ? `Timezone: ${routine.timezone}` : null,
+        routine.schedule_human ? `Schedule: ${routine.schedule_human}` : null,
+      ].filter(Boolean).join(" | ");
+
+      const messageContent = isUpdate
+        ? `[ROUTINE_UPDATE] The user updated routine "${routine.name}" (ID: ${routine.id}). ${scheduleInfo ? scheduleInfo + ". " : ""}Instruction: ${routine.instruction || "unchanged"}. Please update your cron job${routine.openclaw_cron_id ? ` (cron ID: ${routine.openclaw_cron_id})` : ""} accordingly and call clawaxis_update_routine to confirm the changes.`
+        : `[ROUTINE_REQUEST] The user created a new routine: "${routine.name}". ${scheduleInfo ? scheduleInfo + ". " : ""}Instruction: ${routine.instruction}. Please create a cron job for this and call clawaxis_notify_routine with the cron ID and details to register it in the app.`;
+
+      console.log(`${LOG_PREFIX} Dispatching routine to agent: ${routine.name} (${isUpdate ? "update" : "new"})`);
+
+      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
+        }));
+      }
+
+      await relayLog(
+        "system",
+        `Routine ${isUpdate ? "update" : "request"} dispatched to agent: ${routine.name}`,
+        "info",
+        { routine_id: routine.id, instruction: routine.instruction }
+      );
+
+    } catch (err: any) {
+      console.error(`${LOG_PREFIX} Failed to process routine ${routine.id}:`, err);
+      await relayLog(
+        "error",
+        `Failed to dispatch routine: ${routine.name}`,
+        "error",
+        { routine_id: routine.id, error: err.message }
+      );
+    }
+  }
+}

package/src/tools/content.ts

@@ -0,0 +1,64 @@
+import { Type } from "@sinclair/typebox";
+import { LOG_PREFIX } from "../config.js";
+import { relayFetch } from "../utils.js";
+import { toolOk, toolFail, wsSendOrHttp } from "./helpers.js";
+
+export function registerContentTools(api: any) {
+  api.registerTool({
+    name: "clawaxis_post_content",
+    description: "Post content to the ClawAxis app for user review. Requires title, body, and content_type. See CLAWAXIS.md for content_type rendering rules, character limits, and media requirements.",
+    parameters: Type.Object({
+      title: Type.String({ description: "Content title. REQUIRED. Used as card header and for identification." }),
+      body: Type.String({ description: "Full content body. Plain text for social platforms, Markdown for blog/report/email/ad, raw HTML for website." }),
+      content_type: Type.String({ description: "REQUIRED. Determines rendering: twitter, instagram, linkedin, facebook, tiktok, youtube, website, blog, report, email, ad, document, other" }),
+      platform: Type.Optional(Type.String({ description: "Legacy field. Use content_type instead." })),
+      tags: Type.Optional(Type.Array(Type.String(), { description: "Tag strings. For instagram/tiktok these become #hashtags. For blog/report these are pill badges. Provide without # prefix." })),
+      seo_keywords: Type.Optional(Type.Array(Type.String(), { description: "SEO keyword phrases. Shown in blog/report card footer." })),
+      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." })),
+    }),
+    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");
+    },
+  });
+
+  api.registerTool({
+    name: "clawaxis_get_content",
+    description: "Retrieve content from the ClawAxis app. Get recent content list or fetch a specific item by ID.",
+    parameters: Type.Object({
+      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");
+    },
+  });
+
+  api.registerTool({
+    name: "clawaxis_update_content",
+    description: "Update existing content in the ClawAxis app by content_id. Relay auto-increments edit_count and preserves original_body on first edit.",
+    parameters: Type.Object({
+      content_id: Type.String({ description: "UUID of the content to update (from a previous clawaxis_post_content or clawaxis_get_content call)" }),
+      body: Type.String({ description: "The complete updated body. Same format rules as post: plain text for social, Markdown for blog/report, HTML for website." }),
+      title: Type.Optional(Type.String({ description: "Updated title. Omit to keep existing." })),
+      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");
+    },
+  });
+}

package/src/tools/helpers.ts

@@ -0,0 +1,40 @@
+import WS from "ws";
+import { getWs, getIsAuthenticated } from "../runtime.js";
+import { relayFetch } from "../utils.js";
+
+export interface ToolResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: Record<string, any>;
+}
+
+export function toolOk(message: string, extra?: Record<string, any>): ToolResult {
+  return {
+    content: [{ type: "text", text: message }],
+    details: { success: true, ...extra },
+  };
+}
+
+export function toolFail(message: string, extra?: Record<string, any>): ToolResult {
+  return {
+    content: [{ type: "text", text: message }],
+    details: { success: false, ...extra },
+  };
+}
+
+/**
+ * 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).
+ */
+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);
+}

package/src/tools/index.ts

@@ -0,0 +1,16 @@
+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";
+
+export function registerTools(api: any, agentToken: string) {
+  setMemoryAgentToken(agentToken);
+  registerContentTools(api);
+  registerLoggingTools(api);
+  registerSyncTools(api);
+  registerRoutineTools(api);
+  registerMediaTools(api);
+  registerMemoryTools(api);
+}

package/src/tools/logging.ts

@@ -0,0 +1,33 @@
+import { Type } from "@sinclair/typebox";
+import { relayLog } from "../utils.js";
+import { toolOk } from "./helpers.js";
+
+export function registerLoggingTools(api: any) {
+  api.registerTool({
+    name: "clawaxis_post_log",
+    description: "Log activity to the ClawAxis dashboard Recent Activity feed. Use for task progress, errors, and milestones.",
+    parameters: Type.Object({
+      action: Type.String({ description: "Action type. MUST be one of: chat_message, content_generate, content_post, web_search, web_fetch, browser_action, cron_execute, skill_update, file_operation, system, error, tool_call" }),
+      detail: Type.String({ description: "Human-readable description of what happened (e.g. 'Generated blog post: AI Governance in Automotive')" }),
+      level: Type.Optional(Type.String({ description: "Log level. Must be: info, success, warning, or error. Default: info. Use 'success' for completed actions, 'error' for failures." })),
+      tokens_used: Type.Optional(Type.Number({ description: "Token count consumed by this action" })),
+      cost: Type.Optional(Type.Number({ description: "Cost in USD (e.g. 0.015)" })),
+      duration_ms: Type.Optional(Type.Number({ description: "How long the action took in milliseconds" })),
+      metadata: Type.Optional(Type.Any({ description: "Additional context as JSON object (e.g. {tool_name: 'generate_image'})" })),
+    }),
+    async execute(_id: string, params: any) {
+      await relayLog(
+        params.action,
+        params.detail,
+        params.level as any || "info",
+        {
+          tokens_used: params.tokens_used,
+          cost: params.cost,
+          duration_ms: params.duration_ms,
+          ...params.metadata
+        }
+      );
+      return toolOk("Log posted to ClawAxis app");
+    },
+  });
+}

package/src/tools/media.ts

@@ -0,0 +1,21 @@
+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 });
+    },
+  });
+}