@stackmemoryai/stackmemory 1.12.0 → 1.14.0

package/dist/src/features/browser/stagehand-workflows.js

@@ -0,0 +1,578 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  existsSync,
+  mkdirSync,
+  appendFileSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID, createHash } from "crypto";
+import { logger } from "../../core/monitoring/logger.js";
+const SM_DIR = join(homedir(), ".stackmemory");
+const DP_DIR = join(SM_DIR, "desire-paths");
+const WORKFLOW_DIR = join(SM_DIR, "workflows");
+const STREAM_FILE = join(DP_DIR, "action-stream.jsonl");
+const WORKFLOW_CACHE_FILE = join(WORKFLOW_DIR, "cached-workflows.json");
+const BENCHMARK_FILE = join(WORKFLOW_DIR, "benchmarks.jsonl");
+class StagehandWorkflowCapture {
+  stagehand;
+  // Stagehand instance (peer dep, not typed)
+  sessionId;
+  recording = false;
+  currentWorkflow = null;
+  steps = [];
+  constructor(stagehandInstance, sessionId) {
+    this.stagehand = stagehandInstance;
+    this.sessionId = sessionId || `wf-${Date.now()}-${randomUUID().slice(0, 8)}`;
+    ensureDir(DP_DIR);
+    ensureDir(WORKFLOW_DIR);
+  }
+  /** Start recording a workflow */
+  startCapture(name) {
+    this.recording = true;
+    this.steps = [];
+    const page = this.stagehand.context?.pages?.()?.[0];
+    const startUrl = page?.url?.() || "about:blank";
+    this.currentWorkflow = {
+      id: randomUUID(),
+      name,
+      startUrl,
+      steps: [],
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalDuration: 0,
+      totalTokens: 0,
+      sessionId: this.sessionId
+    };
+    logger.info("Workflow capture started", { name, startUrl });
+  }
+  /** Navigate to a URL */
+  async navigate(url) {
+    const start = Date.now();
+    const page = this.stagehand.context.pages()[0];
+    await page.goto(url);
+    const dur = Date.now() - start;
+    this.recordStep({
+      type: "navigate",
+      instruction: url,
+      url,
+      duration: dur,
+      tokens: 0,
+      cached: false
+    });
+  }
+  /** Execute a Stagehand act() — natural language browser action */
+  async act(instruction, options) {
+    const start = Date.now();
+    const result = await this.stagehand.act(instruction, options);
+    const dur = Date.now() - start;
+    const page = this.stagehand.context.pages()[0];
+    const url = page?.url?.() || "";
+    const tokens = estimateActTokens(instruction);
+    this.recordStep({
+      type: "act",
+      instruction,
+      url,
+      duration: dur,
+      tokens,
+      cached: false,
+      // TODO: detect from Stagehand cache hits
+      result
+    });
+    return result;
+  }
+  /** Execute a Stagehand extract() — structured data extraction */
+  async extract(instruction, schema, options) {
+    const start = Date.now();
+    const result = await this.stagehand.extract(instruction, schema, options);
+    const dur = Date.now() - start;
+    const page = this.stagehand.context.pages()[0];
+    const url = page?.url?.() || "";
+    const tokens = estimateActTokens(instruction);
+    this.recordStep({
+      type: "extract",
+      instruction,
+      url,
+      duration: dur,
+      tokens,
+      cached: false,
+      result
+    });
+    return result;
+  }
+  /** Execute a Stagehand observe() — discover available actions */
+  async observe(instruction) {
+    const start = Date.now();
+    const result = await this.stagehand.observe(instruction);
+    const dur = Date.now() - start;
+    const page = this.stagehand.context.pages()[0];
+    const url = page?.url?.() || "";
+    this.recordStep({
+      type: "observe",
+      instruction,
+      url,
+      duration: dur,
+      tokens: estimateActTokens(instruction),
+      cached: false,
+      result
+    });
+    return result;
+  }
+  /** Stop recording and return the captured workflow */
+  stopCapture() {
+    if (!this.currentWorkflow) return null;
+    this.recording = false;
+    this.currentWorkflow.steps = [...this.steps];
+    this.currentWorkflow.totalDuration = this.steps.reduce(
+      (sum, s) => sum + s.duration,
+      0
+    );
+    this.currentWorkflow.totalTokens = this.steps.reduce(
+      (sum, s) => sum + s.tokens,
+      0
+    );
+    saveWorkflow(this.currentWorkflow);
+    const desirePathPattern = workflowToDesirePathPattern(this.currentWorkflow);
+    appendDesirePathPattern(desirePathPattern);
+    logger.info("Workflow capture stopped", {
+      id: this.currentWorkflow.id,
+      steps: this.steps.length,
+      duration: this.currentWorkflow.totalDuration
+    });
+    const wf = this.currentWorkflow;
+    this.currentWorkflow = null;
+    this.steps = [];
+    return wf;
+  }
+  /** Record a step + emit to action-stream */
+  recordStep(step) {
+    if (this.recording) {
+      this.steps.push(step);
+    }
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      sid: this.sessionId,
+      tool: `stagehand:${step.type}`,
+      target: sanitizeInstruction(step.instruction),
+      dur: step.duration,
+      meta: {
+        url: step.url,
+        cached: step.cached,
+        tokens: step.tokens,
+        success: !step.result?.error
+      }
+    };
+    emitToActionStream(entry);
+  }
+  /** Get the underlying Stagehand instance for direct access */
+  get instance() {
+    return this.stagehand;
+  }
+}
+class WorkflowCache {
+  workflows = /* @__PURE__ */ new Map();
+  constructor() {
+    this.load();
+  }
+  /** Load cached workflows from disk */
+  load() {
+    if (!existsSync(WORKFLOW_CACHE_FILE)) return;
+    try {
+      const data = JSON.parse(readFileSync(WORKFLOW_CACHE_FILE, "utf-8"));
+      if (Array.isArray(data)) {
+        for (const entry of data) {
+          this.workflows.set(entry.id, entry);
+        }
+      }
+    } catch {
+    }
+  }
+  /** Save to disk */
+  save() {
+    ensureDir(WORKFLOW_DIR);
+    writeFileSync(
+      WORKFLOW_CACHE_FILE,
+      JSON.stringify([...this.workflows.values()], null, 2)
+    );
+  }
+  /** Store a captured workflow as a cached entry */
+  cacheWorkflow(workflow) {
+    const entry = {
+      version: 1,
+      id: workflow.id,
+      name: workflow.name,
+      startUrl: workflow.startUrl,
+      steps: workflow.steps.map((s) => ({
+        type: s.type,
+        instruction: s.instruction,
+        url: s.url
+      })),
+      capturedAt: workflow.capturedAt,
+      replayCount: 0,
+      avgDuration: workflow.totalDuration,
+      successRate: 1
+    };
+    this.workflows.set(entry.id, entry);
+    this.save();
+    return entry;
+  }
+  /** Find a cached workflow by name (fuzzy match) */
+  findByName(query) {
+    const lower = query.toLowerCase();
+    for (const entry of this.workflows.values()) {
+      if (entry.name.toLowerCase().includes(lower)) return entry;
+    }
+    return void 0;
+  }
+  /** Find workflows matching a URL pattern */
+  findByUrl(url) {
+    const host = extractHost(url);
+    return [...this.workflows.values()].filter(
+      (w) => extractHost(w.startUrl) === host
+    );
+  }
+  /** List all cached workflows */
+  list() {
+    return [...this.workflows.values()].sort(
+      (a, b) => b.replayCount - a.replayCount
+    );
+  }
+  /** Update replay stats after a replay attempt */
+  recordReplay(id, success, duration) {
+    const entry = this.workflows.get(id);
+    if (!entry) return;
+    entry.replayCount++;
+    entry.lastReplayAt = (/* @__PURE__ */ new Date()).toISOString();
+    entry.avgDuration = (entry.avgDuration * (entry.replayCount - 1) + duration) / entry.replayCount;
+    entry.successRate = (entry.successRate * (entry.replayCount - 1) + (success ? 1 : 0)) / entry.replayCount;
+    this.save();
+  }
+  get(id) {
+    return this.workflows.get(id);
+  }
+}
+class WorkflowReplayer {
+  stagehand;
+  cache;
+  constructor(stagehandInstance, cache) {
+    this.stagehand = stagehandInstance;
+    this.cache = cache || new WorkflowCache();
+  }
+  /** Replay a workflow by ID */
+  async replay(workflowId, mode = "hybrid", variables) {
+    const entry = this.cache.get(workflowId);
+    if (!entry) {
+      return {
+        success: false,
+        error: "Workflow not found",
+        duration: 0,
+        steps: 0,
+        selfHealed: false
+      };
+    }
+    return this.replayEntry(entry, mode, variables);
+  }
+  /** Replay by name (fuzzy match) */
+  async replayByName(name, mode = "hybrid", variables) {
+    const entry = this.cache.findByName(name);
+    if (!entry) {
+      return {
+        success: false,
+        error: `No workflow matching "${name}"`,
+        duration: 0,
+        steps: 0,
+        selfHealed: false
+      };
+    }
+    return this.replayEntry(entry, mode, variables);
+  }
+  async replayEntry(entry, mode, variables) {
+    const start = Date.now();
+    let selfHealed = false;
+    let stepsCompleted = 0;
+    try {
+      const page = this.stagehand.context.pages()[0];
+      let startUrl = entry.startUrl;
+      if (variables) {
+        startUrl = substituteVars(startUrl, variables);
+      }
+      await page.goto(startUrl);
+      for (const step of entry.steps) {
+        let instruction = step.instruction;
+        if (variables) {
+          instruction = substituteVars(instruction, variables);
+        }
+        if (step.type === "navigate" && step.url) {
+          const url = variables ? substituteVars(step.url, variables) : step.url;
+          await page.goto(url);
+        } else if (step.type === "act") {
+          if (mode === "cached" && step.actions?.length) {
+            try {
+              await replayActions(page, step.actions);
+            } catch {
+              if (mode === "cached")
+                throw new Error("Cache miss \u2014 selector changed");
+              selfHealed = true;
+              await this.stagehand.act(instruction);
+            }
+          } else {
+            await this.stagehand.act(instruction);
+          }
+        } else if (step.type === "extract") {
+          await this.stagehand.extract(
+            instruction,
+            step.schema ? JSON.parse(step.schema) : void 0
+          );
+        } else if (step.type === "observe") {
+          await this.stagehand.observe(instruction);
+        }
+        stepsCompleted++;
+      }
+      const duration = Date.now() - start;
+      this.cache.recordReplay(entry.id, true, duration);
+      return {
+        success: true,
+        duration,
+        steps: stepsCompleted,
+        selfHealed
+      };
+    } catch (error) {
+      const duration = Date.now() - start;
+      this.cache.recordReplay(entry.id, false, duration);
+      return {
+        success: false,
+        error: error.message,
+        duration,
+        steps: stepsCompleted,
+        selfHealed
+      };
+    }
+  }
+}
+class WorkflowBenchmark {
+  results = [];
+  /** Run a benchmark with Stagehand AI mode */
+  async benchmarkStagehandAI(name, stagehand, steps) {
+    const start = Date.now();
+    let success = true;
+    let error;
+    let totalTokens = 0;
+    try {
+      const page = stagehand.context.pages()[0];
+      for (const step of steps) {
+        if (step.type === "navigate") {
+          await page.goto(step.instruction);
+        } else if (step.type === "act") {
+          await stagehand.act(step.instruction);
+          totalTokens += estimateActTokens(step.instruction);
+        } else if (step.type === "extract") {
+          await stagehand.extract(step.instruction, step.schema);
+          totalTokens += estimateActTokens(step.instruction);
+        }
+      }
+    } catch (e) {
+      success = false;
+      error = e.message;
+    }
+    const result = {
+      workflow: name,
+      approach: "stagehand-ai",
+      duration: Date.now() - start,
+      tokens: totalTokens,
+      success,
+      selfHealed: false,
+      steps: steps.length,
+      error
+    };
+    this.results.push(result);
+    return result;
+  }
+  /** Run a benchmark with cached replay */
+  async benchmarkStagehandCached(name, replayer, workflowId, variables) {
+    const replayResult = await replayer.replay(workflowId, "cached", variables);
+    const result = {
+      workflow: name,
+      approach: "stagehand-cached",
+      duration: replayResult.duration,
+      tokens: 0,
+      // Cached = no AI tokens
+      success: replayResult.success,
+      selfHealed: replayResult.selfHealed,
+      steps: replayResult.steps,
+      error: replayResult.error
+    };
+    this.results.push(result);
+    return result;
+  }
+  /** Run a benchmark with a Playwright code function */
+  async benchmarkPlaywright(name, fn, stepCount) {
+    const start = Date.now();
+    let success = true;
+    let error;
+    try {
+      await fn();
+    } catch (e) {
+      success = false;
+      error = e.message;
+    }
+    const result = {
+      workflow: name,
+      approach: "playwright-code",
+      duration: Date.now() - start,
+      tokens: 0,
+      success,
+      selfHealed: false,
+      steps: stepCount,
+      error
+    };
+    this.results.push(result);
+    return result;
+  }
+  /** Get all results */
+  getResults() {
+    return [...this.results];
+  }
+  /** Print a comparison table */
+  formatTable() {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const r of this.results) {
+      const list = grouped.get(r.workflow) || [];
+      list.push(r);
+      grouped.set(r.workflow, list);
+    }
+    const lines = [];
+    lines.push(
+      "| Workflow | Approach | Duration | Tokens | Success | Self-Healed |"
+    );
+    lines.push(
+      "|----------|----------|----------|--------|---------|-------------|"
+    );
+    for (const [name, results] of grouped) {
+      for (const r of results) {
+        lines.push(
+          `| ${name} | ${r.approach} | ${r.duration}ms | ${r.tokens} | ${r.success ? "Y" : "N"} | ${r.selfHealed ? "Y" : "N"} |`
+        );
+      }
+    }
+    return lines.join("\n");
+  }
+  /** Save results to JSONL */
+  save() {
+    ensureDir(WORKFLOW_DIR);
+    for (const result of this.results) {
+      appendFileSync(BENCHMARK_FILE, JSON.stringify(result) + "\n");
+    }
+  }
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function sanitizeInstruction(instruction) {
+  return instruction.slice(0, 100).replace(/[\n\r]/g, " ");
+}
+function estimateActTokens(instruction) {
+  return Math.ceil(instruction.length / 4) + 2e3;
+}
+function extractHost(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+function substituteVars(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return result;
+}
+function emitToActionStream(entry) {
+  try {
+    ensureDir(DP_DIR);
+    appendFileSync(STREAM_FILE, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+function workflowToDesirePathPattern(workflow) {
+  return {
+    id: workflow.id,
+    sequence: workflow.steps.map(
+      (s) => `stagehand:${s.type}:${sanitizeInstruction(s.instruction)}`
+    ),
+    frequency: 1,
+    sessions: 1,
+    score: workflow.steps.length,
+    // longer = more valuable
+    first_seen: workflow.capturedAt,
+    last_seen: workflow.capturedAt,
+    source: "stagehand"
+  };
+}
+function appendDesirePathPattern(pattern) {
+  const patternsFile = join(DP_DIR, "patterns.json");
+  let patterns = [];
+  if (existsSync(patternsFile)) {
+    try {
+      patterns = JSON.parse(readFileSync(patternsFile, "utf-8"));
+    } catch {
+      patterns = [];
+    }
+  }
+  const seqHash = createHash("sha256").update(pattern.sequence.join("|")).digest("hex").slice(0, 16);
+  const existing = patterns.find((p) => {
+    const h = createHash("sha256").update((p.sequence || []).join("|")).digest("hex").slice(0, 16);
+    return h === seqHash;
+  });
+  if (existing) {
+    existing.frequency = (existing.frequency || 0) + 1;
+    existing.sessions = (existing.sessions || 0) + 1;
+    existing.score = existing.frequency * existing.sessions;
+    existing.last_seen = pattern.last_seen;
+  } else {
+    patterns.push(pattern);
+  }
+  ensureDir(DP_DIR);
+  writeFileSync(patternsFile, JSON.stringify(patterns, null, 2));
+}
+async function replayActions(page, actions) {
+  for (const action of actions) {
+    if (!action.selector) continue;
+    const element = await page.locator(action.selector);
+    switch (action.action) {
+      case "click":
+        await element.click();
+        break;
+      case "fill":
+      case "type":
+        if (action.text) await element.fill(action.text);
+        break;
+      case "selectOption":
+        if (action.args?.[0]) await element.selectOption(action.args[0]);
+        break;
+      default:
+        if (action.action && typeof element[action.action] === "function") {
+          await element[action.action](...action.args || []);
+        }
+    }
+  }
+}
+function saveWorkflow(workflow) {
+  const file = join(WORKFLOW_DIR, `${workflow.id}.json`);
+  ensureDir(WORKFLOW_DIR);
+  writeFileSync(file, JSON.stringify(workflow, null, 2));
+  const cache = new WorkflowCache();
+  cache.cacheWorkflow(workflow);
+}
+export {
+  StagehandWorkflowCapture,
+  WorkflowBenchmark,
+  WorkflowCache,
+  WorkflowReplayer
+};

package/dist/src/features/operator/adapter-factory.js

@@ -0,0 +1,62 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { execSync } from "child_process";
+import { TmuxAdapter } from "./screen-adapter.js";
+function createAdapter(config) {
+  const mode = config.mode === "auto" ? detectMode(config) : config.mode;
+  switch (mode) {
+    case "tmux":
+      return new TmuxAdapter(config.sessionName, "0");
+    case "desktop": {
+      if (!config.llmConfig?.apiKey) {
+        throw new Error(
+          "Desktop mode requires ANTHROPIC_API_KEY for screenshot interpretation.\nSet it via: export ANTHROPIC_API_KEY=sk-ant-..."
+        );
+      }
+      const { DesktopAdapter } = require("./desktop-adapter.js");
+      return new DesktopAdapter(config.appName ?? "Claude", config.llmConfig);
+    }
+    case "browser":
+      throw new Error(
+        "Browser mode requires a Playwright page instance.\nUse BrowserAdapter directly with an initialized page,\nor use: stackmemory operator start --mode browser --url https://claude.ai/code"
+      );
+    default:
+      return new TmuxAdapter(config.sessionName, "0");
+  }
+}
+function detectMode(config) {
+  if (isTmuxAvailable()) {
+    return "tmux";
+  }
+  if (process.platform === "darwin" && isClaudeDesktopRunning(config.appName)) {
+    return "desktop";
+  }
+  process.stderr.write(
+    "[operator] Warning: tmux not found and no desktop app detected.\n  Install tmux: brew install tmux\n  Or use --mode desktop/browser\n"
+  );
+  return "tmux";
+}
+function isTmuxAvailable() {
+  try {
+    execSync("which tmux", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isClaudeDesktopRunning(appName = "Claude") {
+  try {
+    const result = execSync(
+      `osascript -e 'tell application "System Events" to (name of processes) contains "${appName}"'`,
+      { encoding: "utf-8", timeout: 5e3 }
+    ).trim();
+    return result === "true";
+  } catch {
+    return false;
+  }
+}
+export {
+  createAdapter
+};