daemora 1.0.0

package/src/tools/browserAutomation.js

@@ -0,0 +1,223 @@
+/**
+ * Browser Automation — Playwright-based web interaction.
+ * Upgraded: multi-tab, navigation guard, dialog handling, waitFor, cookies.
+ */
+
+let browser = null;
+let browserContext = null;
+const pages = []; // Multi-tab support
+
+// Blocked navigation patterns — SSRF / security guard
+const NAV_BLOCKLIST = [
+  /^file:\/\//i,
+  /^(http:\/\/|https:\/\/)(127\.|0\.|10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.|169\.254\.)/,
+  /^(http:\/\/|https:\/\/)localhost/i,
+];
+
+function isBlockedUrl(url) {
+  return NAV_BLOCKLIST.some((pattern) => pattern.test(url));
+}
+
+async function ensureBrowser() {
+  if (browser && browser.isConnected()) {
+    if (pages.length === 0 || pages[0].isClosed()) {
+      pages[0] = await browserContext.newPage();
+      pages[0].setDefaultTimeout(15000);
+    }
+    return pages[0];
+  }
+
+  try {
+    const { chromium } = await import("playwright");
+    browser = await chromium.launch({ headless: true });
+    browserContext = await browser.newContext({
+      userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+      viewport: { width: 1280, height: 720 },
+    });
+
+    // Auto-handle dialogs (accept by default)
+    browserContext.on("dialog", async (dialog) => {
+      console.log(`      [browser] Auto-dismissed dialog: ${dialog.type()} — "${dialog.message().slice(0, 80)}"`);
+      await dialog.dismiss();
+    });
+
+    const page = await browserContext.newPage();
+    page.setDefaultTimeout(15000);
+    pages.push(page);
+    return pages[0];
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.message.includes("playwright")) {
+      throw new Error("Playwright not installed. Run: pnpm add playwright && npx playwright install chromium");
+    }
+    throw error;
+  }
+}
+
+function currentPage() {
+  if (pages.length === 0) throw new Error("No browser open. Use navigate first.");
+  const activePage = pages[pages.length - 1];
+  if (activePage.isClosed()) throw new Error("Current page is closed. Navigate to a URL first.");
+  return activePage;
+}
+
+export async function browserAction(action, param1, param2) {
+  console.log(`      [browser] ${action}: ${param1 || ""}`);
+
+  try {
+    switch (action) {
+      case "navigate":
+      case "openPage": {
+        if (!param1) return "Error: URL is required.";
+        if (isBlockedUrl(param1)) return `Error: Navigation to "${param1}" is blocked for security (private/local addresses not allowed).`;
+        const p = await ensureBrowser();
+        await p.goto(param1, { waitUntil: "domcontentloaded" });
+        const title = await p.title();
+        return `Navigated to: ${param1}\nTitle: ${title}`;
+      }
+
+      case "click": {
+        if (!param1) return "Error: selector is required.";
+        await currentPage().click(param1);
+        return `Clicked: ${param1}`;
+      }
+
+      case "fill": {
+        if (!param1 || param2 === undefined) return "Error: selector and value are required.";
+        await currentPage().fill(param1, param2);
+        return `Filled "${param1}" with "${param2}"`;
+      }
+
+      case "getText": {
+        const selector = param1 || "body";
+        const text = await currentPage().textContent(selector);
+        const trimmed = (text || "").trim().slice(0, 10000);
+        return trimmed || "(empty)";
+      }
+
+      case "screenshot": {
+        const p = await ensureBrowser();
+        const path = param1 || `/tmp/screenshot-${Date.now()}.png`;
+        await p.screenshot({ path, fullPage: param2 === "full" });
+        return `Screenshot saved to: ${path}`;
+      }
+
+      case "evaluate": {
+        if (!param1) return "Error: JavaScript expression is required.";
+        const result = await currentPage().evaluate(param1);
+        return JSON.stringify(result, null, 2);
+      }
+
+      case "getLinks": {
+        const links = await currentPage().evaluate(() =>
+          Array.from(document.querySelectorAll("a[href]"))
+            .slice(0, 50)
+            .map((a) => ({ text: a.textContent.trim().slice(0, 80), href: a.href }))
+        );
+        return links.map((l) => `${l.text} → ${l.href}`).join("\n") || "(no links found)";
+      }
+
+      // Multi-tab support
+      case "newTab": {
+        const url = param1;
+        if (url && isBlockedUrl(url)) return `Error: Navigation to "${url}" is blocked.`;
+        if (!browserContext) await ensureBrowser();
+        const newPage = await browserContext.newPage();
+        newPage.setDefaultTimeout(15000);
+        pages.push(newPage);
+        if (url) {
+          await newPage.goto(url, { waitUntil: "domcontentloaded" });
+          return `Opened new tab (${pages.length - 1}) at: ${url}`;
+        }
+        return `Opened new blank tab (index: ${pages.length - 1})`;
+      }
+
+      case "switchTab": {
+        const idx = parseInt(param1 || "0");
+        if (isNaN(idx) || idx < 0 || idx >= pages.length) {
+          return `Error: Tab index ${idx} out of range. Open tabs: 0–${pages.length - 1}`;
+        }
+        // Bring to focus (Playwright doesn't have focus concept, but we track active)
+        pages.push(pages.splice(idx, 1)[0]); // Move selected to end (= current)
+        return `Switched to tab ${idx} (now active)`;
+      }
+
+      case "listTabs": {
+        if (pages.length === 0) return "No open tabs.";
+        const titles = await Promise.all(
+          pages.map(async (p, i) => {
+            if (p.isClosed()) return `  ${i}: [closed]`;
+            const title = await p.title().catch(() => "?");
+            const url = p.url();
+            return `  ${i}${i === pages.length - 1 ? " (active)" : ""}: ${title} — ${url}`;
+          })
+        );
+        return `Open tabs (${pages.length}):\n${titles.join("\n")}`;
+      }
+
+      case "closeTab": {
+        const idx = parseInt(param1 || `${pages.length - 1}`);
+        if (idx < 0 || idx >= pages.length) return `Error: Tab index ${idx} out of range.`;
+        await pages[idx].close();
+        pages.splice(idx, 1);
+        return `Closed tab ${idx}. Open tabs: ${pages.length}`;
+      }
+
+      // Waiting
+      case "waitFor": {
+        if (!param1) return "Error: selector is required.";
+        const timeout = param2 ? parseInt(param2) : 10000;
+        await currentPage().waitForSelector(param1, { timeout });
+        return `Element "${param1}" found.`;
+      }
+
+      // Dialog handling
+      case "handleDialog": {
+        // Override default dismiss behavior for next dialog
+        const action = param1 || "accept"; // accept | dismiss
+        const text = param2 || "";
+        currentPage().once("dialog", async (dialog) => {
+          if (action === "accept") await dialog.accept(text);
+          else await dialog.dismiss();
+        });
+        return `Next dialog will be ${action}ed${text ? ` with text: "${text}"` : ""}.`;
+      }
+
+      // Cookies
+      case "getCookies": {
+        if (!browserContext) return "No browser open.";
+        const cookies = await browserContext.cookies();
+        const filtered = param1
+          ? cookies.filter((c) => c.domain.includes(param1))
+          : cookies;
+        return JSON.stringify(filtered.slice(0, 20), null, 2);
+      }
+
+      case "setCookie": {
+        if (!param1) return "Error: cookie JSON is required (e.g., {\"name\":\"token\",\"value\":\"abc\",\"domain\":\"example.com\"}).";
+        if (!browserContext) await ensureBrowser();
+        const cookie = JSON.parse(param1);
+        await browserContext.addCookies([cookie]);
+        return `Cookie "${cookie.name}" set.`;
+      }
+
+      case "close": {
+        if (browser) {
+          await browser.close();
+          browser = null;
+          browserContext = null;
+          pages.length = 0;
+        }
+        return "Browser closed.";
+      }
+
+      default:
+        return `Unknown action: "${action}". Available: navigate, click, fill, getText, screenshot, evaluate, getLinks, newTab, switchTab, listTabs, closeTab, waitFor, handleDialog, getCookies, setCookie, close`;
+    }
+  } catch (error) {
+    console.log(`      [browser] Error: ${error.message}`);
+    return `Browser error: ${error.message}`;
+  }
+}
+
+export const browserActionDescription =
+  'browserAction(action: string, param1?: string, param2?: string) - Browser automation via Playwright. Actions: navigate(url), click(selector), fill(selector,value), getText(selector), screenshot(path,full?), evaluate(js), getLinks, newTab(url?), switchTab(index), listTabs, closeTab(index), waitFor(selector,timeoutMs?), handleDialog(accept|dismiss,text?), getCookies(domain?), setCookie(json), close.';

package/src/tools/createDocument.js

@@ -0,0 +1,265 @@
+import { writeFileSync, mkdirSync, readFileSync } from "fs";
+import { dirname } from "path";
+
+/**
+ * Create Document — creates Markdown, text, PDF, or DOCX documents.
+ * Upgraded: better PDF rendering (bold, italic, code, tables, numbered lists),
+ *           optional DOCX support via 'docx' package.
+ */
+
+export async function createDocument(filePath, content, format) {
+  const fmt = (format || "markdown").toLowerCase();
+  console.log(`      [createDocument] Creating ${fmt}: ${filePath}`);
+
+  if (!filePath || !content) {
+    return "Error: filePath and content are required.";
+  }
+
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+
+    if (fmt === "pdf") {
+      return await createPDF(filePath, content);
+    }
+
+    if (fmt === "docx") {
+      return await createDOCX(filePath, content);
+    }
+
+    // Markdown / text / html — write as-is
+    writeFileSync(filePath, content, "utf-8");
+    console.log(`      [createDocument] Written: ${filePath} (${content.length} chars)`);
+    return `Document created: ${filePath} (${content.length} characters)`;
+  } catch (error) {
+    console.log(`      [createDocument] Failed: ${error.message}`);
+    return `Failed to create document: ${error.message}`;
+  }
+}
+
+// ─── PDF ──────────────────────────────────────────────────────────────────────
+
+async function createPDF(filePath, content) {
+  try {
+    const PDFDocument = (await import("pdfkit")).default;
+
+    return new Promise((resolve, reject) => {
+      const doc = new PDFDocument({ margin: 50 });
+      const chunks = [];
+
+      doc.on("data", (chunk) => chunks.push(chunk));
+      doc.on("end", () => {
+        const buffer = Buffer.concat(chunks);
+        writeFileSync(filePath, buffer);
+        console.log(`      [createDocument] PDF written: ${filePath} (${buffer.length} bytes)`);
+        resolve(`PDF created: ${filePath} (${buffer.length} bytes)`);
+      });
+      doc.on("error", reject);
+
+      renderMarkdownToPDF(doc, content);
+      doc.end();
+    });
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.message.includes("pdfkit")) {
+      return "PDF requires pdfkit. Install with: pnpm add pdfkit";
+    }
+    throw error;
+  }
+}
+
+function renderMarkdownToPDF(doc, content) {
+  const lines = content.split("\n");
+  let inCodeBlock = false;
+  let codeLines = [];
+  let tableBuffer = [];
+
+  function flushTable() {
+    if (tableBuffer.length === 0) return;
+    // Simple table: pipe-delimited
+    for (const row of tableBuffer) {
+      const cells = row.split("|").map((c) => c.trim()).filter(Boolean);
+      if (cells.length === 0) continue;
+      if (cells.every((c) => /^[-:]+$/.test(c))) continue; // separator row
+      doc.fontSize(10).font("Courier").text(cells.join("   "), { paragraphGap: 2 });
+    }
+    tableBuffer = [];
+    doc.moveDown(0.3);
+  }
+
+  function flushCode() {
+    if (codeLines.length === 0) return;
+    doc.fontSize(9).font("Courier")
+      .fillColor("#333333")
+      .text(codeLines.join("\n"), { lineGap: 2, paragraphGap: 6 });
+    doc.fillColor("black");
+    codeLines = [];
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Code block toggle
+    if (line.startsWith("```")) {
+      if (inCodeBlock) {
+        flushCode();
+        inCodeBlock = false;
+      } else {
+        flushTable();
+        inCodeBlock = true;
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeLines.push(line);
+      continue;
+    }
+
+    // Table rows
+    if (line.startsWith("|")) {
+      tableBuffer.push(line);
+      continue;
+    } else if (tableBuffer.length > 0) {
+      flushTable();
+    }
+
+    // Headings
+    if (line.startsWith("# ")) {
+      doc.fontSize(24).font("Helvetica-Bold").fillColor("#000000")
+        .text(line.slice(2), { paragraphGap: 10 });
+    } else if (line.startsWith("## ")) {
+      doc.fontSize(18).font("Helvetica-Bold").fillColor("#111111")
+        .text(line.slice(3), { paragraphGap: 8 });
+    } else if (line.startsWith("### ")) {
+      doc.fontSize(14).font("Helvetica-Bold").fillColor("#222222")
+        .text(line.slice(4), { paragraphGap: 6 });
+    } else if (line.startsWith("#### ")) {
+      doc.fontSize(12).font("Helvetica-Bold").fillColor("#333333")
+        .text(line.slice(5), { paragraphGap: 4 });
+
+    // Horizontal rule
+    } else if (/^---+$/.test(line.trim())) {
+      doc.moveDown(0.3).moveTo(50, doc.y).lineTo(545, doc.y).stroke().moveDown(0.3);
+
+    // Unordered lists
+    } else if (/^(\s*)[*\-+] /.test(line)) {
+      const indent = line.match(/^(\s*)/)[1].length;
+      const text = line.replace(/^\s*[*\-+] /, "");
+      doc.fontSize(12).font("Helvetica").fillColor("#000000")
+        .text(`${"  ".repeat(indent / 2)}• ${renderInline(text)}`, { paragraphGap: 3, indent: indent * 6 });
+
+    // Ordered lists
+    } else if (/^\d+\. /.test(line.trim())) {
+      const num = line.match(/^(\d+)\./)[1];
+      const text = line.replace(/^\d+\. /, "");
+      doc.fontSize(12).font("Helvetica").fillColor("#000000")
+        .text(`${num}. ${renderInline(text)}`, { paragraphGap: 3 });
+
+    // Blockquote
+    } else if (line.startsWith("> ")) {
+      doc.fontSize(11).font("Helvetica-Oblique").fillColor("#555555")
+        .text(`"${line.slice(2)}"`, { indent: 20, paragraphGap: 3 });
+      doc.fillColor("#000000");
+
+    // Blank line
+    } else if (line.trim() === "") {
+      doc.moveDown(0.5);
+
+    // Normal paragraph
+    } else {
+      doc.fontSize(12).font("Helvetica").fillColor("#000000")
+        .text(renderInline(line), { paragraphGap: 3 });
+    }
+  }
+
+  // Flush any remaining
+  if (inCodeBlock) flushCode();
+  if (tableBuffer.length > 0) flushTable();
+}
+
+/** Strip bold/italic/code markdown for inline text (PDFKit doesn't do inline styles easily) */
+function renderInline(text) {
+  return text
+    .replace(/`([^`]+)`/g, (_, code) => `[${code}]`)  // `code` → [code]
+    .replace(/\*\*([^*]+)\*\*/g, "$1")                 // **bold** → bold
+    .replace(/\*([^*]+)\*/g, "$1")                     // *italic* → italic
+    .replace(/__([^_]+)__/g, "$1")                     // __bold__ → bold
+    .replace(/_([^_]+)_/g, "$1")                       // _italic_ → italic
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");          // [text](url) → text
+}
+
+// ─── DOCX ─────────────────────────────────────────────────────────────────────
+
+async function createDOCX(filePath, content) {
+  try {
+    const docx = await import("docx");
+    const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType } = docx;
+
+    const children = [];
+    const lines = content.split("\n");
+
+    for (const line of lines) {
+      if (line.startsWith("# ")) {
+        children.push(new Paragraph({ text: line.slice(2), heading: HeadingLevel.HEADING_1 }));
+      } else if (line.startsWith("## ")) {
+        children.push(new Paragraph({ text: line.slice(3), heading: HeadingLevel.HEADING_2 }));
+      } else if (line.startsWith("### ")) {
+        children.push(new Paragraph({ text: line.slice(4), heading: HeadingLevel.HEADING_3 }));
+      } else if (/^[*\-+] /.test(line)) {
+        children.push(new Paragraph({
+          text: line.replace(/^[*\-+] /, ""),
+          bullet: { level: 0 },
+        }));
+      } else if (line.trim() === "") {
+        children.push(new Paragraph({ text: "" }));
+      } else {
+        // Parse inline bold/italic
+        const runs = parseInlineDocx(line, TextRun);
+        children.push(new Paragraph({ children: runs }));
+      }
+    }
+
+    const doc = new Document({ sections: [{ properties: {}, children }] });
+    const buffer = await Packer.toBuffer(doc);
+    writeFileSync(filePath, buffer);
+
+    console.log(`      [createDocument] DOCX written: ${filePath} (${buffer.length} bytes)`);
+    return `DOCX created: ${filePath} (${buffer.length} bytes)`;
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.message.includes("docx")) {
+      return "DOCX requires the docx package. Install with: pnpm add docx";
+    }
+    throw error;
+  }
+}
+
+function parseInlineDocx(text, TextRun) {
+  // Split by **bold** and *italic* patterns
+  const runs = [];
+  const regex = /(\*\*[^*]+\*\*|\*[^*]+\*|`[^`]+`)/g;
+  let last = 0;
+  let match;
+
+  while ((match = regex.exec(text)) !== null) {
+    if (match.index > last) {
+      runs.push(new TextRun({ text: text.slice(last, match.index) }));
+    }
+    const token = match[0];
+    if (token.startsWith("**")) {
+      runs.push(new TextRun({ text: token.slice(2, -2), bold: true }));
+    } else if (token.startsWith("*")) {
+      runs.push(new TextRun({ text: token.slice(1, -1), italics: true }));
+    } else if (token.startsWith("`")) {
+      runs.push(new TextRun({ text: token.slice(1, -1), font: "Courier New", size: 20 }));
+    }
+    last = match.index + token.length;
+  }
+
+  if (last < text.length) {
+    runs.push(new TextRun({ text: text.slice(last) }));
+  }
+
+  return runs.length > 0 ? runs : [new TextRun({ text })];
+}
+
+export const createDocumentDescription =
+  'createDocument(filePath: string, content: string, format?: string) - Create a document. Formats: "markdown" (default), "pdf" (requires pdfkit), "docx" (requires docx). PDF/DOCX support # headings, ## h2, ### h3, - bullets, 1. numbered lists, **bold**, *italic*, `code`, tables, > blockquotes, --- rules, ```code blocks```.';

package/src/tools/cronTool.js

@@ -0,0 +1,105 @@
+/**
+ * cron(action, paramsJson?) — Schedule recurring tasks from within the agent.
+ * Bridge to the existing Scheduler. Inspired by OpenClaw's cron tool.
+ *
+ * Actions:
+ *   status  — show scheduler status
+ *   list    — list all schedules
+ *   add     — create a new schedule
+ *   update  — patch an existing schedule (change expression, name, or taskInput)
+ *   enable  — re-enable a disabled schedule
+ *   disable — pause a schedule without deleting it
+ *   remove  — delete a schedule permanently
+ *   run     — trigger a schedule immediately (regardless of cron timing)
+ */
+import scheduler from "../scheduler/Scheduler.js";
+
+export function cron(action, paramsJson) {
+  try {
+    const params = paramsJson ? JSON.parse(paramsJson) : {};
+
+    switch (action) {
+      case "status": {
+        const schedules = scheduler.list();
+        return JSON.stringify({
+          running: scheduler.running,
+          total: schedules.length,
+          enabled: schedules.filter((s) => s.enabled).length,
+          disabled: schedules.filter((s) => !s.enabled).length,
+        });
+      }
+
+      case "list": {
+        const schedules = scheduler.list();
+        if (schedules.length === 0) return "No schedules configured.";
+        return schedules
+          .map(
+            (s) =>
+              `• ${s.id.slice(0, 8)} — "${s.name}" | ${s.cronExpression} | ${s.enabled ? "enabled" : "DISABLED"} | runs: ${s.runCount} | last: ${s.lastRun || "never"}`
+          )
+          .join("\n");
+      }
+
+      case "add": {
+        if (!params.cronExpression) return 'Error: cronExpression is required. Example: "0 9 * * *" for daily at 9am.';
+        if (!params.taskInput) return "Error: taskInput is required — the task/message to send when triggered.";
+        const schedule = scheduler.create({
+          cronExpression: params.cronExpression,
+          taskInput: params.taskInput,
+          name: params.name,
+          channel: params.channel,
+          model: params.model,
+        });
+        return `Schedule created: "${schedule.name}" | ${schedule.cronExpression} | ID: ${schedule.id.slice(0, 8)}`;
+      }
+
+      case "update": {
+        if (!params.id) return 'Error: id is required. Use cron("list") to see schedule IDs.';
+        // Allow partial prefix ID match (first 8 chars is enough)
+        const schedule = scheduler.update(params.id, {
+          cronExpression: params.cronExpression,
+          taskInput: params.taskInput,
+          name: params.name,
+        });
+        return `Schedule updated: "${schedule.name}" | ${schedule.cronExpression} | ID: ${schedule.id.slice(0, 8)}`;
+      }
+
+      case "enable": {
+        if (!params.id) return 'Error: id is required.';
+        const schedule = scheduler.update(params.id, { enabled: true });
+        return `Schedule "${schedule.name}" (${params.id.slice(0, 8)}) enabled — will run on next trigger.`;
+      }
+
+      case "disable": {
+        if (!params.id) return 'Error: id is required.';
+        const schedule = scheduler.update(params.id, { enabled: false });
+        return `Schedule "${schedule.name}" (${params.id.slice(0, 8)}) disabled — cron job paused, not deleted.`;
+      }
+
+      case "remove": {
+        if (!params.id) return 'Error: id is required. Use cron("list") to see schedule IDs.';
+        scheduler.delete(params.id);
+        return `Schedule ${params.id.slice(0, 8)} removed.`;
+      }
+
+      case "run": {
+        if (!params.id) return 'Error: id is required. Use cron("list") to see schedule IDs.';
+        scheduler.triggerSchedule(params.id);
+        return `Schedule ${params.id.slice(0, 8)} triggered manually.`;
+      }
+
+      default:
+        return `Unknown action: "${action}". Available: status, list, add, update, enable, disable, remove, run`;
+    }
+  } catch (error) {
+    return `Cron error: ${error.message}`;
+  }
+}
+
+export const cronDescription =
+  'cron(action, paramsJson?) — Manage scheduled recurring tasks. ' +
+  'Actions: "status", "list", ' +
+  '"add" ({"cronExpression":"0 9 * * *","taskInput":"Check emails","name":"Morning"}), ' +
+  '"update" ({"id":"...","cronExpression":"0 10 * * *"}), ' +
+  '"enable" ({"id":"..."}), "disable" ({"id":"..."}), ' +
+  '"remove" ({"id":"..."}), "run" ({"id":"..."}).';