@lovelybunch/api 1.0.57 → 1.0.59

package/dist/lib/git.d.ts

@@ -4,6 +4,7 @@ export declare function sanitizeBranchName(name: string): string;
 export declare function resolveSafeWorktreePath(name: string): Promise<string>;
 export declare function runGit(args: string[], opts?: {
     cwd?: string;
+    timeout?: number;
 }): Promise<{
     stdout: string;
     stderr: string;
@@ -25,9 +26,21 @@ export declare function listBranches(): Promise<{
 }[]>;
 export declare function createBranch(name: string, from?: string): Promise<void>;
 export declare function deleteBranch(name: string): Promise<void>;
+export declare function switchBranch(name: string): Promise<void>;
+export declare function mergeBranch(branchName: string, strategy?: 'merge' | 'squash' | 'rebase'): Promise<string>;
 export declare function pushCurrent(): Promise<string>;
 export type PullStrategy = 'merge' | 'rebase' | 'ff-only';
 export declare function pullCurrent(strategy?: PullStrategy): Promise<string>;
+export declare function checkRemoteAuth(): Promise<{
+    authenticated: boolean;
+    remote?: string;
+    error?: string;
+}>;
+export declare function getCredentialConfig(): Promise<{
+    helper?: string;
+    origin?: string;
+}>;
+export declare function storeCredentials(username: string, password: string): Promise<void>;
 export interface WorktreeInfo {
     name: string;
     path: string;

package/dist/lib/git.js

@@ -43,7 +43,13 @@ export async function resolveSafeWorktreePath(name) {
 export async function runGit(args, opts) {
     const repoRoot = await getRepoRoot();
     const cwd = opts?.cwd || repoRoot;
-    return execFile('git', args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+    const timeout = opts?.timeout || 120000; // 2 minutes default
+    // Prevent git from prompting for credentials in non-interactive environment
+    const env = {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: '0',
+    };
+    return execFile('git', args, { cwd, maxBuffer: 10 * 1024 * 1024, timeout, env });
 }
 // --- Status ---
 export async function getRepoStatus() {
@@ -106,16 +112,142 @@ export async function deleteBranch(name) {
     const safe = sanitizeBranchName(name);
     await runGit(['branch', '-D', safe]);
 }
+export async function switchBranch(name) {
+    const safe = sanitizeBranchName(name);
+    await runGit(['switch', safe]);
+}
+export async function mergeBranch(branchName, strategy = 'merge') {
+    const safe = sanitizeBranchName(branchName);
+    if (strategy === 'rebase') {
+        const { stdout } = await runGit(['rebase', safe]);
+        return stdout;
+    }
+    else if (strategy === 'squash') {
+        const { stdout } = await runGit(['merge', '--squash', safe]);
+        return stdout;
+    }
+    else {
+        const { stdout } = await runGit(['merge', safe]);
+        return stdout;
+    }
+}
 // --- Push / Pull ---
 export async function pushCurrent() {
-    const { stdout } = await runGit(['push']);
+    const { stdout } = await runGit(['push'], { timeout: 30000 }); // 30 second timeout for push
     return stdout;
 }
 export async function pullCurrent(strategy = 'rebase') {
     const args = strategy === 'rebase' ? ['pull', '--rebase'] : strategy === 'ff-only' ? ['pull', '--ff-only'] : ['pull', '--no-rebase'];
-    const { stdout } = await runGit(args);
+    const { stdout } = await runGit(args, { timeout: 30000 }); // 30 second timeout for pull
     return stdout;
 }
+// --- Auth Status ---
+export async function checkRemoteAuth() {
+    try {
+        // Get remote URL
+        const { stdout: remoteUrl } = await runGit(['config', '--get', 'remote.origin.url']);
+        const remote = remoteUrl.trim();
+        // Try to ls-remote with minimal timeout
+        await runGit(['ls-remote', '--exit-code', 'origin', 'HEAD'], { timeout: 10000 });
+        return { authenticated: true, remote };
+    }
+    catch (error) {
+        // Check if it's an auth error vs other errors
+        const message = error.message || error.stderr || '';
+        const isAuthError = message.includes('Authentication failed') ||
+            message.includes('could not read Username') ||
+            message.includes('could not read Password') ||
+            message.includes('terminal prompts disabled') ||
+            error.code === 'ETIMEDOUT';
+        return {
+            authenticated: false,
+            error: isAuthError ? 'Authentication required' : message
+        };
+    }
+}
+export async function getCredentialConfig() {
+    try {
+        const { stdout } = await runGit(['config', '--show-origin', '--get', 'credential.helper']);
+        const lines = stdout.trim().split('\n');
+        const lastLine = lines[lines.length - 1]; // Get the last configured helper (takes precedence)
+        if (lastLine) {
+            // Format: "file:/path/to/config\thelper-value"
+            const [origin, helper] = lastLine.split('\t');
+            return { helper: helper?.trim(), origin: origin?.replace('file:', '').trim() };
+        }
+        return {};
+    }
+    catch {
+        // No credential helper configured
+        return {};
+    }
+}
+export async function storeCredentials(username, password) {
+    // Get remote URL to determine protocol and host
+    const { stdout: remoteUrl } = await runGit(['config', '--get', 'remote.origin.url']);
+    const remote = remoteUrl.trim();
+    // Parse the remote URL to extract protocol and host
+    let protocol = 'https';
+    let host = '';
+    if (remote.startsWith('https://')) {
+        protocol = 'https';
+        host = remote.replace('https://', '').split('/')[0];
+    }
+    else if (remote.startsWith('http://')) {
+        protocol = 'http';
+        host = remote.replace('http://', '').split('/')[0];
+    }
+    else {
+        throw new Error('Remote URL is not HTTPS/HTTP. Please use SSH keys for SSH remotes.');
+    }
+    // Ensure a credential helper is configured
+    const config = await getCredentialConfig();
+    if (!config.helper) {
+        // Auto-configure based on platform
+        const platform = process.platform;
+        if (platform === 'darwin') {
+            await runGit(['config', '--global', 'credential.helper', 'osxkeychain']);
+        }
+        else if (platform === 'win32') {
+            await runGit(['config', '--global', 'credential.helper', 'manager']);
+        }
+        else {
+            // Linux - use store as fallback
+            await runGit(['config', '--global', 'credential.helper', 'store']);
+        }
+    }
+    // Use git credential approve to store credentials via stdin
+    const credentialInput = `protocol=${protocol}\nhost=${host}\nusername=${username}\npassword=${password}\n\n`;
+    const repoRoot = await getRepoRoot();
+    const { spawn } = await import('child_process');
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', ['credential', 'approve'], {
+            cwd: repoRoot,
+            env: {
+                ...process.env,
+                GIT_TERMINAL_PROMPT: '0',
+            },
+        });
+        let stderr = '';
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`git credential approve failed with code ${code}: ${stderr}`));
+            }
+        });
+        // Write credentials to stdin
+        child.stdin?.write(credentialInput);
+        child.stdin?.end();
+    });
+}
 export async function listWorktrees() {
     const { stdout } = await runGit(['worktree', 'list', '--porcelain']);
     // Parse porcelain groups separated by blank lines with fields: worktree <path>, HEAD <sha>, branch <refs/heads/x>, locked
@@ -195,13 +327,13 @@ export async function commitInWorktree(name, message, files) {
 export async function pushWorktree(name) {
     const found = await getWorktreeByName(name);
     const wtPath = found ? found.path : await resolveSafeWorktreePath(name);
-    const { stdout } = await runGit(['-C', wtPath, 'push']);
+    const { stdout } = await runGit(['-C', wtPath, 'push'], { timeout: 30000 }); // 30 second timeout
     return stdout;
 }
 export async function pullWorktree(name, strategy = 'rebase') {
     const found = await getWorktreeByName(name);
     const wtPath = found ? found.path : await resolveSafeWorktreePath(name);
     const args = strategy === 'rebase' ? ['-C', wtPath, 'pull', '--rebase'] : strategy === 'ff-only' ? ['-C', wtPath, 'pull', '--ff-only'] : ['-C', wtPath, 'pull', '--no-rebase'];
-    const { stdout } = await runGit(args);
+    const { stdout } = await runGit(args, { timeout: 30000 }); // 30 second timeout
     return stdout;
 }

package/dist/lib/jobs/global-job-scheduler.d.ts

@@ -0,0 +1,2 @@
+import { JobScheduler } from './job-scheduler.js';
+export declare function getGlobalJobScheduler(): JobScheduler;

package/dist/lib/jobs/global-job-scheduler.js

@@ -0,0 +1,11 @@
+import { JobScheduler } from './job-scheduler.js';
+let scheduler = null;
+export function getGlobalJobScheduler() {
+    if (!scheduler) {
+        scheduler = new JobScheduler();
+        scheduler.initialize().catch((error) => {
+            console.error('Failed to initialize job scheduler:', error);
+        });
+    }
+    return scheduler;
+}

package/dist/lib/jobs/job-runner.d.ts

@@ -0,0 +1,17 @@
+import { ScheduledJob } from '@lovelybunch/types';
+interface JobRunResult {
+    status: 'succeeded' | 'failed';
+    summary?: string;
+    outputPath?: string;
+    error?: string;
+    cliCommand: string;
+}
+export declare class JobRunner {
+    private projectRootPromise;
+    constructor();
+    private ensureCliAvailable;
+    private ensureLogPath;
+    private buildInstruction;
+    run(job: ScheduledJob, runId: string): Promise<JobRunResult>;
+}
+export {};

package/dist/lib/jobs/job-runner.js

@@ -0,0 +1,167 @@
+import { spawn, spawnSync } from 'child_process';
+import { createWriteStream } from 'fs';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getProjectRoot } from '../project-paths.js';
+function shellQuote(value) {
+    if (value === '')
+        return "''";
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function resolveAgent(model) {
+    if (!model)
+        return 'claude';
+    const lower = model.toLowerCase();
+    if (lower.includes('gemini'))
+        return 'gemini';
+    if (lower.includes('codex') || lower.includes('gpt') || lower.includes('openai'))
+        return 'codex';
+    return 'claude';
+}
+function buildCommand(agent, instruction) {
+    const quotedInstruction = shellQuote(instruction);
+    switch (agent) {
+        case 'gemini': {
+            const cmd = `gemini --yolo -i ${quotedInstruction}`;
+            return { command: 'gemini', shellCommand: cmd };
+        }
+        case 'codex': {
+            const cmd = `codex ${quotedInstruction} --dangerously-bypass-approvals-and-sandbox`;
+            return { command: 'codex', shellCommand: cmd };
+        }
+        case 'claude':
+        default: {
+            const cmd = `claude ${quotedInstruction} --dangerously-skip-permissions`;
+            return { command: 'claude', shellCommand: cmd };
+        }
+    }
+}
+const CLI_AGENT_LABEL = {
+    claude: 'Claude',
+    gemini: 'Gemini',
+    codex: 'Code'
+};
+const CLI_AGENT_BINARY = {
+    claude: 'claude',
+    gemini: 'gemini',
+    codex: 'codex'
+};
+const DEFAULT_MAX_RUNTIME_MS = 30 * 60 * 1000; // 30 minutes
+function getMaxRuntime() {
+    const raw = process.env.COCONUT_JOB_MAX_RUNTIME_MS;
+    if (!raw)
+        return DEFAULT_MAX_RUNTIME_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return DEFAULT_MAX_RUNTIME_MS;
+    }
+    return parsed;
+}
+export class JobRunner {
+    projectRootPromise;
+    constructor() {
+        this.projectRootPromise = getProjectRoot();
+    }
+    ensureCliAvailable(agent) {
+        const binary = CLI_AGENT_BINARY[agent];
+        const result = spawnSync('bash', ['-lc', `command -v ${binary}`], { stdio: 'ignore' });
+        if (result.status !== 0) {
+            throw new Error(`${CLI_AGENT_LABEL[agent]} CLI (“${binary}”) is not installed or not on PATH.`);
+        }
+    }
+    async ensureLogPath(jobId, runId) {
+        const projectRoot = await this.projectRootPromise;
+        const logsDir = path.join(projectRoot, '.nut', 'jobs', 'logs', jobId);
+        await fs.mkdir(logsDir, { recursive: true });
+        return path.join(logsDir, `${runId}.log`);
+    }
+    buildInstruction(job, agentLabel) {
+        const prompt = job.prompt.trim();
+        const scheduleDescription = job.schedule.type === 'cron'
+            ? `Cron: ${job.schedule.expression}`
+            : `Interval: every ${job.schedule.hours}h on ${job.schedule.daysOfWeek.join(', ')}`;
+        return `Run this scheduled Coconut job (${job.id}).\nSchedule: ${scheduleDescription}.\nPreferred CLI agent: ${agentLabel}.\nInstruction:\n${prompt}`;
+    }
+    async run(job, runId) {
+        const agent = resolveAgent(job.model);
+        const instruction = this.buildInstruction(job, CLI_AGENT_LABEL[agent] || agent);
+        const { shellCommand } = buildCommand(agent, instruction);
+        const projectRoot = await this.projectRootPromise;
+        const logPath = await this.ensureLogPath(job.id, runId);
+        const logStream = createWriteStream(logPath, { flags: 'a' });
+        const summaryChunks = [];
+        logStream.write(`[${new Date().toISOString()}] Starting job ${job.id} using ${agent} CLI\n`);
+        logStream.write(`Instruction: ${instruction}\n`);
+        logStream.write(`Command: ${shellCommand}\n`);
+        return new Promise((resolve) => {
+            let cliMissingError = null;
+            try {
+                this.ensureCliAvailable(agent);
+            }
+            catch (error) {
+                cliMissingError = error instanceof Error ? error : new Error(String(error));
+            }
+            if (cliMissingError) {
+                const message = cliMissingError.message;
+                logStream.write(`${message}\n`);
+                logStream.end();
+                resolve({
+                    status: 'failed',
+                    error: message,
+                    summary: message,
+                    outputPath: path.relative(projectRoot, logPath),
+                    cliCommand: shellCommand,
+                });
+                return;
+            }
+            const child = spawn('bash', ['-lc', shellCommand], {
+                cwd: projectRoot,
+                env: process.env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const maxRuntime = getMaxRuntime();
+            const abortTimeout = setTimeout(() => {
+                logStream.write(`\n[${new Date().toISOString()}] Max runtime ${maxRuntime}ms exceeded. Sending SIGTERM...\n`);
+                child.kill('SIGTERM');
+                setTimeout(() => child.kill('SIGKILL'), 10_000);
+            }, maxRuntime);
+            child.stdout?.on('data', (chunk) => {
+                const text = chunk.toString();
+                logStream.write(text);
+                summaryChunks.push(text);
+            });
+            child.stderr?.on('data', (chunk) => {
+                const text = chunk.toString();
+                logStream.write(text);
+                summaryChunks.push(text);
+            });
+            child.on('error', (error) => {
+                const message = `Failed to start CLI command: ${error.message}`;
+                logStream.write(`${message}\n`);
+                logStream.end();
+                clearTimeout(abortTimeout);
+                resolve({
+                    status: 'failed',
+                    error: message,
+                    summary: summaryChunks.join('').slice(-600),
+                    outputPath: path.relative(projectRoot, logPath),
+                    cliCommand: shellCommand,
+                });
+            });
+            child.on('close', (code) => {
+                const status = code === 0 ? 'succeeded' : 'failed';
+                logStream.write(`\n[${new Date().toISOString()}] Job ${job.id} completed with exit code ${code}\n`);
+                logStream.end();
+                clearTimeout(abortTimeout);
+                const summary = summaryChunks.join('');
+                resolve({
+                    status,
+                    summary: summary.slice(Math.max(0, summary.length - 2000)),
+                    outputPath: path.relative(projectRoot, logPath),
+                    error: code === 0 ? undefined : `CLI exited with code ${code}`,
+                    cliCommand: shellCommand,
+                });
+            });
+        });
+    }
+}

package/dist/lib/jobs/job-scheduler.d.ts

@@ -0,0 +1,39 @@
+import { ScheduledJob, ScheduledJobRun, ScheduledJobStatus, ScheduledJobTrigger } from '@lovelybunch/types';
+import { JobStore } from './job-store.js';
+import { JobRunner } from './job-runner.js';
+export declare class JobScheduler {
+    private store;
+    private runner;
+    private jobs;
+    private runningJobs;
+    private initialized;
+    constructor(store?: JobStore, runner?: JobRunner);
+    initialize(): Promise<void>;
+    register(job: ScheduledJob): Promise<void>;
+    unregister(jobId: string): Promise<void>;
+    refresh(jobId: string): Promise<void>;
+    runNow(jobId: string, trigger?: ScheduledJobTrigger): Promise<ScheduledJobRun | null>;
+    private clearTimer;
+    private execute;
+    private updateJobMetadata;
+    private calculateNextRun;
+    private calculateNextInterval;
+    private calculateNextCron;
+    private resolveDayMatch;
+    private parseCronField;
+    private expandCronSegment;
+    private storeCronValue;
+    getStatus(): {
+        initialized: boolean;
+        jobCount: number;
+        runningCount: number;
+        jobs: {
+            id: string;
+            status: ScheduledJobStatus;
+            nextRunAt?: Date;
+            lastRunAt?: Date;
+            timerActive: boolean;
+            running: boolean;
+        }[];
+    };
+}