canicode 0.3.3 → 0.4.0

package/dist/mcp/server.js

@@ -10,6 +10,204 @@ import { join, resolve, basename } from 'path';
 import { readFile } from 'fs/promises';
 import { homedir } from 'os';
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/monitoring/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  initBrowserMonitoring: () => initBrowserMonitoring,
+  shutdownBrowserMonitoring: () => shutdownBrowserMonitoring,
+  trackBrowserError: () => trackBrowserError,
+  trackBrowserEvent: () => trackBrowserEvent
+});
+function getGlobal() {
+  return globalThis;
+}
+function injectScript(src) {
+  return new Promise((resolve4, reject) => {
+    const g = getGlobal();
+    const doc = g["document"];
+    if (!doc) {
+      resolve4();
+      return;
+    }
+    const script = doc["createElement"]("script");
+    script["src"] = src;
+    script["async"] = true;
+    script["onload"] = () => resolve4();
+    script["onerror"] = () => reject(new Error(`Failed to load script: ${src}`));
+    doc["head"]["appendChild"](script);
+  });
+}
+async function initBrowserMonitoring(config2) {
+  if (config2.enabled === false) return;
+  const g = getGlobal();
+  if (!g["document"]) return;
+  monitoringEnabled = true;
+  if (config2.posthogApiKey) {
+    try {
+      await injectScript("https://us-assets.i.posthog.com/static/array.js");
+      g["posthog"]?.["init"]?.(config2.posthogApiKey, {
+        api_host: "https://us.i.posthog.com",
+        autocapture: false,
+        capture_pageview: true
+      });
+    } catch {
+    }
+  }
+  if (config2.sentryDsn) {
+    try {
+      await injectScript("https://browser.sentry-cdn.com/8.0.0/bundle.min.js");
+      g["Sentry"]?.["init"]?.({
+        dsn: config2.sentryDsn,
+        environment: config2.environment ?? "web",
+        release: config2.version,
+        tracesSampleRate: 0
+      });
+    } catch {
+    }
+  }
+}
+function trackBrowserEvent(event, properties) {
+  if (!monitoringEnabled) return;
+  try {
+    getGlobal()["posthog"]?.["capture"]?.(event, properties);
+  } catch {
+  }
+}
+function trackBrowserError(error, context) {
+  if (!monitoringEnabled) return;
+  try {
+    getGlobal()["Sentry"]?.["captureException"]?.(
+      error,
+      context ? { extra: context } : void 0
+    );
+  } catch {
+  }
+  try {
+    getGlobal()["posthog"]?.["capture"]?.("error", {
+      error: error.message,
+      ...context
+    });
+  } catch {
+  }
+}
+async function shutdownBrowserMonitoring() {
+  monitoringEnabled = false;
+}
+var monitoringEnabled;
+var init_browser = __esm({
+  "src/monitoring/browser.ts"() {
+    monitoringEnabled = false;
+  }
+});
+
+// src/monitoring/node.ts
+var node_exports = {};
+__export(node_exports, {
+  initNodeMonitoring: () => initNodeMonitoring,
+  shutdownNodeMonitoring: () => shutdownNodeMonitoring,
+  trackNodeError: () => trackNodeError,
+  trackNodeEvent: () => trackNodeEvent
+});
+async function initNodeMonitoring(config2) {
+  if (config2.enabled === false) return;
+  monitoringEnabled2 = true;
+  commonProps = {
+    _sdk: "canicode",
+    _sdk_version: config2.version ?? "unknown",
+    _env: config2.environment ?? "unknown"
+  };
+  if (config2.posthogApiKey) {
+    try {
+      const mod = await import('posthog-node');
+      const PostHog = mod.PostHog;
+      posthogClient = new PostHog(config2.posthogApiKey, {
+        host: "https://us.i.posthog.com",
+        flushAt: 10,
+        flushInterval: 1e4
+      });
+    } catch {
+    }
+  }
+  if (config2.sentryDsn) {
+    try {
+      const mod = await import('@sentry/node');
+      sentryModule = mod;
+      sentryModule.init({
+        dsn: config2.sentryDsn,
+        environment: config2.environment ?? "cli",
+        release: config2.version,
+        tracesSampleRate: 0
+      });
+    } catch {
+    }
+  }
+}
+function trackNodeEvent(event, properties) {
+  if (!monitoringEnabled2 || !posthogClient) return;
+  try {
+    const captureOpts = {
+      distinctId: "anonymous",
+      event
+    };
+    captureOpts.properties = { ...commonProps, ...properties };
+    posthogClient.capture(captureOpts);
+  } catch {
+  }
+}
+function trackNodeError(error, context) {
+  if (!monitoringEnabled2) return;
+  try {
+    sentryModule?.captureException(error, context ? { extra: context } : void 0);
+  } catch {
+  }
+  try {
+    posthogClient?.capture({
+      distinctId: "anonymous",
+      event: "cic_error",
+      properties: { ...commonProps, error: error.message, ...context }
+    });
+  } catch {
+  }
+}
+async function shutdownNodeMonitoring() {
+  if (!monitoringEnabled2) return;
+  const tasks = [];
+  if (posthogClient) {
+    tasks.push(
+      posthogClient.shutdown().catch(() => {
+      })
+    );
+  }
+  if (sentryModule) {
+    tasks.push(
+      sentryModule.close(2e3).catch(() => {
+      })
+    );
+  }
+  await Promise.allSettled(tasks);
+  posthogClient = null;
+  sentryModule = null;
+  monitoringEnabled2 = false;
+}
+var posthogClient, sentryModule, monitoringEnabled2, commonProps;
+var init_node = __esm({
+  "src/monitoring/node.ts"() {
+    posthogClient = null;
+    sentryModule = null;
+    monitoringEnabled2 = false;
+    commonProps = {};
+  }
+});
 var CategorySchema = z.enum([
   "layout",
   "token",
@@ -1024,6 +1222,15 @@ function getReportsDir() {
 function ensureReportsDir() {
   ensureDir(REPORTS_DIR);
 }
+function getTelemetryEnabled() {
+  return readConfig().telemetry !== false;
+}
+function getPosthogApiKey() {
+  return process.env["POSTHOG_API_KEY"] ?? readConfig().posthogApiKey;
+}
+function getSentryDsn() {
+  return process.env["SENTRY_DSN"] ?? readConfig().sentryDsn;
+}
 
 // src/core/loader.ts
 function isFigmaUrl(input) {
@@ -1713,6 +1920,77 @@ function createPromptBasedCheck(_cr) {
   };
 }
 
+// src/monitoring/events.ts
+var EVENT_PREFIX = "cic_";
+var EVENTS = {
+  // Analysis
+  ANALYSIS_STARTED: `${EVENT_PREFIX}analysis_started`,
+  ANALYSIS_COMPLETED: `${EVENT_PREFIX}analysis_completed`,
+  ANALYSIS_FAILED: `${EVENT_PREFIX}analysis_failed`,
+  // Report
+  REPORT_GENERATED: `${EVENT_PREFIX}report_generated`,
+  COMMENT_POSTED: `${EVENT_PREFIX}comment_posted`,
+  COMMENT_FAILED: `${EVENT_PREFIX}comment_failed`,
+  // MCP
+  MCP_TOOL_CALLED: `${EVENT_PREFIX}mcp_tool_called`,
+  // CLI
+  CLI_COMMAND: `${EVENT_PREFIX}cli_command`,
+  CLI_INIT: `${EVENT_PREFIX}cli_init`
+};
+
+// src/monitoring/index.ts
+var _trackEvent = () => {
+};
+var _trackError = () => {
+};
+var _shutdown = () => Promise.resolve();
+function isBrowser() {
+  const g = globalThis;
+  return typeof g["window"] !== "undefined" && typeof g["document"] !== "undefined";
+}
+async function initMonitoring(config2) {
+  if (config2.enabled === false) return;
+  if (!config2.posthogApiKey && !config2.sentryDsn) return;
+  try {
+    if (isBrowser()) {
+      const { initBrowserMonitoring: initBrowserMonitoring2, trackBrowserEvent: trackBrowserEvent2, trackBrowserError: trackBrowserError2, shutdownBrowserMonitoring: shutdownBrowserMonitoring2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
+      await initBrowserMonitoring2(config2);
+      _trackEvent = trackBrowserEvent2;
+      _trackError = trackBrowserError2;
+      _shutdown = shutdownBrowserMonitoring2;
+    } else {
+      const { initNodeMonitoring: initNodeMonitoring2, trackNodeEvent: trackNodeEvent2, trackNodeError: trackNodeError2, shutdownNodeMonitoring: shutdownNodeMonitoring2 } = await Promise.resolve().then(() => (init_node(), node_exports));
+      await initNodeMonitoring2(config2);
+      _trackEvent = trackNodeEvent2;
+      _trackError = trackNodeError2;
+      _shutdown = shutdownNodeMonitoring2;
+    }
+  } catch {
+  }
+}
+function trackEvent(event, properties) {
+  try {
+    _trackEvent(event, properties);
+  } catch {
+  }
+}
+function trackError(error, context) {
+  try {
+    _trackError(error, context);
+  } catch {
+  }
+}
+async function shutdownMonitoring() {
+  try {
+    await _shutdown();
+  } catch {
+  }
+}
+
+// src/monitoring/keys.ts
+var POSTHOG_API_KEY = "phc_rBFeG140KqJLpUnlpYDEFgdMM6JozZeqQsf9twXf5Dq" ;
+var SENTRY_DSN = "https://80a836a8300b25f17ef5bbf23afb5b3a@o4511080656207872.ingest.us.sentry.io/4511080661319680" ;
+
 // src/rules/excluded-names.ts
 var EXCLUDED_NAME_PATTERN = /(badge|close|dismiss|overlay|float|fab|dot|indicator|corner|decoration|tag|status|notification|icon|ico|image|asset|filter|dim|dimmed|bg|background|logo|avatar|divider|separator|nav|navigation|gnb|header|footer|sidebar|toolbar|modal|dialog|popup|toast|tooltip|dropdown|menu|sticky|spinner|loader|cursor|cta|chatbot|thumb|thumbnail|tabbar|tab-bar|statusbar|status-bar)/i;
 function isExcludedName(name) {
@@ -2916,6 +3194,7 @@ Typical flow with Figma MCP:
     customRulesPath: z.string().optional().describe("Path to custom rules JSON file")
   },
   async ({ designData, input, fileKey, fileName, token, preset, targetNodeId, configPath, customRulesPath }) => {
+    trackEvent(EVENTS.MCP_TOOL_CALLED, { tool: "analyze" });
     try {
       let file;
       let nodeId;
@@ -2961,6 +3240,13 @@ Typical flow with Figma MCP:
       });
       const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
       exec(`${openCmd} "${reportPath}"`);
+      trackEvent(EVENTS.ANALYSIS_COMPLETED, {
+        nodeCount: result.nodeCount,
+        issueCount: result.issues.length,
+        grade: scores.overall.grade,
+        percentage: scores.overall.percentage,
+        source: designData ? "mcp-data" : "url"
+      });
       const issuesByRule = {};
       for (const issue of result.issues) {
         const id = issue.violation.ruleId;
@@ -2990,6 +3276,13 @@ Typical flow with Figma MCP:
         ]
       };
     } catch (error) {
+      trackError(
+        error instanceof Error ? error : new Error(String(error)),
+        { tool: "analyze" }
+      );
+      trackEvent(EVENTS.ANALYSIS_FAILED, {
+        error: error instanceof Error ? error.message : String(error)
+      });
       return {
         content: [
           {
@@ -3084,9 +3377,24 @@ Use this when the user asks about customization, configuration, rule settings, o
   }
 );
 async function main() {
+  const monitoringConfig = {
+    environment: "mcp",
+    version: pkg.version,
+    enabled: getTelemetryEnabled()
+  };
+  const phKey = getPosthogApiKey() || POSTHOG_API_KEY;
+  monitoringConfig.posthogApiKey = phKey;
+  const sDsn = getSentryDsn() || SENTRY_DSN;
+  monitoringConfig.sentryDsn = sDsn;
+  await initMonitoring(monitoringConfig).catch(() => {
+  });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
+process.on("beforeExit", () => {
+  shutdownMonitoring().catch(() => {
+  });
+});
 main().catch(console.error);
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map