clawmatrix 0.5.0 → 0.6.0

package/src/api.ts

@@ -10,6 +10,9 @@ import type { KnowledgeSync } from "./knowledge-sync.ts";
 import { nanoid } from "nanoid";
 import { timingSafeEqual } from "./auth.ts";
 import { readBody } from "./http-utils.ts";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname } from "node:path";
 
 const COOKIE_NAME = "clawmatrix_token";
 const SESSION_MAX_AGE = 86400 * 7; // 7 days
@@ -27,6 +30,255 @@ const CLUSTER_TOOLS = [
   "cluster_notify", "cluster_query",
 ];
 
+/** Full tool definitions for /api/tools endpoint. */
+const CLUSTER_TOOL_DEFS: Array<{ name: string; description: string; inputSchema: Record<string, unknown> }> = [
+  {
+    name: "cluster_peers",
+    description: "List all peers in the cluster with their agents, models, tools, tags, and connection status. Call this first to discover what's available before using other cluster tools.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "cluster_exec",
+    description: "Execute a shell command on a remote cluster node. Returns {stdout, stderr, exitCode}. Use nodeId or 'tags:<tag>' to specify the target.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node: { type: "string", description: "Target nodeId or \"tags:<tag>\"" },
+        command: { type: "string", description: "Shell command to execute" },
+        workdir: { type: "string", description: "Working directory (optional)" },
+        timeout: { type: "number", description: "Timeout in seconds (default 1800)" },
+      },
+      required: ["node", "command"],
+    },
+  },
+  {
+    name: "cluster_read",
+    description: "Read a file from a remote cluster node. Returns {content} with the file text.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node: { type: "string", description: "Target nodeId or \"tags:<tag>\"" },
+        path: { type: "string", description: "File path to read" },
+      },
+      required: ["node", "path"],
+    },
+  },
+  {
+    name: "cluster_write",
+    description: "Write content to a file on a remote cluster node (creates or overwrites).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node: { type: "string", description: "Target nodeId or \"tags:<tag>\"" },
+        path: { type: "string", description: "File path to write" },
+        content: { type: "string", description: "Content to write" },
+      },
+      required: ["node", "path", "content"],
+    },
+  },
+  {
+    name: "cluster_edit",
+    description: "Edit a file on a remote cluster node by replacing exact text. Use cluster_read first to get exact file content.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node: { type: "string", description: "Target nodeId or \"tags:<tag>\"" },
+        path: { type: "string", description: "File path to edit" },
+        oldText: { type: "string", description: "Exact text to find and replace" },
+        newText: { type: "string", description: "New text to replace with" },
+      },
+      required: ["node", "path", "oldText", "newText"],
+    },
+  },
+  {
+    name: "cluster_handoff",
+    description: "Hand off a complex task to another agent in the cluster and wait for the result. Use for multi-step tasks that require the remote agent's full capabilities.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Agent ID or \"tags:<tag>\" expression" },
+        task: { type: "string", description: "Task description for the remote agent" },
+        context: { type: "string", description: "Additional context for the task" },
+      },
+      required: ["target", "task"],
+    },
+  },
+  {
+    name: "cluster_handoff_reply",
+    description: "Reply to a remote agent that requested more input during a handoff. Use the handoff_id returned by cluster_handoff.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        handoff_id: { type: "string", description: "The handoff ID from cluster_handoff's response" },
+        message: { type: "string", description: "Your reply to the remote agent's question" },
+      },
+      required: ["handoff_id", "message"],
+    },
+  },
+  {
+    name: "cluster_send",
+    description: "Send a one-way notification to a remote agent. Fire-and-forget: does not wait for a response.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Agent ID or \"tags:<tag>\" expression" },
+        message: { type: "string", description: "Message content to send" },
+      },
+      required: ["target", "message"],
+    },
+  },
+  {
+    name: "cluster_batch",
+    description: "Execute multiple tools on a remote node in a single round-trip. Tools run sequentially (supports dependencies like read→edit).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node: { type: "string", description: "Target nodeId or \"tags:<tag>\"" },
+        items: { type: "array", description: "Array of { tool, params } to execute in order", items: { type: "object", properties: { tool: { type: "string" }, params: { type: "object" } }, required: ["tool", "params"] } },
+        stopOnError: { type: "boolean", description: "Stop on first error (default true)" },
+      },
+      required: ["node", "items"],
+    },
+  },
+  {
+    name: "cluster_tool",
+    description: "Invoke any tool on a remote cluster node by name. Preferred for device-specific tools (screenshot, battery, location, clipboard, etc.).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node: { type: "string", description: "Target nodeId or \"tags:<tag>\"" },
+        tool: { type: "string", description: "Remote tool name to invoke" },
+        params: { type: "object", description: "Parameters to pass to the remote tool" },
+        timeout: { type: "number", description: "Timeout in seconds (default 30)" },
+      },
+      required: ["node", "tool"],
+    },
+  },
+  {
+    name: "cluster_terminal",
+    description: "Interactive terminal (PTY) on a remote cluster node. Actions: open, input, read, resize, list, close. Prefer cluster_exec for one-shot commands.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["open", "input", "read", "resize", "list", "close"], description: "Action to perform (default: open)" },
+        node: { type: "string", description: "Target node ID (required for open)" },
+        sessionId: { type: "string", description: "Session ID (required for input/read/resize/close)" },
+        data: { type: "string", description: "Input data to send (for input action)" },
+        shell: { type: "string", description: "Shell to use (default: $SHELL)" },
+        cols: { type: "number", description: "Terminal columns (default: 80)" },
+        rows: { type: "number", description: "Terminal rows (default: 24)" },
+      },
+    },
+  },
+  {
+    name: "cluster_transfer",
+    description: "Transfer a file between local and remote nodes. Supports up to 100MB with chunked transfer and SHA-256 integrity check.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        source_path: { type: "string", description: "File path on the source node" },
+        target_path: { type: "string", description: "File path on the target node" },
+        source_node: { type: "string", description: "Source nodeId (omit for local)" },
+        target_node: { type: "string", description: "Target nodeId (omit for local)" },
+      },
+      required: ["source_path", "target_path"],
+    },
+  },
+  {
+    name: "cluster_events",
+    description: "Query and consume events from external sources (iOS Shortcuts, webhooks, etc.). Events are persistent until consumed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["query", "consume"], description: "\"query\" to list events, \"consume\" to mark as processed" },
+        type: { type: "string", description: "Filter by event type" },
+        source: { type: "string", description: "Filter by source" },
+        unconsumed: { type: "boolean", description: "Only unconsumed events (default true)" },
+        limit: { type: "number", description: "Max events to return (default 20)" },
+        ids: { type: "array", items: { type: "string" }, description: "Event IDs to consume" },
+      },
+      required: ["action"],
+    },
+  },
+  {
+    name: "cluster_diagnostic",
+    description: "Diagnose or execute commands on a remote node's sentinel process. Works even when the gateway is down.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node: { type: "string", description: "Target nodeId" },
+        action: { type: "string", enum: ["status", "exec"], description: "\"status\" to check health, \"exec\" to run a command" },
+        command: { type: "string", description: "Shell command (required for exec)" },
+        timeout: { type: "number", description: "Timeout in seconds (default 30)" },
+      },
+      required: ["node", "action"],
+    },
+  },
+  {
+    name: "cluster_acp",
+    description: "Run a task on a remote coding agent (Claude Code, Codex, Gemini CLI) via ACP protocol. Supports one-shot and persistent sessions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["prompt", "list", "resume", "cancel", "set_mode", "get_modes", "close"], description: "Action to perform (default: prompt)" },
+        node: { type: "string", description: "Target node ID or \"tags:<tag>\"" },
+        agent: { type: "string", description: "ACP agent name: \"claude\", \"codex\", \"gemini\"" },
+        task: { type: "string", description: "Task or prompt to send" },
+        sessionId: { type: "string", description: "Session ID for follow-up or management" },
+        mode: { type: "string", enum: ["oneshot", "persistent"], description: "Session mode (default: oneshot)" },
+        cwd: { type: "string", description: "Working directory on the remote node" },
+      },
+      required: ["node"],
+    },
+  },
+  {
+    name: "cluster_kanban",
+    description: "Manage the distributed kanban board for tracking work items across the cluster. Supports create, list, get, claim, move, annotate, update, delete, summary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "list", "get", "claim", "move", "annotate", "update", "delete", "summary"], description: "Action to perform (default: list)" },
+        cardId: { type: "string", description: "Card ID for get/claim/move/annotate/update/delete" },
+        title: { type: "string", description: "Card title (for create or update)" },
+        description: { type: "string", description: "Card description in Markdown" },
+        stage: { type: "string", enum: ["backlog", "claimed", "in_progress", "review", "done", "archived"], description: "Target stage or filter" },
+        priority: { type: "string", enum: ["low", "medium", "high", "urgent"], description: "Card priority" },
+        labels: { type: "array", items: { type: "string" }, description: "Labels" },
+      },
+    },
+  },
+  {
+    name: "cluster_notify",
+    description: "Push a notification to mobile devices in the cluster (Dynamic Island / Live Activity on iOS). Track long-running task progress.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["start", "update", "end"], description: "Action to perform (default: start)" },
+        taskId: { type: "string", description: "Task ID for update/end actions" },
+        title: { type: "string", description: "Activity title" },
+        detail: { type: "string", description: "Activity detail text" },
+        progress: { type: "number", description: "Progress 0.0 to 1.0" },
+        tool: { type: "string", description: "Current tool being executed" },
+        success: { type: "boolean", description: "For end: true=completed, false=failed" },
+      },
+    },
+  },
+  {
+    name: "cluster_query",
+    description: "Query replicated data from SQLite: audit_log, health_events, handoff_history. Data is replicated across peers for cluster-wide view.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        table: { type: "string", enum: ["audit_log", "health_events", "handoff_history"], description: "Which table to query" },
+        since: { type: "number", description: "Events after this unix timestamp (ms). Negative for relative." },
+        node_id: { type: "string", description: "Filter by node ID" },
+        limit: { type: "number", description: "Max rows (default 50)" },
+      },
+      required: ["table"],
+    },
+  },
+];
+
 interface SatelliteEvent {
   ts: number;
   type: "peer_online" | "peer_offline" | "handoff_done" | "context_update" | "event_ingested" | "kanban";
@@ -216,6 +468,11 @@ export class ApiHandler {
       return;
     }
 
+    if (path === "/api/tools" && req.method === "GET") {
+      this.handleToolsList(res);
+      return;
+    }
+
     if (path === "/api/chat" && req.method === "POST") {
       this.handleChat(req, res);
       return;
@@ -267,6 +524,16 @@ export class ApiHandler {
       return;
     }
 
+    if (path === "/api/config/read" && req.method === "GET") {
+      this.handleConfigRead(req, res);
+      return;
+    }
+
+    if (path === "/api/config/write" && req.method === "POST") {
+      this.handleConfigWrite(req, res);
+      return;
+    }
+
     if (path === "/api/availability" && req.method === "GET") {
       this.handleAvailability(req, res);
       return;
@@ -298,6 +565,11 @@ export class ApiHandler {
       return;
     }
 
+    if (path === "/api/knowledge/content" && req.method === "GET") {
+      this.handleKnowledgeContent(req, res);
+      return;
+    }
+
     // Board / Kanban API
     if (path === "/api/board" && req.method === "GET") {
       this.handleBoardSummary(res);
@@ -434,9 +706,138 @@ export class ApiHandler {
       return;
     }
 
-    const result = this.healthTracker.getAvailability(range);
+    try {
+      const result = this.healthTracker.getAvailability(range);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: String((err as Error)?.message ?? err) }));
+    }
+  }
+
+  // ── Config file API (local node) ────────────────────────────────
+
+  /** Resolve config path, restricted to ~/.openclaw/ for safety. */
+  private resolveConfigPath(configPath: string): string | null {
+    const home = homedir();
+    const openclawDir = `${home}/.openclaw`;
+    // Normalize: replace ~ with home dir
+    const resolved = configPath.startsWith("~")
+      ? configPath.replace(/^~/, home)
+      : configPath;
+    // Security: only allow files under ~/.openclaw/
+    if (!resolved.startsWith(openclawDir)) return null;
+    // Prevent path traversal
+    if (resolved.includes("..")) return null;
+    return resolved;
+  }
+
+  /** Read a config file (for gateway methods). */
+  async readConfigFile(configPath: string): Promise<{ success: boolean; content?: string; error?: string }> {
+    const resolved = this.resolveConfigPath(configPath);
+    if (!resolved) return { success: false, error: "Path must be under ~/.openclaw/" };
+    try {
+      const content = await readFile(resolved, "utf-8");
+      return { success: true, content };
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") return { success: true, content: "{}" };
+      return { success: false, error: err instanceof Error ? err.message : "Failed to read config" };
+    }
+  }
+
+  /** Write a config file (for gateway methods). */
+  async writeConfigFile(configPath: string, content: string): Promise<{ success: boolean; error?: string }> {
+    const resolved = this.resolveConfigPath(configPath);
+    if (!resolved) return { success: false, error: "Path must be under ~/.openclaw/" };
+    try {
+      await mkdir(dirname(resolved), { recursive: true });
+      await writeFile(resolved, content, "utf-8");
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : "Failed to write config" };
+    }
+  }
+
+  /** GET /api/config/read?path=<configPath> — read a local config file. */
+  private async handleConfigRead(req: IncomingMessage, res: ServerResponse) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const configPath = url.searchParams.get("path");
+    if (!configPath) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing required query param: path" }));
+      return;
+    }
+
+    const resolved = this.resolveConfigPath(configPath);
+    if (!resolved) {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Path must be under ~/.openclaw/" }));
+      return;
+    }
+
+    try {
+      const content = await readFile(resolved, "utf-8");
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, content }));
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: true, content: "{}" }));
+      } else {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: err instanceof Error ? err.message : "Failed to read config" }));
+      }
+    }
+  }
+
+  /** POST /api/config/write — write a local config file. Body: { path, content } */
+  private async handleConfigWrite(req: IncomingMessage, res: ServerResponse) {
+    try {
+      const body = await readBody(req);
+      const { path: configPath, content } = JSON.parse(body);
+      if (!configPath || typeof content !== "string") {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "path and content required" }));
+        return;
+      }
+
+      const resolved = this.resolveConfigPath(configPath);
+      if (!resolved) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Path must be under ~/.openclaw/" }));
+        return;
+      }
+
+      // Ensure directory exists
+      await mkdir(dirname(resolved), { recursive: true });
+      await writeFile(resolved, content, "utf-8");
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: err instanceof Error ? err.message : "Failed to write config" }));
+    }
+  }
+
+  /** GET /api/tools — list cluster tools with descriptions and input schemas. */
+  private handleToolsList(res: ServerResponse) {
+    // Build per-node tool info: local node tools + remote peer tools
+    const nodes: Array<{ nodeId: string; tools: typeof CLUSTER_TOOL_DEFS }> = [];
+
+    // Local node
+    nodes.push({ nodeId: this.config.nodeId, tools: CLUSTER_TOOL_DEFS });
+
+    // Remote peers — include cluster tools for each online peer with toolProxy
+    const peers = this.peerManager.router.getAllPeers();
+    for (const p of peers) {
+      if (!this.peerManager.canReach(p.nodeId)) continue;
+      if (!p.toolProxy?.enabled) continue;
+      nodes.push({ nodeId: p.nodeId, tools: CLUSTER_TOOL_DEFS });
+    }
+
     res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify(result));
+    res.end(JSON.stringify({ nodes }));
   }
 
   private handleStatus(res: ServerResponse) {
@@ -1208,6 +1609,46 @@ export class ApiHandler {
     return events.slice(-(opts?.limit ?? 50)).reverse();
   }
 
+  /** Ingest events programmatically (from gateway methods, CLI, etc.). */
+  ingestEvents(items: Array<Record<string, unknown>>): { count: number; ids: string[] } {
+    const ingested: IngestedEvent[] = [];
+    for (const item of items) {
+      if (!item.type) continue;
+      const event: IngestedEvent = {
+        id: nanoid(),
+        source: String(item.source || "unknown"),
+        type: String(item.type),
+        data: (typeof item.data === "object" && item.data !== null ? item.data : { value: item.data ?? item }) as Record<string, unknown>,
+        ts: typeof item.ts === "number" ? Math.min(item.ts as number, Date.now()) : Date.now(),
+        consumed: false,
+      };
+      this.ingestedEvents.push(event);
+      ingested.push(event);
+      try {
+        this.store?.insertIngestedEvent({
+          id: event.id, ts: event.ts, type: event.type, source: event.source,
+          data: JSON.stringify(event.data),
+        });
+      } catch { /* non-fatal */ }
+    }
+    if (this.ingestedEvents.length > MAX_INGESTED_EVENTS) {
+      this.ingestedEvents.splice(0, this.ingestedEvents.length - MAX_INGESTED_EVENTS);
+    }
+    for (const event of ingested) {
+      this.pushSatelliteEvent({
+        ts: event.ts,
+        type: "event_ingested" as SatelliteEvent["type"],
+        data: { id: event.id, source: event.source, type: event.type },
+      });
+    }
+    if (this.automationManager) {
+      for (const event of ingested) {
+        this.automationManager.onEventIngested(event);
+      }
+    }
+    return { count: ingested.length, ids: ingested.map(e => e.id) };
+  }
+
   /** Mark events as consumed by id(s). */
   consumeEvents(ids: string[]): number {
     if (this.store) {
@@ -1251,8 +1692,9 @@ export class ApiHandler {
       return;
     }
     const files = this.knowledgeSync.listSyncedFiles();
+    const workspacePath = this.knowledgeSync.workspacePath;
     res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ success: true, files }));
+    res.end(JSON.stringify({ success: true, files, workspacePath }));
   }
 
   /** GET /api/knowledge/history?path=<relPath> — file change history from CRDT. */
@@ -1292,6 +1734,37 @@ export class ApiHandler {
     res.end(JSON.stringify({ success: true, path: filePath, history }));
   }
 
+  /** GET /api/knowledge/content?path=<relPath> — read synced file content from CRDT. */
+  private handleKnowledgeContent(req: IncomingMessage, res: ServerResponse) {
+    if (!this.knowledgeSync) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Knowledge sync not enabled" }));
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const filePath = url.searchParams.get("path");
+    if (!filePath) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing required query param: path" }));
+      return;
+    }
+    const content = this.knowledgeSync.getFileContent(filePath);
+    if (content === null) {
+      // Distinguish between "not in registry" and "in registry but content not yet synced"
+      const listed = this.knowledgeSync.listSyncedFiles().find(f => f.path === filePath);
+      if (listed) {
+        res.writeHead(202, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "File content not yet synced", syncing: true }));
+      } else {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "File not found" }));
+      }
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true, path: filePath, content }));
+  }
+
   // ── Board / Kanban API handlers ─────────────────────────────────
 
   private handleBoardSummary(res: ServerResponse) {

package/src/automation.ts

@@ -27,7 +27,14 @@ export interface AutomationTrigger {
   type: "event" | "schedule";
   source?: string;
   eventType?: string;
+  /** Interval-based schedule: repeat every N milliseconds (min 10s). */
   intervalMs?: number;
+  /** Daily schedule: time of day in "HH:MM" (24h) format. */
+  dailyTime?: string;
+  /** IANA timezone for daily schedule (default: system timezone). */
+  timezone?: string;
+  /** Days of week to run (0=Sun, 1=Mon, ..., 6=Sat). Empty/undefined = every day. */
+  daysOfWeek?: number[];
 }
 
 export interface AutomationCondition {
@@ -318,6 +325,27 @@ export class AutomationManager {
 
   async saveRules(rules: AutomationRule[]): Promise<void> {
     const normalized = rules.map((rule) => ({ ...rule, action: normalizeAction(rule.action) }));
+    for (const rule of normalized) {
+      const action = rule.action;
+      if (action.type === "handoff" || action.type == null) {
+        const handoff = action as AutomationHandoffAction;
+        if (!handoff.agent || !handoff.agent.trim()) {
+          throw new Error(`Rule "${rule.name || rule.id}": handoff action requires a non-empty agent`);
+        }
+        if (!handoff.task || !handoff.task.trim()) {
+          throw new Error(`Rule "${rule.name || rule.id}": handoff action requires a non-empty task`);
+        }
+      }
+      if (action.type === "tool") {
+        const tool = action as AutomationToolAction;
+        if (!tool.node || !tool.node.trim()) {
+          throw new Error(`Rule "${rule.name || rule.id}": tool action requires a non-empty node`);
+        }
+        if (!tool.tool || !tool.tool.trim()) {
+          throw new Error(`Rule "${rule.name || rule.id}": tool action requires a non-empty tool name`);
+        }
+      }
+    }
     const content: AutomationsFile = { rules: normalized };
     await writeFile(this.filePath, JSON.stringify(content, null, 2), "utf-8");
     this.stopScheduleTimers();
@@ -523,7 +551,7 @@ export class AutomationManager {
           title,
           detail,
           progress,
-          status: success ? "completed" : "error",
+          status: success ? "completed" : "failed",
         },
       });
     } catch {
@@ -577,6 +605,13 @@ export class AutomationManager {
     for (const rule of this.rules) {
       if (!rule.enabled) continue;
       if (rule.trigger.type !== "schedule") continue;
+
+      if (rule.trigger.dailyTime) {
+        // Daily schedule: check every 30s if we should fire
+        this.scheduleDailyTimer(rule);
+        continue;
+      }
+
       if (!rule.trigger.intervalMs || rule.trigger.intervalMs < 10_000) continue;
 
       const timer = setInterval(() => {
@@ -589,6 +624,60 @@ export class AutomationManager {
     }
   }
 
+  private scheduleDailyTimer(rule: AutomationRule): void {
+    const CHECK_INTERVAL = 30_000; // Check every 30s
+    const fired = new Set<string>(); // Track fired dates to prevent double-fire
+
+    const timer = setInterval(() => {
+      const { dailyTime, timezone, daysOfWeek } = rule.trigger;
+      if (!dailyTime) return;
+
+      const now = new Date();
+      // Format current time in the target timezone
+      const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone || undefined,
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+        weekday: "short",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+      });
+      const parts = Object.fromEntries(
+        formatter.formatToParts(now).map((p) => [p.type, p.value]),
+      );
+
+      const currentTime = `${parts.hour}:${parts.minute}`;
+      const dateKey = `${parts.year}-${parts.month}-${parts.day}`;
+
+      // Check time match (within 1-minute window)
+      if (currentTime !== dailyTime) return;
+
+      // Check day-of-week filter
+      if (daysOfWeek && daysOfWeek.length > 0) {
+        const dayMap: Record<string, number> = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+        const currentDay = dayMap[parts.weekday] ?? now.getDay();
+        if (!daysOfWeek.includes(currentDay)) return;
+      }
+
+      // Prevent double-fire within same date
+      if (fired.has(dateKey)) return;
+      fired.add(dateKey);
+      // Cleanup old entries
+      if (fired.size > 7) {
+        const entries = [...fired];
+        entries.slice(0, entries.length - 7).forEach((k) => fired.delete(k));
+      }
+
+      if (!this.isOnCooldown(rule)) {
+        void this.executeRule(rule);
+      }
+    }, CHECK_INTERVAL);
+
+    this.scheduleTimers.set(rule.id, timer);
+  }
+
   private stopScheduleTimers(): void {
     for (const timer of this.scheduleTimers.values()) {
       clearInterval(timer);