augure 0.5.1 → 0.6.0

package/dist/bin.js

@@ -135,6 +135,11 @@ var AppConfigSchema = z.object({
       checkInterval: z.string().min(1).default("24h"),
       notifyChannel: z.string().min(1).default("telegram")
     }).optional()
+  }).optional(),
+  codeMode: z.object({
+    runtime: z.enum(["vm", "docker", "auto"]).default("auto"),
+    timeout: z.number().int().positive().default(30),
+    memoryLimit: z.number().int().positive().default(128)
   }).optional()
 });
 function interpolateEnvVars(raw) {
@@ -267,6 +272,403 @@ ${memoryContent}`;
   return messages;
 }
 
+// ../code-mode/dist/typegen.js
+var JSON_TO_TS = {
+  string: "string",
+  number: "number",
+  integer: "number",
+  boolean: "boolean",
+  array: "unknown[]",
+  object: "Record<string, unknown>"
+};
+function sanitizeName(name) {
+  return name.replace(/[-. ]/g, "_");
+}
+function toPascalCase(name) {
+  return sanitizeName(name).split("_").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function mapType(schema) {
+  const t = schema.type;
+  if (schema.enum) {
+    return schema.enum.map((v) => `"${v}"`).join(" | ");
+  }
+  return JSON_TO_TS[t ?? "string"] ?? "unknown";
+}
+function generateDeclarations(registry) {
+  const tools = registry.list();
+  const blocks = [];
+  const apiEntries = [];
+  for (const tool of tools) {
+    const safeName = sanitizeName(tool.name);
+    const interfaceName = `${toPascalCase(tool.name)}Input`;
+    const params = tool.parameters;
+    const properties = params.properties ?? {};
+    const required = new Set(params.required ?? []);
+    const fields = [];
+    for (const [key, schema] of Object.entries(properties)) {
+      const optional = required.has(key) ? "" : "?";
+      const tsType = mapType(schema);
+      const desc = schema.description;
+      if (desc) {
+        fields.push(`  /** ${desc} */
+  ${key}${optional}: ${tsType};`);
+      } else {
+        fields.push(`  ${key}${optional}: ${tsType};`);
+      }
+    }
+    blocks.push(`interface ${interfaceName} {
+${fields.join("\n")}
+}`);
+    apiEntries.push(`  /** ${tool.description} */
+  ${safeName}: (input: ${interfaceName}) => Promise<{ success: boolean; output: string }>;`);
+  }
+  const apiBlock = `declare const api: {
+${apiEntries.join("\n")}
+};`;
+  return [...blocks, "", apiBlock].join("\n");
+}
+
+// ../code-mode/dist/bridge.js
+function createBridgeHandler(registry) {
+  return async (toolName, input) => {
+    try {
+      return await registry.execute(toolName, input);
+    } catch (err2) {
+      return {
+        success: false,
+        output: `Bridge error calling ${toolName}: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+  };
+}
+function generateHarnessCode(userCode) {
+  return `
+const __logs = [];
+const __originalLog = console.log;
+const __originalWarn = console.warn;
+const __originalError = console.error;
+console.log = (...args) => __logs.push(args.map(String).join(" "));
+console.warn = (...args) => __logs.push("[warn] " + args.map(String).join(" "));
+console.error = (...args) => __logs.push("[error] " + args.map(String).join(" "));
+
+let __toolCalls = 0;
+
+const api = new Proxy({}, {
+  get: (_target, toolName) => {
+    return async (input) => {
+      __toolCalls++;
+      return await __bridge(String(toolName), input);
+    };
+  }
+});
+
+async function __run() {
+  ${userCode}
+}
+
+try {
+  const __result = await __run();
+  __originalLog(JSON.stringify({
+    success: true,
+    output: __result,
+    logs: __logs,
+    toolCalls: __toolCalls,
+  }));
+} catch (err) {
+  __originalLog(JSON.stringify({
+    success: false,
+    error: err.message ?? String(err),
+    logs: __logs,
+    toolCalls: __toolCalls,
+  }));
+}
+`;
+}
+
+// ../code-mode/dist/vm-sandbox.js
+import { createContext, runInContext } from "vm";
+import { transform } from "esbuild";
+var VmExecutor = class {
+  registry;
+  config;
+  constructor(registry, config) {
+    this.registry = registry;
+    this.config = config;
+  }
+  async execute(code) {
+    const start = performance.now();
+    try {
+      const harnessTs = generateHarnessCode(code);
+      const { code: harnessJs } = await transform(harnessTs, {
+        loader: "ts",
+        target: "es2024"
+      });
+      const bridgeHandler = createBridgeHandler(this.registry);
+      const consoleLogs = [];
+      const captureConsole = {
+        log: (...args) => consoleLogs.push(args.map(String).join(" ")),
+        warn: (...args) => consoleLogs.push("[warn] " + args.map(String).join(" ")),
+        error: (...args) => consoleLogs.push("[error] " + args.map(String).join(" "))
+      };
+      const context = createContext({
+        console: captureConsole,
+        __bridge: bridgeHandler,
+        JSON,
+        String,
+        Number,
+        Boolean,
+        Array,
+        Object,
+        Error,
+        Promise,
+        Map,
+        Set,
+        parseInt,
+        parseFloat,
+        isNaN,
+        isFinite,
+        setTimeout,
+        Date,
+        RegExp,
+        Math,
+        Symbol,
+        Uint8Array,
+        TextEncoder,
+        TextDecoder,
+        Buffer,
+        URL,
+        URLSearchParams
+      });
+      const wrappedCode = `(async () => { ${harnessJs} })()`;
+      const timeoutPromise = new Promise((_, reject) => {
+        const timer = setTimeout(() => reject(new Error("Timeout: code execution exceeded time limit")), this.config.timeout);
+        timer.unref?.();
+      });
+      const resultPromise = runInContext(wrappedCode, context, {
+        timeout: this.config.timeout
+      });
+      await Promise.race([resultPromise, timeoutPromise]);
+      const durationMs = performance.now() - start;
+      const lastLine = consoleLogs[consoleLogs.length - 1];
+      if (!lastLine) {
+        return {
+          success: false,
+          output: void 0,
+          logs: consoleLogs,
+          error: "No output produced by code execution",
+          durationMs,
+          toolCalls: 0
+        };
+      }
+      const parsed = JSON.parse(lastLine);
+      return {
+        success: parsed.success,
+        output: parsed.output,
+        logs: parsed.logs,
+        error: parsed.error,
+        durationMs,
+        toolCalls: parsed.toolCalls
+      };
+    } catch (err2) {
+      const durationMs = performance.now() - start;
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        error: err2 instanceof Error ? err2.message : String(err2),
+        durationMs,
+        toolCalls: 0
+      };
+    }
+  }
+};
+
+// ../code-mode/dist/docker-sandbox.js
+var DOCKER_HARNESS = `
+import { readFile } from "node:fs/promises";
+
+const __logs = [];
+const __originalLog = console.log;
+console.log = (...args) => __logs.push(args.map(String).join(" "));
+console.warn = (...args) => __logs.push("[warn] " + args.map(String).join(" "));
+console.error = (...args) => __logs.push("[error] " + args.map(String).join(" "));
+
+let __toolCalls = 0;
+
+const api = new Proxy({}, {
+  get: (_target, toolName) => {
+    return async () => {
+      __toolCalls++;
+      return { success: false, output: "Tool calls not yet supported in Docker executor" };
+    };
+  }
+});
+
+const __userCode = await readFile("/workspace/user-code.js", "utf-8");
+const __fn = new Function("api", "__logs",
+  "return (async () => { " + __userCode + " })();"
+);
+
+try {
+  const __result = await __fn(api, __logs);
+  __originalLog(JSON.stringify({
+    success: true,
+    output: __result,
+    logs: __logs,
+    toolCalls: __toolCalls,
+  }));
+} catch (err) {
+  __originalLog(JSON.stringify({
+    success: false,
+    error: err.message ?? String(err),
+    logs: __logs,
+    toolCalls: __toolCalls,
+  }));
+}
+`;
+var DockerExecutor = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async execute(code) {
+    const start = Date.now();
+    let container;
+    try {
+      container = await this.config.pool.acquire({
+        trust: "sandboxed",
+        timeout: this.config.timeout,
+        memory: this.config.memoryLimit,
+        cpu: this.config.cpuLimit
+      });
+    } catch (err2) {
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        toolCalls: 0,
+        error: `Failed to acquire container: ${err2 instanceof Error ? err2.message : String(err2)}`,
+        durationMs: Date.now() - start
+      };
+    }
+    try {
+      await container.exec("mkdir -p /workspace");
+      const codeB64 = Buffer.from(code).toString("base64");
+      await container.exec(`sh -c 'echo "${codeB64}" | base64 -d > /workspace/user-code.js'`);
+      const harnessB64 = Buffer.from(DOCKER_HARNESS).toString("base64");
+      await container.exec(`sh -c 'echo "${harnessB64}" | base64 -d > /workspace/harness.ts'`);
+      const execResult = await container.exec("npx tsx /workspace/harness.ts", {
+        timeout: this.config.timeout,
+        cwd: "/workspace"
+      });
+      if (execResult.exitCode === 0 && execResult.stdout.trim()) {
+        try {
+          const lastLine = execResult.stdout.trim().split("\n").pop();
+          const parsed = JSON.parse(lastLine);
+          return {
+            success: parsed.success,
+            output: parsed.output,
+            logs: parsed.logs ?? [],
+            error: parsed.error,
+            durationMs: Date.now() - start,
+            toolCalls: parsed.toolCalls ?? 0
+          };
+        } catch {
+          return {
+            success: true,
+            output: execResult.stdout.trim(),
+            logs: [],
+            durationMs: Date.now() - start,
+            toolCalls: 0
+          };
+        }
+      }
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        toolCalls: 0,
+        error: execResult.stderr || execResult.stdout || "Unknown error",
+        durationMs: Date.now() - start
+      };
+    } catch (err2) {
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        toolCalls: 0,
+        error: err2 instanceof Error ? err2.message : String(err2),
+        durationMs: Date.now() - start
+      };
+    } finally {
+      await this.config.pool.release(container);
+    }
+  }
+};
+
+// ../code-mode/dist/tool.js
+function createCodeModeTool(registry, executor) {
+  const declarations = generateDeclarations(registry);
+  return {
+    name: "execute_code",
+    description: `Execute TypeScript code with access to the agent's APIs. Write the body of an async function.
+
+Available APIs:
+
+\`\`\`typescript
+${declarations}
+\`\`\`
+
+Each API call returns { success: boolean, output: string }.
+Use console.log() for intermediate output. Return your final result.`,
+    parameters: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The body of an async TypeScript function. Use the 'api' object to call tools."
+        }
+      },
+      required: ["code"]
+    },
+    execute: async (params) => {
+      const { code } = params;
+      const result = await executor.execute(code);
+      if (result.success) {
+        const parts = [];
+        if (result.logs.length > 0) {
+          parts.push(`[logs]
+${result.logs.join("\n")}`);
+        }
+        parts.push(typeof result.output === "string" ? result.output : JSON.stringify(result.output));
+        return { success: true, output: parts.join("\n\n") };
+      }
+      return {
+        success: false,
+        output: result.error ?? "Code execution failed"
+      };
+    }
+  };
+}
+
+// ../code-mode/dist/auto-executor.js
+var AutoExecutor = class {
+  primary;
+  fallback;
+  constructor(primary, fallback) {
+    this.primary = primary;
+    this.fallback = fallback;
+  }
+  async execute(code) {
+    try {
+      const result = await this.primary.execute(code);
+      return result;
+    } catch {
+      return this.fallback.execute(code);
+    }
+  }
+};
+
 // ../core/dist/audit.js
 import { appendFile, mkdir } from "fs/promises";
 import { join } from "path";
@@ -349,6 +751,19 @@ var Agent = class {
     const maxLoops = this.config.maxToolLoops ?? 10;
     let loopCount = 0;
     const toolSchemas = this.config.tools.toFunctionSchemas();
+    let effectiveSchemas = toolSchemas;
+    let codeModeTool;
+    if (this.config.codeModeExecutor) {
+      codeModeTool = createCodeModeTool(this.config.tools, this.config.codeModeExecutor);
+      effectiveSchemas = [{
+        type: "function",
+        function: {
+          name: codeModeTool.name,
+          description: codeModeTool.description,
+          parameters: codeModeTool.parameters
+        }
+      }];
+    }
     while (loopCount < maxLoops) {
       const messages = assembleContext({
         systemPrompt: this.config.systemPrompt,
@@ -357,7 +772,7 @@ var Agent = class {
         persona: this.config.persona
       });
       this.log.debug(`LLM call #${loopCount + 1} (${messages.length} messages)`);
-      const response = await this.config.llm.chat(messages, toolSchemas);
+      const response = await this.config.llm.chat(messages, effectiveSchemas);
       if (response.toolCalls.length === 0) {
         history.push({
           role: "assistant",
@@ -393,7 +808,12 @@ var Agent = class {
       for (const toolCall of response.toolCalls) {
         const toolStart = Date.now();
         this.log.debug(`Tool: ${toolCall.name}`);
-        const result = await this.config.tools.execute(toolCall.name, toolCall.arguments);
+        let result;
+        if (codeModeTool && toolCall.name === "execute_code") {
+          result = await codeModeTool.execute(toolCall.arguments, {});
+        } else {
+          result = await this.config.tools.execute(toolCall.name, toolCall.arguments);
+        }
         this.log.debug(`Tool ${toolCall.name}: ${result.success ? "ok" : "fail"} (${Date.now() - toolStart}ms)`);
         history.push({
           role: "tool",
@@ -2303,6 +2723,7 @@ var CronScheduler = class {
   timers = /* @__PURE__ */ new Map();
   handlers = [];
   persistChain = Promise.resolve();
+  running = false;
   constructor(store) {
     this.store = store;
   }
@@ -2320,12 +2741,21 @@ var CronScheduler = class {
       throw new Error(`Invalid runAt date: ${job.runAt}`);
     }
     this.jobs.set(job.id, job);
+    console.log(`[scheduler] Added job ${job.id} (${job.cron ? `cron: ${job.cron}` : `runAt: ${job.runAt}`})`);
     if (job.enabled && job.cron) {
       const task = createTask(job.cron, () => {
+        console.log(`[scheduler] Cron fired for job ${job.id}`);
         void this.executeHandlers(job);
       });
+      if (this.running) {
+        task.start();
+        console.log(`[scheduler] Started cron task for ${job.id} immediately (scheduler already running)`);
+      }
       this.tasks.set(job.id, task);
     }
+    if (this.running && job.enabled && job.runAt && !job.cron) {
+      this.scheduleOneShot(job);
+    }
     this.persist();
   }
   removeJob(id) {
@@ -2340,6 +2770,7 @@ var CronScheduler = class {
       this.timers.delete(id);
     }
     this.jobs.delete(id);
+    console.log(`[scheduler] Removed job ${id}`);
     this.persist();
   }
   listJobs() {
@@ -2356,16 +2787,21 @@ var CronScheduler = class {
     if (!this.store)
       return;
     const jobs = await this.store.load();
+    console.log(`[scheduler] Loading ${jobs.length} persisted jobs`);
     for (const job of jobs) {
       if (job.runAt && Date.parse(job.runAt) <= Date.now()) {
+        console.log(`[scheduler] Skipping expired one-shot job ${job.id} (runAt: ${job.runAt})`);
         continue;
       }
       this.addJob(job);
     }
   }
   start() {
-    for (const task of this.tasks.values()) {
+    this.running = true;
+    console.log(`[scheduler] Starting with ${this.tasks.size} cron tasks and ${this.handlers.length} handlers`);
+    for (const [id, task] of this.tasks) {
       task.start();
+      console.log(`[scheduler] Started cron task: ${id}`);
     }
     for (const job of this.jobs.values()) {
       if (job.enabled && job.runAt && !job.cron) {
@@ -2374,6 +2810,7 @@ var CronScheduler = class {
     }
   }
   stop() {
+    this.running = false;
     for (const task of this.tasks.values()) {
       task.stop();
     }
@@ -2384,9 +2821,13 @@ var CronScheduler = class {
   }
   scheduleOneShot(job) {
     const delayMs = Date.parse(job.runAt) - Date.now();
-    if (delayMs <= 0)
+    if (delayMs <= 0) {
+      console.log(`[scheduler] One-shot job ${job.id} already expired (delay: ${delayMs}ms), skipping`);
       return;
+    }
+    console.log(`[scheduler] Scheduled one-shot job ${job.id} in ${Math.round(delayMs / 1e3)}s (${job.runAt})`);
     const timer = setTimeout(() => {
+      console.log(`[scheduler] One-shot job ${job.id} firing now`);
       this.timers.delete(job.id);
       void this.executeHandlers(job).then(() => {
         this.removeJob(job.id);
@@ -2401,6 +2842,7 @@ var CronScheduler = class {
     this.persistChain = this.persistChain.then(() => this.store.save(jobs));
   }
   async executeHandlers(job) {
+    console.log(`[scheduler] Executing ${this.handlers.length} handlers for job ${job.id}`);
     for (const handler of this.handlers) {
       await handler(job);
     }
@@ -3977,6 +4419,40 @@ async function startAgent(configPath, opts) {
     log.info(`Skills initialized: ${skillsPath}`);
   }
   tools.setContext({ config, memory, scheduler, pool });
+  let codeModeExecutor;
+  if (config.codeMode) {
+    const cmConfig = config.codeMode;
+    if (cmConfig.runtime === "vm") {
+      codeModeExecutor = new VmExecutor(tools, {
+        timeout: cmConfig.timeout * 1e3,
+        // VmExecutor expects ms
+        memoryLimit: cmConfig.memoryLimit
+      });
+    } else if (cmConfig.runtime === "docker") {
+      codeModeExecutor = new DockerExecutor({
+        registry: tools,
+        pool,
+        timeout: cmConfig.timeout,
+        // DockerExecutor expects seconds
+        memoryLimit: config.sandbox.defaults.memoryLimit,
+        cpuLimit: config.sandbox.defaults.cpuLimit
+      });
+    } else {
+      const vmExec = new VmExecutor(tools, {
+        timeout: cmConfig.timeout * 1e3,
+        memoryLimit: cmConfig.memoryLimit
+      });
+      const dockerExec = new DockerExecutor({
+        registry: tools,
+        pool,
+        timeout: cmConfig.timeout,
+        memoryLimit: config.sandbox.defaults.memoryLimit,
+        cpuLimit: config.sandbox.defaults.cpuLimit
+      });
+      codeModeExecutor = new AutoExecutor(vmExec, dockerExec);
+    }
+    log.info(`Code Mode enabled: runtime=${cmConfig.runtime}, timeout=${cmConfig.timeout}s`);
+  }
   const auditConfig = config.audit ?? { path: "./logs", enabled: true };
   const auditPath = resolve(configPath, "..", auditConfig.path);
   const audit = auditConfig.enabled ? new FileAuditLogger(auditPath, log.child("audit")) : new NullAuditLogger();
@@ -4020,7 +4496,8 @@ async function startAgent(configPath, opts) {
     audit,
     guard,
     modelName: config.llm.default.model,
-    logger: log.child("agent")
+    logger: log.child("agent"),
+    codeModeExecutor
   });
   if (config.channels.telegram?.enabled) {
     const telegramLog = log.child("telegram");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "augure",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Augure — your proactive AI agent",
   "type": "module",
   "bin": {
@@ -12,18 +12,10 @@
   "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",
+    "esbuild": "^0.25.0",
     "grammy": "^1.40.0",
     "imapflow": "^1.2.10",
     "nodemailer": "^6.10.1",
@@ -33,17 +25,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.3",
+    "@augure/core": "0.4.0",
+    "@augure/sandbox": "0.1.2",
+    "@augure/scheduler": "0.1.2",
+    "@augure/memory": "0.0.5",
+    "@augure/types": "0.3.0",
+    "@augure/skills": "0.1.3",
+    "@augure/tools": "0.1.1"
   },
   "keywords": [
     "ai",
@@ -61,5 +53,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"
   }
-}
+}