@stackmemoryai/stackmemory 1.12.0 → 1.14.0

package/dist/src/integrations/linear/webhook-retry.js

@@ -0,0 +1,196 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import Database from "better-sqlite3";
+import { randomUUID } from "crypto";
+import { calculateBackoff } from "../../core/errors/recovery.js";
+import { logger } from "../../core/monitoring/logger.js";
+const DEFAULT_CONFIG = {
+  maxAttempts: 5,
+  initialDelay: 1e3,
+  maxDelay: 3e5,
+  backoffFactor: 2,
+  workerIntervalMs: 5e3
+};
+class WebhookDeliveryQueue {
+  db;
+  config;
+  workerTimer = null;
+  handler = null;
+  constructor(dbPath, config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.ensureSchema();
+  }
+  ensureSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS webhook_deliveries (
+        id TEXT PRIMARY KEY,
+        event_type TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        attempts INTEGER NOT NULL DEFAULT 0,
+        max_attempts INTEGER NOT NULL DEFAULT 5,
+        next_retry_at INTEGER,
+        last_error TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_webhook_deliveries_status_retry
+        ON webhook_deliveries(status, next_retry_at);
+    `);
+  }
+  /**
+   * Set the handler function that processes webhook events.
+   */
+  setHandler(fn) {
+    this.handler = fn;
+  }
+  /**
+   * Enqueue a webhook event for processing.
+   */
+  enqueue(eventType, payload) {
+    const id = randomUUID();
+    const now = Date.now();
+    this.db.prepare(
+      `INSERT INTO webhook_deliveries
+         (id, event_type, payload, status, attempts, max_attempts, next_retry_at, created_at, updated_at)
+         VALUES (?, ?, ?, 'pending', 0, ?, ?, ?, ?)`
+    ).run(
+      id,
+      eventType,
+      JSON.stringify(payload),
+      this.config.maxAttempts,
+      now,
+      now,
+      now
+    );
+    return id;
+  }
+  /**
+   * Process the next eligible delivery. Returns true if a delivery was processed.
+   */
+  async processNext() {
+    if (!this.handler) {
+      return false;
+    }
+    const now = Date.now();
+    const delivery = this.db.prepare(
+      `UPDATE webhook_deliveries
+         SET status = 'processing', updated_at = ?
+         WHERE id = (
+           SELECT id FROM webhook_deliveries
+           WHERE (status = 'pending' OR (status = 'failed' AND next_retry_at <= ?))
+           ORDER BY next_retry_at ASC, created_at ASC
+           LIMIT 1
+         )
+         RETURNING *`
+    ).get(now, now);
+    if (!delivery) {
+      return false;
+    }
+    const attempt = delivery.attempts + 1;
+    try {
+      const payload = JSON.parse(delivery.payload);
+      await this.handler(delivery.event_type, payload);
+      this.db.prepare(
+        `UPDATE webhook_deliveries
+           SET status = 'completed', attempts = ?, last_error = NULL, updated_at = ?
+           WHERE id = ?`
+      ).run(attempt, Date.now(), delivery.id);
+      logger.info(
+        `Webhook delivery ${delivery.id} completed on attempt ${attempt}`
+      );
+      return true;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (attempt >= delivery.max_attempts) {
+        this.db.prepare(
+          `UPDATE webhook_deliveries
+             SET status = 'dead', attempts = ?, last_error = ?, updated_at = ?
+             WHERE id = ?`
+        ).run(attempt, errorMsg, Date.now(), delivery.id);
+        logger.error(
+          `Webhook delivery ${delivery.id} dead after ${attempt} attempts: ${errorMsg}`
+        );
+      } else {
+        const delay = calculateBackoff(
+          attempt,
+          this.config.initialDelay,
+          this.config.maxDelay,
+          this.config.backoffFactor
+        );
+        const nextRetry = Date.now() + delay;
+        this.db.prepare(
+          `UPDATE webhook_deliveries
+             SET status = 'failed', attempts = ?, last_error = ?, next_retry_at = ?, updated_at = ?
+             WHERE id = ?`
+        ).run(attempt, errorMsg, nextRetry, Date.now(), delivery.id);
+        logger.warn(
+          `Webhook delivery ${delivery.id} failed (attempt ${attempt}/${delivery.max_attempts}), retry in ${delay}ms`
+        );
+      }
+      return true;
+    }
+  }
+  /**
+   * Start the background worker that polls for deliveries.
+   */
+  startWorker() {
+    if (this.workerTimer) return;
+    this.workerTimer = setInterval(async () => {
+      try {
+        while (await this.processNext()) {
+        }
+      } catch (error) {
+        logger.error("Webhook retry worker error", error);
+      }
+    }, this.config.workerIntervalMs);
+  }
+  /**
+   * Stop the background worker.
+   */
+  stopWorker() {
+    if (this.workerTimer) {
+      clearInterval(this.workerTimer);
+      this.workerTimer = null;
+    }
+  }
+  /**
+   * Get delivery counts by status.
+   */
+  getStats() {
+    const rows = this.db.prepare(
+      `SELECT status, COUNT(*) as count FROM webhook_deliveries GROUP BY status`
+    ).all();
+    const stats = {
+      pending: 0,
+      processing: 0,
+      completed: 0,
+      failed: 0,
+      dead: 0
+    };
+    for (const row of rows) {
+      stats[row.status] = row.count;
+    }
+    return stats;
+  }
+  /**
+   * Get a single delivery by ID.
+   */
+  getDelivery(id) {
+    return this.db.prepare(`SELECT * FROM webhook_deliveries WHERE id = ?`).get(id);
+  }
+  /**
+   * Close the database connection and stop the worker.
+   */
+  close() {
+    this.stopWorker();
+    this.db.close();
+  }
+}
+export {
+  WebhookDeliveryQueue
+};

package/dist/src/integrations/linear/webhook-server.js

@@ -8,7 +8,10 @@ import crypto from "crypto";
 import { LinearSyncService } from "./sync-service.js";
 import { IntegrationError, ErrorCode } from "../../core/errors/index.js";
 import { logger } from "../../core/monitoring/logger.js";
+import { WebhookDeliveryQueue } from "./webhook-retry.js";
 import chalk from "chalk";
+import { join } from "path";
+import { homedir } from "os";
 function _getEnv(key, defaultValue) {
   const value = process.env[key];
   if (value === void 0) {
@@ -29,21 +32,28 @@ class LinearWebhookServer {
   // Using singleton logger from monitoring
   syncService;
   config;
-  eventQueue = [];
-  isProcessing = false;
+  deliveryQueue;
   constructor(config) {
     this.app = express();
     this.syncService = new LinearSyncService();
+    const dbPath = config?.dbPath || join(homedir(), ".stackmemory", "webhook-deliveries.db");
     this.config = {
       port: config?.port || parseInt(process.env["WEBHOOK_PORT"] || "3456"),
       host: config?.host || process.env["WEBHOOK_HOST"] || "localhost",
       webhookSecret: config?.webhookSecret || process.env["LINEAR_WEBHOOK_SECRET"],
       maxPayloadSize: config?.maxPayloadSize || "10mb",
+      dbPath,
       rateLimit: {
         windowMs: config?.rateLimit?.windowMs || 6e4,
         max: config?.rateLimit?.max || 100
       }
     };
+    this.deliveryQueue = new WebhookDeliveryQueue(dbPath);
+    this.deliveryQueue.setHandler(
+      async (eventType, payload) => {
+        await this.handleWebhookEvent(payload);
+      }
+    );
     this.setupMiddleware();
     this.setupRoutes();
   }
@@ -61,12 +71,12 @@ class LinearWebhookServer {
   }
   setupRoutes() {
     this.app.get("/health", (req, res) => {
+      const stats = this.deliveryQueue.getStats();
       res.json({
         status: "healthy",
         service: "linear-webhook",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        queue: this.eventQueue.length,
-        processing: this.isProcessing
+        deliveries: stats
       });
     });
     this.app.post("/webhook/linear", async (req, res) => {
@@ -77,11 +87,10 @@ class LinearWebhookServer {
         }
         const payload = JSON.parse(req.body.toString());
         logger.info(`Received webhook: ${payload.type} - ${payload.action}`);
-        this.eventQueue.push(payload);
-        this.processQueue();
+        const deliveryId = this.deliveryQueue.enqueue(payload.type, payload);
         return res.status(200).json({
           status: "accepted",
-          queued: true
+          deliveryId
         });
       } catch (error) {
         logger.error("Webhook processing error:", error);
@@ -104,21 +113,6 @@ class LinearWebhookServer {
     const hash = crypto.createHmac("sha256", this.config.webhookSecret).update(req.body).digest("hex");
     return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(hash));
   }
-  async processQueue() {
-    if (this.isProcessing || this.eventQueue.length === 0) {
-      return;
-    }
-    this.isProcessing = true;
-    while (this.eventQueue.length > 0) {
-      const event = this.eventQueue.shift();
-      try {
-        await this.handleWebhookEvent(event);
-      } catch (error) {
-        logger.error(`Failed to process event: ${event.type}`, error);
-      }
-    }
-    this.isProcessing = false;
-  }
   async handleWebhookEvent(payload) {
     const { type, action, data } = payload;
     switch (type) {
@@ -166,6 +160,7 @@ class LinearWebhookServer {
         this.config.port,
         this.config.host,
         () => {
+          this.deliveryQueue.startWorker();
           console.log(
             chalk.green("\u2713") + chalk.bold(" Linear Webhook Server Started")
           );
@@ -188,6 +183,7 @@ class LinearWebhookServer {
     });
   }
   async stop() {
+    this.deliveryQueue.close();
     return new Promise((resolve) => {
       if (this.server) {
         this.server.close(() => {

package/dist/src/integrations/mcp/handlers/cloud-sync-handlers.js

@@ -0,0 +1,101 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const VALID_SYNC_TABLES = /* @__PURE__ */ new Set([
+  "frames",
+  "events",
+  "anchors",
+  "trace_events",
+  "entity_states"
+]);
+class CloudSyncHandlers {
+  syncManager;
+  constructor(deps) {
+    this.syncManager = deps.syncManager;
+  }
+  ensureManager() {
+    if (!this.syncManager) {
+      throw new Error(
+        "Cloud sync not configured. Run `stackmemory login` to connect to Provenant."
+      );
+    }
+    return this.syncManager;
+  }
+  async handlePush(args) {
+    const manager = this.ensureManager();
+    const result = await manager.performPush("manual", args.force);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: result.success,
+              pushed: result.pushed,
+              rejected: result.rejected,
+              conflicts: result.conflicts,
+              error: result.error
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+  async handlePull(args) {
+    const manager = this.ensureManager();
+    const tables = args.tables?.filter((t) => VALID_SYNC_TABLES.has(t));
+    const result = await manager.performPull("manual", tables);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: result.success,
+              pulled: result.pulled,
+              applied: result.applied,
+              conflicts: result.conflicts,
+              error: result.error
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+  async handleStatus() {
+    if (!this.syncManager) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                connected: false,
+                message: "Cloud sync not configured. Run `stackmemory login` to connect."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    const status = this.syncManager.getStatus();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(status, null, 2)
+        }
+      ]
+    };
+  }
+}
+export {
+  CloudSyncHandlers
+};

package/dist/src/integrations/mcp/handlers/index.js

@@ -15,15 +15,12 @@ import {
 import {
   DiscoveryHandlers
 } from "./discovery-handlers.js";
-import {
-  ProviderHandlers
-} from "./provider-handlers.js";
 import {
   ProvenantHandlers
 } from "./provenant-handlers.js";
 import {
-  CrossSearchHandlers
-} from "./cross-search-handlers.js";
+  CloudSyncHandlers
+} from "./cloud-sync-handlers.js";
 import {
   ContextHandlers as ContextHandlers2
 } from "./context-handlers.js";
@@ -32,9 +29,8 @@ import {
   LinearHandlers as LinearHandlers2
 } from "./linear-handlers.js";
 import { TraceHandlers as TraceHandlers2 } from "./trace-handlers.js";
-import { ProviderHandlers as ProviderHandlers2 } from "./provider-handlers.js";
 import { ProvenantHandlers as ProvenantHandlers2 } from "./provenant-handlers.js";
-import { CrossSearchHandlers as CrossSearchHandlers2 } from "./cross-search-handlers.js";
+import { CloudSyncHandlers as CloudSyncHandlers2 } from "./cloud-sync-handlers.js";
 import {
   resolveToolAlias
 } from "../tool-alias-registry.js";
@@ -43,9 +39,8 @@ class MCPHandlerFactory {
   taskHandlers;
   linearHandlers;
   traceHandlers;
-  providerHandlers;
   provenantHandlers;
-  crossSearchHandlers;
+  cloudSyncHandlers;
   constructor(deps) {
     this.contextHandlers = new ContextHandlers2({
       frameManager: deps.frameManager
@@ -63,13 +58,21 @@ class MCPHandlerFactory {
       traceDetector: deps.traceDetector,
       browserMCP: deps.browserMCP
     });
-    this.providerHandlers = new ProviderHandlers2();
     if (deps.projectDir) {
       this.provenantHandlers = new ProvenantHandlers2({
         projectDir: deps.projectDir
       });
     }
-    this.crossSearchHandlers = new CrossSearchHandlers2({});
+    this.cloudSyncHandlers = new CloudSyncHandlers2({
+      syncManager: null
+      // Initialized lazily when cloud sync is configured
+    });
+  }
+  /**
+   * Set the cloud sync manager (called after config/auth is loaded)
+   */
+  setCloudSyncManager(manager) {
+    this.cloudSyncHandlers = new CloudSyncHandlers2({ syncManager: manager });
   }
   /**
    * Get handler for a specific tool.
@@ -133,19 +136,6 @@ class MCPHandlerFactory {
           this.traceHandlers
         );
       // Provider handlers
-      case "delegate_to_model":
-        return this.providerHandlers.handleDelegateToModel.bind(
-          this.providerHandlers
-        );
-      case "batch_submit":
-        return this.providerHandlers.handleBatchSubmit.bind(
-          this.providerHandlers
-        );
-      case "batch_check":
-        return this.providerHandlers.handleBatchCheck.bind(
-          this.providerHandlers
-        );
-      // Provenant decision graph handlers
       case "provenant_search":
         if (!this.provenantHandlers)
           throw new Error("Provenant tools require projectDir");
@@ -171,22 +161,13 @@ class MCPHandlerFactory {
           this.provenantHandlers
         );
       // Cross-project search handlers
-      case "sm_cross_search":
-        return this.crossSearchHandlers.handleCrossSearch.bind(
-          this.crossSearchHandlers
-        );
-      case "sm_cross_discover":
-        return this.crossSearchHandlers.handleCrossDiscover.bind(
-          this.crossSearchHandlers
-        );
-      case "sm_cross_register":
-        return this.crossSearchHandlers.handleCrossRegister.bind(
-          this.crossSearchHandlers
-        );
-      case "sm_cross_list":
-        return this.crossSearchHandlers.handleCrossList.bind(
-          this.crossSearchHandlers
-        );
+      case "cloud_sync_push":
+        return this.cloudSyncHandlers.handlePush.bind(this.cloudSyncHandlers);
+      case "cloud_sync_pull":
+        return this.cloudSyncHandlers.handlePull.bind(this.cloudSyncHandlers);
+      case "cloud_sync_status":
+        return this.cloudSyncHandlers.handleStatus.bind(this.cloudSyncHandlers);
+      // Workflow handlers
       default:
         throw new Error(`Unknown tool: ${toolName}`);
     }
@@ -219,21 +200,16 @@ class MCPHandlerFactory {
       "take_screenshot",
       "execute_script",
       "stop_browser_debug",
-      // Provider tools (conditionally active)
-      "delegate_to_model",
-      "batch_submit",
-      "batch_check",
-      // Provenant decision graph tools
+      // Provenant tools
       "provenant_search",
       "provenant_log",
       "provenant_status",
       "provenant_contradictions",
       "provenant_resolve",
-      // Cross-project search tools
-      "sm_cross_search",
-      "sm_cross_discover",
-      "sm_cross_register",
-      "sm_cross_list"
+      // Cloud sync tools
+      "cloud_sync_push",
+      "cloud_sync_pull",
+      "cloud_sync_status"
     ];
   }
   /**
@@ -245,13 +221,12 @@ class MCPHandlerFactory {
   }
 }
 export {
+  CloudSyncHandlers,
   ContextHandlers,
-  CrossSearchHandlers,
   DiscoveryHandlers,
   LinearHandlers,
   MCPHandlerFactory,
   ProvenantHandlers,
-  ProviderHandlers,
   TaskHandlers,
   TraceHandlers
 };