augure 0.4.2 → 0.5.0

package/dist/bin.js

@@ -50,9 +50,12 @@ var AppConfigSchema = z.object({
     heartbeatInterval: z.string().min(1),
     jobs: z.array(z.object({
       id: z.string().min(1),
-      cron: z.string().min(1),
+      cron: z.string().min(1).optional(),
+      runAt: z.string().min(1).optional(),
       prompt: z.string().min(1),
       channel: z.string().min(1)
+    }).refine((j) => j.cron || j.runAt, {
+      message: "Job must have either cron or runAt"
     }))
   }),
   sandbox: z.object({
@@ -582,62 +585,6 @@ function createOutgoingPipeline(middlewares, send) {
   };
 }
 
-// ../channels/dist/middleware/escape-markdown.js
-var SPECIAL_CHARS = /* @__PURE__ */ new Set([".", "!", ">", "#", "+", "-", "=", "|", "{", "}", "~"]);
-function escapeMarkdownV2(text) {
-  if (!text)
-    return "";
-  const parts = [];
-  let i = 0;
-  while (i < text.length) {
-    if (text.startsWith("```", i)) {
-      const endIdx = text.indexOf("```", i + 3);
-      if (endIdx !== -1) {
-        parts.push(text.slice(i, endIdx + 3));
-        i = endIdx + 3;
-        continue;
-      }
-    }
-    if (text[i] === "`") {
-      const endIdx = text.indexOf("`", i + 1);
-      if (endIdx !== -1) {
-        parts.push(text.slice(i, endIdx + 1));
-        i = endIdx + 1;
-        continue;
-      }
-    }
-    if (text[i] === "*" || text[i] === "_") {
-      parts.push(text[i]);
-      i++;
-      continue;
-    }
-    if (text[i] === "[" || text[i] === "(") {
-      parts.push(text[i]);
-      i++;
-      continue;
-    }
-    if (text[i] === "]") {
-      parts.push(text[i]);
-      i++;
-      continue;
-    }
-    const char = text[i];
-    if (SPECIAL_CHARS.has(char)) {
-      parts.push(`\\${char}`);
-    } else {
-      parts.push(char);
-    }
-    i++;
-  }
-  return parts.join("");
-}
-function createEscapeMarkdownMiddleware() {
-  return async (message, next) => {
-    message.text = escapeMarkdownV2(message.text);
-    await next();
-  };
-}
-
 // ../channels/dist/middleware/split-message.js
 var TELEGRAM_MAX = 4096;
 function splitText(text, maxLength) {
@@ -743,6 +690,38 @@ async function withRetry(fn, options) {
   throw lastError;
 }
 
+// ../channels/dist/middleware/markdown-to-html.js
+function markdownToTelegramHtml(text) {
+  if (!text)
+    return "";
+  const placeholders = [];
+  const PH_PREFIX = "\uFFFCPH";
+  const PH_SUFFIX = "\uFFFC";
+  function hold(html) {
+    const idx = placeholders.length;
+    placeholders.push(html);
+    return `${PH_PREFIX}${idx}${PH_SUFFIX}`;
+  }
+  let out = text;
+  out = out.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => hold(lang ? `<pre><code class="language-${escapeHtml(lang)}">${escapeHtml(code.trimEnd())}</code></pre>` : `<pre>${escapeHtml(code.trimEnd())}</pre>`));
+  out = out.replace(/`([^`\n]+)`/g, (_, code) => hold(`<code>${escapeHtml(code)}</code>`));
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, linkText, url) => hold(`<a href="${escapeHtml(url)}">${escapeHtml(linkText)}</a>`));
+  out = escapeHtml(out);
+  out = out.replace(/\*\*\*(.+?)\*\*\*/g, "<b><i>$1</i></b>");
+  out = out.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  out = out.replace(/\*([^*\n]+?)\*/g, "<i>$1</i>");
+  out = out.replace(/~~(.+?)~~/g, "<s>$1</s>");
+  out = out.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+  out = out.replace(/^&gt;\s?(.*)$/gm, "<blockquote>$1</blockquote>");
+  out = out.replace(/<\/blockquote>\n<blockquote>/g, "\n");
+  const phPattern = new RegExp(`${PH_PREFIX}(\\d+)${PH_SUFFIX}`, "g");
+  out = out.replace(phPattern, (_, idx) => placeholders[Number(idx)]);
+  return out;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
 // ../channels/dist/telegram/media.js
 function registerMediaHandlers(bot, isAllowed, handlers, onRejected) {
   bot.on("message:photo", async (ctx) => {
@@ -832,23 +811,20 @@ var TelegramChannel = class {
       }
     });
     registerMediaHandlers(this.bot, (id) => this.isUserAllowed(id), this.handlers, (userId, ts) => this.handleRejected(userId, Math.floor(ts.getTime() / 1e3), config.rejectMessage));
-    const rawSend = async (msg) => {
-      await withRetry(() => this.bot.api.sendMessage(Number(msg.userId), msg.text, {
-        parse_mode: "MarkdownV2",
-        ...msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {}
+    const convertAndSend = async (msg) => {
+      const htmlText = markdownToTelegramHtml(msg.text);
+      const replyOpts = msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {};
+      await withRetry(() => this.bot.api.sendMessage(Number(msg.userId), htmlText, {
+        parse_mode: "HTML",
+        ...replyOpts
       }), { maxRetries: 3, baseDelayMs: 500 }).catch(async () => {
-        await this.bot.api.sendMessage(Number(msg.userId), msg.text, {
-          ...msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {}
-        }).catch((fallbackErr) => {
+        await this.bot.api.sendMessage(Number(msg.userId), msg.text, replyOpts).catch((fallbackErr) => {
           console.error("[augure:telegram] Fallback send also failed:", fallbackErr);
           throw fallbackErr;
         });
       });
     };
-    this.sendPipeline = createOutgoingPipeline([
-      createEscapeMarkdownMiddleware(),
-      createSplitMessageMiddleware(rawSend)
-    ], rawSend);
+    this.sendPipeline = createOutgoingPipeline([createSplitMessageMiddleware(convertAndSend)], convertAndSend);
   }
   isUserAllowed(userId) {
     return this.allowedUsers.has(userId);
@@ -967,7 +943,7 @@ var memoryWriteTool = {
 // ../tools/dist/schedule.js
 var scheduleTool = {
   name: "schedule",
-  description: "Manage scheduled tasks: create, delete, or list cron jobs",
+  description: "Manage scheduled tasks: create recurring (cron) or one-shot (runAt) jobs, delete, or list them",
   parameters: {
     type: "object",
     properties: {
@@ -977,13 +953,14 @@ var scheduleTool = {
         description: "The scheduling action to perform"
       },
       id: { type: "string", description: "The schedule ID (for create/delete)" },
-      cron: { type: "string", description: "Cron expression (for create)" },
+      cron: { type: "string", description: "Cron expression for recurring jobs (for create)" },
+      runAt: { type: "string", description: "ISO 8601 date for one-shot jobs, e.g. 2025-03-15T14:00:00Z (for create)" },
       prompt: { type: "string", description: "The prompt to execute on schedule (for create)" }
     },
     required: ["action"]
   },
   execute: async (params, ctx) => {
-    const { action, id, cron, prompt } = params;
+    const { action, id, cron, runAt, prompt } = params;
     try {
       switch (action) {
         case "list": {
@@ -991,22 +968,29 @@ var scheduleTool = {
           if (jobs.length === 0) {
             return { success: true, output: "No scheduled jobs." };
           }
-          const lines = jobs.map((j) => `- ${j.id}: "${j.prompt}" @ ${j.cron} (${j.enabled ? "enabled" : "disabled"})`);
+          const lines = jobs.map((j) => {
+            const schedule = j.cron ? `cron: ${j.cron}` : `runAt: ${j.runAt}`;
+            return `- ${j.id}: "${j.prompt}" @ ${schedule} (${j.enabled ? "enabled" : "disabled"})`;
+          });
           return { success: true, output: lines.join("\n") };
         }
         case "create": {
-          if (!cron || !prompt) {
-            return { success: false, output: "Missing required fields: cron and prompt" };
+          if (!prompt) {
+            return { success: false, output: "Missing required field: prompt" };
+          }
+          if (!cron && !runAt) {
+            return { success: false, output: "Must provide either cron (recurring) or runAt (one-shot)" };
           }
           const jobId = id ?? `job-${Date.now()}`;
           ctx.scheduler.addJob({
             id: jobId,
             cron,
+            runAt,
             prompt,
             channel: "default",
             enabled: true
           });
-          return { success: true, output: `Created job ${jobId}` };
+          return { success: true, output: `Created job ${jobId} (${cron ? "recurring" : `one-shot at ${runAt}`})` };
         }
         case "delete": {
           if (!id) {
@@ -1665,6 +1649,63 @@ var DockerContainerPool = class {
   }
 };
 
+// ../sandbox/dist/ensure-image.js
+import { Readable } from "stream";
+var DOCKERFILE = `FROM node:22-slim
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    python3 curl jq git \\
+  && rm -rf /var/lib/apt/lists/*
+WORKDIR /workspace
+`;
+function buildTar(content) {
+  const data = Buffer.from(content, "utf-8");
+  const name = "Dockerfile";
+  const header = Buffer.alloc(512, 0);
+  header.write(name, 0, 100, "utf-8");
+  header.write("0000644\0", 100, 8, "utf-8");
+  header.write("0000000\0", 108, 8, "utf-8");
+  header.write("0000000\0", 116, 8, "utf-8");
+  header.write(data.length.toString(8).padStart(11, "0") + "\0", 124, 12, "utf-8");
+  header.write(Math.floor(Date.now() / 1e3).toString(8).padStart(11, "0") + "\0", 136, 12, "utf-8");
+  header.write("0", 156, 1, "utf-8");
+  header.fill(32, 148, 156);
+  let checksum = 0;
+  for (let i = 0; i < 512; i++)
+    checksum += header[i];
+  header.write(checksum.toString(8).padStart(6, "0") + "\0 ", 148, 8, "utf-8");
+  const padding = 512 - (data.length % 512 || 512);
+  const dataPadded = padding > 0 && padding < 512 ? Buffer.concat([data, Buffer.alloc(padding, 0)]) : data;
+  const end = Buffer.alloc(1024, 0);
+  return Buffer.concat([header, dataPadded, end]);
+}
+async function ensureImage(docker, imageName) {
+  try {
+    await docker.getImage(imageName).inspect();
+    return;
+  } catch (err2) {
+    const statusCode = err2.statusCode;
+    if (statusCode !== void 0 && statusCode !== 404)
+      throw err2;
+  }
+  console.log(`[augure] Image "${imageName}" not found, building...`);
+  const tar = buildTar(DOCKERFILE);
+  const stream = await docker.buildImage(Readable.from(tar), {
+    t: imageName
+  });
+  await new Promise((resolve5, reject) => {
+    docker.modem.followProgress(stream, (err2) => {
+      if (err2)
+        reject(err2);
+      else
+        resolve5();
+    }, (event) => {
+      if (event.stream)
+        process.stdout.write(event.stream);
+    });
+  });
+  console.log(`[augure] Image "${imageName}" built successfully`);
+}
+
 // ../memory/dist/store.js
 import { readFile as readFile3, writeFile, mkdir as mkdir2, readdir as readdir2, access } from "fs/promises";
 import { join as join3, dirname, relative } from "path";
@@ -1828,6 +1869,7 @@ var CronScheduler = class {
   store;
   jobs = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
   handlers = [];
   persistChain = Promise.resolve();
   constructor(store) {
@@ -1837,11 +1879,17 @@ var CronScheduler = class {
     this.handlers.push(handler);
   }
   addJob(job) {
-    if (!validate(job.cron)) {
+    if (!job.cron && !job.runAt) {
+      throw new Error(`Job ${job.id} must have either cron or runAt`);
+    }
+    if (job.cron && !validate(job.cron)) {
       throw new Error(`Invalid cron expression: ${job.cron}`);
     }
+    if (job.runAt && isNaN(Date.parse(job.runAt))) {
+      throw new Error(`Invalid runAt date: ${job.runAt}`);
+    }
     this.jobs.set(job.id, job);
-    if (job.enabled) {
+    if (job.enabled && job.cron) {
       const task = createTask(job.cron, () => {
         void this.executeHandlers(job);
       });
@@ -1855,6 +1903,11 @@ var CronScheduler = class {
       task.stop();
       this.tasks.delete(id);
     }
+    const timer = this.timers.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(id);
+    }
     this.jobs.delete(id);
     this.persist();
   }
@@ -1873,6 +1926,9 @@ var CronScheduler = class {
       return;
     const jobs = await this.store.load();
     for (const job of jobs) {
+      if (job.runAt && Date.parse(job.runAt) <= Date.now()) {
+        continue;
+      }
       this.addJob(job);
     }
   }
@@ -1880,11 +1936,32 @@ var CronScheduler = class {
     for (const task of this.tasks.values()) {
       task.start();
     }
+    for (const job of this.jobs.values()) {
+      if (job.enabled && job.runAt && !job.cron) {
+        this.scheduleOneShot(job);
+      }
+    }
   }
   stop() {
     for (const task of this.tasks.values()) {
       task.stop();
     }
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+  }
+  scheduleOneShot(job) {
+    const delayMs = Date.parse(job.runAt) - Date.now();
+    if (delayMs <= 0)
+      return;
+    const timer = setTimeout(() => {
+      this.timers.delete(job.id);
+      void this.executeHandlers(job).then(() => {
+        this.removeJob(job.id);
+      });
+    }, delayMs);
+    this.timers.set(job.id, timer);
   }
   persist() {
     if (!this.store)
@@ -3222,6 +3299,17 @@ var SkillUpdater = class {
       };
     }
     const toVersion = newSkill.meta.version;
+    if (!newSkill.meta.sandbox) {
+      await this.config.manager.save(backup);
+      return {
+        skillId,
+        success: false,
+        rolledBack: true,
+        fromVersion,
+        toVersion,
+        error: "Downloaded skill has sandbox disabled \u2014 rejected for security"
+      };
+    }
     const testResult = await this.config.tester.test(newSkill);
     if (testResult.success) {
       await this.config.manager.save(newSkill);
@@ -3295,10 +3383,11 @@ var VersionChecker = class _VersionChecker {
       };
     }
   }
-  /** Compare two semver strings. Returns -1 if a < b, 0 if equal, 1 if a > b */
+  /** Compare two semver strings (MAJOR.MINOR.PATCH only, pre-release suffixes stripped). Returns -1 if a < b, 0 if equal, 1 if a > b */
   static compareVersions(a, b) {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
+    const clean = (v) => v.replace(/^v/, "").split("-")[0];
+    const pa = clean(a).split(".").map(Number);
+    const pb = clean(b).split(".").map(Number);
     for (let i = 0; i < 3; i++) {
       const va = pa[i] ?? 0;
       const vb = pb[i] ?? 0;
@@ -3356,8 +3445,10 @@ async function startAgent(configPath) {
     }
   }
   const docker = new Dockerode();
+  const sandboxImage = config.sandbox.image ?? "augure-sandbox:latest";
+  await ensureImage(docker, sandboxImage);
   const pool = new DockerContainerPool(docker, {
-    image: config.sandbox.image ?? "augure-sandbox:latest",
+    image: sandboxImage,
     maxTotal: config.security.maxConcurrentSandboxes
   });
   console.log(`[augure] Container pool created (max: ${config.security.maxConcurrentSandboxes})`);
@@ -3433,13 +3524,17 @@ async function startAgent(configPath) {
     await personaResolver.loadAll();
     console.log(`[augure] Personas loaded from ${personaPath}`);
   }
-  if (config.updates?.cli?.enabled !== false) {
+  let cliVersion;
+  try {
     const require3 = createRequire(import.meta.url);
-    const { version: version2 } = require3("augure/package.json");
+    const pkg = require3("augure/package.json");
+    cliVersion = pkg.version;
+  } catch {
+  }
+  if (cliVersion && config.updates?.cli?.enabled !== false) {
     const versionChecker = new VersionChecker({
-      currentVersion: version2,
-      packageName: "augure",
-      githubRepo: "FaureAlexis/augure"
+      currentVersion: cliVersion,
+      packageName: "augure"
     });
     const versionResult = await versionChecker.check();
     if (versionResult.updateAvailable) {
@@ -3526,14 +3621,37 @@ async function startAgent(configPath) {
       console.log(`[augure] Heartbeat response: ${response}`);
     }
   });
+  scheduler.onJobTrigger(async (job) => {
+    console.log(`[augure] Job triggered: ${job.id}`);
+    const response = await agent.handleMessage({
+      id: `job-${job.id}-${Date.now()}`,
+      channelType: "system",
+      userId: "system",
+      text: job.prompt,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (telegram && config.channels.telegram?.enabled) {
+      const userId = config.channels.telegram.allowedUsers[0];
+      if (userId !== void 0) {
+        await telegram.send({
+          channelType: "telegram",
+          userId: String(userId),
+          text: response
+        });
+      }
+    }
+    console.log(`[augure] Job ${job.id} completed`);
+  });
   scheduler.start();
   heartbeat.start();
   console.log(`[augure] Scheduler started with ${scheduler.listJobs().length} jobs. Heartbeat every ${config.scheduler.heartbeatInterval}.`);
+  const updateTimers = [];
   if (skillUpdater && config.updates?.skills?.checkInterval) {
+    const su = skillUpdater;
     const skillCheckMs = parseInterval(config.updates.skills.checkInterval);
-    setInterval(async () => {
+    updateTimers.push(setInterval(async () => {
       try {
-        const results = await skillUpdater.checkAndApply();
+        const results = await su.checkAndApply();
         for (const r of results) {
           if (r.success) {
             console.log(`[augure] Skill auto-updated: ${r.skillId} v${r.fromVersion}\u2192v${r.toVersion}`);
@@ -3544,18 +3662,15 @@ async function startAgent(configPath) {
       } catch (err2) {
         console.error("[augure] Periodic skill update check failed:", err2);
       }
-    }, skillCheckMs);
+    }, skillCheckMs));
   }
-  if (config.updates?.cli?.enabled !== false && config.channels.telegram?.enabled) {
+  if (cliVersion && config.updates?.cli?.enabled !== false && config.channels.telegram?.enabled) {
     const cliCheckMs = parseInterval(config.updates?.cli?.checkInterval ?? "24h");
-    const require3 = createRequire(import.meta.url);
-    const { version: version2 } = require3("augure/package.json");
     const versionChecker = new VersionChecker({
-      currentVersion: version2,
-      packageName: "augure",
-      githubRepo: "FaureAlexis/augure"
+      currentVersion: cliVersion,
+      packageName: "augure"
     });
-    setInterval(async () => {
+    updateTimers.push(setInterval(async () => {
       try {
         const result = await versionChecker.check();
         if (result.updateAvailable && telegram) {
@@ -3572,10 +3687,12 @@ Run: \`npm update -g augure\``
       } catch (err2) {
         console.error("[augure] CLI version check failed:", err2);
       }
-    }, cliCheckMs);
+    }, cliCheckMs));
   }
   const shutdown = async () => {
     console.log("\n[augure] Shutting down...");
+    for (const timer of updateTimers)
+      clearInterval(timer);
     heartbeat.stop();
     scheduler.stop();
     if (telegram)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "augure",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Augure — your proactive AI agent",
   "type": "module",
   "bin": {
@@ -12,15 +12,6 @@
   "engines": {
     "node": ">=22.0.0"
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:unit": "vitest run",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src/",
-    "clean": "rm -rf dist .turbo"
-  },
   "dependencies": {
     "citty": "^0.2.1",
     "dockerode": "^4.0.9",
@@ -33,17 +24,17 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@augure/channels": "workspace:*",
-    "@augure/core": "workspace:*",
-    "@augure/memory": "workspace:*",
-    "@augure/sandbox": "workspace:*",
-    "@augure/scheduler": "workspace:*",
-    "@augure/skills": "workspace:*",
-    "@augure/tools": "workspace:*",
-    "@augure/types": "workspace:*",
     "@types/dockerode": "^4.0.1",
     "@types/node-cron": "^3.0.11",
-    "tsup": "^8.5.1"
+    "tsup": "^8.5.1",
+    "@augure/channels": "0.1.1",
+    "@augure/core": "0.2.0",
+    "@augure/memory": "0.0.3",
+    "@augure/sandbox": "0.1.0",
+    "@augure/scheduler": "0.1.0",
+    "@augure/skills": "0.1.1",
+    "@augure/types": "0.1.1",
+    "@augure/tools": "0.0.3"
   },
   "keywords": [
     "ai",
@@ -61,5 +52,14 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:unit": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist .turbo"
   }
-}
+}