@aight-cool/aight-utils 0.1.0

package/src/config.ts

@@ -0,0 +1,113 @@
+/**
+ * Config RPC module — aight.config.get, aight.config.patch, aight.status
+ */
+
+import type { OpenClawPluginApi, GatewayRequestHandlerOptions } from "openclaw/plugin-sdk";
+import { DEFAULT_PUSH_MODE } from "./defaults.js";
+
+export interface AightConfig {
+  push?: {
+    mode?: "private" | "rich";
+    relayUrl?: string;
+    relaySecret?: string;
+  };
+  today?: {
+    enabled?: boolean;
+  };
+}
+
+/** Secret keys that must never be returned to clients via RPC */
+const SECRET_KEYS: string[] = ["relaySecret"];
+
+/** Returns a sanitized copy of the config with secrets redacted */
+export function getClientSafeConfig(config: AightConfig): Record<string, unknown> {
+  const safe = JSON.parse(JSON.stringify(config));
+  if (safe.push) {
+    for (const key of SECRET_KEYS) {
+      if (key in safe.push) {
+        safe.push[key] = safe.push[key] ? "[REDACTED]" : undefined;
+      }
+    }
+  }
+  return safe;
+}
+
+export function getPluginConfig(api: OpenClawPluginApi): AightConfig {
+  const raw = api.pluginConfig;
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? (raw as AightConfig) : {};
+}
+
+export function registerConfig(api: OpenClawPluginApi) {
+  api.registerGatewayMethod("aight.config.get", ({ respond }: GatewayRequestHandlerOptions) => {
+    respond(true, getClientSafeConfig(getPluginConfig(api)));
+  });
+
+  api.registerGatewayMethod(
+    "aight.config.patch",
+    async ({ params, respond }: GatewayRequestHandlerOptions) => {
+      if (!params || typeof params !== "object") {
+        respond(false, { error: "params must be an object" });
+        return;
+      }
+      try {
+        // Load current config, merge patch into plugin config, write back
+        const currentConfig = await api.runtime.config.loadConfig();
+        const pluginEntry = (currentConfig as any)?.plugins?.entries?.["aight-utils"] ?? {};
+        const currentPluginConfig = pluginEntry.config ?? {};
+
+        // Deep merge the patch into plugin config
+        const merged = { ...currentPluginConfig };
+        for (const [key, value] of Object.entries(params as Record<string, unknown>)) {
+          if (
+            value &&
+            typeof value === "object" &&
+            !Array.isArray(value) &&
+            merged[key] &&
+            typeof merged[key] === "object"
+          ) {
+            merged[key] = { ...merged[key], ...value };
+          } else {
+            merged[key] = value;
+          }
+        }
+
+        // Write updated config
+        const updatedConfig = {
+          ...(currentConfig as Record<string, unknown>),
+          plugins: {
+            ...((currentConfig as any)?.plugins ?? {}),
+            entries: {
+              ...((currentConfig as any)?.plugins?.entries ?? {}),
+              "aight-utils": {
+                ...pluginEntry,
+                config: merged,
+              },
+            },
+          },
+        };
+
+        await api.runtime.config.writeConfigFile(updatedConfig as any);
+        respond(true, { ok: true, config: getClientSafeConfig(merged as AightConfig) });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        api.logger.error(`[aight-utils] config.patch failed: ${msg}`);
+        respond(false, { error: msg });
+      }
+    },
+  );
+
+  api.registerGatewayMethod("aight.status", ({ respond }: GatewayRequestHandlerOptions) => {
+    const cfg = getPluginConfig(api);
+    respond(true, {
+      ok: true,
+      version: "0.1.0",
+      push: {
+        mode: cfg.push?.mode ?? DEFAULT_PUSH_MODE,
+        relayUrl: cfg.push?.relayUrl ?? "https://push.aight.app",
+      },
+      today: {
+        enabled: cfg.today?.enabled ?? true,
+      },
+    });
+  });
+}

package/src/defaults.ts

@@ -0,0 +1,5 @@
+/** Default push relay URL */
+export const DEFAULT_RELAY_URL = "https://push.aight.cool";
+
+/** Default push notification mode */
+export const DEFAULT_PUSH_MODE: "private" | "rich" = "rich";

package/src/health.ts

@@ -0,0 +1,95 @@
+/**
+ * System health RPC — aight.health
+ *
+ * Returns memory, CPU, disk stats without needing an LLM call.
+ */
+
+import { execSync } from "child_process";
+import { platform } from "os";
+import type { OpenClawPluginApi, GatewayRequestHandlerOptions } from "openclaw/plugin-sdk";
+
+interface HealthStats {
+  memory: { usedGB: number; totalGB: number; percent: number } | null;
+  cpu: { percent: number } | null;
+  disk: { usedGB: number; totalGB: number; percent: number } | null;
+}
+
+function getStats(): HealthStats {
+  const os = platform();
+  let memory: HealthStats["memory"] = null;
+  let cpu: HealthStats["cpu"] = null;
+  let disk: HealthStats["disk"] = null;
+
+  try {
+    if (os === "darwin") {
+      // Memory
+      const totalBytes = parseInt(
+        execSync("/usr/sbin/sysctl -n hw.memsize", { encoding: "utf8", timeout: 5000 }).trim(),
+      );
+      const top = execSync("top -l 1 -n 0", { encoding: "utf8", timeout: 5000 });
+      const memMatch = top.match(/PhysMem:\s*(\d+)([GM])\s*used/);
+      const usedGB = memMatch ? parseInt(memMatch[1]) * (memMatch[2] === "G" ? 1 : 1 / 1024) : 0;
+      const totalGB = totalBytes / 1073741824;
+      memory = {
+        usedGB: Math.round(usedGB * 10) / 10,
+        totalGB: Math.round(totalGB * 10) / 10,
+        percent: Math.round((usedGB / totalGB) * 100),
+      };
+
+      // CPU
+      const idleMatch = top.match(/([\d.]+)% idle/);
+      cpu = {
+        percent: idleMatch ? Math.round(100 - parseFloat(idleMatch[1])) : 0,
+      };
+    } else {
+      // Linux memory
+      const meminfo = execSync("cat /proc/meminfo", { encoding: "utf8", timeout: 5000 });
+      const totalKB = parseInt(meminfo.match(/MemTotal:\s*(\d+)/)?.[1] ?? "0");
+      const availKB = parseInt(meminfo.match(/MemAvailable:\s*(\d+)/)?.[1] ?? "0");
+      const totalGB = (totalKB * 1024) / 1073741824;
+      const usedGB = ((totalKB - availKB) * 1024) / 1073741824;
+      memory = {
+        usedGB: Math.round(usedGB * 10) / 10,
+        totalGB: Math.round(totalGB * 10) / 10,
+        percent: Math.round((usedGB / totalGB) * 100),
+      };
+
+      // Linux CPU
+      const loadavg = execSync("cat /proc/loadavg", { encoding: "utf8", timeout: 5000 });
+      const load1m = parseFloat(loadavg.split(" ")[0]);
+      const cores = parseInt(execSync("nproc", { encoding: "utf8", timeout: 5000 }).trim());
+      cpu = { percent: Math.round(Math.min((load1m / cores) * 100, 100)) };
+    }
+
+    // Disk (cross-platform via df)
+    const df = execSync("df -k /", { encoding: "utf8", timeout: 5000 });
+    const dfLine = df.split("\n")[1];
+    const dfParts = dfLine?.split(/\s+/);
+    if (dfParts && dfParts.length >= 4) {
+      const totalKB = parseInt(dfParts[1]);
+      const usedKB = parseInt(dfParts[2]);
+      disk = {
+        totalGB: Math.round(totalKB / 1048576),
+        usedGB: Math.round(usedKB / 1048576),
+        percent: Math.round((usedKB / totalKB) * 100),
+      };
+    }
+  } catch {
+    // Best effort — return whatever we got
+  }
+
+  return { memory, cpu, disk };
+}
+
+export function registerHealth(api: OpenClawPluginApi) {
+  api.registerGatewayMethod("aight.health", async ({ respond }: GatewayRequestHandlerOptions) => {
+    try {
+      const stats = getStats();
+      respond(true, stats);
+    } catch (err) {
+      respond(false, {
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  });
+}

package/src/items.ts

@@ -0,0 +1,228 @@
+/**
+ * Items Store — aight.items.list, aight.items.upsert, aight.items.delete + aight_item tool
+ */
+
+import { Type, type Static } from "@sinclair/typebox";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { OpenClawPluginApi, GatewayRequestHandlerOptions } from "openclaw/plugin-sdk";
+
+// ── Types ──
+
+export const ItemType = Type.Union([
+  Type.Literal("trigger"),
+  Type.Literal("item"),
+  Type.Literal("process"),
+]);
+
+export const ItemStatus = Type.Union([
+  Type.Literal("active"),
+  Type.Literal("done"),
+  Type.Literal("fired"),
+  Type.Literal("cancelled"),
+  Type.Literal("deleted"),
+]);
+
+export const ItemSchema = Type.Object({
+  id: Type.String({ description: "Unique item ID" }),
+  type: ItemType,
+  title: Type.String({ description: "Display title" }),
+  status: Type.Optional(ItemStatus),
+  labels: Type.Optional(Type.Array(Type.String())),
+  scheduledFor: Type.Optional(Type.String({ description: "ISO 8601 datetime for triggers" })),
+  description: Type.Optional(Type.String()),
+  url: Type.Optional(Type.String({ description: "Related URL (PR, issue, etc.)" })),
+  metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+  createdAt: Type.Optional(Type.String()),
+  updatedAt: Type.Optional(Type.String()),
+});
+
+export type Item = Static<typeof ItemSchema>;
+
+// ── Store ──
+
+const STORE_DIR = path.join(os.homedir(), ".openclaw", "aight");
+const STORE_FILE = path.join(STORE_DIR, "items.json");
+
+export function loadItems(): Item[] {
+  try {
+    if (!fs.existsSync(STORE_FILE)) return [];
+    const raw = fs.readFileSync(STORE_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveItems(items: Item[]): void {
+  fs.mkdirSync(STORE_DIR, { recursive: true });
+  fs.writeFileSync(STORE_FILE, JSON.stringify(items, null, 2), { encoding: "utf-8", mode: 0o600 });
+}
+
+const MAX_TITLE_LEN = 500;
+const MAX_DESC_LEN = 5000;
+const MAX_ITEMS = 10000;
+
+export function upsertItem(item: Item): Item {
+  if (item.title && item.title.length > MAX_TITLE_LEN) {
+    throw new Error(`title exceeds max length of ${MAX_TITLE_LEN}`);
+  }
+  if (item.description && item.description.length > MAX_DESC_LEN) {
+    throw new Error(`description exceeds max length of ${MAX_DESC_LEN}`);
+  }
+  const items = loadItems();
+  const now = new Date().toISOString();
+  const idx = items.findIndex((i) => i.id === item.id);
+  if (idx < 0 && items.length >= MAX_ITEMS) {
+    throw new Error(`item store full (max ${MAX_ITEMS})`);
+  }
+  const merged: Item = {
+    ...item,
+    status: item.status ?? "active",
+    updatedAt: now,
+    createdAt: idx >= 0 ? items[idx].createdAt : now,
+  };
+  if (idx >= 0) {
+    items[idx] = merged;
+  } else {
+    items.push(merged);
+  }
+  saveItems(items);
+  return merged;
+}
+
+export function deleteItem(id: string): boolean {
+  const items = loadItems();
+  const idx = items.findIndex((i) => i.id === id);
+  if (idx < 0) return false;
+  items[idx] = { ...items[idx], status: "deleted", updatedAt: new Date().toISOString() };
+  saveItems(items);
+  return true;
+}
+
+export interface ListFilters {
+  type?: string;
+  labels?: string[];
+  status?: string;
+  from?: string;
+  to?: string;
+}
+
+export function listItems(filters: ListFilters = {}): Item[] {
+  let items = loadItems().filter((i) => i.status !== "deleted");
+
+  if (filters.type) {
+    items = items.filter((i) => i.type === filters.type);
+  }
+  if (filters.status) {
+    items = items.filter((i) => i.status === filters.status);
+  }
+  if (filters.labels && filters.labels.length > 0) {
+    items = items.filter((i) => filters.labels!.some((l) => i.labels?.includes(l)));
+  }
+  if (filters.from) {
+    const fromTs = new Date(filters.from).getTime();
+    items = items.filter((i) => {
+      if (!i.scheduledFor) return true;
+      return new Date(i.scheduledFor).getTime() >= fromTs;
+    });
+  }
+  if (filters.to) {
+    const toTs = new Date(filters.to).getTime();
+    items = items.filter((i) => {
+      if (!i.scheduledFor) return true;
+      return new Date(i.scheduledFor).getTime() <= toTs;
+    });
+  }
+
+  return items;
+}
+
+// ── Tool schema ──
+
+export const AightItemToolParams = Type.Object({
+  action: Type.Union([Type.Literal("create"), Type.Literal("update"), Type.Literal("delete")]),
+  item: Type.Optional(ItemSchema),
+  id: Type.Optional(Type.String({ description: "Item ID (for delete)" })),
+});
+
+// ── Registration ──
+
+export function registerItems(api: OpenClawPluginApi) {
+  api.registerGatewayMethod(
+    "aight.items.list",
+    ({ params, respond }: GatewayRequestHandlerOptions) => {
+      const filters: ListFilters =
+        params && typeof params === "object" ? (params as ListFilters) : {};
+      respond(true, { items: listItems(filters) });
+    },
+  );
+
+  api.registerGatewayMethod(
+    "aight.items.upsert",
+    ({ params, respond }: GatewayRequestHandlerOptions) => {
+      if (
+        !params ||
+        typeof params !== "object" ||
+        !("id" in params) ||
+        !("type" in params) ||
+        !("title" in params)
+      ) {
+        respond(false, { error: "item must have id, type, and title" });
+        return;
+      }
+      const item = upsertItem(params as Item);
+      respond(true, { item });
+    },
+  );
+
+  api.registerGatewayMethod(
+    "aight.items.delete",
+    ({ params, respond }: GatewayRequestHandlerOptions) => {
+      const id = typeof params?.id === "string" ? params.id : "";
+      if (!id) {
+        respond(false, { error: "id required" });
+        return;
+      }
+      const ok = deleteItem(id);
+      respond(true, { ok, id });
+    },
+  );
+
+  api.registerTool({
+    name: "aight_item",
+    label: "Aight Item",
+    description:
+      "Create, update, or delete a structured item in the Aight Today view. " +
+      "Use for reminders, tasks, events, deadlines, and process tracking. " +
+      "Parse natural language dates/times before calling (e.g. 'tomorrow at 3pm' → ISO 8601).",
+    parameters: AightItemToolParams,
+    async execute(_toolCallId: string, params: any) {
+      const json = (payload: unknown) => ({
+        content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
+        details: payload,
+      });
+
+      try {
+        if (params.action === "delete") {
+          const id = params.id ?? params.item?.id;
+          if (!id) throw new Error("id required for delete");
+          const ok = deleteItem(id);
+          return json({ ok, id });
+        }
+
+        if (!params.item) throw new Error("item required for create/update");
+        if (!params.item.id || !params.item.type || !params.item.title) {
+          throw new Error("item must have id, type, and title");
+        }
+
+        const item = upsertItem(params.item);
+        return json({ action: params.action, item });
+      } catch (err) {
+        return json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    },
+  });
+}

package/src/push-hook.ts

@@ -0,0 +1,90 @@
+/**
+ * Push notification hook — sends push on agent_end.
+ */
+
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { getPluginConfig } from "./config.js";
+import { sendPush, loadTokens } from "./push.js";
+
+export function registerPushHook(api: OpenClawPluginApi) {
+  try {
+    api.on("agent_end", async (event, ctx) => {
+      api.logger.info(
+        `[aight-utils] agent_end fired session=${ctx.sessionKey} agent=${ctx.agentId}`,
+      );
+      const tokens = loadTokens();
+      if (tokens.length === 0) return;
+
+      const msgs = event.messages ?? [];
+      api.logger.info(
+        `[aight-utils] messages count=${msgs.length} roles=${msgs.map((m: any) => m.role).join(",")}`,
+      );
+
+      // Extract last assistant message - try string and array content formats
+      let preview = "";
+      for (let i = msgs.length - 1; i >= 0; i--) {
+        const m = msgs[i] as any;
+        if (m.role === "assistant") {
+          if (typeof m.content === "string" && m.content.trim()) {
+            preview = m.content.slice(0, 200);
+            break;
+          }
+          if (Array.isArray(m.content)) {
+            const textBlock = m.content.find(
+              (b: any) => b.type === "text" && typeof b.text === "string",
+            );
+            if (textBlock) {
+              preview = textBlock.text.slice(0, 200);
+              break;
+            }
+          }
+        }
+      }
+
+      if (!preview) {
+        api.logger.info(`[aight-utils] No preview found, skipping push`);
+        return;
+      }
+
+      // Skip internal/meta responses
+      const skip = ["NO_REPLY", "REPLY_SKIP", "ANNOUNCE_SKIP", "HEARTBEAT_OK"];
+      if (skip.includes(preview.trim())) {
+        api.logger.info(`[aight-utils] Skipping meta response: ${preview.trim()}`);
+        return;
+      }
+
+      const freshConfig = getPluginConfig(api);
+
+      // Resolve display name from gateway config agent list
+      const agentId = ctx.agentId ?? "agent";
+      const agents = (api.config as any)?.agents?.list ?? [];
+      const agent = agents.find((a: any) => a.id === agentId);
+      const displayName = agent?.name ?? agent?.identity?.name ?? agentId;
+
+      for (const device of tokens) {
+        if (!device.sendKey) continue;
+        try {
+          await sendPush(
+            device.deviceId,
+            {
+              title: displayName,
+              body: preview,
+              data: { sessionKey: ctx.sessionKey, agentId },
+            },
+            freshConfig,
+          );
+        } catch (err) {
+          api.logger.warn(
+            `[aight-utils] Push failed: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+      }
+    });
+
+    api.logger.info("[aight-utils] Push hook registered (agent_end)");
+  } catch (err) {
+    api.logger.error(
+      `[aight-utils] Failed to register push hook: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}