@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/integrations/github/pr-state.js

@@ -0,0 +1,158 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { execFileSync } from "child_process";
+import {
+  canonicalStateStore
+} from "../../core/shared-state/canonical-store.js";
+import { projectIdFromIdentifier } from "../../core/shared-state/canonical-store.js";
+function runGit(args, cwd) {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function runGh(args, cwd) {
+  return execFileSync("gh", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function normalizeRemoteToRepo(remote) {
+  const cleaned = remote.replace(/\.git$/, "").trim();
+  if (cleaned.startsWith("git@github.com:")) {
+    return cleaned.replace("git@github.com:", "");
+  }
+  if (cleaned.startsWith("https://github.com/")) {
+    return cleaned.replace("https://github.com/", "");
+  }
+  if (cleaned.startsWith("http://github.com/")) {
+    return cleaned.replace("http://github.com/", "");
+  }
+  throw new Error(`Unsupported GitHub remote: ${remote}`);
+}
+function summarizeStatusCheckRollup(rollup) {
+  if (!rollup || rollup.length === 0) {
+    return void 0;
+  }
+  const states = rollup.map((item) => item.conclusion || item.status || item.state).filter(Boolean);
+  if (states.length === 0) {
+    return void 0;
+  }
+  if (states.every((state) => state === "SUCCESS")) {
+    return "SUCCESS";
+  }
+  if (states.some((state) => state === "FAILURE" || state === "ERROR")) {
+    return "FAILURE";
+  }
+  if (states.some(
+    (state) => state === "PENDING" || state === "IN_PROGRESS" || state === "EXPECTED"
+  )) {
+    return "PENDING";
+  }
+  return states[0];
+}
+function getCurrentRepoGitHubInfo(cwd = process.cwd()) {
+  try {
+    const projectPath = runGit(["rev-parse", "--show-toplevel"], cwd);
+    const branch = runGit(["rev-parse", "--abbrev-ref", "HEAD"], projectPath);
+    const remote = runGit(
+      ["config", "--get", "remote.origin.url"],
+      projectPath
+    );
+    const repo = normalizeRemoteToRepo(remote);
+    return {
+      repo,
+      branch,
+      projectPath,
+      projectId: projectIdFromIdentifier(remote)
+    };
+  } catch {
+    return null;
+  }
+}
+async function refreshCurrentRepoPullRequestState(cwd = process.cwd()) {
+  const info = getCurrentRepoGitHubInfo(cwd);
+  if (!info) {
+    return null;
+  }
+  try {
+    const output = runGh(
+      [
+        "pr",
+        "view",
+        "--repo",
+        info.repo,
+        "--json",
+        [
+          "number",
+          "title",
+          "state",
+          "isDraft",
+          "url",
+          "baseRefName",
+          "headRefName",
+          "headRefOid",
+          "mergedAt",
+          "updatedAt",
+          "reviewDecision",
+          "statusCheckRollup"
+        ].join(",")
+      ],
+      info.projectPath
+    );
+    const parsed = JSON.parse(output);
+    const projection = {
+      repo: info.repo,
+      branch: info.branch,
+      projectId: info.projectId,
+      projectPath: info.projectPath,
+      prNumber: parsed.number,
+      title: parsed.title,
+      state: parsed.mergedAt && parsed.state === "MERGED" ? "MERGED" : parsed.state,
+      isDraft: parsed.isDraft,
+      url: parsed.url,
+      baseRefName: parsed.baseRefName,
+      headRefName: parsed.headRefName,
+      headRefOid: parsed.headRefOid,
+      mergedAt: parsed.mergedAt || void 0,
+      updatedAt: parsed.updatedAt,
+      reviewDecision: parsed.reviewDecision || void 0,
+      statusCheckRollup: summarizeStatusCheckRollup(parsed.statusCheckRollup),
+      lastSyncedAt: Date.now()
+    };
+    await canonicalStateStore.saveGitHubPullRequest(projection);
+    if (projection.state === "MERGED" || projection.state === "CLOSED") {
+      await canonicalStateStore.releaseClaims({
+        projectId: info.projectId,
+        projectPath: info.projectPath,
+        branch: info.branch,
+        reason: `github_pr_${projection.state.toLowerCase()}`
+      });
+    }
+    await canonicalStateStore.appendEvent({
+      type: "github_pr_refreshed",
+      tool: "stackmemory",
+      projectId: info.projectId,
+      projectPath: info.projectPath,
+      branch: info.branch,
+      payload: {
+        repo: info.repo,
+        prNumber: projection.prNumber,
+        state: projection.state,
+        reviewDecision: projection.reviewDecision,
+        statusCheckRollup: projection.statusCheckRollup
+      }
+    });
+    return projection;
+  } catch {
+    return null;
+  }
+}
+export {
+  getCurrentRepoGitHubInfo,
+  refreshCurrentRepoPullRequestState
+};

package/dist/src/integrations/linear/client.js

@@ -496,7 +496,10 @@ class LinearClient {
       filter: Object.keys(filter).length > 0 ? filter : void 0,
       first: options?.limit || 50
     });
-    return result.issues.nodes;
+    return result.issues.nodes.map((issue) => ({
+      ...issue,
+      labels: Array.isArray(issue.labels) ? issue.labels : issue.labels?.nodes || []
+    }));
   }
   /**
    * Assign an issue to a user

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
+};