cowork-os 0.3.21

package/dist/electron/electron/settings/x-manager.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * X/Twitter Settings Manager
+ *
+ * Stores X integration settings in encrypted database.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XSettingsManager = void 0;
+const SecureSettingsRepository_1 = require("../database/SecureSettingsRepository");
+const DEFAULT_SETTINGS = {
+    enabled: false,
+    authMethod: 'browser',
+    cookieSource: ['chrome'],
+    timeoutMs: 20000,
+    cookieTimeoutMs: 20000,
+    quoteDepth: 1,
+};
+class XSettingsManager {
+    static loadSettings() {
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        let settings = { ...DEFAULT_SETTINGS };
+        try {
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('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) {
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                throw new Error('SecureSettingsRepository not initialized');
+            }
+            const repository = SecureSettingsRepository_1.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() {
+        this.cachedSettings = null;
+    }
+}
+exports.XSettingsManager = XSettingsManager;
+XSettingsManager.cachedSettings = null;

package/dist/electron/electron/tailscale/exposure.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Tailscale Exposure Manager
+ *
+ * High-level API for exposing local services via Tailscale Serve or Funnel.
+ * Handles lifecycle management, cleanup, and status tracking.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExposureStatus = getExposureStatus;
+exports.startTailscaleExposure = startTailscaleExposure;
+exports.stopTailscaleExposure = stopTailscaleExposure;
+exports.checkTailscaleAvailability = checkTailscaleAvailability;
+const tailscale_1 = require("./tailscale");
+const settings_1 = require("./settings");
+let activeExposure = null;
+/**
+ * Get current exposure status
+ */
+function getExposureStatus() {
+    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
+ */
+async function startTailscaleExposure(config) {
+    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 (0, tailscale_1.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 (0, tailscale_1.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 (0, tailscale_1.enableTailscaleFunnel)(config.port, config.pathPrefix || '/');
+        }
+        else if (config.mode === 'serve') {
+            enabled = await (0, tailscale_1.enableTailscaleServe)(config.port, config.pathPrefix || '/');
+        }
+    }
+    catch (error) {
+        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 (0, tailscale_1.getTailnetHostname)();
+    if (!hostname) {
+        warn('[Tailscale Exposure] Could not determine Tailnet hostname');
+        // Try to clean up
+        if (config.mode === 'funnel') {
+            await (0, tailscale_1.disableTailscaleFunnel)();
+        }
+        else {
+            await (0, tailscale_1.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
+    settings_1.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 (0, tailscale_1.disableTailscaleFunnel)();
+                }
+                else if (config.mode === 'serve') {
+                    await (0, tailscale_1.disableTailscaleServe)();
+                }
+                log(`[Tailscale Exposure] ${config.mode} disabled`);
+            }
+        }
+        catch (error) {
+            warn(`[Tailscale Exposure] Cleanup error: ${error.message || error}`);
+        }
+        finally {
+            activeExposure = null;
+            settings_1.TailscaleSettingsManager.updateSettings({ mode: 'off' });
+        }
+    };
+    return {
+        success: true,
+        hostname,
+        httpsUrl,
+        wssUrl,
+        cleanup,
+    };
+}
+/**
+ * Stop any active Tailscale exposure
+ */
+async function stopTailscaleExposure() {
+    if (!activeExposure) {
+        return;
+    }
+    try {
+        if (activeExposure.mode === 'funnel') {
+            await (0, tailscale_1.disableTailscaleFunnel)();
+        }
+        else if (activeExposure.mode === 'serve') {
+            await (0, tailscale_1.disableTailscaleServe)();
+        }
+        console.log(`[Tailscale Exposure] ${activeExposure.mode} disabled`);
+    }
+    catch (error) {
+        console.error('[Tailscale Exposure] Stop error:', error.message || error);
+    }
+    finally {
+        activeExposure = null;
+        settings_1.TailscaleSettingsManager.updateSettings({ mode: 'off' });
+    }
+}
+/**
+ * Check Tailscale availability and status
+ */
+async function checkTailscaleAvailability() {
+    const installed = await (0, tailscale_1.isTailscaleInstalled)();
+    if (!installed) {
+        return {
+            installed: false,
+            funnelAvailable: false,
+            hostname: null,
+        };
+    }
+    const [funnelAvailable, hostname] = await Promise.all([
+        (0, tailscale_1.checkTailscaleFunnelAvailable)(),
+        (0, tailscale_1.getTailnetHostname)(),
+    ]);
+    return {
+        installed: true,
+        funnelAvailable,
+        hostname,
+    };
+}

package/dist/electron/electron/tailscale/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTailscaleAvailability = exports.getExposureStatus = exports.stopTailscaleExposure = exports.startTailscaleExposure = exports.TailscaleSettingsManager = exports.checkTailscaleFunnelAvailable = exports.disableTailscaleFunnel = exports.enableTailscaleFunnel = exports.disableTailscaleServe = exports.enableTailscaleServe = exports.getTailnetHostname = exports.getTailscaleStatus = exports.isTailscaleInstalled = exports.getTailscaleBinary = exports.findTailscaleBinary = void 0;
+var tailscale_1 = require("./tailscale");
+Object.defineProperty(exports, "findTailscaleBinary", { enumerable: true, get: function () { return tailscale_1.findTailscaleBinary; } });
+Object.defineProperty(exports, "getTailscaleBinary", { enumerable: true, get: function () { return tailscale_1.getTailscaleBinary; } });
+Object.defineProperty(exports, "isTailscaleInstalled", { enumerable: true, get: function () { return tailscale_1.isTailscaleInstalled; } });
+Object.defineProperty(exports, "getTailscaleStatus", { enumerable: true, get: function () { return tailscale_1.getTailscaleStatus; } });
+Object.defineProperty(exports, "getTailnetHostname", { enumerable: true, get: function () { return tailscale_1.getTailnetHostname; } });
+Object.defineProperty(exports, "enableTailscaleServe", { enumerable: true, get: function () { return tailscale_1.enableTailscaleServe; } });
+Object.defineProperty(exports, "disableTailscaleServe", { enumerable: true, get: function () { return tailscale_1.disableTailscaleServe; } });
+Object.defineProperty(exports, "enableTailscaleFunnel", { enumerable: true, get: function () { return tailscale_1.enableTailscaleFunnel; } });
+Object.defineProperty(exports, "disableTailscaleFunnel", { enumerable: true, get: function () { return tailscale_1.disableTailscaleFunnel; } });
+Object.defineProperty(exports, "checkTailscaleFunnelAvailable", { enumerable: true, get: function () { return tailscale_1.checkTailscaleFunnelAvailable; } });
+var settings_1 = require("./settings");
+Object.defineProperty(exports, "TailscaleSettingsManager", { enumerable: true, get: function () { return settings_1.TailscaleSettingsManager; } });
+var exposure_1 = require("./exposure");
+Object.defineProperty(exports, "startTailscaleExposure", { enumerable: true, get: function () { return exposure_1.startTailscaleExposure; } });
+Object.defineProperty(exports, "stopTailscaleExposure", { enumerable: true, get: function () { return exposure_1.stopTailscaleExposure; } });
+Object.defineProperty(exports, "getExposureStatus", { enumerable: true, get: function () { return exposure_1.getExposureStatus; } });
+Object.defineProperty(exports, "checkTailscaleAvailability", { enumerable: true, get: function () { return exposure_1.checkTailscaleAvailability; } });

package/dist/electron/electron/tailscale/settings.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Tailscale Settings Manager
+ *
+ * Manages Tailscale configuration persistence.
+ * Settings are stored encrypted in the database using SecureSettingsRepository.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TailscaleSettingsManager = exports.DEFAULT_TAILSCALE_SETTINGS = void 0;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SecureSettingsRepository_1 = require("../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'tailscale-settings.json';
+/**
+ * Default Tailscale settings
+ */
+exports.DEFAULT_TAILSCALE_SETTINGS = {
+    mode: 'off',
+    resetOnExit: true,
+};
+/**
+ * Tailscale Settings Manager
+ */
+class TailscaleSettingsManager {
+    /**
+     * Initialize the settings manager (must be called after app is ready)
+     */
+    static initialize() {
+        if (this.initialized)
+            return;
+        const userDataPath = electron_1.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
+     */
+    static migrateFromLegacyFile() {
+        if (this.migrationCompleted)
+            return;
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                console.log('[Tailscale Settings] SecureSettingsRepository not yet initialized, skipping migration');
+                return;
+            }
+            const repository = SecureSettingsRepository_1.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 = { ...exports.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
+     */
+    static ensureInitialized() {
+        if (!this.initialized) {
+            this.initialize();
+        }
+    }
+    /**
+     * Load settings from encrypted database
+     */
+    static loadSettings() {
+        this.ensureInitialized();
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        try {
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('tailscale');
+                if (stored) {
+                    const merged = {
+                        ...exports.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 = { ...exports.DEFAULT_TAILSCALE_SETTINGS };
+        return this.cachedSettings;
+    }
+    /**
+     * Save settings to encrypted database
+     */
+    static saveSettings(settings) {
+        this.ensureInitialized();
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                throw new Error('SecureSettingsRepository not initialized');
+            }
+            const repository = SecureSettingsRepository_1.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) {
+        const settings = this.loadSettings();
+        const updated = { ...settings, ...updates };
+        this.saveSettings(updated);
+        return updated;
+    }
+    /**
+     * Set the Tailscale mode
+     */
+    static setMode(mode) {
+        return this.updateSettings({ mode });
+    }
+    /**
+     * Clear the settings cache
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+    /**
+     * Get default settings
+     */
+    static getDefaults() {
+        return { ...exports.DEFAULT_TAILSCALE_SETTINGS };
+    }
+}
+exports.TailscaleSettingsManager = TailscaleSettingsManager;
+TailscaleSettingsManager.cachedSettings = null;
+TailscaleSettingsManager.initialized = false;
+TailscaleSettingsManager.migrationCompleted = false;