@stackmemoryai/stackmemory 0.5.58 → 0.5.59

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

@@ -0,0 +1,219 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { createHmac } from "crypto";
+import { LinearSyncEngine } from "./sync.js";
+import { LinearAuthManager } from "./auth.js";
+import { IntegrationError, ErrorCode } from "../../core/errors/index.js";
+import { logger } from "../../core/monitoring/logger.js";
+function getEnv(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0) {
+    if (defaultValue !== void 0) return defaultValue;
+    throw new IntegrationError(
+      `Environment variable ${key} is required`,
+      ErrorCode.LINEAR_WEBHOOK_FAILED
+    );
+  }
+  return value;
+}
+function getOptionalEnv(key) {
+  return process.env[key];
+}
+class LinearWebhookHandler {
+  taskStore;
+  syncEngine = null;
+  webhookSecret;
+  constructor(taskStore, webhookSecret) {
+    this.taskStore = taskStore;
+    this.webhookSecret = webhookSecret;
+    if (process.env["LINEAR_API_KEY"]) {
+      const authManager = new LinearAuthManager();
+      this.syncEngine = new LinearSyncEngine(taskStore, authManager, {
+        enabled: true,
+        direction: "from_linear",
+        autoSync: false,
+        conflictResolution: "linear_wins"
+      });
+    }
+  }
+  /**
+   * Verify webhook signature
+   */
+  verifySignature(payload, signature) {
+    const hmac = createHmac("sha256", this.webhookSecret);
+    hmac.update(payload);
+    const expectedSignature = hmac.digest("hex");
+    return signature === expectedSignature;
+  }
+  /**
+   * Handle incoming webhook from Linear
+   */
+  async handleWebhook(req, res) {
+    try {
+      const rawBody = JSON.stringify(req.body);
+      const signature = req.headers["linear-signature"];
+      if (!this.verifySignature(rawBody, signature)) {
+        logger.error("Invalid webhook signature");
+        res.status(401).json({ error: "Invalid signature" });
+        return;
+      }
+      const payload = req.body;
+      if (payload.type !== "Issue") {
+        res.status(200).json({ message: "Ignored non-issue webhook" });
+        return;
+      }
+      switch (payload.action) {
+        case "create":
+          await this.handleIssueCreate(payload);
+          break;
+        case "update":
+          await this.handleIssueUpdate(payload);
+          break;
+        case "remove":
+          await this.handleIssueRemove(payload);
+          break;
+        default:
+          logger.warn(`Unknown webhook action: ${payload.action}`);
+      }
+      res.status(200).json({ message: "Webhook processed successfully" });
+    } catch (error) {
+      logger.error("Failed to process webhook:", error);
+      res.status(500).json({ error: "Failed to process webhook" });
+    }
+  }
+  /**
+   * Handle issue creation
+   */
+  async handleIssueCreate(payload) {
+    const issue = payload.data;
+    const existingTasks = this.taskStore.getActiveTasks();
+    const exists = existingTasks.some(
+      (t) => t.title.includes(issue.identifier) || t.external_refs?.linear === issue.id
+    );
+    if (exists) {
+      logger.info(`Task ${issue.identifier} already exists locally`);
+      return;
+    }
+    const taskId = this.taskStore.createTask({
+      title: `[${issue.identifier}] ${issue.title}`,
+      description: issue.description || "",
+      priority: this.mapLinearPriorityToLocal(issue.priority),
+      frameId: "linear-webhook",
+      tags: issue.labels?.map((l) => l.name) || ["linear"],
+      estimatedEffort: issue.estimate ? issue.estimate * 60 : void 0,
+      assignee: issue.assignee?.name
+    });
+    const status = this.mapLinearStateToLocalStatus(issue.state.type);
+    if (status !== "pending") {
+      this.taskStore.updateTaskStatus(
+        taskId,
+        status,
+        `Synced from Linear (${issue.state.name})`
+      );
+    }
+    await this.storeLinearMapping(taskId, issue.id, issue.identifier);
+    logger.info(`Created task ${taskId} from Linear issue ${issue.identifier}`);
+  }
+  /**
+   * Handle issue update
+   */
+  async handleIssueUpdate(payload) {
+    const issue = payload.data;
+    const tasks = this.taskStore.getActiveTasks();
+    const localTask = tasks.find(
+      (t) => t.title.includes(issue.identifier) || t.external_refs?.linear === issue.id
+    );
+    if (!localTask) {
+      await this.handleIssueCreate(payload);
+      return;
+    }
+    const newStatus = this.mapLinearStateToLocalStatus(issue.state.type);
+    if (newStatus !== localTask.status) {
+      this.taskStore.updateTaskStatus(
+        localTask.id,
+        newStatus,
+        `Updated from Linear (${issue.state.name})`
+      );
+    }
+    const newPriority = this.mapLinearPriorityToLocal(issue.priority);
+    if (newPriority !== localTask.priority) {
+      logger.info(
+        `Priority changed for ${issue.identifier}: ${localTask.priority} -> ${newPriority}`
+      );
+    }
+    logger.info(
+      `Updated task ${localTask.id} from Linear issue ${issue.identifier}`
+    );
+  }
+  /**
+   * Handle issue removal
+   */
+  async handleIssueRemove(payload) {
+    const issue = payload.data;
+    const tasks = this.taskStore.getActiveTasks();
+    const localTask = tasks.find(
+      (t) => t.title.includes(issue.identifier) || t.external_refs?.linear === issue.id
+    );
+    if (localTask) {
+      this.taskStore.updateTaskStatus(
+        localTask.id,
+        "cancelled",
+        `Removed in Linear`
+      );
+      logger.info(
+        `Cancelled task ${localTask.id} (Linear issue ${issue.identifier} was removed)`
+      );
+    }
+  }
+  /**
+   * Store Linear mapping for a task
+   */
+  async storeLinearMapping(taskId, linearId, linearIdentifier) {
+    logger.info(
+      `Mapped task ${taskId} to Linear ${linearIdentifier} (${linearId})`
+    );
+  }
+  /**
+   * Map Linear priority to local priority
+   */
+  mapLinearPriorityToLocal(priority) {
+    if (!priority) return "medium";
+    switch (priority) {
+      case 0:
+        return "urgent";
+      case 1:
+        return "high";
+      case 2:
+        return "medium";
+      case 3:
+      case 4:
+        return "low";
+      default:
+        return "medium";
+    }
+  }
+  /**
+   * Map Linear state to local status
+   */
+  mapLinearStateToLocalStatus(state) {
+    switch (state) {
+      case "backlog":
+      case "unstarted":
+        return "pending";
+      case "started":
+        return "in_progress";
+      case "completed":
+        return "completed";
+      case "cancelled":
+        return "cancelled";
+      default:
+        return "pending";
+    }
+  }
+}
+export {
+  LinearWebhookHandler
+};
+//# sourceMappingURL=webhook-handler.js.map

package/dist/src/integrations/linear/webhook-handler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/integrations/linear/webhook-handler.ts"],
+  "sourcesContent": ["/**\n * Linear Webhook Handler\n * Processes incoming webhooks from Linear to update local task store\n */\n\nimport { createHmac } from 'crypto';\nimport { LinearTaskManager } from '../../features/tasks/linear-task-manager.js';\nimport { LinearSyncEngine } from './sync.js';\nimport { LinearAuthManager } from './auth.js';\nimport { LinearClient } from './client.js';\nimport { IntegrationError, ErrorCode } from '../../core/errors/index.js';\nimport { logger } from '../../core/monitoring/logger.js';\nimport type { Request, Response } from 'express';\n// Type-safe environment variable access\nfunction getEnv(key: string, defaultValue?: string): string {\n  const value = process.env[key];\n  if (value === undefined) {\n    if (defaultValue !== undefined) return defaultValue;\n    throw new IntegrationError(\n      `Environment variable ${key} is required`,\n      ErrorCode.LINEAR_WEBHOOK_FAILED\n    );\n  }\n  return value;\n}\n\nfunction getOptionalEnv(key: string): string | undefined {\n  return process.env[key];\n}\n\nexport interface LinearWebhookPayload {\n  action: 'create' | 'update' | 'remove';\n  createdAt: string;\n  data: {\n    id: string;\n    identifier: string;\n    title: string;\n    description?: string;\n    state: {\n      id: string;\n      name: string;\n      type: 'backlog' | 'unstarted' | 'started' | 'completed' | 'cancelled';\n    };\n    priority?: number;\n    estimate?: number;\n    assignee?: {\n      id: string;\n      name: string;\n      email: string;\n    };\n    labels?: Array<{ id: string; name: string }>;\n    updatedAt: string;\n    url: string;\n  };\n  type: 'Issue';\n  organizationId: string;\n  webhookId: string;\n}\n\nexport class LinearWebhookHandler {\n  private taskStore: LinearTaskManager;\n  private syncEngine: LinearSyncEngine | null = null;\n  private webhookSecret: string;\n\n  constructor(taskStore: LinearTaskManager, webhookSecret: string) {\n    this.taskStore = taskStore;\n    this.webhookSecret = webhookSecret;\n\n    // Initialize sync engine if API key is available\n    if (process.env['LINEAR_API_KEY']) {\n      const authManager = new LinearAuthManager();\n      this.syncEngine = new LinearSyncEngine(taskStore, authManager, {\n        enabled: true,\n        direction: 'from_linear',\n        autoSync: false,\n        conflictResolution: 'linear_wins',\n      });\n    }\n  }\n\n  /**\n   * Verify webhook signature\n   */\n  private verifySignature(payload: string, signature: string): boolean {\n    const hmac = createHmac('sha256', this.webhookSecret);\n    hmac.update(payload);\n    const expectedSignature = hmac.digest('hex');\n    return signature === expectedSignature;\n  }\n\n  /**\n   * Handle incoming webhook from Linear\n   */\n  async handleWebhook(req: Request, res: Response): Promise<void> {\n    try {\n      // Get raw body for signature verification\n      const rawBody = JSON.stringify(req.body);\n      const signature = req.headers['linear-signature'] as string;\n\n      // Verify signature\n      if (!this.verifySignature(rawBody, signature)) {\n        logger.error('Invalid webhook signature');\n        res.status(401).json({ error: 'Invalid signature' });\n        return;\n      }\n\n      const payload = req.body as LinearWebhookPayload;\n\n      // Only process Issue webhooks\n      if (payload.type !== 'Issue') {\n        res.status(200).json({ message: 'Ignored non-issue webhook' });\n        return;\n      }\n\n      // Process based on action\n      switch (payload.action) {\n        case 'create':\n          await this.handleIssueCreate(payload);\n          break;\n        case 'update':\n          await this.handleIssueUpdate(payload);\n          break;\n        case 'remove':\n          await this.handleIssueRemove(payload);\n          break;\n        default:\n          logger.warn(`Unknown webhook action: ${payload.action}`);\n      }\n\n      res.status(200).json({ message: 'Webhook processed successfully' });\n    } catch (error: unknown) {\n      logger.error('Failed to process webhook:', error as Error);\n      res.status(500).json({ error: 'Failed to process webhook' });\n    }\n  }\n\n  /**\n   * Handle issue creation\n   */\n  private async handleIssueCreate(\n    payload: LinearWebhookPayload\n  ): Promise<void> {\n    const issue = payload.data;\n\n    // Check if task already exists locally\n    const existingTasks = this.taskStore.getActiveTasks();\n    const exists = existingTasks.some(\n      (t) =>\n        t.title.includes(issue.identifier) ||\n        t.external_refs?.linear === issue.id\n    );\n\n    if (exists) {\n      logger.info(`Task ${issue.identifier} already exists locally`);\n      return;\n    }\n\n    // Create local task\n    const taskId = this.taskStore.createTask({\n      title: `[${issue.identifier}] ${issue.title}`,\n      description: issue.description || '',\n      priority: this.mapLinearPriorityToLocal(issue.priority),\n      frameId: 'linear-webhook',\n      tags: issue.labels?.map((l) => l.name) || ['linear'],\n      estimatedEffort: issue.estimate ? issue.estimate * 60 : undefined,\n      assignee: issue.assignee?.name,\n    });\n\n    // Update task status if not pending\n    const status = this.mapLinearStateToLocalStatus(issue.state.type);\n    if (status !== 'pending') {\n      this.taskStore.updateTaskStatus(\n        taskId,\n        status,\n        `Synced from Linear (${issue.state.name})`\n      );\n    }\n\n    // Store Linear mapping\n    await this.storeLinearMapping(taskId, issue.id, issue.identifier);\n\n    logger.info(`Created task ${taskId} from Linear issue ${issue.identifier}`);\n  }\n\n  /**\n   * Handle issue update\n   */\n  private async handleIssueUpdate(\n    payload: LinearWebhookPayload\n  ): Promise<void> {\n    const issue = payload.data;\n\n    // Find local task by Linear ID or identifier\n    const tasks = this.taskStore.getActiveTasks();\n    const localTask = tasks.find(\n      (t) =>\n        t.title.includes(issue.identifier) ||\n        t.external_refs?.linear === issue.id\n    );\n\n    if (!localTask) {\n      // Task doesn't exist locally, create it\n      await this.handleIssueCreate(payload);\n      return;\n    }\n\n    // Update task status\n    const newStatus = this.mapLinearStateToLocalStatus(issue.state.type);\n    if (newStatus !== localTask.status) {\n      this.taskStore.updateTaskStatus(\n        localTask.id,\n        newStatus,\n        `Updated from Linear (${issue.state.name})`\n      );\n    }\n\n    // Update priority if changed\n    const newPriority = this.mapLinearPriorityToLocal(issue.priority);\n    if (newPriority !== localTask.priority) {\n      // Note: Would need to add updateTaskPriority method to taskStore\n      logger.info(\n        `Priority changed for ${issue.identifier}: ${localTask.priority} -> ${newPriority}`\n      );\n    }\n\n    logger.info(\n      `Updated task ${localTask.id} from Linear issue ${issue.identifier}`\n    );\n  }\n\n  /**\n   * Handle issue removal\n   */\n  private async handleIssueRemove(\n    payload: LinearWebhookPayload\n  ): Promise<void> {\n    const issue = payload.data;\n\n    // Find and cancel local task\n    const tasks = this.taskStore.getActiveTasks();\n    const localTask = tasks.find(\n      (t) =>\n        t.title.includes(issue.identifier) ||\n        t.external_refs?.linear === issue.id\n    );\n\n    if (localTask) {\n      this.taskStore.updateTaskStatus(\n        localTask.id,\n        'cancelled',\n        `Removed in Linear`\n      );\n      logger.info(\n        `Cancelled task ${localTask.id} (Linear issue ${issue.identifier} was removed)`\n      );\n    }\n  }\n\n  /**\n   * Store Linear mapping for a task\n   */\n  private async storeLinearMapping(\n    taskId: string,\n    linearId: string,\n    linearIdentifier: string\n  ): Promise<void> {\n    // This would update the linear-mappings.json file\n    // For now, just log it\n    logger.info(\n      `Mapped task ${taskId} to Linear ${linearIdentifier} (${linearId})`\n    );\n  }\n\n  /**\n   * Map Linear priority to local priority\n   */\n  private mapLinearPriorityToLocal(\n    priority?: number\n  ): 'urgent' | 'high' | 'medium' | 'low' {\n    if (!priority) return 'medium';\n    switch (priority) {\n      case 0:\n        return 'urgent';\n      case 1:\n        return 'high';\n      case 2:\n        return 'medium';\n      case 3:\n      case 4:\n        return 'low';\n      default:\n        return 'medium';\n    }\n  }\n\n  /**\n   * Map Linear state to local status\n   */\n  private mapLinearStateToLocalStatus(\n    state: string\n  ): 'pending' | 'in_progress' | 'completed' | 'cancelled' | 'blocked' {\n    switch (state) {\n      case 'backlog':\n      case 'unstarted':\n        return 'pending';\n      case 'started':\n        return 'in_progress';\n      case 'completed':\n        return 'completed';\n      case 'cancelled':\n        return 'cancelled';\n      default:\n        return 'pending';\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import express from "express";
+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 chalk from "chalk";
+function getEnv(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0) {
+    if (defaultValue !== void 0) return defaultValue;
+    throw new IntegrationError(
+      `Environment variable ${key} is required`,
+      ErrorCode.LINEAR_WEBHOOK_FAILED
+    );
+  }
+  return value;
+}
+function getOptionalEnv(key) {
+  return process.env[key];
+}
+class LinearWebhookServer {
+  app;
+  server = null;
+  // Using singleton logger from monitoring
+  syncService;
+  config;
+  eventQueue = [];
+  isProcessing = false;
+  constructor(config) {
+    this.app = express();
+    this.syncService = new LinearSyncService();
+    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",
+      rateLimit: {
+        windowMs: config?.rateLimit?.windowMs || 6e4,
+        max: config?.rateLimit?.max || 100
+      }
+    };
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+  setupMiddleware() {
+    this.app.use(
+      express.raw({
+        type: "application/json",
+        limit: this.config.maxPayloadSize
+      })
+    );
+    this.app.use((req, res, next) => {
+      res.setHeader("X-Powered-By", "StackMemory");
+      next();
+    });
+  }
+  setupRoutes() {
+    this.app.get("/health", (req, res) => {
+      res.json({
+        status: "healthy",
+        service: "linear-webhook",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        queue: this.eventQueue.length,
+        processing: this.isProcessing
+      });
+    });
+    this.app.post("/webhook/linear", async (req, res) => {
+      try {
+        if (!this.verifyWebhookSignature(req)) {
+          logger.warn("Invalid webhook signature");
+          return res.status(401).json({ error: "Unauthorized" });
+        }
+        const payload = JSON.parse(req.body.toString());
+        logger.info(`Received webhook: ${payload.type} - ${payload.action}`);
+        this.eventQueue.push(payload);
+        this.processQueue();
+        return res.status(200).json({
+          status: "accepted",
+          queued: true
+        });
+      } catch (error) {
+        logger.error("Webhook processing error:", error);
+        return res.status(500).json({ error: "Internal server error" });
+      }
+    });
+    this.app.use((req, res) => {
+      res.status(404).json({ error: "Not found" });
+    });
+  }
+  verifyWebhookSignature(req) {
+    if (!this.config.webhookSecret) {
+      logger.warn("No webhook secret configured, accepting all webhooks");
+      return true;
+    }
+    const signature = req.headers["linear-signature"];
+    if (!signature) {
+      return false;
+    }
+    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) {
+      case "Issue":
+        await this.handleIssueEvent(action, data);
+        break;
+      case "Comment":
+        await this.handleCommentEvent(action, data);
+        break;
+      case "Project":
+        await this.handleProjectEvent(action, data);
+        break;
+      default:
+        logger.debug(`Unhandled event type: ${type}`);
+    }
+  }
+  async handleIssueEvent(action, data) {
+    const issue = data;
+    switch (action) {
+      case "create":
+        logger.info(`New issue created: ${issue.identifier} - ${issue.title}`);
+        await this.syncService.syncIssueToLocal(issue);
+        break;
+      case "update":
+        logger.info(`Issue updated: ${issue.identifier} - ${issue.title}`);
+        await this.syncService.syncIssueToLocal(issue);
+        break;
+      case "remove":
+        logger.info(`Issue removed: ${issue.identifier}`);
+        await this.syncService.removeLocalIssue(issue.identifier);
+        break;
+      default:
+        logger.debug(`Unhandled issue action: ${action}`);
+    }
+  }
+  async handleCommentEvent(action, data) {
+    logger.debug(`Comment event: ${action}`, { issueId: data.issue?.id });
+  }
+  async handleProjectEvent(action, data) {
+    logger.debug(`Project event: ${action}`, { projectId: data.id });
+  }
+  async start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(
+        this.config.port,
+        this.config.host,
+        () => {
+          console.log(
+            chalk.green("\u2713") + chalk.bold(" Linear Webhook Server Started")
+          );
+          console.log(
+            chalk.cyan("  URL: ") + `http://${this.config.host}:${this.config.port}/webhook/linear`
+          );
+          console.log(
+            chalk.cyan("  Health: ") + `http://${this.config.host}:${this.config.port}/health`
+          );
+          if (!this.config.webhookSecret) {
+            console.log(
+              chalk.yellow(
+                "  \u26A0 Warning: No webhook secret configured (insecure)"
+              )
+            );
+          }
+          resolve();
+        }
+      );
+    });
+  }
+  async stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          logger.info("Webhook server stopped");
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+if (process.argv[1] === new URL(import.meta.url).pathname) {
+  const server = new LinearWebhookServer();
+  server.start().catch((error) => {
+    console.error(chalk.red("Failed to start webhook server:"), error);
+    process.exit(1);
+  });
+  process.on("SIGINT", async () => {
+    console.log(chalk.yellow("\n\nShutting down webhook server..."));
+    await server.stop();
+    process.exit(0);
+  });
+}
+export {
+  LinearWebhookServer
+};
+//# sourceMappingURL=webhook-server.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/integrations/linear/webhook-server.ts"],
+  "sourcesContent": ["#!/usr/bin/env node\n\nimport express from 'express';\nimport crypto from 'crypto';\nimport http from 'http';\nimport {\n  LinearWebhookPayload,\n  LinearIssue,\n  LinearComment,\n  LinearProject,\n} from './types.js';\nimport { LinearSyncService } from './sync-service.js';\nimport { LinearIssue as ClientLinearIssue } from './client.js';\nimport { IntegrationError, ErrorCode } from '../../core/errors/index.js';\nimport { logger } from '../../core/monitoring/logger.js';\nimport chalk from 'chalk';\n// Type-safe environment variable access\nfunction getEnv(key: string, defaultValue?: string): string {\n  const value = process.env[key];\n  if (value === undefined) {\n    if (defaultValue !== undefined) return defaultValue;\n    throw new IntegrationError(\n      `Environment variable ${key} is required`,\n      ErrorCode.LINEAR_WEBHOOK_FAILED\n    );\n  }\n  return value;\n}\n\nfunction getOptionalEnv(key: string): string | undefined {\n  return process.env[key];\n}\n\nexport interface WebhookServerConfig {\n  port?: number;\n  host?: string;\n  webhookSecret?: string;\n  maxPayloadSize?: string;\n  rateLimit?: {\n    windowMs?: number;\n    max?: number;\n  };\n}\n\nexport class LinearWebhookServer {\n  private app: express.Application;\n  private server: http.Server | null = null;\n  // Using singleton logger from monitoring\n  private syncService: LinearSyncService;\n  private config: WebhookServerConfig;\n  private eventQueue: LinearWebhookPayload[] = [];\n  private isProcessing = false;\n\n  constructor(config?: WebhookServerConfig) {\n    this.app = express();\n    // Use singleton logger\n    this.syncService = new LinearSyncService();\n\n    this.config = {\n      port: config?.port || parseInt(process.env['WEBHOOK_PORT'] || '3456'),\n      host: config?.host || process.env['WEBHOOK_HOST'] || 'localhost',\n      webhookSecret:\n        config?.webhookSecret || process.env['LINEAR_WEBHOOK_SECRET'],\n      maxPayloadSize: config?.maxPayloadSize || '10mb',\n      rateLimit: {\n        windowMs: config?.rateLimit?.windowMs || 60000,\n        max: config?.rateLimit?.max || 100,\n      },\n    };\n\n    this.setupMiddleware();\n    this.setupRoutes();\n  }\n\n  private setupMiddleware(): void {\n    this.app.use(\n      express.raw({\n        type: 'application/json',\n        limit: this.config.maxPayloadSize,\n      })\n    );\n\n    this.app.use((req, res, next) => {\n      res.setHeader('X-Powered-By', 'StackMemory');\n      next();\n    });\n  }\n\n  private setupRoutes(): void {\n    this.app.get('/health', (req, res) => {\n      res.json({\n        status: 'healthy',\n        service: 'linear-webhook',\n        timestamp: new Date().toISOString(),\n        queue: this.eventQueue.length,\n        processing: this.isProcessing,\n      });\n    });\n\n    this.app.post('/webhook/linear', async (req, res) => {\n      try {\n        if (!this.verifyWebhookSignature(req)) {\n          logger.warn('Invalid webhook signature');\n          return res.status(401).json({ error: 'Unauthorized' });\n        }\n\n        const payload = JSON.parse(req.body.toString()) as LinearWebhookPayload;\n\n        logger.info(`Received webhook: ${payload.type} - ${payload.action}`);\n\n        this.eventQueue.push(payload);\n        this.processQueue();\n\n        return res.status(200).json({\n          status: 'accepted',\n          queued: true,\n        });\n      } catch (error: unknown) {\n        logger.error('Webhook processing error:', error);\n        return res.status(500).json({ error: 'Internal server error' });\n      }\n    });\n\n    this.app.use((req, res) => {\n      res.status(404).json({ error: 'Not found' });\n    });\n  }\n\n  private verifyWebhookSignature(req: express.Request): boolean {\n    if (!this.config.webhookSecret) {\n      logger.warn('No webhook secret configured, accepting all webhooks');\n      return true;\n    }\n\n    const signature = req.headers['linear-signature'] as string;\n    if (!signature) {\n      return false;\n    }\n\n    const hash = crypto\n      .createHmac('sha256', this.config.webhookSecret)\n      .update(req.body)\n      .digest('hex');\n\n    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(hash));\n  }\n\n  private async processQueue(): Promise<void> {\n    if (this.isProcessing || this.eventQueue.length === 0) {\n      return;\n    }\n\n    this.isProcessing = true;\n\n    while (this.eventQueue.length > 0) {\n      const event = this.eventQueue.shift()!;\n\n      try {\n        await this.handleWebhookEvent(event);\n      } catch (error: unknown) {\n        logger.error(`Failed to process event: ${event.type}`, error);\n      }\n    }\n\n    this.isProcessing = false;\n  }\n\n  private async handleWebhookEvent(\n    payload: LinearWebhookPayload\n  ): Promise<void> {\n    const { type, action, data } = payload;\n\n    switch (type) {\n      case 'Issue':\n        await this.handleIssueEvent(action, data as LinearIssue);\n        break;\n      case 'Comment':\n        await this.handleCommentEvent(action, data as LinearComment);\n        break;\n      case 'Project':\n        await this.handleProjectEvent(action, data as LinearProject);\n        break;\n      default:\n        logger.debug(`Unhandled event type: ${type}`);\n    }\n  }\n\n  private async handleIssueEvent(\n    action: string,\n    data: LinearIssue\n  ): Promise<void> {\n    const issue = data as ClientLinearIssue;\n\n    switch (action) {\n      case 'create':\n        logger.info(`New issue created: ${issue.identifier} - ${issue.title}`);\n        await this.syncService.syncIssueToLocal(issue);\n        break;\n      case 'update':\n        logger.info(`Issue updated: ${issue.identifier} - ${issue.title}`);\n        await this.syncService.syncIssueToLocal(issue);\n        break;\n      case 'remove':\n        logger.info(`Issue removed: ${issue.identifier}`);\n        await this.syncService.removeLocalIssue(issue.identifier);\n        break;\n      default:\n        logger.debug(`Unhandled issue action: ${action}`);\n    }\n  }\n\n  private async handleCommentEvent(\n    action: string,\n    data: LinearComment\n  ): Promise<void> {\n    logger.debug(`Comment event: ${action}`, { issueId: data.issue?.id });\n  }\n\n  private async handleProjectEvent(\n    action: string,\n    data: LinearProject\n  ): Promise<void> {\n    logger.debug(`Project event: ${action}`, { projectId: data.id });\n  }\n\n  public async start(): Promise<void> {\n    return new Promise((resolve) => {\n      this.server = this.app.listen(\n        this.config.port!,\n        this.config.host!,\n        () => {\n          console.log(\n            chalk.green('\u2713') + chalk.bold(' Linear Webhook Server Started')\n          );\n          console.log(\n            chalk.cyan('  URL: ') +\n              `http://${this.config.host}:${this.config.port}/webhook/linear`\n          );\n          console.log(\n            chalk.cyan('  Health: ') +\n              `http://${this.config.host}:${this.config.port}/health`\n          );\n\n          if (!this.config.webhookSecret) {\n            console.log(\n              chalk.yellow(\n                '  \u26A0 Warning: No webhook secret configured (insecure)'\n              )\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  public async stop(): Promise<void> {\n    return new Promise((resolve) => {\n      if (this.server) {\n        this.server.close(() => {\n          logger.info('Webhook server stopped');\n          resolve();\n        });\n      } else {\n        resolve();\n      }\n    });\n  }\n}\n\n// Standalone execution support\nif (process.argv[1] === new URL(import.meta.url).pathname) {\n  const server = new LinearWebhookServer();\n\n  server.start().catch((error) => {\n    console.error(chalk.red('Failed to start webhook server:'), error);\n    process.exit(1);\n  });\n\n  process.on('SIGINT', async () => {\n    console.log(chalk.yellow('\\n\\nShutting down webhook server...'));\n    await server.stop();\n    process.exit(0);\n  });\n}\n"],
+  "mappings": "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",
+  "names": []
+}