Merge pull request continuedev#7591 from continuedev/nate/cli-headless-flag

sestinj · web-flow · commit b3f4b82600f6 · 2025-09-08T22:33:13.000-07:00
note whether headless mode / github actions in telemetry
diff --git a/extensions/cli/src/__mocks__/services/BaseService.ts b/extensions/cli/src/__mocks__/services/BaseService.ts
@@ -0,0 +1,74 @@
+import { EventEmitter } from "events";
+import { vi } from "vitest";
+
+/**
+ * Mocked base service class for testing
+ */
+export class BaseService<TState> extends EventEmitter {
+  protected serviceName: string;
+  protected currentState: TState;
+  private isInitialized: boolean = false;
+
+  constructor(serviceName: string, initialState: TState) {
+    super();
+    this.serviceName = serviceName;
+    this.currentState = initialState;
+  }
+
+  // Mock the abstract method
+  doInitialize = vi.fn<any>();
+
+  async initialize(...args: any[]): Promise<TState> {
+    this.emit("initializing");
+    try {
+      const state = await this.doInitialize(...args);
+      this.currentState = state;
+      this.isInitialized = true;
+      this.emit("initialized", state);
+      return state;
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    }
+  }
+
+  getState(): TState {
+    return { ...this.currentState };
+  }
+
+  protected setState(newState: Partial<TState>): void {
+    const previousState = this.currentState;
+    this.currentState = { ...this.currentState, ...newState };
+    this.emit("stateChanged", this.currentState, previousState);
+  }
+
+  isReady(): boolean {
+    return this.isInitialized;
+  }
+
+  async reload(...args: any[]): Promise<TState> {
+    this.isInitialized = false;
+    return this.initialize(...args);
+  }
+
+  async cleanup(): Promise<void> {
+    this.removeAllListeners();
+    this.isInitialized = false;
+  }
+}
+
+/**
+ * Interface for services with dependencies
+ */
+export interface ServiceWithDependencies {
+  getDependencies(): string[];
+}
+
+/**
+ * Helper to check if a service has dependencies
+ */
+export function hasDependencies(
+  service: any,
+): service is ServiceWithDependencies {
+  return !!service && typeof service.getDependencies === "function";
+}
diff --git a/extensions/cli/src/services/BaseService.test.ts b/extensions/cli/src/services/BaseService.test.ts
@@ -1,10 +1,118 @@
-import { describe, expect, test, beforeEach, vi } from "vitest";
+import { EventEmitter } from "events";
 
-import {
-  BaseService,
-  hasDependencies,
-  ServiceWithDependencies,
-} from "./BaseService.js";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+import { logger } from "../util/logger.js";
+
+/**
+ * Base abstract class for all services
+ * Provides common lifecycle methods and state management
+ */
+abstract class BaseService<TState> extends EventEmitter {
+  protected serviceName: string;
+  protected currentState: TState;
+  private isInitialized: boolean = false;
+
+  constructor(serviceName: string, initialState: TState) {
+    super();
+    this.serviceName = serviceName;
+    this.currentState = initialState;
+  }
+
+  /**
+   * Initialize the service (must be implemented by subclasses)
+   * This is automatically wrapped with initialization logic
+   */
+  abstract doInitialize(...args: any[]): Promise<TState>;
+
+  /**
+   * Public initialization method that wraps the implementation
+   */
+  async initialize(...args: any[]): Promise<TState> {
+    logger.debug(`Initializing ${this.serviceName}`, {
+      wasInitialized: this.isInitialized,
+      hadPreviousState: !!this.currentState,
+    });
+    this.emit("initializing");
+
+    try {
+      const state = await this.doInitialize(...args);
+      this.currentState = state;
+      this.isInitialized = true;
+      logger.debug(`${this.serviceName} initialized successfully`, {
+        stateKeys: state ? Object.keys(state as any) : [],
+        isNowInitialized: this.isInitialized,
+      });
+      this.emit("initialized", state);
+      return state;
+    } catch (error: any) {
+      logger.debug(`Failed to initialize ${this.serviceName}:`, error);
+      if (this.listenerCount("error") > 0) {
+        this.emit("error", error);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get current service state (shallow copy for immutability)
+   */
+  getState(): TState {
+    return { ...this.currentState };
+  }
+
+  /**
+   * Update service state and emit change event
+   */
+  protected setState(newState: Partial<TState>): void {
+    const previousState = this.currentState;
+    this.currentState = { ...this.currentState, ...newState };
+    // Only log state updates if not in production to avoid circular reference issues
+    if (process.env.NODE_ENV !== "production") {
+      logger.debug(`${this.serviceName} state updated`);
+    }
+    this.emit("stateChanged", this.currentState, previousState);
+  }
+
+  /**
+   * Check if service is ready for use
+   */
+  isReady(): boolean {
+    return this.isInitialized;
+  }
+
+  /**
+   * Reload/refresh the service
+   */
+  async reload(...args: any[]): Promise<TState> {
+    logger.debug(`Reloading ${this.serviceName}`);
+    this.isInitialized = false;
+    return this.initialize(...args);
+  }
+
+  /**
+   * Cleanup resources (can be overridden by subclasses)
+   */
+  async cleanup(): Promise<void> {
+    logger.debug(`Cleaning up ${this.serviceName}`);
+    this.removeAllListeners();
+    this.isInitialized = false;
+  }
+}
+
+/**
+ * Interface for services with dependencies
+ */
+interface ServiceWithDependencies {
+  getDependencies(): string[];
+}
+
+/**
+ * Helper to check if a service has dependencies
+ */
+function hasDependencies(service: any): service is ServiceWithDependencies {
+  return !!service && typeof service.getDependencies === "function";
+}
 
 // Test implementation of BaseService
 interface TestState {
diff --git a/extensions/cli/src/telemetry/posthogService.errorHandling.test.ts b/extensions/cli/src/telemetry/posthogService.errorHandling.test.ts
@@ -39,7 +39,7 @@ describe("PosthogService Error Handling", () => {
       properties: expect.objectContaining({
         test: "data",
         os: expect.any(String),
-        extensionVersion: "",
+        extensionVersion: expect.any(String),
         ideName: "cn",
         ideType: "cli",
       }),
diff --git a/extensions/cli/src/telemetry/posthogService.ts b/extensions/cli/src/telemetry/posthogService.ts
@@ -5,7 +5,9 @@ import node_machine_id from "node-machine-id";
 import type { PostHog as PostHogType } from "posthog-node";
 
 import { isAuthenticatedConfig, loadAuthConfig } from "../auth/workos.js";
+import { isGitHubActions } from "../util/git.js";
 import { logger } from "../util/logger.js";
+import { getVersion } from "../version.js";
 
 export class PosthogService {
   private os: string | undefined;
@@ -36,6 +38,14 @@ export class PosthogService {
     return this._hasInternetConnection;
   }
 
+  /**
+   * Check if running in headless mode (-p/--print flags)
+   */
+  private isHeadlessMode(): boolean {
+    const args = process.argv.slice(2);
+    return args.includes("-p") || args.includes("--print");
+  }
+
   get isEnabled() {
     return process.env.CONTINUE_CLI_ENABLE_TELEMETRY !== "0";
   }
@@ -87,9 +97,11 @@ export class PosthogService {
       const augmentedProperties = {
         ...properties,
         os: this.os,
-        extensionVersion: "", // TODO cn version
+        extensionVersion: getVersion(),
         ideName: "cn",
         ideType: "cli",
+        isHeadless: this.isHeadlessMode(),
+        isGitHubCI: isGitHubActions(),
       };
       const payload = {
         distinctId: this.uniqueId,
diff --git a/extensions/cli/src/version.ts b/extensions/cli/src/version.ts
@@ -2,6 +2,9 @@ import { readFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 
+import node_machine_id from "node-machine-id";
+
+import { isAuthenticatedConfig, loadAuthConfig } from "./auth/workos.js";
 import { logger } from "./util/logger.js";
 
 export function getVersion(): string {
@@ -17,29 +20,68 @@ export function getVersion(): string {
   }
 }
 
+function getEventUserId(): string {
+  const authConfig = loadAuthConfig();
+
+  if (isAuthenticatedConfig(authConfig)) {
+    return authConfig.userId;
+  }
+
+  // Fall back to unique machine id if not signed in
+  return node_machine_id.machineIdSync();
+}
+
+// Singleton to cache the latest version result
+let latestVersionCache: Promise<string | null> | null = null;
+
 export async function getLatestVersion(
   signal?: AbortSignal,
 ): Promise<string | null> {
-  try {
-    const response = await fetch(
-      "https://registry.npmjs.org/@continuedev/cli/latest",
-      { signal },
-    );
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
-    const data = await response.json();
-    return data.version;
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      // Request was aborted, don't log
+  // Return cached promise if it exists
+  if (latestVersionCache) {
+    return latestVersionCache;
+  }
+
+  // Create and cache the promise
+  latestVersionCache = (async () => {
+    try {
+      const id = getEventUserId();
+      const response = await fetch(
+        `https://api.continue.dev/cn/info?id=${encodeURIComponent(id)}`,
+        { signal },
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const data = await response.json();
+      return data.version;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        // Request was aborted, don't log
+        return null;
+      }
+      logger?.debug(
+        "Warning: Could not fetch latest version from api.continue.dev",
+      );
       return null;
     }
-    logger.debug("Warning: Could not fetch latest version from npm registry");
-    return null;
-  }
+  })();
+
+  return latestVersionCache;
 }
 
+getLatestVersion()
+  .then((version) => {
+    if (version) {
+      logger?.info(`Latest version: ${version}`);
+    }
+  })
+  .catch((error) => {
+    logger?.debug(
+      `Warning: Could not fetch latest version from api.continue.dev: ${error}`,
+    );
+  });
+
 export function compareVersions(
   current: string,
   latest: string,
