augure 0.8.0 → 0.9.0

package/dist/chunk-DZMTL3S3.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+// ../core/dist/mcp-server.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+function validateMemoryPath(path) {
+  if (path.includes("..") || path.startsWith("/")) {
+    throw new Error(`Invalid memory path: ${path}`);
+  }
+}
+function createMcpServer(config) {
+  const server = new Server({ name: "augure", version: config.version ?? "0.0.0" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: config.tools.list().map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.parameters
+    }))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const result = await config.tools.execute(req.params.name, req.params.arguments ?? {});
+    return {
+      content: [{ type: "text", text: result.output }],
+      isError: !result.success
+    };
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const memFiles = await config.memory.list();
+    const jobs = config.scheduler.listJobs();
+    return {
+      resources: [
+        ...memFiles.map((f) => ({
+          uri: `memory://${f}`,
+          name: f,
+          mimeType: "text/markdown"
+        })),
+        {
+          uri: "jobs://list",
+          name: "Scheduled Jobs",
+          mimeType: "application/json"
+        },
+        ...jobs.map((j) => ({
+          uri: `jobs://${j.id}`,
+          name: `Job: ${j.id}`,
+          mimeType: "application/json"
+        }))
+      ]
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+    const uri = req.params.uri;
+    if (uri.startsWith("memory://")) {
+      const path = uri.slice("memory://".length);
+      validateMemoryPath(path);
+      let content;
+      try {
+        content = await config.memory.read(path);
+      } catch {
+        throw new Error(`Memory file not found: ${path}`);
+      }
+      return {
+        contents: [{ uri, text: content, mimeType: "text/markdown" }]
+      };
+    }
+    if (uri === "jobs://list") {
+      return {
+        contents: [{
+          uri,
+          text: JSON.stringify(config.scheduler.listJobs(), null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+    if (uri.startsWith("jobs://")) {
+      const jobId = uri.slice("jobs://".length);
+      const job = config.scheduler.listJobs().find((j) => j.id === jobId);
+      if (!job) {
+        throw new Error(`Job not found: ${jobId}`);
+      }
+      return {
+        contents: [{
+          uri,
+          text: JSON.stringify(job, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    if (!config.personaResolver)
+      return { prompts: [] };
+    const personas = config.personaResolver.listAll();
+    return {
+      prompts: personas.map((p) => ({
+        name: p.meta.id,
+        description: `Persona: ${p.meta.name}`,
+        arguments: [
+          { name: "message", description: "User message for context", required: false }
+        ]
+      }))
+    };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (req) => {
+    if (!config.personaResolver)
+      throw new Error("No personas configured");
+    const message = req.params.arguments?.message ?? "";
+    const personaText = config.personaResolver.resolve(String(message));
+    return {
+      messages: [
+        { role: "user", content: { type: "text", text: personaText } }
+      ]
+    };
+  });
+  return server;
+}
+
+export {
+  createMcpServer
+};

package/dist/chunk-FYS2JH42.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};

package/dist/chunk-H6PBSIJ5.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import {
+  noopLogger
+} from "./chunk-62OPINAX.js";
+
+// ../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 actions = await entry.stagehand.observe(instruction);
+    return actions.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);
+  }
+};
+
+export {
+  createStagehandConfig,
+  BrowserSessionManager
+};