cowork-os 0.3.21

package/src/electron/settings/x-manager.ts

@@ -0,0 +1,62 @@
+/**
+ * X/Twitter Settings Manager
+ *
+ * Stores X integration settings in encrypted database.
+ */
+
+import { SecureSettingsRepository } from '../database/SecureSettingsRepository';
+import { XSettingsData } from '../../shared/types';
+
+const DEFAULT_SETTINGS: XSettingsData = {
+  enabled: false,
+  authMethod: 'browser',
+  cookieSource: ['chrome'],
+  timeoutMs: 20000,
+  cookieTimeoutMs: 20000,
+  quoteDepth: 1,
+};
+
+export class XSettingsManager {
+  private static cachedSettings: XSettingsData | null = null;
+
+  static loadSettings(): XSettingsData {
+    if (this.cachedSettings) {
+      return this.cachedSettings;
+    }
+
+    let settings: XSettingsData = { ...DEFAULT_SETTINGS };
+
+    try {
+      if (SecureSettingsRepository.isInitialized()) {
+        const repository = SecureSettingsRepository.getInstance();
+        const stored = repository.load<XSettingsData>('x');
+        if (stored) {
+          settings = { ...DEFAULT_SETTINGS, ...stored };
+        }
+      }
+    } catch (error) {
+      console.error('[XSettingsManager] Failed to load settings:', error);
+    }
+
+    this.cachedSettings = settings;
+    return settings;
+  }
+
+  static saveSettings(settings: XSettingsData): void {
+    try {
+      if (!SecureSettingsRepository.isInitialized()) {
+        throw new Error('SecureSettingsRepository not initialized');
+      }
+      const repository = SecureSettingsRepository.getInstance();
+      repository.save('x', settings);
+      this.cachedSettings = settings;
+      console.log('[XSettingsManager] Settings saved');
+    } catch (error) {
+      console.error('[XSettingsManager] Failed to save settings:', error);
+    }
+  }
+
+  static clearCache(): void {
+    this.cachedSettings = null;
+  }
+}

package/src/electron/tailscale/exposure.ts

@@ -0,0 +1,262 @@
+/**
+ * Tailscale Exposure Manager
+ *
+ * High-level API for exposing local services via Tailscale Serve or Funnel.
+ * Handles lifecycle management, cleanup, and status tracking.
+ */
+
+import {
+  isTailscaleInstalled,
+  getTailnetHostname,
+  enableTailscaleServe,
+  disableTailscaleServe,
+  enableTailscaleFunnel,
+  disableTailscaleFunnel,
+  checkTailscaleFunnelAvailable,
+} from './tailscale';
+import { TailscaleSettingsManager, type TailscaleMode } from './settings';
+
+/**
+ * Configuration for starting Tailscale exposure
+ */
+export interface TailscaleExposureConfig {
+  /** Mode: 'serve' (Tailnet only) or 'funnel' (public internet) */
+  mode: TailscaleMode;
+  /** Local port to expose */
+  port: number;
+  /** URL path prefix (default: '/') */
+  pathPrefix?: string;
+  /** Reset Tailscale config on cleanup */
+  resetOnExit?: boolean;
+  /** Logger functions */
+  log?: (message: string) => void;
+  warn?: (message: string) => void;
+}
+
+/**
+ * Result from starting Tailscale exposure
+ */
+export interface TailscaleExposureResult {
+  /** Whether exposure was successfully enabled */
+  success: boolean;
+  /** The public/Tailnet hostname */
+  hostname?: string;
+  /** Full HTTPS URL to access the service */
+  httpsUrl?: string;
+  /** Full WebSocket URL */
+  wssUrl?: string;
+  /** Error message if failed */
+  error?: string;
+  /** Cleanup function to disable exposure */
+  cleanup?: () => Promise<void>;
+}
+
+/**
+ * Active exposure state tracking
+ */
+interface ActiveExposure {
+  mode: TailscaleMode;
+  port: number;
+  hostname: string;
+  startedAt: number;
+}
+
+let activeExposure: ActiveExposure | null = null;
+
+/**
+ * Get current exposure status
+ */
+export function getExposureStatus(): {
+  active: boolean;
+  mode?: TailscaleMode;
+  hostname?: string;
+  httpsUrl?: string;
+  wssUrl?: string;
+  startedAt?: number;
+} {
+  if (!activeExposure) {
+    return { active: false };
+  }
+
+  return {
+    active: true,
+    mode: activeExposure.mode,
+    hostname: activeExposure.hostname,
+    httpsUrl: `https://${activeExposure.hostname}`,
+    wssUrl: `wss://${activeExposure.hostname}`,
+    startedAt: activeExposure.startedAt,
+  };
+}
+
+/**
+ * Start Tailscale exposure for a local service
+ *
+ * @param config - Exposure configuration
+ * @returns Result with URLs and cleanup function
+ */
+export async function startTailscaleExposure(
+  config: TailscaleExposureConfig
+): Promise<TailscaleExposureResult> {
+  const log = config.log || console.log;
+  const warn = config.warn || console.warn;
+
+  // Return early if mode is 'off'
+  if (config.mode === 'off') {
+    return { success: true };
+  }
+
+  // Check if Tailscale is installed
+  const installed = await isTailscaleInstalled();
+  if (!installed) {
+    const error = 'Tailscale is not installed. Please install Tailscale first.';
+    warn(`[Tailscale Exposure] ${error}`);
+    return { success: false, error };
+  }
+
+  // If mode is funnel, check availability
+  if (config.mode === 'funnel') {
+    const funnelAvailable = await checkTailscaleFunnelAvailable();
+    if (!funnelAvailable) {
+      warn('[Tailscale Exposure] Funnel not available, falling back to Serve mode');
+      config.mode = 'serve';
+    }
+  }
+
+  // Enable the appropriate mode
+  let enabled = false;
+  try {
+    if (config.mode === 'funnel') {
+      enabled = await enableTailscaleFunnel(config.port, config.pathPrefix || '/');
+    } else if (config.mode === 'serve') {
+      enabled = await enableTailscaleServe(config.port, config.pathPrefix || '/');
+    }
+  } catch (error: any) {
+    const message = error.message || String(error);
+    warn(`[Tailscale Exposure] Failed to enable ${config.mode}: ${message}`);
+    return { success: false, error: message };
+  }
+
+  if (!enabled) {
+    const error = `Failed to enable Tailscale ${config.mode}`;
+    return { success: false, error };
+  }
+
+  // Get the hostname
+  const hostname = await getTailnetHostname();
+  if (!hostname) {
+    warn('[Tailscale Exposure] Could not determine Tailnet hostname');
+    // Try to clean up
+    if (config.mode === 'funnel') {
+      await disableTailscaleFunnel();
+    } else {
+      await disableTailscaleServe();
+    }
+    return { success: false, error: 'Could not determine Tailnet hostname' };
+  }
+
+  // Build URLs
+  const pathPrefix = config.pathPrefix || '';
+  const httpsUrl = `https://${hostname}${pathPrefix}`;
+  const wssUrl = `wss://${hostname}${pathPrefix}`;
+
+  // Update settings
+  TailscaleSettingsManager.updateSettings({
+    mode: config.mode,
+    lastHostname: hostname,
+    lastStatusCheck: Date.now(),
+    resetOnExit: config.resetOnExit ?? true,
+    pathPrefix: config.pathPrefix,
+  });
+
+  // Track active exposure
+  activeExposure = {
+    mode: config.mode,
+    port: config.port,
+    hostname,
+    startedAt: Date.now(),
+  };
+
+  log(`[Tailscale Exposure] ${config.mode === 'funnel' ? 'Funnel' : 'Serve'} enabled`);
+  log(`[Tailscale Exposure] HTTPS: ${httpsUrl}`);
+  log(`[Tailscale Exposure] WSS: ${wssUrl}`);
+
+  // Create cleanup function
+  const cleanup = async () => {
+    try {
+      if (config.resetOnExit !== false) {
+        if (config.mode === 'funnel') {
+          await disableTailscaleFunnel();
+        } else if (config.mode === 'serve') {
+          await disableTailscaleServe();
+        }
+        log(`[Tailscale Exposure] ${config.mode} disabled`);
+      }
+    } catch (error: any) {
+      warn(`[Tailscale Exposure] Cleanup error: ${error.message || error}`);
+    } finally {
+      activeExposure = null;
+      TailscaleSettingsManager.updateSettings({ mode: 'off' });
+    }
+  };
+
+  return {
+    success: true,
+    hostname,
+    httpsUrl,
+    wssUrl,
+    cleanup,
+  };
+}
+
+/**
+ * Stop any active Tailscale exposure
+ */
+export async function stopTailscaleExposure(): Promise<void> {
+  if (!activeExposure) {
+    return;
+  }
+
+  try {
+    if (activeExposure.mode === 'funnel') {
+      await disableTailscaleFunnel();
+    } else if (activeExposure.mode === 'serve') {
+      await disableTailscaleServe();
+    }
+    console.log(`[Tailscale Exposure] ${activeExposure.mode} disabled`);
+  } catch (error: any) {
+    console.error('[Tailscale Exposure] Stop error:', error.message || error);
+  } finally {
+    activeExposure = null;
+    TailscaleSettingsManager.updateSettings({ mode: 'off' });
+  }
+}
+
+/**
+ * Check Tailscale availability and status
+ */
+export async function checkTailscaleAvailability(): Promise<{
+  installed: boolean;
+  funnelAvailable: boolean;
+  hostname: string | null;
+}> {
+  const installed = await isTailscaleInstalled();
+
+  if (!installed) {
+    return {
+      installed: false,
+      funnelAvailable: false,
+      hostname: null,
+    };
+  }
+
+  const [funnelAvailable, hostname] = await Promise.all([
+    checkTailscaleFunnelAvailable(),
+    getTailnetHostname(),
+  ]);
+
+  return {
+    installed: true,
+    funnelAvailable,
+    hostname,
+  };
+}

package/src/electron/tailscale/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Tailscale Integration Module
+ *
+ * Provides utilities for Tailscale Serve and Funnel functionality.
+ * - Serve: Share local services to your Tailnet (private network)
+ * - Funnel: Expose local services to the public internet via Tailscale
+ */
+
+export {
+  findTailscaleBinary,
+  getTailscaleBinary,
+  isTailscaleInstalled,
+  getTailscaleStatus,
+  getTailnetHostname,
+  enableTailscaleServe,
+  disableTailscaleServe,
+  enableTailscaleFunnel,
+  disableTailscaleFunnel,
+  checkTailscaleFunnelAvailable,
+} from './tailscale';
+
+export {
+  TailscaleSettingsManager,
+  type TailscaleSettings,
+} from './settings';
+
+export {
+  startTailscaleExposure,
+  stopTailscaleExposure,
+  getExposureStatus,
+  checkTailscaleAvailability,
+  type TailscaleExposureConfig,
+  type TailscaleExposureResult,
+} from './exposure';

package/src/electron/tailscale/settings.ts

@@ -0,0 +1,218 @@
+/**
+ * Tailscale Settings Manager
+ *
+ * Manages Tailscale configuration persistence.
+ * Settings are stored encrypted in the database using SecureSettingsRepository.
+ */
+
+import { app } from 'electron';
+import * as fs from 'fs';
+import * as path from 'path';
+import { SecureSettingsRepository } from '../database/SecureSettingsRepository';
+
+const LEGACY_SETTINGS_FILE = 'tailscale-settings.json';
+
+/**
+ * Tailscale mode options
+ * - off: Tailscale integration disabled
+ * - serve: Expose to Tailnet (private network)
+ * - funnel: Expose to public internet
+ */
+export type TailscaleMode = 'off' | 'serve' | 'funnel';
+
+/**
+ * Tailscale settings interface
+ */
+export interface TailscaleSettings {
+  /** Current mode */
+  mode: TailscaleMode;
+  /** Whether to reset Tailscale config on app exit */
+  resetOnExit: boolean;
+  /** Custom path prefix for the exposed endpoint */
+  pathPrefix?: string;
+  /** Last known hostname */
+  lastHostname?: string;
+  /** Timestamp of last status check */
+  lastStatusCheck?: number;
+}
+
+/**
+ * Default Tailscale settings
+ */
+export const DEFAULT_TAILSCALE_SETTINGS: TailscaleSettings = {
+  mode: 'off',
+  resetOnExit: true,
+};
+
+/**
+ * Tailscale Settings Manager
+ */
+export class TailscaleSettingsManager {
+  private static legacySettingsPath: string;
+  private static cachedSettings: TailscaleSettings | null = null;
+  private static initialized = false;
+  private static migrationCompleted = false;
+
+  /**
+   * Initialize the settings manager (must be called after app is ready)
+   */
+  static initialize(): void {
+    if (this.initialized) return;
+
+    const userDataPath = app.getPath('userData');
+    this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+    this.initialized = true;
+
+    console.log('[Tailscale Settings] Initialized');
+
+    // Migrate from legacy JSON file to encrypted database
+    this.migrateFromLegacyFile();
+  }
+
+  /**
+   * Migrate settings from legacy JSON file to encrypted database
+   */
+  private static migrateFromLegacyFile(): void {
+    if (this.migrationCompleted) return;
+
+    try {
+      if (!SecureSettingsRepository.isInitialized()) {
+        console.log('[Tailscale Settings] SecureSettingsRepository not yet initialized, skipping migration');
+        return;
+      }
+
+      const repository = SecureSettingsRepository.getInstance();
+
+      if (repository.exists('tailscale')) {
+        this.migrationCompleted = true;
+        return;
+      }
+
+      if (!fs.existsSync(this.legacySettingsPath)) {
+        console.log('[Tailscale Settings] No legacy settings file found');
+        this.migrationCompleted = true;
+        return;
+      }
+
+      console.log('[Tailscale Settings] Migrating settings from legacy JSON file to encrypted database...');
+
+      // Create backup before migration
+      const backupPath = this.legacySettingsPath + '.migration-backup';
+      fs.copyFileSync(this.legacySettingsPath, backupPath);
+
+      try {
+        const data = fs.readFileSync(this.legacySettingsPath, 'utf-8');
+        const legacySettings = { ...DEFAULT_TAILSCALE_SETTINGS, ...JSON.parse(data) };
+
+        repository.save('tailscale', legacySettings);
+        console.log('[Tailscale Settings] Settings migrated to encrypted database');
+
+        // Migration successful - delete backup and original
+        fs.unlinkSync(backupPath);
+        fs.unlinkSync(this.legacySettingsPath);
+        console.log('[Tailscale Settings] Migration complete, cleaned up legacy files');
+
+        this.migrationCompleted = true;
+      } catch (migrationError) {
+        console.error('[Tailscale Settings] Migration failed, backup preserved at:', backupPath);
+        throw migrationError;
+      }
+    } catch (error) {
+      console.error('[Tailscale Settings] Migration failed:', error);
+    }
+  }
+
+  /**
+   * Ensure the manager is initialized
+   */
+  private static ensureInitialized(): void {
+    if (!this.initialized) {
+      this.initialize();
+    }
+  }
+
+  /**
+   * Load settings from encrypted database
+   */
+  static loadSettings(): TailscaleSettings {
+    this.ensureInitialized();
+
+    if (this.cachedSettings) {
+      return this.cachedSettings;
+    }
+
+    try {
+      if (SecureSettingsRepository.isInitialized()) {
+        const repository = SecureSettingsRepository.getInstance();
+        const stored = repository.load<TailscaleSettings>('tailscale');
+        if (stored) {
+          const merged: TailscaleSettings = {
+            ...DEFAULT_TAILSCALE_SETTINGS,
+            ...stored,
+          };
+          this.cachedSettings = merged;
+          console.log('[Tailscale Settings] Loaded settings from encrypted database');
+          return this.cachedSettings;
+        }
+      }
+    } catch (error) {
+      console.error('[Tailscale Settings] Failed to load settings:', error);
+    }
+
+    console.log('[Tailscale Settings] No settings found, using defaults');
+    this.cachedSettings = { ...DEFAULT_TAILSCALE_SETTINGS };
+    return this.cachedSettings;
+  }
+
+  /**
+   * Save settings to encrypted database
+   */
+  static saveSettings(settings: TailscaleSettings): void {
+    this.ensureInitialized();
+
+    try {
+      if (!SecureSettingsRepository.isInitialized()) {
+        throw new Error('SecureSettingsRepository not initialized');
+      }
+
+      const repository = SecureSettingsRepository.getInstance();
+      repository.save('tailscale', settings);
+      this.cachedSettings = settings;
+      console.log('[Tailscale Settings] Saved settings to encrypted database');
+    } catch (error) {
+      console.error('[Tailscale Settings] Failed to save settings:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Update settings partially
+   */
+  static updateSettings(updates: Partial<TailscaleSettings>): TailscaleSettings {
+    const settings = this.loadSettings();
+    const updated = { ...settings, ...updates };
+    this.saveSettings(updated);
+    return updated;
+  }
+
+  /**
+   * Set the Tailscale mode
+   */
+  static setMode(mode: TailscaleMode): TailscaleSettings {
+    return this.updateSettings({ mode });
+  }
+
+  /**
+   * Clear the settings cache
+   */
+  static clearCache(): void {
+    this.cachedSettings = null;
+  }
+
+  /**
+   * Get default settings
+   */
+  static getDefaults(): TailscaleSettings {
+    return { ...DEFAULT_TAILSCALE_SETTINGS };
+  }
+}