@renseiai/agentfactory-cli 0.8.0

package/dist/src/lib/agent-runner.js

@@ -0,0 +1,272 @@
+/**
+ * Agent Runner -- Programmatic API for the af-agent CLI.
+ *
+ * Provides stop, chat, status, and reconnect commands for managing running
+ * agent sessions. Works by updating Redis state directly — workers poll for
+ * status changes and pending prompts every 5 seconds.
+ */
+import { getRedisClient, getAllSessions, updateSessionStatus, storeSessionState, storePendingPrompt, disconnectRedis, } from '@renseiai/agentfactory-server';
+import { createLinearAgentClient } from '@renseiai/agentfactory-linear';
+// ---------------------------------------------------------------------------
+// ANSI colors
+// ---------------------------------------------------------------------------
+export const C = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function ensureRedis() {
+    if (!process.env.REDIS_URL) {
+        throw new Error('REDIS_URL environment variable is not set');
+    }
+    getRedisClient();
+}
+/**
+ * Find a session by issue identifier (e.g., SUP-674) or partial session ID.
+ * Prefers active sessions (running/claimed) over inactive ones.
+ */
+async function findSession(issueId) {
+    const sessions = await getAllSessions();
+    const normalizedInput = issueId.toUpperCase();
+    const activeStatuses = new Set(['running', 'claimed', 'pending']);
+    let activeMatch = null;
+    let fallback = null;
+    for (const session of sessions) {
+        const matchesIdentifier = session.issueIdentifier?.toUpperCase() === normalizedInput;
+        const matchesSessionId = session.linearSessionId.includes(issueId);
+        if (!matchesIdentifier && !matchesSessionId)
+            continue;
+        if (activeStatuses.has(session.status)) {
+            activeMatch = session;
+            break;
+        }
+        if (!fallback) {
+            fallback = session;
+        }
+    }
+    return activeMatch ?? fallback;
+}
+function formatSession(session) {
+    const statusColors = {
+        pending: C.yellow,
+        claimed: C.cyan,
+        running: C.green,
+        completed: C.gray,
+        failed: C.red,
+        stopped: C.yellow,
+        finalizing: C.cyan,
+    };
+    const color = statusColors[session.status] ?? '';
+    const identifier = session.issueIdentifier ?? session.issueId.slice(0, 8);
+    const sessionShort = session.linearSessionId.slice(0, 12);
+    const worker = session.workerId ? ` worker:${session.workerId.slice(0, 8)}` : '';
+    const workType = session.workType ? ` (${session.workType})` : '';
+    return `${identifier} [${color}${session.status}${C.reset}]${workType} session:${sessionShort}${worker}`;
+}
+// ---------------------------------------------------------------------------
+// Command handlers
+// ---------------------------------------------------------------------------
+async function stopWork(issueId) {
+    ensureRedis();
+    const session = await findSession(issueId);
+    if (!session) {
+        console.error(`${C.red}No session found for: ${issueId}${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    console.log(`Found: ${formatSession(session)}`);
+    if (session.status === 'stopped') {
+        console.log(`${C.yellow}Session already stopped${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    if (session.status === 'completed' || session.status === 'failed') {
+        console.log(`${C.yellow}Session already in terminal state: ${session.status}${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    const updated = await updateSessionStatus(session.linearSessionId, 'stopped');
+    if (updated) {
+        console.log(`${C.green}Stop signal sent${C.reset} — worker will abort within ~5 seconds`);
+    }
+    else {
+        console.error(`${C.red}Failed to update session status${C.reset}`);
+    }
+    await disconnectRedis();
+}
+async function chatWithAgent(issueId, message) {
+    ensureRedis();
+    const session = await findSession(issueId);
+    if (!session) {
+        console.error(`${C.red}No session found for: ${issueId}${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    console.log(`Found: ${formatSession(session)}`);
+    if (session.status !== 'running' && session.status !== 'claimed') {
+        console.error(`${C.red}Cannot chat — session is ${session.status}, not running${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    const prompt = await storePendingPrompt(session.linearSessionId, session.issueId, message);
+    if (prompt) {
+        console.log(`${C.green}Message queued${C.reset} (id: ${prompt.id}) — worker will pick up within ~5 seconds`);
+    }
+    else {
+        console.error(`${C.red}Failed to store pending prompt${C.reset}`);
+    }
+    await disconnectRedis();
+}
+async function showStatus(issueId) {
+    ensureRedis();
+    const session = await findSession(issueId);
+    if (!session) {
+        console.error(`${C.red}No session found for: ${issueId}${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    console.log(`\n${C.cyan}Session Details${C.reset}`);
+    console.log('='.repeat(50));
+    console.log(`  Issue:       ${session.issueIdentifier ?? session.issueId}`);
+    console.log(`  Status:      ${session.status}`);
+    console.log(`  Work Type:   ${session.workType ?? 'development'}`);
+    console.log(`  Session:     ${session.linearSessionId}`);
+    console.log(`  Worker:      ${session.workerId ?? '(none)'}`);
+    console.log(`  Provider:    ${session.provider ?? '(unknown)'}`);
+    console.log(`  Worktree:    ${session.worktreePath}`);
+    if (session.providerSessionId) {
+        console.log(`  Provider ID: ${session.providerSessionId}`);
+    }
+    if (session.totalCostUsd !== undefined) {
+        console.log(`  Cost:        $${session.totalCostUsd.toFixed(4)}`);
+    }
+    console.log(`  Created:     ${new Date(session.createdAt * 1000).toISOString()}`);
+    console.log(`  Updated:     ${new Date(session.updatedAt * 1000).toISOString()}`);
+    await disconnectRedis();
+}
+async function reconnectSession(issueId) {
+    ensureRedis();
+    const session = await findSession(issueId);
+    if (!session) {
+        console.error(`${C.red}No session found for: ${issueId}${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    console.log(`Found: ${formatSession(session)}`);
+    // Create a new Linear agent session on the issue
+    const apiKey = process.env.LINEAR_API_KEY;
+    if (!apiKey) {
+        console.error(`${C.red}LINEAR_API_KEY is required for reconnect${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    const linearClient = createLinearAgentClient({ apiKey });
+    console.log('Creating new Linear agent session...');
+    const result = await linearClient.createAgentSessionOnIssue({
+        issueId: session.issueId,
+    });
+    if (!result.success || !result.sessionId) {
+        console.error(`${C.red}Failed to create Linear agent session${C.reset}`);
+        await disconnectRedis();
+        return;
+    }
+    const newSessionId = result.sessionId;
+    console.log(`New Linear session: ${newSessionId.slice(0, 12)}...`);
+    // Store a new Redis session state with the new Linear session ID,
+    // preserving the existing state (worktree, worker, provider session, etc.)
+    await storeSessionState(newSessionId, {
+        issueId: session.issueId,
+        issueIdentifier: session.issueIdentifier,
+        providerSessionId: session.providerSessionId,
+        worktreePath: session.worktreePath,
+        status: session.status,
+        workerId: session.workerId,
+        queuedAt: session.queuedAt,
+        claimedAt: session.claimedAt,
+        priority: session.priority,
+        promptContext: session.promptContext,
+        organizationId: session.organizationId,
+        workType: session.workType,
+        agentId: session.agentId,
+        projectName: session.projectName,
+        provider: session.provider,
+        totalCostUsd: session.totalCostUsd,
+        inputTokens: session.inputTokens,
+        outputTokens: session.outputTokens,
+    });
+    // Mark the old session as stopped so the worker picks up the new one
+    await updateSessionStatus(session.linearSessionId, 'stopped');
+    console.log(`${C.green}Reconnected${C.reset}`);
+    console.log(`  Old session: ${session.linearSessionId.slice(0, 12)}... (stopped)`);
+    console.log(`  New session: ${newSessionId.slice(0, 12)}... (${session.status})`);
+    console.log('');
+    console.log(`The agent's Linear issue view will now show a fresh session.`);
+    console.log(`Worker activities will be reported to the new session.`);
+    await disconnectRedis();
+}
+async function listSessions(showAll) {
+    ensureRedis();
+    const sessions = await getAllSessions();
+    const activeStatuses = new Set(['running', 'claimed', 'pending', 'finalizing']);
+    const filtered = showAll
+        ? sessions
+        : sessions.filter((s) => activeStatuses.has(s.status));
+    const label = showAll ? 'All Sessions' : 'Active Sessions';
+    console.log(`\n${C.cyan}${label}${C.reset} (${filtered.length}${showAll ? '' : ` of ${sessions.length}`})`);
+    console.log('='.repeat(60));
+    if (filtered.length === 0) {
+        console.log(showAll ? '(none)' : '(no active sessions)');
+        await disconnectRedis();
+        return;
+    }
+    for (const session of filtered) {
+        const elapsed = Math.round(Date.now() / 1000 - session.createdAt);
+        const mins = Math.floor(elapsed / 60);
+        const duration = mins < 60
+            ? `${mins}m`
+            : `${Math.floor(mins / 60)}h${mins % 60}m`;
+        const cost = session.totalCostUsd !== undefined
+            ? ` $${session.totalCostUsd.toFixed(2)}`
+            : '';
+        console.log(`  ${formatSession(session)} ${C.gray}${duration}${cost}${C.reset}`);
+    }
+    await disconnectRedis();
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+export async function runAgent(config) {
+    switch (config.command) {
+        case 'list':
+            await listSessions(config.all ?? false);
+            break;
+        case 'stop':
+            if (!config.issueId)
+                throw new Error('stop command requires an issue ID');
+            await stopWork(config.issueId);
+            break;
+        case 'chat':
+            if (!config.issueId)
+                throw new Error('chat command requires an issue ID');
+            if (!config.message)
+                throw new Error('chat command requires a message');
+            await chatWithAgent(config.issueId, config.message);
+            break;
+        case 'status':
+            if (!config.issueId)
+                throw new Error('status command requires an issue ID');
+            await showStatus(config.issueId);
+            break;
+        case 'reconnect':
+            if (!config.issueId)
+                throw new Error('reconnect command requires an issue ID');
+            await reconnectSession(config.issueId);
+            break;
+    }
+}

package/dist/src/lib/analyze-logs-runner.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Log Analyzer Runner -- Programmatic API for the log analyzer CLI.
+ *
+ * Extracts the core logic from the analyze-logs bin script so that it can be
+ * invoked programmatically (e.g. from a Next.js route handler or test) without
+ * process.exit / dotenv / argv coupling.
+ */
+export interface AnalyzerRunnerConfig {
+    /** Analyze a specific session */
+    sessionId?: string;
+    /** Watch for new sessions and analyze as they complete */
+    follow?: boolean;
+    /** Poll interval in milliseconds (default: 5000) */
+    interval?: number;
+    /** Show what would be created without creating issues */
+    dryRun?: boolean;
+    /** Cleanup old logs based on retention policy */
+    cleanup?: boolean;
+    /** Show detailed analysis output */
+    verbose?: boolean;
+    /** Base directory for logs (default: {gitRoot}/.agent-logs or AGENT_LOGS_DIR env) */
+    logsDir?: string;
+    /** Git root for default paths (default: auto-detect) */
+    gitRoot?: string;
+}
+export interface AnalyzerResult {
+    sessionsAnalyzed: number;
+    totalErrors: number;
+    totalPatterns: number;
+    issuesCreated: number;
+    issuesUpdated: number;
+}
+/** Detect the git repository root. Falls back to cwd. */
+export declare function getGitRoot(): string;
+export declare function printSummary(stats: AnalyzerResult, dryRun: boolean): void;
+/**
+ * Run the log analyzer programmatically.
+ *
+ * For one-shot mode (default) the returned promise resolves with the analysis
+ * result once all sessions have been processed.
+ *
+ * For follow mode (`config.follow = true`) the analyzer keeps running until
+ * the optional `signal` is aborted.  When the signal fires the current poll
+ * cycle finishes and the accumulated stats are returned.
+ */
+export declare function runLogAnalyzer(config?: AnalyzerRunnerConfig, signal?: AbortSignal): Promise<AnalyzerResult>;
+//# sourceMappingURL=analyze-logs-runner.d.ts.map

package/dist/src/lib/analyze-logs-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-logs-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/analyze-logs-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,MAAM,WAAW,oBAAoB;IACnC,iCAAiC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yDAAyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,iDAAiD;IACjD,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,oCAAoC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;CACtB;AAQD,yDAAyD;AACzD,wBAAgB,UAAU,IAAI,MAAM,CASnC;AA0GD,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CASzE;AAqED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,MAAM,GAAE,oBAAyB,EACjC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,CAkDzB"}

package/dist/src/lib/analyze-logs-runner.js

@@ -0,0 +1,216 @@
+/**
+ * Log Analyzer Runner -- Programmatic API for the log analyzer CLI.
+ *
+ * Extracts the core logic from the analyze-logs bin script so that it can be
+ * invoked programmatically (e.g. from a Next.js route handler or test) without
+ * process.exit / dotenv / argv coupling.
+ */
+import { execSync } from 'child_process';
+import { createLogAnalyzer } from '@renseiai/agentfactory';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const DEFAULT_POLL_INTERVAL = 5000;
+/** Detect the git repository root. Falls back to cwd. */
+export function getGitRoot() {
+    try {
+        return execSync('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+function formatTime() {
+    return new Date().toLocaleTimeString();
+}
+function emptyStats() {
+    return {
+        sessionsAnalyzed: 0,
+        totalErrors: 0,
+        totalPatterns: 0,
+        issuesCreated: 0,
+        issuesUpdated: 0,
+    };
+}
+async function analyzeAndPrintSession(analyzer, sessionId, options, stats) {
+    console.log(`\nAnalyzing session: ${sessionId}`);
+    console.log('-'.repeat(50));
+    const result = analyzer.analyzeSession(sessionId);
+    if (!result) {
+        console.log('  [SKIP] Session not found or incomplete');
+        return false;
+    }
+    console.log(`  Issue: ${result.metadata.issueIdentifier}`);
+    console.log(`  Work Type: ${result.metadata.workType}`);
+    console.log(`  Status: ${result.metadata.status}`);
+    console.log(`  Events: ${result.eventsAnalyzed}`);
+    console.log(`  Errors: ${result.errorsFound}`);
+    console.log(`  Patterns: ${result.patterns.length}`);
+    stats.sessionsAnalyzed++;
+    stats.totalErrors += result.errorsFound;
+    stats.totalPatterns += result.patterns.length;
+    if (options.verbose && result.patterns.length > 0) {
+        console.log('\n  Detected Patterns:');
+        for (const pattern of result.patterns) {
+            console.log(`    - [${pattern.severity}] ${pattern.title}`);
+            console.log(`      Type: ${pattern.type}, Occurrences: ${pattern.occurrences}`);
+            if (pattern.tool) {
+                console.log(`      Tool: ${pattern.tool}`);
+            }
+        }
+    }
+    if (result.suggestedIssues.length > 0) {
+        console.log(`\n  Suggested Issues: ${result.suggestedIssues.length}`);
+        if (options.verbose) {
+            for (const issue of result.suggestedIssues) {
+                console.log(`    - ${issue.title}`);
+                console.log(`      Signature: ${issue.signature}`);
+                console.log(`      Labels: ${issue.labels.join(', ')}`);
+            }
+        }
+        try {
+            const issueResults = await analyzer.createIssues(result.suggestedIssues, sessionId, options.dryRun);
+            for (const issueResult of issueResults) {
+                if (issueResult.created) {
+                    console.log(`  [${options.dryRun ? 'WOULD CREATE' : 'CREATED'}] ${issueResult.identifier}`);
+                    stats.issuesCreated++;
+                }
+                else {
+                    console.log(`  [${options.dryRun ? 'WOULD UPDATE' : 'UPDATED'}] ${issueResult.identifier}`);
+                    stats.issuesUpdated++;
+                }
+            }
+        }
+        catch (error) {
+            console.log(`  [ERROR] Failed to create issues: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (!options.dryRun) {
+        analyzer.markProcessed(sessionId, result);
+        console.log('  [PROCESSED]');
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Summary printer
+// ---------------------------------------------------------------------------
+export function printSummary(stats, dryRun) {
+    console.log('\n' + '='.repeat(50));
+    console.log('=== Summary ===\n');
+    console.log(`  Sessions analyzed: ${stats.sessionsAnalyzed}`);
+    console.log(`  Total errors found: ${stats.totalErrors}`);
+    console.log(`  Total patterns detected: ${stats.totalPatterns}`);
+    console.log(`  Issues created: ${stats.issuesCreated}${dryRun ? ' (dry run)' : ''}`);
+    console.log(`  Issues updated: ${stats.issuesUpdated}${dryRun ? ' (dry run)' : ''}`);
+    console.log('');
+}
+// ---------------------------------------------------------------------------
+// Follow mode (watch)
+// ---------------------------------------------------------------------------
+async function runFollowMode(analyzer, options, interval, signal) {
+    const stats = emptyStats();
+    const processedInSession = new Set();
+    console.log(`[${formatTime()}] Watching for new sessions (poll interval: ${interval}ms)`);
+    console.log(`[${formatTime()}] Press Ctrl+C to stop\n`);
+    const isAborted = () => signal?.aborted ?? false;
+    // Initial check for existing unprocessed sessions
+    const initialSessions = analyzer.getUnprocessedSessions();
+    if (initialSessions.length > 0) {
+        console.log(`[${formatTime()}] Found ${initialSessions.length} existing unprocessed session(s)`);
+        for (const sid of initialSessions) {
+            if (isAborted())
+                break;
+            await analyzeAndPrintSession(analyzer, sid, options, stats);
+            processedInSession.add(sid);
+        }
+    }
+    // Poll loop
+    while (!isAborted()) {
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, interval);
+            // If an abort signal fires while waiting, resolve immediately
+            if (signal) {
+                const onAbort = () => {
+                    clearTimeout(timer);
+                    resolve();
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
+        });
+        if (isAborted())
+            break;
+        const sessions = analyzer.getUnprocessedSessions();
+        const newSessions = sessions.filter((s) => !processedInSession.has(s));
+        if (newSessions.length > 0) {
+            console.log(`[${formatTime()}] Found ${newSessions.length} new session(s) ready for analysis`);
+            for (const sid of newSessions) {
+                if (isAborted())
+                    break;
+                const analyzed = await analyzeAndPrintSession(analyzer, sid, options, stats);
+                if (analyzed) {
+                    processedInSession.add(sid);
+                }
+            }
+        }
+    }
+    console.log(`\n[${formatTime()}] Stopping...`);
+    return stats;
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+/**
+ * Run the log analyzer programmatically.
+ *
+ * For one-shot mode (default) the returned promise resolves with the analysis
+ * result once all sessions have been processed.
+ *
+ * For follow mode (`config.follow = true`) the analyzer keeps running until
+ * the optional `signal` is aborted.  When the signal fires the current poll
+ * cycle finishes and the accumulated stats are returned.
+ */
+export async function runLogAnalyzer(config = {}, signal) {
+    const gitRoot = config.gitRoot ?? getGitRoot();
+    const logsDir = config.logsDir ?? process.env.AGENT_LOGS_DIR ?? `${gitRoot}/.agent-logs`;
+    const dryRun = config.dryRun ?? false;
+    const verbose = config.verbose ?? false;
+    const interval = config.interval ?? DEFAULT_POLL_INTERVAL;
+    console.log('\n=== AgentFactory Log Analyzer ===\n');
+    if (dryRun) {
+        console.log('[DRY RUN MODE - No issues will be created]\n');
+    }
+    const analyzer = createLogAnalyzer({ logsDir });
+    // Cleanup mode
+    if (config.cleanup) {
+        console.log('Cleaning up old logs...\n');
+        const deleted = analyzer.cleanupOldLogs();
+        console.log(`Deleted ${deleted} old log entries.\n`);
+        return emptyStats();
+    }
+    // Follow (watch) mode
+    if (config.follow) {
+        return runFollowMode(analyzer, { dryRun, verbose }, interval, signal);
+    }
+    // Standard one-shot mode
+    const stats = emptyStats();
+    let sessionsToAnalyze;
+    if (config.sessionId) {
+        sessionsToAnalyze = [config.sessionId];
+        console.log(`Analyzing session: ${config.sessionId}\n`);
+    }
+    else {
+        sessionsToAnalyze = analyzer.getUnprocessedSessions();
+        console.log(`Found ${sessionsToAnalyze.length} unprocessed session(s)\n`);
+    }
+    if (sessionsToAnalyze.length === 0) {
+        console.log('No sessions to analyze.\n');
+        return stats;
+    }
+    for (const sid of sessionsToAnalyze) {
+        await analyzeAndPrintSession(analyzer, sid, { dryRun, verbose }, stats);
+    }
+    return stats;
+}

package/dist/src/lib/auto-updater.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Auto-Updater for AgentFactory CLI.
+ *
+ * When enabled, checks for new versions and can automatically update
+ * the CLI package. For long-running processes (fleet, governor), it
+ * waits until there are no active workers before restarting.
+ *
+ * Configuration (in order of precedence):
+ *   1. CLI flag: --auto-update / --no-auto-update
+ *   2. .env.local: AF_AUTO_UPDATE=true
+ *   3. .agentfactory/config.yaml: autoUpdate: true
+ */
+import type { UpdateCheckResult } from './version.js';
+export interface AutoUpdateConfig {
+    /** CLI flag override (highest precedence) */
+    cliFlag?: boolean;
+    /** Whether there are active workers/agents to wait for */
+    hasActiveWorkers?: () => boolean | Promise<boolean>;
+    /** Callback invoked right before the process exits for restart */
+    onBeforeRestart?: () => void | Promise<void>;
+}
+/**
+ * Resolve whether auto-update is enabled from all config sources.
+ */
+export declare function isAutoUpdateEnabled(cliFlag?: boolean): boolean;
+/**
+ * Perform auto-update if enabled and an update is available.
+ *
+ * For long-running processes (fleet, governor), this should be called
+ * periodically. It will:
+ *   1. Check if auto-update is enabled
+ *   2. Verify an update is available
+ *   3. Wait for active workers to finish (if hasActiveWorkers provided)
+ *   4. Install the update
+ *   5. Exit the process so the service manager can restart with the new version
+ *
+ * Returns true if an update was applied (process will exit shortly after).
+ */
+export declare function maybeAutoUpdate(updateCheck: UpdateCheckResult | null, config: AutoUpdateConfig): Promise<boolean>;
+//# sourceMappingURL=auto-updater.d.ts.map

package/dist/src/lib/auto-updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-updater.d.ts","sourceRoot":"","sources":["../../../src/lib/auto-updater.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAmBrD,MAAM,WAAW,gBAAgB;IAC/B,6CAA6C;IAC7C,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACnD,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAW9D;AAmCD;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACnC,WAAW,EAAE,iBAAiB,GAAG,IAAI,EACrC,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,OAAO,CAAC,CA+BlB"}