edsger 0.33.4 → 0.33.6

package/dist/auth/env-store.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Env Store - Persistent environment variable storage for the Edsger CLI
+ *
+ * Stores user-configured environment variables in ~/.edsger/env.json
+ * These are loaded into process.env at CLI startup, with lower priority
+ * than real environment variables.
+ */
+/**
+ * Load all stored env vars from ~/.edsger/env.json
+ */
+export declare function loadEnvStore(): Record<string, string>;
+/**
+ * Set a single environment variable
+ */
+export declare function setEnvVar(key: string, value: string): void;
+/**
+ * Get a single environment variable from the store
+ */
+export declare function getEnvVar(key: string): string | undefined;
+/**
+ * Remove a single environment variable from the store
+ */
+export declare function unsetEnvVar(key: string): boolean;
+/**
+ * List all stored environment variables.
+ * Secret values are masked unless showSecrets is true.
+ */
+export declare function listEnvVars(showSecrets?: boolean): Array<{
+    key: string;
+    value: string;
+}>;
+/**
+ * Apply stored env vars to process.env.
+ * Only sets vars that are NOT already defined in process.env
+ * (real env vars take precedence).
+ */
+export declare function applyEnvStore(): void;
+/**
+ * Get the env file path (for display purposes)
+ */
+export declare function getEnvFilePath(): string;

package/dist/auth/env-store.js

@@ -0,0 +1,124 @@
+/**
+ * Env Store - Persistent environment variable storage for the Edsger CLI
+ *
+ * Stores user-configured environment variables in ~/.edsger/env.json
+ * These are loaded into process.env at CLI startup, with lower priority
+ * than real environment variables.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const EDSGER_DIR = join(homedir(), '.edsger');
+const ENV_FILE = join(EDSGER_DIR, 'env.json');
+/** Known keys that contain secrets and should be masked in display */
+const SECRET_KEYS = new Set([
+    'ELEVENLABS_API_KEY',
+    'DEEPGRAM_API_KEY',
+    'OPENAI_API_KEY',
+    'CLAUDE_API_KEY',
+    'GEMINI_API_KEY',
+    'EDSGER_MCP_TOKEN',
+    'GITHUB_TOKEN',
+]);
+/**
+ * Ensure the ~/.edsger directory exists
+ */
+function ensureDir() {
+    if (!existsSync(EDSGER_DIR)) {
+        mkdirSync(EDSGER_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Load all stored env vars from ~/.edsger/env.json
+ */
+export function loadEnvStore() {
+    try {
+        if (!existsSync(ENV_FILE)) {
+            return {};
+        }
+        const content = readFileSync(ENV_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Save env vars to ~/.edsger/env.json
+ */
+function saveEnvStore(env) {
+    ensureDir();
+    writeFileSync(ENV_FILE, JSON.stringify(env, null, 2), 'utf-8');
+    try {
+        chmodSync(ENV_FILE, 0o600);
+    }
+    catch {
+        // chmod may fail on Windows
+    }
+}
+/**
+ * Set a single environment variable
+ */
+export function setEnvVar(key, value) {
+    const env = loadEnvStore();
+    env[key] = value;
+    saveEnvStore(env);
+}
+/**
+ * Get a single environment variable from the store
+ */
+export function getEnvVar(key) {
+    const env = loadEnvStore();
+    return env[key];
+}
+/**
+ * Remove a single environment variable from the store
+ */
+export function unsetEnvVar(key) {
+    const env = loadEnvStore();
+    if (!(key in env)) {
+        return false;
+    }
+    delete env[key];
+    saveEnvStore(env);
+    return true;
+}
+/**
+ * List all stored environment variables.
+ * Secret values are masked unless showSecrets is true.
+ */
+export function listEnvVars(showSecrets = false) {
+    const env = loadEnvStore();
+    return Object.entries(env).map(([key, value]) => ({
+        key,
+        value: !showSecrets && SECRET_KEYS.has(key) ? maskValue(value) : value,
+    }));
+}
+/**
+ * Apply stored env vars to process.env.
+ * Only sets vars that are NOT already defined in process.env
+ * (real env vars take precedence).
+ */
+export function applyEnvStore() {
+    const env = loadEnvStore();
+    for (const [key, value] of Object.entries(env)) {
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+}
+/**
+ * Get the env file path (for display purposes)
+ */
+export function getEnvFilePath() {
+    return ENV_FILE;
+}
+/**
+ * Mask a secret value for display, showing first 4 and last 4 chars
+ */
+function maskValue(value) {
+    if (value.length <= 12) {
+        return '****';
+    }
+    return `${value.substring(0, 4)}...${value.substring(value.length - 4)}`;
+}

package/dist/commands/config/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * edsger config set KEY=VALUE
+ */
+export declare function runConfigSet(pair: string): void;
+/**
+ * edsger config get KEY
+ */
+export declare function runConfigGet(key: string): void;
+/**
+ * edsger config unset KEY
+ */
+export declare function runConfigUnset(key: string): void;
+/**
+ * edsger config list
+ */
+export declare function runConfigList(): void;

package/dist/commands/config/index.js

@@ -0,0 +1,60 @@
+import { logInfo, logSuccess, logError, logWarning, logRaw } from '../../utils/logger.js';
+import { setEnvVar, getEnvVar, unsetEnvVar, listEnvVars, getEnvFilePath, } from '../../auth/env-store.js';
+/**
+ * edsger config set KEY=VALUE
+ */
+export function runConfigSet(pair) {
+    const eqIndex = pair.indexOf('=');
+    if (eqIndex === -1) {
+        logError('Invalid format. Use: edsger config set KEY=VALUE');
+        process.exit(1);
+    }
+    const key = pair.substring(0, eqIndex).trim();
+    const value = pair.substring(eqIndex + 1).trim();
+    if (!key) {
+        logError('Key cannot be empty.');
+        process.exit(1);
+    }
+    setEnvVar(key, value);
+    logSuccess(`${key} saved to ${getEnvFilePath()}`);
+}
+/**
+ * edsger config get KEY
+ */
+export function runConfigGet(key) {
+    const value = getEnvVar(key);
+    if (value === undefined) {
+        logWarning(`${key} is not set.`);
+    }
+    else {
+        logRaw(value);
+    }
+}
+/**
+ * edsger config unset KEY
+ */
+export function runConfigUnset(key) {
+    const removed = unsetEnvVar(key);
+    if (removed) {
+        logSuccess(`${key} removed.`);
+    }
+    else {
+        logWarning(`${key} was not set.`);
+    }
+}
+/**
+ * edsger config list
+ */
+export function runConfigList() {
+    const vars = listEnvVars();
+    if (vars.length === 0) {
+        logInfo('No environment variables configured.');
+        logInfo(`Run \`edsger config set KEY=VALUE\` to add one.`);
+        return;
+    }
+    logInfo(`Stored environment variables (${getEnvFilePath()}):`);
+    logRaw('');
+    for (const { key, value } of vars) {
+        logRaw(`  ${key}=${value}`);
+    }
+}

package/dist/commands/growth-analysis/index.js

@@ -1,6 +1,7 @@
 import { logInfo, logError, logSuccess } from '../../utils/logger.js';
 import { validateConfiguration } from '../../utils/validation.js';
 import { analyseGrowth, } from '../../phases/growth-analysis/index.js';
+import { checkVideoDependencies } from '../../services/video/index.js';
 /**
  * Run AI-powered growth analysis for a product.
  * Analyzes the product, reviews previous campaigns, and generates
@@ -11,6 +12,19 @@ export const runGrowthAnalysis = async (options) => {
     if (!productId) {
         throw new Error('Product ID is required for growth analysis');
     }
+    // Pre-flight checks: ensure TTS key and video dependencies are available
+    if (!process.env.ELEVENLABS_API_KEY && !process.env.DEEPGRAM_API_KEY) {
+        throw new Error('TTS API key required for growth analysis.\n' +
+            'Set one of the following environment variables:\n' +
+            '  ELEVENLABS_API_KEY  (primary)\n' +
+            '  DEEPGRAM_API_KEY    (alternative)\n\n' +
+            'Get a key at https://elevenlabs.io or https://deepgram.com');
+    }
+    const missingDeps = await checkVideoDependencies();
+    if (missingDeps.length > 0) {
+        throw new Error('Missing video dependencies:\n' +
+            missingDeps.map((d) => `  - ${d}`).join('\n'));
+    }
     const config = validateConfiguration(options);
     logInfo(`Starting growth analysis for product: ${productId}`);
     try {

package/dist/index.js

@@ -15,14 +15,19 @@ import { runAnalyzeLogs } from './commands/analyze-logs/index.js';
 import { runAgentWorkflow } from './commands/agent-workflow/index.js';
 import { runTaskWorker } from './commands/task-worker/index.js';
 import { runLogin, runLogout, runStatus } from './auth/login.js';
+import { applyEnvStore } from './auth/env-store.js';
+import { runConfigSet, runConfigGet, runConfigUnset, runConfigList, } from './commands/config/index.js';
 // Get package.json version dynamically
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
 const version = packageJson.version;
-// Load environment variables from .env file
-// Load from current working directory (where the command is run)
+// Load environment variables (each only sets vars not already defined):
+// 1. Real environment variables (highest priority - already in process.env)
+// 2. .env file in cwd (medium priority - loaded first)
+// 3. ~/.edsger/env.json (lowest priority - loaded last)
 dotenvConfig({ path: join(process.cwd(), '.env') });
+applyEnvStore();
 const program = new Command();
 program
     .name('edsger')
@@ -74,6 +79,36 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger config set/get/list/unset
+// ============================================================
+const configCmd = program
+    .command('config')
+    .description('Manage CLI environment variables (stored in ~/.edsger/env.json)');
+configCmd
+    .command('set <key=value>')
+    .description('Set an environment variable (e.g., edsger config set ELEVENLABS_API_KEY=sk-xxx)')
+    .action((pair) => {
+    runConfigSet(pair);
+});
+configCmd
+    .command('get <key>')
+    .description('Get the value of a stored environment variable')
+    .action((key) => {
+    runConfigGet(key);
+});
+configCmd
+    .command('unset <key>')
+    .description('Remove a stored environment variable')
+    .action((key) => {
+    runConfigUnset(key);
+});
+configCmd
+    .command('list')
+    .description('List all stored environment variables')
+    .action(() => {
+    runConfigList();
+});
+// ============================================================
 // Subcommand: edsger growth <productId>
 // ============================================================
 program

package/dist/phases/app-store-generation/agent.js

@@ -41,6 +41,8 @@ async function* prompt(analysisPrompt) {
 export async function executeAppStoreQuery(currentPrompt, systemPrompt, config, verbose, cwd) {
     let lastAssistantResponse = '';
     let structuredResult = null;
+    let turnCount = 0;
+    logInfo('Connecting to AI agent...');
     for await (const message of query({
         prompt: prompt(currentPrompt),
         options: {
@@ -59,19 +61,21 @@ export async function executeAppStoreQuery(currentPrompt, systemPrompt, config,
             logInfo(`Received message type: ${message.type}`);
         }
         if (message.type === 'assistant' && message.message?.content) {
+            turnCount++;
             for (const content of message.message.content) {
                 if (content.type === 'text') {
                     lastAssistantResponse += content.text + '\n';
                     logDebug(`${content.text}`, verbose);
                 }
                 else if (content.type === 'tool_use') {
-                    logDebug(`${content.name}: ${content.input.description || 'Running...'}`, verbose);
+                    const desc = content.input?.description || content.input?.command || 'Running...';
+                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
                 }
             }
         }
         if (message.type === 'result') {
             if (message.subtype === 'success') {
-                logInfo('\nApp store generation completed, parsing results...');
+                logInfo(`\nAI generation completed after ${turnCount} turns, parsing results...`);
                 const responseText = message.result || lastAssistantResponse;
                 const parsed = parseAppStoreResult(responseText);
                 if (parsed.error) {

package/dist/phases/growth-analysis/agent.js

@@ -41,6 +41,8 @@ async function* prompt(analysisPrompt) {
 export async function executeGrowthAnalysisQuery(currentPrompt, systemPrompt, config, verbose, cwd) {
     let lastAssistantResponse = '';
     let structuredResult = null;
+    let turnCount = 0;
+    logInfo('Connecting to AI agent...');
     for await (const message of query({
         prompt: prompt(currentPrompt),
         options: {
@@ -59,19 +61,21 @@ export async function executeGrowthAnalysisQuery(currentPrompt, systemPrompt, co
             logInfo(`Received message type: ${message.type}`);
         }
         if (message.type === 'assistant' && message.message?.content) {
+            turnCount++;
             for (const content of message.message.content) {
                 if (content.type === 'text') {
                     lastAssistantResponse += content.text + '\n';
                     logDebug(`${content.text}`, verbose);
                 }
                 else if (content.type === 'tool_use') {
-                    logDebug(`${content.name}: ${content.input.description || 'Running...'}`, verbose);
+                    const desc = content.input?.description || content.input?.command || 'Running...';
+                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
                 }
             }
         }
         if (message.type === 'result') {
             if (message.subtype === 'success') {
-                logInfo('\nGrowth analysis completed, parsing results...');
+                logInfo(`\nGrowth analysis completed after ${turnCount} turns, parsing results...`);
                 const responseText = message.result || lastAssistantResponse;
                 const parsed = parseGrowthResult(responseText);
                 if (parsed.error) {

package/dist/phases/growth-analysis/index.js

@@ -5,7 +5,7 @@ import { executeGrowthAnalysisQuery } from './agent.js';
 import { saveGrowthAnalysis } from '../../api/growth.js';
 import { getGitHubConfigByProduct } from '../../api/github.js';
 import { ensureWorkspaceDir, cloneFeatureRepo, } from '../../workspace/workspace-manager.js';
-import { generateGrowthVideo, checkVideoDependencies, } from '../../services/video/index.js';
+import { generateGrowthVideo, } from '../../services/video/index.js';
 /**
  * Extract video plans from AI-generated content suggestions
  */
@@ -98,56 +98,44 @@ export const analyseGrowth = async (options, config) => {
         const videoResults = new Map();
         if (videoPlans.length > 0) {
             logInfo(`\nFound ${videoPlans.length} content suggestion(s) with video plans`);
-            // Check video dependencies once
-            const missingDeps = await checkVideoDependencies();
-            const hasTtsKey = !!(process.env.ELEVENLABS_API_KEY || process.env.DEEPGRAM_API_KEY);
-            if (missingDeps.length > 0) {
-                logWarning(`Skipping video generation - missing dependencies:\n${missingDeps.map((d) => `  - ${d}`).join('\n')}`);
+            const analysisId = savedAnalysis?.id || productId;
+            // Log all planned videos
+            for (const { index, plan } of videoPlans) {
+                const suggestion = contentSuggestions[index];
+                logInfo(`\nVideo planned for: "${suggestion.title}" [${suggestion.channel}]`);
+                logInfo(`  Reason: ${plan.videoReason}`);
+                logInfo(`  Scenes: ${plan.scenes.length}`);
             }
-            else if (!hasTtsKey) {
-                logWarning('Skipping video generation - no TTS API key configured.\n' +
-                    '  Set ELEVENLABS_API_KEY or DEEPGRAM_API_KEY environment variable.');
-            }
-            else {
-                const analysisId = savedAnalysis?.id || productId;
-                // Log all planned videos
-                for (const { index, plan } of videoPlans) {
+            // Generate videos with concurrency limit (max 2 simultaneous)
+            const MAX_CONCURRENT_VIDEOS = 2;
+            logInfo(`\nGenerating ${videoPlans.length} video(s) (max ${MAX_CONCURRENT_VIDEOS} concurrent)...`);
+            const settled = await runWithConcurrencyLimit(videoPlans.map(({ index, plan }) => () => generateGrowthVideo(plan, {
+                productId,
+                analysisId,
+                verbose,
+            }).then((result) => ({ index, result }))), MAX_CONCURRENT_VIDEOS);
+            for (const outcome of settled) {
+                if (outcome.status === 'fulfilled') {
+                    const { index, result } = outcome.value;
                     const suggestion = contentSuggestions[index];
-                    logInfo(`\nVideo planned for: "${suggestion.title}" [${suggestion.channel}]`);
-                    logInfo(`  Reason: ${plan.videoReason}`);
-                    logInfo(`  Scenes: ${plan.scenes.length}`);
-                }
-                // Generate videos with concurrency limit (max 2 simultaneous)
-                const MAX_CONCURRENT_VIDEOS = 2;
-                logInfo(`\nGenerating ${videoPlans.length} video(s) (max ${MAX_CONCURRENT_VIDEOS} concurrent)...`);
-                const settled = await runWithConcurrencyLimit(videoPlans.map(({ index, plan }) => () => generateGrowthVideo(plan, {
-                    productId,
-                    analysisId,
-                    verbose,
-                }).then((result) => ({ index, result }))), MAX_CONCURRENT_VIDEOS);
-                for (const outcome of settled) {
-                    if (outcome.status === 'fulfilled') {
-                        const { index, result } = outcome.value;
-                        const suggestion = contentSuggestions[index];
-                        videoResults.set(index, result);
-                        if (result.success) {
-                            logSuccess(`Video generated for "${suggestion.title}": ${result.duration?.toFixed(1)}s, ${result.sceneCount} scenes`);
-                            if (result.localPath) {
-                                logInfo(`  Local: ${result.localPath}`);
-                            }
-                            if (result.videoUrl) {
-                                logInfo(`  URL: ${result.videoUrl}`);
-                            }
+                    videoResults.set(index, result);
+                    if (result.success) {
+                        logSuccess(`Video generated for "${suggestion.title}": ${result.duration?.toFixed(1)}s, ${result.sceneCount} scenes`);
+                        if (result.localPath) {
+                            logInfo(`  Local: ${result.localPath}`);
                         }
-                        else {
-                            logWarning(`Video generation failed for "${suggestion.title}": ${result.error}`);
+                        if (result.videoUrl) {
+                            logInfo(`  URL: ${result.videoUrl}`);
                         }
                     }
                     else {
-                        // Find the index from the error — log it generically
-                        logError(`Video generation error: ${outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)}`);
+                        logWarning(`Video generation failed for "${suggestion.title}": ${result.error}`);
                     }
                 }
+                else {
+                    // Find the index from the error — log it generically
+                    logError(`Video generation error: ${outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)}`);
+                }
             }
         }
         // Build final content suggestions with video results

package/dist/services/video/index.js

@@ -128,15 +128,17 @@ export async function generateGrowthVideo(plan, options) {
         // Step 4: Upload and save
         logInfo('Step 4/4: Uploading video...');
         const uploadResult = await uploadGrowthVideo(assembledVideo.videoPath, productId, analysisId, verbose);
-        // Save metadata
-        await saveVideoMetadata(analysisId, {
-            video_url: uploadResult.publicUrl,
-            video_storage_path: uploadResult.storagePath,
-            video_local_path: uploadResult.localPath,
-            video_duration: assembledVideo.duration,
-            video_file_size: assembledVideo.fileSize,
-            video_scene_count: assembledVideo.sceneCount,
-        }, verbose);
+        // Save metadata only if upload succeeded (has a public URL)
+        if (uploadResult.publicUrl) {
+            await saveVideoMetadata(analysisId, {
+                video_url: uploadResult.publicUrl,
+                video_storage_path: uploadResult.storagePath,
+                video_local_path: uploadResult.localPath,
+                video_duration: assembledVideo.duration,
+                video_file_size: assembledVideo.fileSize,
+                video_scene_count: assembledVideo.sceneCount,
+            }, verbose);
+        }
         logSuccess('Video generation completed successfully!');
         return {
             success: true,

package/dist/services/video/screenshot-generator.d.ts

@@ -52,7 +52,9 @@ export interface ScreenshotOptions {
  */
 export declare function isPlaywrightAvailable(): Promise<boolean>;
 /**
- * Get or create the temporary directory for growth video screenshots
+ * Get a unique temporary directory for a single video generation run.
+ * Each call returns a distinct path to avoid race conditions when
+ * multiple videos are generated concurrently for the same product.
  */
 export declare function getVideoTempDir(productId: string): string;
 /**

package/dist/services/video/screenshot-generator.js

@@ -29,10 +29,13 @@ export async function isPlaywrightAvailable() {
     return chromium !== null;
 }
 /**
- * Get or create the temporary directory for growth video screenshots
+ * Get a unique temporary directory for a single video generation run.
+ * Each call returns a distinct path to avoid race conditions when
+ * multiple videos are generated concurrently for the same product.
  */
 export function getVideoTempDir(productId) {
-    return join(tmpdir(), 'edsger-growth-videos', productId);
+    const uniqueId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    return join(tmpdir(), 'edsger-growth-videos', productId, uniqueId);
 }
 /**
  * Auto-detect device frame type based on viewport dimensions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.33.4",
+  "version": "0.33.6",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"