@snapback/cli 1.6.0 → 3.0.1

package/dist/chunk-YVZXPBSV.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { createLogger, LogLevel } from './chunk-NOWJBG6X.js';
+import { __name } from './chunk-7ADPL4Q3.js';
+import { createClient } from 'redis';
+
+process.env.SNAPBACK_CLI='true';
+createLogger({
+  name: "redis-factory",
+  level: LogLevel.INFO
+});
+function isSocketTimeoutError(cause) {
+  if (!cause) return false;
+  return cause?.name === "SocketTimeoutError" || cause?.message?.includes("socket timeout");
+}
+__name(isSocketTimeoutError, "isSocketTimeoutError");
+
+// ../../packages/platform/dist/cache/redis-metrics.js
+var LATENCY_THRESHOLDS = {
+  /** Under 100ms is healthy */
+  healthy: 100,
+  /** Under 500ms is degraded */
+  degraded: 500
+};
+var RedisMetricsCollector = class {
+  static {
+    __name(this, "RedisMetricsCollector");
+  }
+  reconnectAttempts = 0;
+  lastSuccessAt = null;
+  lastErrorAt = null;
+  lastError = null;
+  keyPrefix;
+  constructor(keyPrefix = "") {
+    this.keyPrefix = keyPrefix;
+  }
+  /**
+   * Record a successful operation
+   */
+  recordSuccess() {
+    this.lastSuccessAt = Date.now();
+  }
+  /**
+   * Record an error
+   */
+  recordError(error) {
+    this.lastErrorAt = Date.now();
+    this.lastError = error.message;
+  }
+  /**
+   * Record a reconnection attempt
+   */
+  recordReconnect() {
+    this.reconnectAttempts++;
+  }
+  /**
+   * Reset reconnection counter (after successful connection)
+   */
+  resetReconnectCount() {
+    this.reconnectAttempts = 0;
+  }
+  /**
+   * Measure Redis latency using PING command
+   */
+  async measureLatency(client) {
+    if (!client || !client.isReady) {
+      return null;
+    }
+    try {
+      const start = Date.now();
+      await client.ping();
+      const latency = Date.now() - start;
+      this.recordSuccess();
+      return latency;
+    } catch (error) {
+      this.recordError(error);
+      return null;
+    }
+  }
+  /**
+   * Collect comprehensive metrics
+   */
+  async collect(client) {
+    const isConnected = client?.isReady ?? false;
+    const isOpen = client?.isOpen ?? false;
+    const latency = await this.measureLatency(client);
+    let status;
+    let message;
+    if (!isConnected) {
+      status = "unhealthy";
+      message = "Redis client not connected";
+    } else if (latency === null) {
+      status = "unhealthy";
+      message = "Redis PING failed";
+    } else if (latency < LATENCY_THRESHOLDS.healthy) {
+      status = "healthy";
+      message = `Redis latency: ${latency}ms`;
+    } else if (latency < LATENCY_THRESHOLDS.degraded) {
+      status = "degraded";
+      message = `Redis latency elevated: ${latency}ms`;
+    } else {
+      status = "unhealthy";
+      message = `Redis latency too high: ${latency}ms`;
+    }
+    return {
+      isConnected,
+      isOpen,
+      latency,
+      status,
+      message,
+      lastSuccessAt: this.lastSuccessAt,
+      lastErrorAt: this.lastErrorAt,
+      lastError: this.lastError,
+      reconnectAttempts: this.reconnectAttempts,
+      keyPrefix: this.keyPrefix
+    };
+  }
+  /**
+   * Get current reconnection attempt count
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+};
+var metricsCollectors = /* @__PURE__ */ new Map();
+function getMetricsCollector(keyPrefix = "") {
+  let collector = metricsCollectors.get(keyPrefix);
+  if (!collector) {
+    collector = new RedisMetricsCollector(keyPrefix);
+    metricsCollectors.set(keyPrefix, collector);
+  }
+  return collector;
+}
+__name(getMetricsCollector, "getMetricsCollector");
+
+// ../../packages/platform/dist/cache/redis-client.js
+var logger2 = createLogger({
+  name: "redis-client",
+  level: LogLevel.INFO
+});
+var KEY_PREFIX = "cache:";
+var redisClient = null;
+var redisAvailable = false;
+var initializationPromise = null;
+var metricsCollector = getMetricsCollector(KEY_PREFIX);
+async function initializeRedis() {
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  initializationPromise = (async () => {
+    const redisUrl = process.env.REDIS_URL;
+    if (!redisUrl) {
+      logger2.warn("REDIS_URL not configured - using in-memory fallback for caching");
+      return;
+    }
+    try {
+      redisClient = createClient({
+        url: redisUrl,
+        socket: {
+          // Connection timeout - how long to wait for initial connection
+          connectTimeout: 1e4,
+          // TCP keepalive - prevents silent connection drops
+          keepAlive: 5e3,
+          // Reconnection strategy with exponential backoff + jitter
+          reconnectStrategy: /* @__PURE__ */ __name((retries, cause) => {
+            if (isSocketTimeoutError(cause)) {
+              logger2.warn("Redis socket timeout - not reconnecting", {
+                cause: cause?.message
+              });
+              return false;
+            }
+            if (retries > 20) {
+              logger2.error("Redis max retries exceeded", {
+                retries,
+                cause: cause?.message
+              });
+              return new Error("Redis connection failed");
+            }
+            const baseDelay = Math.min(2 ** retries * 100, 3e4);
+            const jitter = Math.floor(Math.random() * 200);
+            return baseDelay + jitter;
+          }, "reconnectStrategy")
+        },
+        // Application-level ping to keep connection alive
+        pingInterval: 6e4
+      });
+      redisClient.on("error", (err) => {
+        if (err.message.includes("ECONNRESET") || err.message.includes("ECONNREFUSED")) {
+          logger2.debug("Redis connection error (will reconnect)", {
+            error: err.message
+          });
+        } else {
+          logger2.warn("Redis client error", {
+            error: err.message
+          });
+        }
+        redisAvailable = false;
+        metricsCollector.recordError(err);
+      });
+      redisClient.on("connect", () => {
+        redisAvailable = true;
+        metricsCollector.resetReconnectCount();
+        if (process.env.NODE_ENV !== "production") {
+          logger2.info("Redis connected for platform caching");
+        }
+      });
+      redisClient.on("ready", () => {
+        redisAvailable = true;
+        logger2.debug("Redis client ready for platform caching");
+      });
+      redisClient.on("reconnecting", () => {
+        metricsCollector.recordReconnect();
+        logger2.debug("Redis reconnecting for platform caching");
+      });
+      await redisClient.connect();
+      redisAvailable = true;
+      if (process.env.NODE_ENV !== "production") {
+        logger2.info("\u2705 Redis client initialized for platform caching with production config");
+      }
+    } catch (error) {
+      logger2.error("Redis initialization failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      redisAvailable = false;
+    }
+  })();
+  return initializationPromise;
+}
+__name(initializeRedis, "initializeRedis");
+async function getCache(key) {
+  await initializeRedis();
+  if (!redisAvailable || !redisClient) {
+    return null;
+  }
+  try {
+    const value = await redisClient.get(key);
+    if (!value) {
+      return null;
+    }
+    return JSON.parse(value);
+  } catch (error) {
+    logger2.error("Redis GET failed", {
+      key,
+      error
+    });
+    return null;
+  }
+}
+__name(getCache, "getCache");
+async function setCache(key, value, ttlSeconds) {
+  await initializeRedis();
+  if (!redisAvailable || !redisClient) {
+    return false;
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    if (ttlSeconds) {
+      await redisClient.set(key, serialized, {
+        EX: ttlSeconds
+      });
+    } else {
+      await redisClient.set(key, serialized);
+    }
+    return true;
+  } catch (error) {
+    logger2.error("Redis SET failed", {
+      key,
+      error
+    });
+    return false;
+  }
+}
+__name(setCache, "setCache");
+async function deleteCache(key) {
+  await initializeRedis();
+  if (!redisAvailable || !redisClient) {
+    return false;
+  }
+  try {
+    await redisClient.del(key);
+    return true;
+  } catch (error) {
+    logger2.error("Redis DEL failed", {
+      key,
+      error
+    });
+    return false;
+  }
+}
+__name(deleteCache, "deleteCache");
+async function closeRedis() {
+  if (redisClient) {
+    try {
+      await redisClient.quit();
+      logger2.info("Redis connection closed");
+    } catch (error) {
+      logger2.error("Error closing Redis connection", {
+        error
+      });
+    }
+    redisClient = null;
+    redisAvailable = false;
+  }
+}
+__name(closeRedis, "closeRedis");
+function isRedisAvailable() {
+  return redisAvailable;
+}
+__name(isRedisAvailable, "isRedisAvailable");
+function getRedisClient() {
+  return redisClient;
+}
+__name(getRedisClient, "getRedisClient");
+
+export { closeRedis, deleteCache, getCache, getRedisClient, initializeRedis, isRedisAvailable, setCache };

package/dist/chunk-ZBQDE6WJ.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { __name } from './chunk-7ADPL4Q3.js';
+import { parse } from '@babel/parser';
+
+process.env.SNAPBACK_CLI='true';
+function detectSkippedTests(code, filePath) {
+  const skipped = [];
+  try {
+    let visit2 = function(node) {
+      if (node.type === "CallExpression") {
+        const callee = node.callee;
+        if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "skip" && callee.object.type === "Identifier") {
+          const testType = callee.object.name;
+          if (testType === "describe" || testType === "it" || testType === "test") {
+            let name;
+            if (node.arguments.length > 0) {
+              const firstArg = node.arguments[0];
+              if (firstArg.type === "StringLiteral") {
+                name = firstArg.value;
+              } else if (firstArg.type === "TemplateLiteral" && firstArg.quasis.length === 1) {
+                name = firstArg.quasis[0].value.raw;
+              }
+            }
+            skipped.push({
+              type: testType,
+              name,
+              line: node.loc?.start.line ?? 0,
+              column: node.loc?.start.column ?? 0,
+              file: filePath
+            });
+          }
+        }
+      }
+      for (const key of Object.keys(node)) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              if (item && typeof item === "object" && "type" in item) {
+                visit2(item);
+              }
+            }
+          } else if ("type" in value) {
+            visit2(value);
+          }
+        }
+      }
+    };
+    var visit = visit2;
+    __name(visit2, "visit");
+    const ast = parse(code, {
+      sourceType: "module",
+      plugins: [
+        "typescript",
+        "jsx"
+      ],
+      errorRecovery: true
+    });
+    visit2(ast.program);
+    return {
+      file: filePath,
+      skipped,
+      parsed: true
+    };
+  } catch (error) {
+    return {
+      file: filePath,
+      skipped: [],
+      parsed: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(detectSkippedTests, "detectSkippedTests");
+function analyzeSkippedTests(files) {
+  const results = [];
+  for (const [filePath, content] of files) {
+    if (filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("__tests__")) {
+      results.push(detectSkippedTests(content, filePath));
+    }
+  }
+  return results;
+}
+__name(analyzeSkippedTests, "analyzeSkippedTests");
+function getSkippedTestSummary(results) {
+  const summary = {
+    totalSkipped: 0,
+    byType: {
+      describe: 0,
+      it: 0,
+      test: 0
+    },
+    filesWithSkipped: []
+  };
+  for (const result of results) {
+    if (result.skipped.length > 0) {
+      summary.filesWithSkipped.push(result.file);
+      summary.totalSkipped += result.skipped.length;
+      for (const test of result.skipped) {
+        summary.byType[test.type]++;
+      }
+    }
+  }
+  return summary;
+}
+__name(getSkippedTestSummary, "getSkippedTestSummary");
+
+export { analyzeSkippedTests, detectSkippedTests, getSkippedTestSummary };

package/dist/client-RHDS6NOB.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+export { checkDatabaseConnection, closeDatabaseConnection, combinedSchema, db, pool } from './chunk-BWWPGNZ5.js';
+import './chunk-NOWJBG6X.js';
+import './chunk-5EOPYJ4Y.js';
+import './chunk-CBGOC6RV.js';
+import './chunk-7ADPL4Q3.js';
+
+process.env.SNAPBACK_CLI='true';

package/dist/dist-5LR7APG5.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+export { createManagedMetadata, detectAIClients, detectMCPProcesses, detectWorkspaceConfig, evictCachedPath, getAllCachedPaths, getCachedPath, getClient, getClientConfigPath, getConfiguredClients, getOrCreateIdentity, getServerKey, getSnapbackConfigDir, getSnapbackMCPConfig, injectWorkspacePath, isCommandExecutable2 as isCommandExecutable, isOwnedByThisInstall, isSnapbackMCPRunning, patchApiKeyInClientConfig, readClientConfig, removeSnapbackConfig, repairClientConfig, resetIdentityCache, resolveNodePath, setCachedPath, validateClientConfig, validateConfig, validateWorkspacePath, writeClientConfig } from './chunk-E6V6QKS7.js';
+import './chunk-7ADPL4Q3.js';
+
+process.env.SNAPBACK_CLI='true';

package/dist/dist-CUHOKNLS.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+export { AccountSchema, AiChatSchema, AttributionServiceImpl, EntitlementsServiceImpl, InvitationSchema, MCPService, MemberSchema, OrganizationSchema, OrganizationUpdateSchema, PasskeySchema, PurchaseInsertSchema, PurchaseSchema, PurchaseUpdateSchema, SagaOrchestratorImpl, SessionSchema, SnapshotStoreDb, TelemetrySinkDb, TelemetrySinkDbAdapter, UserSchema, UserUpdateSchema, VerificationSchema, anonymizeEmail, anonymizeUserData, anonymizeUserId, appendFalsePositivePatterns, calculateDecayedWeight, cleanupExpiredData, clearCapabilityCache, closeTestDb, countAllOrganizations, countAllUsers, createPurchase, createTestUser, createTierUpgradeSagaWithDeps, createUser, createUserAccount, databaseService, deletePurchaseBySubscriptionId, deleteUserApiKeys, deleteUserData, exportUserData, extensionLinkTokens, extensionSessions as extensionSessionsAuth, findSimilarPatterns, generateOrganizationSlug, getAccountById, getCacheMetrics, getCapabilities, getCapabilityAuditHistory, getInvitationById, getMCPService, getOrganizationById, getOrganizationBySlug, getOrganizationMembership, getOrganizationWithPurchasesAndMembersCount, getOrganizations, getOrganizationsWithMembers, getPendingInvitationByEmail, getPurchaseById, getPurchaseBySubscriptionId, getPurchasesByOrganizationId, getPurchasesByUserId, getTestDb, getUserByEmail, getUserById, getUserPrivacyPreferences, getUsers, getVectorStats, getWorkspaceLinkById, getWorkspaceLinksByUserId, handleTierDowngrade, handleTierUpgrade, healthCheck, incrementDetectionsAnalyzed, insertPatternWithEmbedding, invalidateCapabilityCache, isPgvectorEnabled, linkWorkspace, logAnonymizedEvent, logCapabilityAudit, mergeSignalIntoPattern, recordFalsePositiveSignal, resetCacheMetrics, resetCapabilities, resolveTierByWorkspaceId, sagaPersistence, sanitizeForLogging, searchSimilarPatterns, shouldRetainData, signalToPattern, testInTransaction, truncateAllTables, unlinkAllWorkspacesForUser, unlinkWorkspace, updateCapabilities, updateOrganization, updatePatternEmbedding, updatePurchase, updateUser, updateWorkspaceTier } from './chunk-V7B37PPD.js';
+export { TOPUP_PACKS, account, activationCodeRedemptions, activationCodes, adminAuditLog, agentSuggestions, analysisEvents, apiKeyMetadata, apiKeyUsage, apiKeys, apiUsage, apiUsageLogs, burnInviteCode, checkDatabaseConnection, clientTokens, combinedSchema, creditJobTypeEnum, creditTopups, creditTransactionStatusEnum, creditTransactionTypeEnum, creditsLedger, db, deviceTrials, emailDeliveries, emailPreferences, extensionSessions, featureUsage, feedback, fileSnapshotSessions, fingerprints, getTopupPackDetails, inviteCodes, isValidPackSize, loops, mcpActivityEvents, mcpAggregatedLearnings, mcpSessions, member, newsletterSubscribers, orgDailyMetrics, organization, pendingApiKeys, policyEvaluations, pool, postAcceptOutcomes, purchase, rateLimitViolations, responseCache, retentionConfig, rollbackEvents, ruleViolations, postgres_exports as schema, securityEvents, snapbackSchema, snapshotFiles, snapshots, subscriptions, superAdmins, telemetryDailyStats, telemetryEvents, telemetryIdempotencyKeys, telemetryOutbox, topupStatusEnum, usageLimits, user, userProductMetrics, userSafetyProfiles, waitlist, waitlistAuditLogs, waitlistReferrals, waitlistTasks } from './chunk-BWWPGNZ5.js';
+export { closeRedis, getRedisClient, initializeRedis, isRedisAvailable } from './chunk-YVZXPBSV.js';
+import './chunk-BE3HNVSV.js';
+import './chunk-PL4HF4M2.js';
+import './chunk-NOWJBG6X.js';
+import './chunk-5EOPYJ4Y.js';
+import './chunk-CBGOC6RV.js';
+import './chunk-7ADPL4Q3.js';
+
+process.env.SNAPBACK_CLI='true';

package/dist/dist-RJE4RSZJ.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+export { AnalyticsEvents, CORRELATION_ANALYSES, CORRELATION_COHORTS, KEY_METRIC_ALERTS, OTelInstrumentationProvider, RETENTION_COHORTS, TelemetryClient, addSentryBreadcrumb, captureError, captureMessage, checkDatabaseConnection, checkErrorBudget, checkHttpService, checkRedisConnection, clearSentryUser, createAlert, createCohort, createGracefulShutdown, createHealthCheck, createSentryMiddleware, deleteAlert, deleteCohort, detectSurface, drainAndCloseServer, flushSentry, getAlerts, getAnalyticsEnv, getAnalyticsSuperProperties, getCohort, getCohortMembers, getCohorts, getCorrelationAnalysis, getDeploymentEnv, getEnvironmentInfo, getErrorRate, getMetrics, initSentry, isDevelopment, isProduction, neon_exports as neon, performCorrelationAnalysis, preStopDelay, prometheus_exports as prometheus, recordError, recordSuccess, registerKeyMetricAlerts, resetMetrics, setSentryUser, startSentryTransaction, toggleAlert, updateCohort } from './chunk-BE3HNVSV.js';
+export { cache_exports as cache, logger, makeWatcher, resiliency_exports as resiliency } from './chunk-PL4HF4M2.js';
+export { LogLevel, NoOpInstrumentationProvider } from './chunk-NOWJBG6X.js';
+import './chunk-5EOPYJ4Y.js';
+import './chunk-CBGOC6RV.js';
+import './chunk-7ADPL4Q3.js';
+
+process.env.SNAPBACK_CLI='true';