listener-ai 2.6.0 → 2.7.1

package/dist/configService.js

@@ -36,6 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigService = exports.DEFAULT_SUMMARY_PROMPT = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const aiProvider_1 = require("./aiProvider");
+const codexOAuth_1 = require("./codexOAuth");
 exports.DEFAULT_SUMMARY_PROMPT = `Based on this meeting transcript, provide:
 
 1. A concise meeting title in Korean (10-20 characters that captures the main topic)
@@ -58,6 +60,12 @@ class ConfigService {
     }
     constructor(dataPath) {
         this.config = {};
+        // Keys this process has explicitly modified since the last successful save.
+        // saveConfig() re-reads the file on every write and applies only these keys on
+        // top of disk state, so a concurrent process (Electron app + CLI hitting the
+        // same config.json during OAuth refresh, etc.) cannot clobber unrelated keys.
+        this.dirtyKeys = new Set();
+        this.envProviderWarned = false;
         let userDataPath;
         if (dataPath) {
             userDataPath = dataPath;
@@ -72,6 +80,31 @@ class ConfigService {
         }
         this.configPath = path.join(userDataPath, 'config.json');
         this.loadConfig();
+        this.migrateLegacyDefaults();
+    }
+    // One-shot upgrade hook for keys that older versions auto-persisted from
+    // their then-current default. The settings modal in those versions wrote
+    // back the full payload on save -- including fields the user never
+    // touched -- so the next default change can't reach existing installs.
+    // Today's case: `codexTranscriptionModel: 'gpt-4o-transcribe'` was the
+    // legacy default before gpt-4o-transcribe-diarize shipped; clearing it
+    // here lets `getCodexTranscriptionModel()` return the current default
+    // (diarize) without forcing every user to manually unset it.
+    //
+    // The marker semantics are "we've considered migrating this user" --
+    // it lands on EVERY install on first launch, not just the ones we
+    // actually had to migrate. That way if a user later opts back into
+    // `gpt-4o-transcribe` deliberately (e.g. for glossary support), the
+    // next ConfigService construction sees the marker and skips the
+    // migration entirely instead of clobbering their explicit choice.
+    migrateLegacyDefaults() {
+        if (this.config.codexTranscriptionMigratedToDiarize)
+            return;
+        if (this.config.codexTranscriptionModel === 'gpt-4o-transcribe') {
+            this.setKey('codexTranscriptionModel', undefined);
+        }
+        this.setKey('codexTranscriptionMigratedToDiarize', true);
+        this.saveConfig();
     }
     loadConfig() {
         try {
@@ -85,10 +118,53 @@ class ConfigService {
             this.config = {};
         }
     }
+    setKey(key, value) {
+        if (value === undefined) {
+            delete this.config[key];
+        }
+        else {
+            this.config[key] = value;
+        }
+        this.dirtyKeys.add(key);
+    }
     saveConfig() {
         try {
             fs.mkdirSync(path.dirname(this.configPath), { recursive: true });
-            fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+            let merged = {};
+            if (fs.existsSync(this.configPath)) {
+                try {
+                    merged = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+                }
+                catch {
+                    // ignore corrupt disk file; treat as empty and let our writes recover it
+                }
+            }
+            for (const key of this.dirtyKeys) {
+                const value = this.config[key];
+                if (value === undefined) {
+                    delete merged[key];
+                }
+                else {
+                    merged[key] = value;
+                }
+            }
+            // 0o600 keeps API keys + OAuth refresh tokens off other users on shared
+            // machines. writeFileSync's `mode` option only applies when the OS
+            // creates the file -- existing config.json from prior versions keeps its
+            // umask-derived mode (typically 0o644). Explicitly chmod after writing
+            // so upgrade paths get tightened too. chmodSync is a no-op for the bits
+            // that matter on Windows but doesn't throw, so the call is unconditional.
+            fs.writeFileSync(this.configPath, JSON.stringify(merged, null, 2), { mode: 0o600 });
+            try {
+                fs.chmodSync(this.configPath, 0o600);
+            }
+            catch (chmodError) {
+                // Don't fail the save if chmod fails (e.g. exotic filesystem) -- the
+                // write succeeded and the override above already covers fresh files.
+                console.warn('Could not chmod config.json to 0o600:', chmodError);
+            }
+            this.config = merged;
+            this.dirtyKeys.clear();
         }
         catch (error) {
             console.error('Error saving config:', error);
@@ -98,30 +174,82 @@ class ConfigService {
         return this.config.geminiApiKey || process.env.GEMINI_API_KEY;
     }
     setGeminiApiKey(apiKey) {
-        this.config.geminiApiKey = apiKey;
+        this.setKey('geminiApiKey', apiKey);
         this.saveConfig();
     }
+    getAiProvider() {
+        const envProvider = (0, aiProvider_1.normalizeAiProvider)(process.env.LISTENER_AI_PROVIDER);
+        if (envProvider) {
+            const configured = (0, aiProvider_1.normalizeAiProvider)(this.config.aiProvider);
+            if (configured && configured !== envProvider && !this.envProviderWarned) {
+                console.warn(`LISTENER_AI_PROVIDER=${envProvider} overrides configured aiProvider=${configured}.`);
+                this.envProviderWarned = true;
+            }
+            return envProvider;
+        }
+        const configured = (0, aiProvider_1.normalizeAiProvider)(this.config.aiProvider);
+        if (configured)
+            return configured;
+        if (!this.getGeminiApiKey() && this.hasCodexOAuth())
+            return 'codex';
+        return 'gemini';
+    }
+    setAiProvider(provider) {
+        this.setKey('aiProvider', provider);
+        this.saveConfig();
+    }
+    // Returns the active OAuth credentials whether they came from config or env.
+    // Callers that intend to PERSIST refreshed credentials must additionally check
+    // `hasStoredCodexOAuth()` and skip the persistence callback when source is env --
+    // otherwise a normal token refresh writes env-sourced tokens to plaintext disk.
+    getCodexOAuth() {
+        return this.config.codexOAuth || (0, codexOAuth_1.getCodexOAuthEnvCredentials)();
+    }
+    // True only when credentials are stored in config.json. Env-only credentials
+    // return false here. Use this to gate `onCodexOAuthUpdate` persistence callbacks.
+    hasStoredCodexOAuth() {
+        const c = this.config.codexOAuth;
+        return !!(c?.access && c.refresh && Number.isFinite(c.expires));
+    }
+    setCodexOAuth(credentials) {
+        this.setKey('codexOAuth', credentials);
+        this.saveConfig();
+    }
+    clearCodexOAuth() {
+        this.setKey('codexOAuth', undefined);
+        this.saveConfig();
+    }
+    hasCodexOAuth() {
+        return (0, codexOAuth_1.hasCodexOAuthEnvCredentials)() || this.hasStoredCodexOAuth();
+    }
+    hasAiAuth() {
+        const provider = this.getAiProvider();
+        if (provider === 'codex')
+            return this.hasCodexOAuth();
+        return !!this.getGeminiApiKey();
+    }
     getNotionApiKey() {
         return this.config.notionApiKey || process.env.NOTION_API_KEY;
     }
     setNotionApiKey(apiKey) {
-        this.config.notionApiKey = apiKey;
+        this.setKey('notionApiKey', apiKey);
         this.saveConfig();
     }
     getNotionDatabaseId() {
         return this.config.notionDatabaseId || process.env.NOTION_DATABASE_ID;
     }
     setNotionDatabaseId(databaseId) {
-        this.config.notionDatabaseId = databaseId;
+        this.setKey('notionDatabaseId', databaseId);
         this.saveConfig();
     }
     hasRequiredConfig() {
-        return !!this.getGeminiApiKey() && !!this.getNotionApiKey() && !!this.getNotionDatabaseId();
+        return this.hasAiAuth() && !!this.getNotionApiKey() && !!this.getNotionDatabaseId();
     }
     getMissingConfigs() {
         const missing = [];
-        if (!this.getGeminiApiKey())
-            missing.push('Gemini API Key');
+        if (!this.hasAiAuth()) {
+            missing.push(this.getAiProvider() === 'codex' ? 'Codex OAuth sign-in' : 'Gemini API Key');
+        }
         if (!this.getNotionApiKey())
             missing.push('Notion Integration Token');
         if (!this.getNotionDatabaseId())
@@ -132,7 +260,7 @@ class ConfigService {
         return this.config.autoMode || false;
     }
     setAutoMode(enabled) {
-        this.config.autoMode = enabled;
+        this.setKey('autoMode', enabled);
         this.saveConfig();
     }
     getMeetingDetection() {
@@ -142,63 +270,77 @@ class ConfigService {
         return this.config.displayDetection || false;
     }
     setDisplayDetection(enabled) {
-        this.config.displayDetection = enabled;
+        this.setKey('displayDetection', enabled);
         this.saveConfig();
     }
     getGlobalShortcut() {
         return this.config.globalShortcut || 'CommandOrControl+Shift+L';
     }
     setGlobalShortcut(shortcut) {
-        this.config.globalShortcut = shortcut;
+        this.setKey('globalShortcut', shortcut);
         this.saveConfig();
     }
     getKnownWords() {
         return this.config.knownWords || [];
     }
     setKnownWords(words) {
-        this.config.knownWords = words;
+        this.setKey('knownWords', words);
         this.saveConfig();
     }
     getGeminiModel() {
-        return this.config.geminiModel || 'gemini-2.5-pro';
+        return this.config.geminiModel || aiProvider_1.DEFAULT_GEMINI_MODEL;
     }
     setGeminiModel(model) {
-        this.config.geminiModel = model;
+        this.setKey('geminiModel', model);
         this.saveConfig();
     }
     getGeminiFlashModel() {
-        return this.config.geminiFlashModel || 'gemini-2.5-flash';
+        return this.config.geminiFlashModel || aiProvider_1.DEFAULT_GEMINI_FLASH_MODEL;
     }
     setGeminiFlashModel(model) {
-        this.config.geminiFlashModel = model;
+        this.setKey('geminiFlashModel', model);
+        this.saveConfig();
+    }
+    getCodexModel() {
+        return this.config.codexModel || aiProvider_1.DEFAULT_CODEX_MODEL;
+    }
+    setCodexModel(model) {
+        this.setKey('codexModel', model);
+        this.saveConfig();
+    }
+    getCodexTranscriptionModel() {
+        return this.config.codexTranscriptionModel || aiProvider_1.DEFAULT_CODEX_TRANSCRIPTION_MODEL;
+    }
+    setCodexTranscriptionModel(model) {
+        this.setKey('codexTranscriptionModel', model);
         this.saveConfig();
     }
     getMaxRecordingMinutes() {
         return this.config.maxRecordingMinutes || 0;
     }
     setMaxRecordingMinutes(minutes) {
-        this.config.maxRecordingMinutes = Math.max(0, Math.floor(minutes));
+        this.setKey('maxRecordingMinutes', Math.max(0, Math.floor(minutes)));
         this.saveConfig();
     }
     getRecordingReminderMinutes() {
         return this.config.recordingReminderMinutes || 0;
     }
     setRecordingReminderMinutes(minutes) {
-        this.config.recordingReminderMinutes = Math.max(0, Math.floor(minutes));
+        this.setKey('recordingReminderMinutes', Math.max(0, Math.floor(minutes)));
         this.saveConfig();
     }
     getMinRecordingSeconds() {
         return this.config.minRecordingSeconds || 0;
     }
     setMinRecordingSeconds(seconds) {
-        this.config.minRecordingSeconds = Math.max(0, Math.floor(seconds));
+        this.setKey('minRecordingSeconds', Math.max(0, Math.floor(seconds)));
         this.saveConfig();
     }
     getRecordSystemAudio() {
         return this.config.recordSystemAudio || false;
     }
     setRecordSystemAudio(enabled) {
-        this.config.recordSystemAudio = enabled;
+        this.setKey('recordSystemAudio', enabled);
         this.saveConfig();
     }
     getAudioDeviceId() {
@@ -208,47 +350,51 @@ class ConfigService {
         return this.config.lastSeenVersion;
     }
     setLastSeenVersion(version) {
-        this.config.lastSeenVersion = version;
+        this.setKey('lastSeenVersion', version);
         this.saveConfig();
     }
     getSummaryPrompt() {
         return this.config.summaryPrompt || exports.DEFAULT_SUMMARY_PROMPT;
     }
     setSummaryPrompt(prompt) {
-        this.config.summaryPrompt = prompt;
+        this.setKey('summaryPrompt', prompt);
         this.saveConfig();
     }
     getSlackWebhookUrl() {
         return this.config.slackWebhookUrl || process.env.SLACK_WEBHOOK_URL;
     }
     setSlackWebhookUrl(url) {
-        this.config.slackWebhookUrl = url;
+        this.setKey('slackWebhookUrl', url);
         this.saveConfig();
     }
     getSlackAutoShare() {
         return this.config.slackAutoShare || false;
     }
     setSlackAutoShare(enabled) {
-        this.config.slackAutoShare = enabled;
+        this.setKey('slackAutoShare', enabled);
         this.saveConfig();
     }
     updateConfig(partial) {
         for (const [key, value] of Object.entries(partial)) {
             if (value !== undefined) {
-                this.config[key] = value;
+                this.setKey(key, value);
             }
         }
         this.saveConfig();
     }
     unsetKey(key) {
-        delete this.config[key];
+        this.setKey(key, undefined);
         this.saveConfig();
     }
     getAllConfig() {
         return {
+            aiProvider: this.getAiProvider(),
             geminiApiKey: this.getGeminiApiKey(),
             geminiModel: this.getGeminiModel(),
             geminiFlashModel: this.getGeminiFlashModel(),
+            codexModel: this.getCodexModel(),
+            codexTranscriptionModel: this.getCodexTranscriptionModel(),
+            codexOAuthConfigured: this.hasCodexOAuth(),
             notionApiKey: this.getNotionApiKey(),
             notionDatabaseId: this.getNotionDatabaseId(),
             autoMode: this.getAutoMode(),

package/dist/dataPath.js

@@ -34,10 +34,27 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDataPath = getDataPath;
+const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-// Must match productName in package.json (used by Electron for app.getPath('userData'))
-const APP_NAME = 'Listener.AI';
+const APP_NAME = 'listener-ai';
+const LEGACY_APP_NAME = 'Listener.AI';
+function platformDataPath(appName) {
+    switch (process.platform) {
+        case 'darwin':
+            return path.join(os.homedir(), 'Library', 'Application Support', appName);
+        case 'win32':
+            return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), appName);
+        default:
+            return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), appName);
+    }
+}
+function hasUserData(dataPath) {
+    return (fs.existsSync(path.join(dataPath, 'config.json')) ||
+        fs.existsSync(path.join(dataPath, 'transcriptions')) ||
+        fs.existsSync(path.join(dataPath, 'recordings')) ||
+        fs.existsSync(path.join(dataPath, 'metadata')));
+}
 function getDataPath() {
     // Test escape hatch: integration tests set this to a temp dir to avoid
     // touching the user's real data. Gated on NODE_ENV=test so a stray
@@ -46,12 +63,15 @@ function getDataPath() {
     if (process.env.LISTENER_DATA_PATH && process.env.NODE_ENV === 'test') {
         return process.env.LISTENER_DATA_PATH;
     }
-    switch (process.platform) {
-        case 'darwin':
-            return path.join(os.homedir(), 'Library', 'Application Support', APP_NAME);
-        case 'win32':
-            return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), APP_NAME);
-        default:
-            return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), APP_NAME);
-    }
+    const currentPath = platformDataPath(APP_NAME);
+    const legacyPath = platformDataPath(LEGACY_APP_NAME);
+    if (hasUserData(currentPath))
+        return currentPath;
+    if (hasUserData(legacyPath))
+        return legacyPath;
+    if (fs.existsSync(currentPath))
+        return currentPath;
+    if (fs.existsSync(legacyPath))
+        return legacyPath;
+    return currentPath;
 }

package/dist/esmImport.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importEsm = void 0;
+// Dynamic ESM import that survives tsc's CJS rewrite. With
+// `module: "commonjs"` in tsconfig.json, a plain `import('pkg')` compiles to
+// `Promise.resolve().then(() => require('pkg'))`, which fails on ESM-only
+// packages with ERR_REQUIRE_ESM. `Function(...)` evaluates at runtime, so the
+// literal `import()` survives untouched and stays an actual dynamic import.
+//
+// Use this for any ESM-only dependency (`@earendil-works/pi-ai`,
+// `@earendil-works/pi-ai/oauth`).
+exports.importEsm = (() => {
+    const fn = new Function('specifier', 'return import(specifier)');
+    return fn;
+})();