augure 0.7.0 → 0.7.1

package/dist/bin.js

@@ -223,7 +223,22 @@ var AppConfigSchema = z.object({
         password: z.string()
       })
     }).optional(),
-    github: z.object({ token: z.string() }).optional()
+    github: z.object({ token: z.string() }).optional(),
+    browser: z.object({
+      provider: z.enum(["local", "browserbase"]),
+      browserbase: z.object({
+        apiKey: z.string().min(1),
+        projectId: z.string().optional()
+      }).optional(),
+      defaults: z.object({
+        timeout: z.number().int().positive().optional(),
+        headless: z.boolean().optional(),
+        viewport: z.object({
+          width: z.number().int().positive(),
+          height: z.number().int().positive()
+        }).optional()
+      }).optional()
+    }).optional()
   }),
   security: z.object({
     sandboxOnly: z.boolean(),
@@ -6345,6 +6360,248 @@ var githubTool = {
   }
 };
 
+// ../tools/dist/browser.js
+function createBrowserTool(manager) {
+  return {
+    name: "browser",
+    description: "AI-powered browser automation. Open a session, then use natural language to interact with web pages. Actions: open (creates session), navigate, act (click/type/interact), extract (get structured data), observe (discover elements), screenshot, close. Use 'act' with natural language instructions instead of CSS selectors. Use 'extract' with an instruction describing what data to get. Always close sessions when done.",
+    parameters: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["open", "navigate", "act", "extract", "observe", "screenshot", "close"],
+          description: "The browser action to perform"
+        },
+        session: {
+          type: "string",
+          description: "Session ID from 'open'. Required for all actions except 'open'."
+        },
+        url: {
+          type: "string",
+          description: "URL to navigate to. Used with 'open' and 'navigate'."
+        },
+        instruction: {
+          type: "string",
+          description: "Natural language instruction for act/extract/observe. Examples: 'click the search button', 'extract all product prices and titles', 'find the login form'."
+        },
+        schema: {
+          type: "object",
+          description: "JSON schema for structured extraction with 'extract'. Optional."
+        },
+        variables: {
+          type: "object",
+          description: "Variables for sensitive data in 'act'. Use %varName% in instruction. Example: instruction='type %password%', variables={password: 'secret'}"
+        }
+      },
+      required: ["action"]
+    },
+    configCheck: (ctx) => {
+      if (!ctx.config.tools?.browser) {
+        return "Browser tool requires tools.browser config in augure.json5. Set provider to 'local' for Playwright or 'browserbase' for cloud.";
+      }
+      if (ctx.config.tools.browser.provider === "browserbase" && !ctx.config.tools.browser.browserbase?.apiKey) {
+        return "Browserbase provider requires tools.browser.browserbase.apiKey";
+      }
+      return null;
+    },
+    execute: async (params, _ctx) => {
+      const p = params;
+      if (p.action !== "open" && !p.session) {
+        return { success: false, output: "Missing 'session' \u2014 open a session first with action: 'open'" };
+      }
+      if (["act", "extract", "observe"].includes(p.action) && !p.instruction) {
+        return { success: false, output: `Missing 'instruction' for action '${p.action}'` };
+      }
+      try {
+        switch (p.action) {
+          case "open": {
+            const sessionId = await manager.open(p.url);
+            return { success: true, output: `Session ${sessionId} opened.${p.url ? ` Navigated to ${p.url}` : ""}` };
+          }
+          case "navigate": {
+            if (!p.url)
+              return { success: false, output: "Missing 'url' for navigate" };
+            await manager.navigate(p.session, p.url);
+            return { success: true, output: `Navigated to ${p.url}` };
+          }
+          case "act": {
+            const result = await manager.act(p.session, p.instruction, p.variables);
+            return { success: result.success, output: result.message || "Action completed" };
+          }
+          case "extract": {
+            const data = await manager.extract(p.session, p.instruction, p.schema);
+            const output = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+            return { success: true, output };
+          }
+          case "observe": {
+            const elements = await manager.observe(p.session, p.instruction);
+            return {
+              success: true,
+              output: elements.length > 0 ? elements.map((e) => `- ${e.description} (${e.selector})`).join("\n") : "No matching elements found"
+            };
+          }
+          case "screenshot": {
+            const base64 = await manager.screenshot(p.session);
+            return {
+              success: true,
+              output: "Screenshot captured",
+              artifacts: [{ type: "image", name: "screenshot.png", content: base64 }]
+            };
+          }
+          case "close": {
+            await manager.close(p.session);
+            return { success: true, output: `Session ${p.session} closed` };
+          }
+          default:
+            return { success: false, output: `Unknown action: ${p.action}` };
+        }
+      } catch (err2) {
+        return {
+          success: false,
+          output: `Browser error: ${err2 instanceof Error ? err2.message : String(err2)}`
+        };
+      }
+    }
+  };
+}
+
+// ../browser/dist/session-manager.js
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// ../browser/dist/provider.js
+var PROVIDER_BASE_URLS = {
+  openrouter: "https://openrouter.ai/api/v1",
+  anthropic: "https://api.anthropic.com/v1",
+  openai: "https://api.openai.com/v1"
+};
+function createStagehandConfig(config, llm) {
+  const baseURL = PROVIDER_BASE_URLS[llm.provider];
+  return {
+    env: config.provider === "local" ? "LOCAL" : "BROWSERBASE",
+    apiKey: config.browserbase?.apiKey,
+    projectId: config.browserbase?.projectId,
+    model: {
+      modelName: llm.model,
+      apiKey: llm.apiKey,
+      ...baseURL ? { baseURL } : {}
+    },
+    localBrowserLaunchOptions: config.provider === "local" ? {
+      headless: config.defaults?.headless ?? true,
+      viewport: config.defaults?.viewport ?? { width: 1280, height: 720 }
+    } : void 0,
+    domSettleTimeout: (config.defaults?.timeout ?? 30) * 1e3,
+    verbose: 0,
+    disablePino: true
+  };
+}
+
+// ../browser/dist/session-manager.js
+var BrowserSessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  config;
+  llm;
+  ttlMs;
+  log;
+  counter = 0;
+  constructor(opts) {
+    this.config = opts.config;
+    this.llm = opts.llm;
+    this.ttlMs = opts.ttlMs ?? 12e4;
+    this.log = opts.logger ?? noopLogger;
+  }
+  async open(url) {
+    const id = `s_${Date.now()}_${++this.counter}`;
+    const stagehandConfig = createStagehandConfig(this.config, this.llm);
+    const stagehand = new Stagehand(stagehandConfig);
+    await stagehand.init();
+    if (url) {
+      const page = stagehand.context.activePage();
+      if (!page)
+        throw new Error(`No active page after init for session ${id}`);
+      await page.goto(url, { waitUntil: "domcontentloaded" });
+    }
+    const timer = setTimeout(() => {
+      this.log.warn(`Browser session ${id} expired (TTL ${this.ttlMs}ms)`);
+      this.close(id).catch(() => {
+      });
+    }, this.ttlMs);
+    this.sessions.set(id, { stagehand, timer });
+    this.log.info(`Browser session ${id} opened`);
+    return id;
+  }
+  async navigate(sessionId, url) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    const page = entry.stagehand.context.activePage();
+    if (!page)
+      throw new Error(`No active page for session ${sessionId}`);
+    await page.goto(url, { waitUntil: "domcontentloaded" });
+  }
+  async act(sessionId, instruction, variables) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    const result = await entry.stagehand.act(instruction, variables ? { variables } : void 0);
+    return { success: result.success, message: result.message ?? result.actionDescription ?? "" };
+  }
+  async extract(sessionId, instruction, schema) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    if (schema) {
+      return entry.stagehand.extract(instruction, schema);
+    }
+    return entry.stagehand.extract(instruction);
+  }
+  async observe(sessionId, instruction) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    const actions2 = await entry.stagehand.observe(instruction);
+    return actions2.map((a) => ({
+      description: a.description ?? "",
+      selector: a.selector ?? ""
+    }));
+  }
+  async screenshot(sessionId) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    const page = entry.stagehand.context.activePage();
+    if (!page)
+      throw new Error(`No active page for session ${sessionId}`);
+    const buffer = await page.screenshot();
+    return Buffer.from(buffer).toString("base64");
+  }
+  async close(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry)
+      return;
+    clearTimeout(entry.timer);
+    this.sessions.delete(sessionId);
+    try {
+      await entry.stagehand.close();
+    } catch {
+    }
+    this.log.info(`Browser session ${sessionId} closed`);
+  }
+  async closeAll() {
+    const ids = [...this.sessions.keys()];
+    await Promise.all(ids.map((id) => this.close(id)));
+  }
+  getSession(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry)
+      throw new Error(`Unknown or expired: no browser session ${sessionId}`);
+    return entry;
+  }
+  resetTtl(sessionId, entry) {
+    clearTimeout(entry.timer);
+    entry.timer = setTimeout(() => {
+      this.log.warn(`Browser session ${sessionId} expired (TTL ${this.ttlMs}ms)`);
+      this.close(sessionId).catch(() => {
+      });
+    }, this.ttlMs);
+  }
+};
+
 // ../core/dist/main.js
 import Dockerode from "dockerode";
 
@@ -6846,15 +7103,25 @@ ${content}`;
 // ../scheduler/dist/cron.js
 import { createTask, validate } from "node-cron";
 var CronScheduler = class {
-  store;
   jobs = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
   timers = /* @__PURE__ */ new Map();
   handlers = [];
   persistChain = Promise.resolve();
   running = false;
-  constructor(store) {
-    this.store = store;
+  store;
+  log;
+  constructor(storeOrOpts) {
+    if (storeOrOpts && "save" in storeOrOpts) {
+      this.store = storeOrOpts;
+      this.log = noopLogger;
+    } else if (storeOrOpts) {
+      const opts = storeOrOpts;
+      this.store = opts.store;
+      this.log = opts.logger ?? noopLogger;
+    } else {
+      this.log = noopLogger;
+    }
   }
   onJobTrigger(handler2) {
     this.handlers.push(handler2);
@@ -6870,20 +7137,24 @@ 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}`})`);
+    this.log.info(`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);
+        this.log.info(`Cron fired for job ${job.id}`);
+        this.executeHandlers(job).catch((err2) => this.log.error(`Cron job ${job.id} handler failed:`, err2));
       });
       if (this.running) {
         task.start();
-        console.log(`[scheduler] Started cron task for ${job.id} immediately (scheduler already running)`);
+        this.log.debug(`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);
+    if (job.enabled && job.runAt && !job.cron) {
+      if (this.running) {
+        this.scheduleOneShot(job);
+      } else {
+        this.log.warn(`Scheduler not running \u2014 one-shot job ${job.id} will be scheduled on start()`);
+      }
     }
     this.persist();
   }
@@ -6899,7 +7170,7 @@ var CronScheduler = class {
       this.timers.delete(id);
     }
     this.jobs.delete(id);
-    console.log(`[scheduler] Removed job ${id}`);
+    this.log.debug(`Removed job ${id}`);
     this.persist();
   }
   listJobs() {
@@ -6916,10 +7187,10 @@ var CronScheduler = class {
     if (!this.store)
       return;
     const jobs = await this.store.load();
-    console.log(`[scheduler] Loading ${jobs.length} persisted jobs`);
+    this.log.info(`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})`);
+        this.log.debug(`Skipping expired one-shot job ${job.id} (runAt: ${job.runAt})`);
         continue;
       }
       this.addJob(job);
@@ -6927,10 +7198,10 @@ var CronScheduler = class {
   }
   start() {
     this.running = true;
-    console.log(`[scheduler] Starting with ${this.tasks.size} cron tasks and ${this.handlers.length} handlers`);
+    this.log.info(`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}`);
+      this.log.debug(`Started cron task: ${id}`);
     }
     for (const job of this.jobs.values()) {
       if (job.enabled && job.runAt && !job.cron) {
@@ -6939,6 +7210,7 @@ var CronScheduler = class {
     }
   }
   stop() {
+    this.log.info("Scheduler stopped");
     this.running = false;
     for (const task of this.tasks.values()) {
       task.stop();
@@ -6951,16 +7223,14 @@ var CronScheduler = class {
   scheduleOneShot(job) {
     const delayMs = Date.parse(job.runAt) - Date.now();
     if (delayMs <= 0) {
-      console.log(`[scheduler] One-shot job ${job.id} already expired (delay: ${delayMs}ms), skipping`);
+      this.log.warn(`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})`);
+    this.log.info(`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.log.info(`One-shot job ${job.id} firing now`);
       this.timers.delete(job.id);
-      void this.executeHandlers(job).then(() => {
-        this.removeJob(job.id);
-      });
+      this.executeHandlers(job).then(() => this.removeJob(job.id)).catch((err2) => this.log.error(`One-shot job ${job.id} handler failed:`, err2));
     }, delayMs);
     this.timers.set(job.id, timer);
   }
@@ -6971,7 +7241,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}`);
+    this.log.debug(`Executing ${this.handlers.length} handlers for job ${job.id}`);
     for (const handler2 of this.handlers) {
       await handler2(job);
     }
@@ -8468,9 +8738,26 @@ async function startAgent(configPath, opts) {
   tools.register(sandboxExecTool);
   tools.register(opencodeTool);
   tools.register(githubTool);
+  let browserManager;
+  if (config.tools?.browser) {
+    const browserLlm = config.llm.coding ?? config.llm.default;
+    browserManager = new BrowserSessionManager({
+      config: config.tools.browser,
+      llm: {
+        provider: browserLlm.provider ?? config.llm.default.provider,
+        apiKey: browserLlm.apiKey ?? config.llm.default.apiKey,
+        model: browserLlm.model ?? config.llm.default.model,
+        maxTokens: browserLlm.maxTokens ?? config.llm.default.maxTokens
+      },
+      ttlMs: 12e4,
+      logger: log.child("browser")
+    });
+    tools.register(createBrowserTool(browserManager));
+    log.info("Browser tool registered", { provider: config.tools.browser.provider });
+  }
   const jobStorePath = resolve(configPath, "..", "jobs.json");
   const jobStore = new JobStore(jobStorePath);
-  const scheduler = new CronScheduler(jobStore);
+  const scheduler = new CronScheduler({ store: jobStore, logger: log.child("scheduler") });
   await scheduler.loadPersistedJobs();
   log.info(`Loaded ${scheduler.listJobs().length} persisted jobs`);
   for (const job of config.scheduler.jobs) {
@@ -8498,7 +8785,8 @@ async function startAgent(configPath, opts) {
     const skillRunner = new SkillRunner({
       pool,
       manager: skillManager,
-      defaults: config.sandbox.defaults
+      defaults: config.sandbox.defaults,
+      browserManager
     });
     const skillTester = new SkillTester({
       pool,
@@ -8773,6 +9061,8 @@ Run: \`npm update -g augure\``
     scheduler.stop();
     if (telegram)
       await telegram.stop();
+    if (browserManager)
+      await browserManager.closeAll();
     await pool.destroyAll();
     await audit.close();
     log.info("All containers destroyed");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "augure",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Augure — your proactive AI agent",
   "type": "module",
   "bin": {
@@ -22,20 +22,21 @@
     "gray-matter": "^4.0.3",
     "json5": "^2.2.3",
     "node-cron": "^4.2.1",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@browserbasehq/stagehand": "^3.0.0"
   },
   "devDependencies": {
     "@types/dockerode": "^4.0.1",
     "@types/node-cron": "^3.0.11",
     "tsup": "^8.5.1",
-    "@augure/channels": "0.1.3",
-    "@augure/core": "0.6.0",
-    "@augure/sandbox": "0.1.2",
-    "@augure/scheduler": "0.1.2",
-    "@augure/memory": "0.0.5",
-    "@augure/tools": "0.3.0",
-    "@augure/types": "0.3.0",
-    "@augure/skills": "0.1.3"
+    "@augure/channels": "0.1.4",
+    "@augure/core": "0.7.0",
+    "@augure/sandbox": "0.1.3",
+    "@augure/scheduler": "0.1.3",
+    "@augure/memory": "0.0.6",
+    "@augure/skills": "0.1.4",
+    "@augure/tools": "0.4.0",
+    "@augure/types": "0.4.0"
   },
   "keywords": [
     "ai",