edsger 0.26.4 → 0.27.1

package/dist/api/cross-product.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Cross-product API - Fetch features across all products
+ *
+ * Used in the new default mode (agent workflow) where the CLI
+ * processes features from all products the user has access to,
+ * not just a single product.
+ */
+import { FeatureInfo } from '../types/features.js';
+export interface ProductSummary {
+    id: string;
+    name: string;
+    description?: string;
+    status?: string;
+}
+export interface FeatureWithProduct extends FeatureInfo {
+    product_name?: string;
+}
+/**
+ * List all products the authenticated user has access to
+ */
+export declare function listProducts(verbose?: boolean): Promise<ProductSummary[]>;
+/**
+ * List all ready_for_ai features across all products
+ * Iterates through all accessible products and collects their features
+ */
+export declare function listAllReadyFeatures(verbose?: boolean): Promise<FeatureWithProduct[]>;
+/**
+ * Claim a specific feature for processing
+ * Unlike the product-level claim, this claims a specific feature by ID
+ */
+export declare function claimFeatureById(featureId: string, productId: string, verbose?: boolean): Promise<FeatureInfo | null>;

package/dist/api/cross-product.js

@@ -0,0 +1,111 @@
+/**
+ * Cross-product API - Fetch features across all products
+ *
+ * Used in the new default mode (agent workflow) where the CLI
+ * processes features from all products the user has access to,
+ * not just a single product.
+ */
+import { callMcpEndpoint } from './mcp-client.js';
+import { logInfo, logError } from '../utils/logger.js';
+/**
+ * List all products the authenticated user has access to
+ */
+export async function listProducts(verbose) {
+    if (verbose) {
+        logInfo('Fetching products...');
+    }
+    try {
+        const result = (await callMcpEndpoint('products/list', {}));
+        const products = result.products || [];
+        if (verbose) {
+            logInfo(`Found ${products.length} product(s)`);
+        }
+        return products;
+    }
+    catch (error) {
+        logError(`Failed to list products: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+/**
+ * List all ready_for_ai features across all products
+ * Iterates through all accessible products and collects their features
+ */
+export async function listAllReadyFeatures(verbose) {
+    if (verbose) {
+        logInfo('Fetching ready_for_ai features across all products...');
+    }
+    try {
+        // First, get all products
+        const products = await listProducts(verbose);
+        if (products.length === 0) {
+            if (verbose) {
+                logInfo('No products found');
+            }
+            return [];
+        }
+        // Fetch ready_for_ai features for all products in parallel
+        const featureResults = await Promise.allSettled(products.map(async (product) => {
+            const result = (await callMcpEndpoint('features/list', {
+                product_id: product.id,
+                status: 'ready_for_ai',
+            }));
+            return (result.features || []).map((feature) => ({
+                ...feature,
+                product_name: product.name,
+            }));
+        }));
+        const allFeatures = [];
+        featureResults.forEach((result, i) => {
+            if (result.status === 'fulfilled') {
+                allFeatures.push(...result.value);
+            }
+            else if (verbose) {
+                logInfo(`Could not fetch features for product: ${products[i].name}`);
+            }
+        });
+        // Sort by updated_at (oldest first)
+        allFeatures.sort((a, b) => {
+            const dateA = new Date(a.updated_at || 0).getTime();
+            const dateB = new Date(b.updated_at || 0).getTime();
+            return dateA - dateB;
+        });
+        if (verbose) {
+            logInfo(`Found ${allFeatures.length} ready_for_ai feature(s) across ${products.length} product(s)`);
+            allFeatures.forEach((f, i) => {
+                logInfo(`  ${i + 1}. [${f.product_name}] ${f.name}`);
+            });
+        }
+        return allFeatures;
+    }
+    catch (error) {
+        logError(`Failed to list features: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+/**
+ * Claim a specific feature for processing
+ * Unlike the product-level claim, this claims a specific feature by ID
+ */
+export async function claimFeatureById(featureId, productId, verbose) {
+    if (verbose) {
+        logInfo(`Claiming feature: ${featureId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('features/claim', {
+            product_id: productId,
+            feature_id: featureId,
+        }));
+        if (result.feature) {
+            if (verbose) {
+                logInfo(`Claimed feature: ${result.feature.name}`);
+            }
+            return result.feature;
+        }
+        return null;
+    }
+    catch (error) {
+        logError(`Failed to claim feature: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}

package/dist/api/mcp-client.d.ts

@@ -1,5 +1,10 @@
 /**
  * Common MCP client utilities for making HTTP requests to MCP servers
+ *
+ * Supports two authentication modes:
+ * 1. Stored auth via `edsger login` (~/.edsger/auth.json)
+ * 2. Environment variables (EDSGER_MCP_SERVER_URL, EDSGER_MCP_TOKEN)
+ * Environment variables take precedence over stored auth.
  */
 export interface McpRequestOptions {
     method: string;
@@ -8,7 +13,7 @@ export interface McpRequestOptions {
 }
 /**
  * Helper function to make HTTP requests to the MCP server
- * Reads EDSGER_MCP_SERVER_URL and EDSGER_MCP_TOKEN from environment variables
+ * Uses stored auth from `edsger login` or environment variables
  */
 export declare function callMcpEndpoint(method: string, params: unknown): Promise<unknown>;
 /**

package/dist/api/mcp-client.js

@@ -1,18 +1,24 @@
 /**
  * Common MCP client utilities for making HTTP requests to MCP servers
+ *
+ * Supports two authentication modes:
+ * 1. Stored auth via `edsger login` (~/.edsger/auth.json)
+ * 2. Environment variables (EDSGER_MCP_SERVER_URL, EDSGER_MCP_TOKEN)
+ * Environment variables take precedence over stored auth.
  */
+import { getMcpServerUrl, getMcpToken } from '../auth/auth-store.js';
 /**
  * Helper function to make HTTP requests to the MCP server
- * Reads EDSGER_MCP_SERVER_URL and EDSGER_MCP_TOKEN from environment variables
+ * Uses stored auth from `edsger login` or environment variables
  */
 export async function callMcpEndpoint(method, params) {
-    const mcpServerUrl = process.env.EDSGER_MCP_SERVER_URL;
-    const mcpToken = process.env.EDSGER_MCP_TOKEN;
+    const mcpServerUrl = getMcpServerUrl();
+    const mcpToken = getMcpToken();
     if (!mcpServerUrl) {
-        throw new Error('EDSGER_MCP_SERVER_URL environment variable is not set');
+        throw new Error('Not authenticated. Run `edsger login` or set EDSGER_MCP_SERVER_URL environment variable.');
     }
     if (!mcpToken) {
-        throw new Error('EDSGER_MCP_TOKEN environment variable is not set');
+        throw new Error('Not authenticated. Run `edsger login` or set EDSGER_MCP_TOKEN environment variable.');
     }
     try {
         const response = await fetch(`${mcpServerUrl}/mcp`, {

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

@@ -0,0 +1,52 @@
+/**
+ * Auth Store - Persistent authentication storage for the Edsger CLI
+ *
+ * Stores auth credentials in ~/.edsger/auth.json
+ * Provides read/write/clear operations for auth tokens
+ */
+export interface AuthConfig {
+    /** MCP server URL (e.g., https://xxx.supabase.co/functions/v1) */
+    mcpServerUrl: string;
+    /** MCP auth token */
+    mcpToken: string;
+    /** Timestamp of when login was performed */
+    loggedInAt: string;
+    /** Edsger.ai base URL */
+    edsgerBaseUrl?: string;
+}
+/**
+ * Save auth configuration to ~/.edsger/auth.json
+ */
+export declare function saveAuth(config: AuthConfig): void;
+/**
+ * Load auth configuration from ~/.edsger/auth.json
+ * Returns null if no auth file exists.
+ * Results are cached in memory to avoid repeated disk reads.
+ */
+export declare function loadAuth(): AuthConfig | null;
+/**
+ * Clear stored auth (logout)
+ */
+export declare function clearAuth(): void;
+/**
+ * Check if user is logged in (has stored auth)
+ */
+export declare function isLoggedIn(): boolean;
+/**
+ * Get the MCP server URL from stored auth or environment variable
+ * Stored auth takes lower priority than environment variables
+ */
+export declare function getMcpServerUrl(): string | undefined;
+/**
+ * Get the MCP token from stored auth or environment variable
+ * Environment variable takes precedence
+ */
+export declare function getMcpToken(): string | undefined;
+/**
+ * Get the Edsger base URL (defaults to https://edsger.ai)
+ */
+export declare function getEdsgerBaseUrl(): string;
+/**
+ * Get the auth file path (for display purposes)
+ */
+export declare function getAuthFilePath(): string;

package/dist/auth/auth-store.js

@@ -0,0 +1,117 @@
+/**
+ * Auth Store - Persistent authentication storage for the Edsger CLI
+ *
+ * Stores auth credentials in ~/.edsger/auth.json
+ * Provides read/write/clear operations for auth tokens
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync, chmodSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const EDSGER_DIR = join(homedir(), '.edsger');
+const AUTH_FILE = join(EDSGER_DIR, 'auth.json');
+/** In-memory cache for auth config to avoid repeated disk reads */
+let _authCache = undefined;
+/**
+ * Ensure the ~/.edsger directory exists with restricted permissions
+ */
+function ensureEdsgerDir() {
+    if (!existsSync(EDSGER_DIR)) {
+        mkdirSync(EDSGER_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Save auth configuration to ~/.edsger/auth.json
+ */
+export function saveAuth(config) {
+    ensureEdsgerDir();
+    writeFileSync(AUTH_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    // Restrict file permissions to owner only (contains sensitive token)
+    try {
+        chmodSync(AUTH_FILE, 0o600);
+    }
+    catch {
+        // chmod may fail on Windows, ignore
+    }
+    // Update cache
+    _authCache = config;
+}
+/**
+ * Load auth configuration from ~/.edsger/auth.json
+ * Returns null if no auth file exists.
+ * Results are cached in memory to avoid repeated disk reads.
+ */
+export function loadAuth() {
+    if (_authCache !== undefined) {
+        return _authCache;
+    }
+    try {
+        if (!existsSync(AUTH_FILE)) {
+            _authCache = null;
+            return null;
+        }
+        const content = readFileSync(AUTH_FILE, 'utf-8');
+        _authCache = JSON.parse(content);
+        return _authCache;
+    }
+    catch {
+        _authCache = null;
+        return null;
+    }
+}
+/**
+ * Clear stored auth (logout)
+ */
+export function clearAuth() {
+    _authCache = undefined;
+    try {
+        if (existsSync(AUTH_FILE)) {
+            unlinkSync(AUTH_FILE);
+        }
+    }
+    catch {
+        // Ignore errors during cleanup
+    }
+}
+/**
+ * Check if user is logged in (has stored auth)
+ */
+export function isLoggedIn() {
+    return loadAuth() !== null;
+}
+/**
+ * Get the MCP server URL from stored auth or environment variable
+ * Stored auth takes lower priority than environment variables
+ */
+export function getMcpServerUrl() {
+    // Environment variable takes precedence
+    if (process.env.EDSGER_MCP_SERVER_URL) {
+        return process.env.EDSGER_MCP_SERVER_URL;
+    }
+    const auth = loadAuth();
+    return auth?.mcpServerUrl;
+}
+/**
+ * Get the MCP token from stored auth or environment variable
+ * Environment variable takes precedence
+ */
+export function getMcpToken() {
+    // Environment variable takes precedence
+    if (process.env.EDSGER_MCP_TOKEN) {
+        return process.env.EDSGER_MCP_TOKEN;
+    }
+    const auth = loadAuth();
+    return auth?.mcpToken;
+}
+/**
+ * Get the Edsger base URL (defaults to https://edsger.ai)
+ */
+export function getEdsgerBaseUrl() {
+    const auth = loadAuth();
+    return auth?.edsgerBaseUrl || process.env.EDSGER_BASE_URL || 'https://edsger.ai';
+}
+/**
+ * Get the auth file path (for display purposes)
+ */
+export function getAuthFilePath() {
+    return AUTH_FILE;
+}

package/dist/auth/login.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Login Command - Browser-based authentication for Edsger CLI
+ *
+ * Opens the user's browser to edsger.ai/cli/auth where they can
+ * copy a token, then paste it into the CLI to complete login.
+ */
+/**
+ * Run the login flow
+ */
+export declare function runLogin(): Promise<void>;
+/**
+ * Run the logout flow
+ */
+export declare function runLogout(): Promise<void>;
+/**
+ * Show current login status
+ */
+export declare function runStatus(): Promise<void>;

package/dist/auth/login.js

@@ -0,0 +1,179 @@
+/**
+ * Login Command - Browser-based authentication for Edsger CLI
+ *
+ * Opens the user's browser to edsger.ai/cli/auth where they can
+ * copy a token, then paste it into the CLI to complete login.
+ */
+import { createInterface } from 'readline';
+import { execSync } from 'child_process';
+import { platform } from 'os';
+import { saveAuth, loadAuth, clearAuth, getEdsgerBaseUrl, getAuthFilePath } from './auth-store.js';
+import { logInfo, logSuccess, logError, logWarning } from '../utils/logger.js';
+/**
+ * Open a URL in the user's default browser
+ */
+function openBrowser(url) {
+    try {
+        const os = platform();
+        if (os === 'darwin') {
+            execSync(`open "${url}"`);
+        }
+        else if (os === 'win32') {
+            execSync(`start "${url}"`);
+        }
+        else {
+            // Linux - try xdg-open, then fallback to common browsers
+            try {
+                execSync(`xdg-open "${url}"`);
+            }
+            catch {
+                try {
+                    execSync(`sensible-browser "${url}"`);
+                }
+                catch {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read a line from stdin (with optional masking for sensitive input)
+ */
+function readLine(prompt) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/** Default MCP server URL */
+const MCP_SERVER_URL = 'https://ktkogvogdaffjmvrewiu.supabase.co/functions/v1';
+/**
+ * Run the login flow
+ */
+export async function runLogin() {
+    const baseUrl = getEdsgerBaseUrl();
+    const authUrl = `${baseUrl}/cli/auth`;
+    logInfo('Starting Edsger CLI login...');
+    console.log();
+    // Check if already logged in
+    const existingAuth = loadAuth();
+    if (existingAuth) {
+        logWarning('You are already logged in.');
+        const answer = await readLine('Do you want to re-login? (y/N): ');
+        if (answer.toLowerCase() !== 'y') {
+            logInfo('Login cancelled. Using existing credentials.');
+            return;
+        }
+    }
+    // Open browser
+    console.log(`  Opening browser to: ${authUrl}`);
+    console.log();
+    const opened = openBrowser(authUrl);
+    if (!opened) {
+        logWarning(`Could not open browser automatically.`);
+        console.log(`  Please open this URL manually:`);
+        console.log(`  ${authUrl}`);
+        console.log();
+    }
+    console.log('  1. Sign in to edsger.ai (if not already signed in)');
+    console.log('  2. Click "Generate CLI Token" on the page');
+    console.log('  3. Copy the CLI Token and paste it below');
+    console.log();
+    const mcpServerUrl = process.env.EDSGER_MCP_SERVER_URL || MCP_SERVER_URL;
+    // Read token
+    const mcpToken = await readLine('CLI Token: ');
+    if (!mcpToken) {
+        logError('Token is required. Login cancelled.');
+        return;
+    }
+    // Validate the token by making a test request
+    logInfo('Validating credentials...');
+    try {
+        const response = await fetch(`${mcpServerUrl}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${mcpToken}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'products/list',
+                params: {},
+                id: 'login-validation',
+            }),
+        });
+        if (!response.ok) {
+            logError(`Authentication failed: HTTP ${response.status}`);
+            logError('Please check your token and try again.');
+            return;
+        }
+        const data = await response.json();
+        if (data.error) {
+            logError(`Authentication failed: ${data.error.message}`);
+            return;
+        }
+        // Save auth
+        saveAuth({
+            mcpServerUrl,
+            mcpToken,
+            loggedInAt: new Date().toISOString(),
+            edsgerBaseUrl: baseUrl,
+        });
+        console.log();
+        logSuccess('Login successful!');
+        logInfo(`Credentials saved to ${getAuthFilePath()}`);
+        // Show available products
+        const products = data.result?.products || [];
+        if (products.length > 0) {
+            console.log();
+            logInfo(`You have access to ${products.length} product(s):`);
+            products.forEach((p, i) => {
+                console.log(`  ${i + 1}. ${p.name} (${p.id})`);
+            });
+        }
+        console.log();
+        logInfo('You can now run `edsger` to start processing features.');
+    }
+    catch (error) {
+        logError(`Connection failed: ${error instanceof Error ? error.message : String(error)}`);
+        logError('Please check the MCP server URL and try again.');
+    }
+}
+/**
+ * Run the logout flow
+ */
+export async function runLogout() {
+    const auth = loadAuth();
+    if (!auth) {
+        logInfo('You are not logged in.');
+        return;
+    }
+    clearAuth();
+    logSuccess('Logged out successfully.');
+    logInfo(`Credentials removed from ${getAuthFilePath()}`);
+}
+/**
+ * Show current login status
+ */
+export async function runStatus() {
+    const auth = loadAuth();
+    if (!auth) {
+        logInfo('Not logged in. Run `edsger login` to authenticate.');
+        return;
+    }
+    logInfo('Login status:');
+    console.log(`  Server: ${auth.mcpServerUrl}`);
+    console.log(`  Logged in at: ${auth.loggedInAt}`);
+    console.log(`  Token: ${auth.mcpToken.substring(0, 8)}...${auth.mcpToken.substring(auth.mcpToken.length - 4)}`);
+}

package/dist/commands/agent-workflow/feature-worker.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Feature Worker - Child process entry point for processing a single feature
+ *
+ * This file is spawned by the parent AgentWorkflowProcessor via child_process.fork().
+ * Each worker runs in its own process with its own cwd, which:
+ * 1. Allows concurrent feature processing (no shared process.chdir())
+ * 2. After auto-update, new workers load the latest code from disk
+ *
+ * Communication with parent via IPC messages:
+ * - Parent sends: { type: 'start', featureId, verbose, config }
+ * - Worker sends: { type: 'result', success: boolean, featureId }
+ * - Worker sends: { type: 'log', level, message } for logging
+ */
+export {};

package/dist/commands/agent-workflow/feature-worker.js

@@ -0,0 +1,65 @@
+/**
+ * Feature Worker - Child process entry point for processing a single feature
+ *
+ * This file is spawned by the parent AgentWorkflowProcessor via child_process.fork().
+ * Each worker runs in its own process with its own cwd, which:
+ * 1. Allows concurrent feature processing (no shared process.chdir())
+ * 2. After auto-update, new workers load the latest code from disk
+ *
+ * Communication with parent via IPC messages:
+ * - Parent sends: { type: 'start', featureId, verbose, config }
+ * - Worker sends: { type: 'result', success: boolean, featureId }
+ * - Worker sends: { type: 'log', level, message } for logging
+ */
+import { runFeatureWorkflow } from '../workflow/feature-coordinator.js';
+import { evaluatePipelineResults } from '../workflow/core/pipeline-evaluator.js';
+function sendMessage(msg) {
+    if (process.send) {
+        process.send(msg);
+    }
+}
+function log(level, message) {
+    sendMessage({ type: 'log', level, message });
+}
+async function handleStart(msg) {
+    const { featureId, verbose, config } = msg;
+    try {
+        log('info', `Worker started for feature: ${featureId}`);
+        const results = await runFeatureWorkflow({ featureId, verbose }, config);
+        const allSuccessful = evaluatePipelineResults(results);
+        sendMessage({
+            type: 'result',
+            featureId,
+            success: allSuccessful,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log('error', `Worker error for feature ${featureId}: ${errorMessage}`);
+        sendMessage({
+            type: 'result',
+            featureId,
+            success: false,
+            error: errorMessage,
+        });
+    }
+}
+// Listen for messages from parent
+process.on('message', (msg) => {
+    if (msg.type === 'start') {
+        handleStart(msg).finally(() => {
+            // Exit worker process after completion
+            process.exit(0);
+        });
+    }
+});
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+    sendMessage({
+        type: 'result',
+        featureId: 'unknown',
+        success: false,
+        error: `Uncaught exception: ${error.message}`,
+    });
+    process.exit(1);
+});

package/dist/commands/agent-workflow/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Agent Workflow - New default workflow mode
+ *
+ * This is the new cross-product workflow that:
+ * 1. Uses stored auth from `edsger login` (no per-repo env config needed)
+ * 2. Fetches ready_for_ai features across ALL products
+ * 3. Clones repos using GitHub App installation tokens
+ * 4. Manages workspace directories with feature ID naming
+ * 5. Runs continuously with auto-update, sleep prevention, and session management
+ * 6. Responds to web dashboard commands (pause/resume/stop)
+ */
+import { CliOptions } from '../../types/index.js';
+export declare function runAgentWorkflow(options: CliOptions): Promise<void>;