@lovelybunch/api 1.0.57 → 1.0.59

package/dist/lib/terminal/terminal-manager.js

@@ -117,6 +117,7 @@ export class TerminalManager {
             previewSockets: new Set(),
             previewBuffer: '',
             previewFlushTimer: null,
+            previewPingIntervals: new Map(),
         };
         this.sessions.set(sessionId, session);
         // Set up PTY event handlers
@@ -206,6 +207,21 @@ export class TerminalManager {
         }
         session.websocket = ws;
         session.lastActivity = new Date();
+        // Setup WebSocket keepalive ping (every 30 seconds)
+        const pingInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+                try {
+                    ws.ping();
+                }
+                catch (e) {
+                    clearInterval(pingInterval);
+                }
+            }
+            else {
+                clearInterval(pingInterval);
+            }
+        }, 30000);
+        session.pingInterval = pingInterval;
         // On attach, send a snapshot of recent backlog so refreshed clients render prior output
         try {
             if (session.backlog && session.backlog.length > 0 && ws.readyState === WebSocket.OPEN) {
@@ -245,12 +261,20 @@ export class TerminalManager {
             }
         });
         ws.on('close', () => {
+            if (session.pingInterval) {
+                clearInterval(session.pingInterval);
+                session.pingInterval = undefined;
+            }
             if (session.websocket === ws) {
                 session.websocket = undefined;
             }
         });
         ws.on('error', (error) => {
             console.error('WebSocket error:', error);
+            if (session.pingInterval) {
+                clearInterval(session.pingInterval);
+                session.pingInterval = undefined;
+            }
             if (session.websocket === ws) {
                 session.websocket = undefined;
             }
@@ -262,10 +286,22 @@ export class TerminalManager {
         if (!session) {
             return false;
         }
+        // Clear main WebSocket ping interval
+        if (session.pingInterval) {
+            clearInterval(session.pingInterval);
+            session.pingInterval = undefined;
+        }
         // Close WebSocket if connected
         if (session.websocket && session.websocket.readyState === WebSocket.OPEN) {
             session.websocket.close();
         }
+        // Clear all preview ping intervals and close preview sockets
+        if (session.previewPingIntervals && session.previewPingIntervals.size > 0) {
+            for (const interval of session.previewPingIntervals.values()) {
+                clearInterval(interval);
+            }
+            session.previewPingIntervals.clear();
+        }
         // Close all preview sockets
         if (session.previewSockets && session.previewSockets.size > 0) {
             for (const ws of Array.from(session.previewSockets)) {
@@ -366,8 +402,27 @@ export class TerminalManager {
             return false;
         if (!session.previewSockets)
             session.previewSockets = new Set();
+        if (!session.previewPingIntervals)
+            session.previewPingIntervals = new Map();
         session.previewSockets.add(ws);
         session.lastActivity = new Date();
+        // Setup WebSocket keepalive ping for preview socket (every 30 seconds)
+        const pingInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+                try {
+                    ws.ping();
+                }
+                catch (e) {
+                    clearInterval(pingInterval);
+                    session.previewPingIntervals?.delete(ws);
+                }
+            }
+            else {
+                clearInterval(pingInterval);
+                session.previewPingIntervals?.delete(ws);
+            }
+        }, 30000);
+        session.previewPingIntervals.set(ws, pingInterval);
         // On attach, send a snapshot of recent backlog (last 4KB)
         try {
             const backlog = session.backlog || '';
@@ -382,9 +437,19 @@ export class TerminalManager {
             // Ignore messages: preview sockets are read-only
         });
         ws.on('close', () => {
+            const interval = session.previewPingIntervals?.get(ws);
+            if (interval) {
+                clearInterval(interval);
+                session.previewPingIntervals?.delete(ws);
+            }
             session.previewSockets?.delete(ws);
         });
         ws.on('error', () => {
+            const interval = session.previewPingIntervals?.get(ws);
+            if (interval) {
+                clearInterval(interval);
+                session.previewPingIntervals?.delete(ws);
+            }
             session.previewSockets?.delete(ws);
         });
         return true;

package/dist/routes/api/v1/ai/route.d.ts

@@ -1,8 +1,2 @@
 import { Context } from 'hono';
-export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">) | (Response & import("hono").TypedResponse<{
-    response: any;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+export declare function POST(c: Context): Promise<Response>;

package/dist/routes/api/v1/ai/route.js

@@ -34,7 +34,7 @@ function getGlobalApiKey(provider) {
 }
 export async function POST(c) {
     try {
-        const { message: userMessage, history, model, context, contextContent, agentPersona, systemPrompt: systemOverride, maxTokens, enableTools, attachedContextFiles } = await c.req.json();
+        const { message: userMessage, history, model, context, contextContent, agentPersona, systemPrompt: systemOverride, maxTokens, enableTools, attachedContextFiles, stream } = await c.req.json();
         if (!userMessage) {
             return c.json({ error: "Message is required" }, 400);
         }
@@ -95,7 +95,8 @@ export async function POST(c) {
             model: model || "openai/gpt-4o",
             messages: messagesPayload,
             temperature: 0.7,
-            max_tokens: typeof maxTokens === 'number' ? Math.max(256, Math.min(4000, Math.floor(maxTokens))) : 2000,
+            max_tokens: typeof maxTokens === 'number' ? Math.max(256, Math.min(8000, Math.floor(maxTokens))) : 8000,
+            stream: stream === true,
         };
         // Add tools if enabled
         if (tools) {
@@ -124,6 +125,17 @@ export async function POST(c) {
             console.error("OpenRouter API error:", error);
             return c.json({ error: "Failed to get AI response" }, 500);
         }
+        // Handle streaming response
+        if (stream === true && response.body) {
+            return c.newResponse(response.body, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                },
+            });
+        }
         const data = await response.json();
         const aiMessage = data.choices?.[0]?.message;
         if (!aiMessage) {
@@ -143,6 +155,7 @@ export async function POST(c) {
                 }))
             ];
             // Get final response from AI with tool results
+            // Use lower max_tokens for tool result synthesis (typically just needs to summarize)
             const finalResponse = await fetch("https://openrouter.ai/api/v1/chat/completions", {
                 method: "POST",
                 headers: {
@@ -154,8 +167,8 @@ export async function POST(c) {
                 body: JSON.stringify({
                     model: model || "openai/gpt-4o",
                     messages: messagesWithTools,
-                    temperature: 0.7,
-                    max_tokens: typeof maxTokens === 'number' ? Math.max(256, Math.min(4000, Math.floor(maxTokens))) : 2000,
+                    temperature: 0.5, // Lower temperature for more consistent tool result summaries
+                    max_tokens: 2000, // Reduced from 8000 - tool summaries don't need to be as long
                 }),
             });
             if (!finalResponse.ok) {
@@ -179,9 +192,9 @@ export async function POST(c) {
     }
 }
 async function executeToolCalls(toolCalls) {
-    const results = [];
     const storage = new FileStorageAdapter();
-    for (const toolCall of toolCalls) {
+    // Execute all tool calls in parallel for better performance
+    const resultPromises = toolCalls.map(async (toolCall) => {
         try {
             // Handle both function calling formats
             const functionName = toolCall.function?.name || toolCall.name;
@@ -199,7 +212,7 @@ async function executeToolCalls(toolCalls) {
             else if (functionName === 'knowledge_documents') {
                 result = await executeKnowledgeToolDirect(functionArgs);
             }
-            results.push({
+            return {
                 tool_call_id: toolCall.id,
                 content: JSON.stringify({
                     success: result.success,
@@ -207,19 +220,19 @@ async function executeToolCalls(toolCalls) {
                     message: result.message,
                     error: result.error
                 })
-            });
+            };
         }
         catch (error) {
-            results.push({
+            return {
                 tool_call_id: toolCall.id,
                 content: JSON.stringify({
                     success: false,
                     error: error instanceof Error ? error.message : 'Unknown error'
                 })
-            });
+            };
         }
-    }
-    return results;
+    });
+    return Promise.all(resultPromises);
 }
 async function executeProposalsToolDirect(args, storage) {
     const { operation, id, filters, proposal } = args;

package/dist/routes/api/v1/git/index.js

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { getRepoStatus, listBranches, createBranch, deleteBranch, pushCurrent, pullCurrent, listWorktrees, addWorktree, removeWorktree, commitInWorktree, pushWorktree, pullWorktree, } from '../../../../lib/git.js';
+import { getRepoStatus, listBranches, createBranch, deleteBranch, switchBranch, mergeBranch, pushCurrent, pullCurrent, listWorktrees, addWorktree, removeWorktree, commitInWorktree, pushWorktree, pullWorktree, checkRemoteAuth, getCredentialConfig, storeCredentials, } from '../../../../lib/git.js';
 import { loadGitSettings, setDefaultWorktreePath } from '../../../../lib/git-settings.js';
 const app = new Hono();
 // Settings
@@ -38,6 +38,42 @@ app.get('/status', async (c) => {
         return c.json({ success: false, error: { message: e.message } }, 500);
     }
 });
+// Auth Status
+app.get('/auth-status', async (c) => {
+    try {
+        const authStatus = await checkRemoteAuth();
+        return c.json({ success: true, data: authStatus });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+// Credential Config
+app.get('/credential-config', async (c) => {
+    try {
+        const config = await getCredentialConfig();
+        return c.json({ success: true, data: config });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+// Store Credentials
+app.post('/credentials', async (c) => {
+    try {
+        const body = await c.req.json();
+        const username = String(body?.username || '');
+        const password = String(body?.password || '');
+        if (!username || !password) {
+            return c.json({ success: false, error: { message: 'Username and password are required' } }, 400);
+        }
+        await storeCredentials(username, password);
+        return c.json({ success: true, data: { message: 'Credentials stored successfully' } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
 // Branches
 app.get('/branches', async (c) => {
     try {
@@ -72,6 +108,32 @@ app.delete('/branches/:branch', async (c) => {
         return c.json({ success: false, error: { message: e.message } }, 500);
     }
 });
+app.post('/branches/:branch/switch', async (c) => {
+    try {
+        const name = c.req.param('branch');
+        await switchBranch(name);
+        return c.json({ success: true, data: { switched: name } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.post('/branches/:branch/merge', async (c) => {
+    try {
+        const name = c.req.param('branch');
+        let strategy;
+        try {
+            strategy = await c.req.json();
+        }
+        catch { }
+        const mergeStrategy = strategy?.strategy === 'squash' || strategy?.strategy === 'rebase' ? strategy.strategy : 'merge';
+        const result = await mergeBranch(name, mergeStrategy);
+        return c.json({ success: true, data: { branch: name, strategy: mergeStrategy, result } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
 // Commits (in current repo root)
 app.post('/commits', async (c) => {
     try {

package/dist/routes/api/v1/jobs/[id]/route.d.ts

@@ -0,0 +1,133 @@
+import { Context } from 'hono';
+import { ScheduledJobStatus } from '@lovelybunch/types';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        name: string;
+        description?: string;
+        prompt: string;
+        model: string;
+        status: ScheduledJobStatus;
+        schedule: {
+            type: "cron";
+            expression: string;
+            timezone?: string;
+            description?: string;
+        } | {
+            type: "interval";
+            hours: number;
+            daysOfWeek: import("@lovelybunch/types").DayOfWeek[];
+            timezone?: string;
+            anchorHour?: number;
+        };
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            lastRunAt?: string;
+            nextRunAt?: string;
+        };
+        runs: {
+            id: string;
+            jobId: string;
+            trigger: import("@lovelybunch/types").ScheduledJobTrigger;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            startedAt: string;
+            finishedAt?: string;
+            outputPath?: string;
+            summary?: string;
+            error?: string;
+            cliCommand?: string;
+        }[];
+        tags?: string[];
+        contextPaths?: string[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function PATCH(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        name: string;
+        description?: string;
+        prompt: string;
+        model: string;
+        status: ScheduledJobStatus;
+        schedule: {
+            type: "cron";
+            expression: string;
+            timezone?: string;
+            description?: string;
+        } | {
+            type: "interval";
+            hours: number;
+            daysOfWeek: import("@lovelybunch/types").DayOfWeek[];
+            timezone?: string;
+            anchorHour?: number;
+        };
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            lastRunAt?: string;
+            nextRunAt?: string;
+        };
+        runs: {
+            id: string;
+            jobId: string;
+            trigger: import("@lovelybunch/types").ScheduledJobTrigger;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            startedAt: string;
+            finishedAt?: string;
+            outputPath?: string;
+            summary?: string;
+            error?: string;
+            cliCommand?: string;
+        }[];
+        tags?: string[];
+        contextPaths?: string[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function DELETE(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

package/dist/routes/api/v1/jobs/[id]/route.js

@@ -0,0 +1,135 @@
+import { JobStore } from '../../../../../lib/jobs/job-store.js';
+import { getGlobalJobScheduler } from '../../../../../lib/jobs/global-job-scheduler.js';
+import { normalizeSchedule, normalizeStatus, } from '../route.js';
+const store = new JobStore();
+const scheduler = getGlobalJobScheduler();
+function normalizeScheduleUpdate(current, incoming) {
+    if (!incoming)
+        return current;
+    const scheduleInput = {
+        ...(current.type === 'interval' ? current : {}),
+        ...(current.type === 'cron' ? current : {}),
+        ...incoming,
+        type: incoming?.type ?? current.type
+    };
+    return normalizeSchedule(scheduleInput);
+}
+function normalizeStatusUpdate(current, status) {
+    if (status === undefined)
+        return current;
+    return normalizeStatus(status);
+}
+export async function GET(c) {
+    try {
+        const id = c.req.param('id');
+        const job = await store.getJob(id);
+        if (!job) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'JOB_NOT_FOUND',
+                    message: `Job ${id} not found`
+                }
+            }, 404);
+        }
+        return c.json({ success: true, data: job });
+    }
+    catch (error) {
+        console.error('Failed to fetch job:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'GET_JOB_ERROR',
+                message: error?.message ?? 'Unknown error retrieving job'
+            }
+        }, 500);
+    }
+}
+export async function PATCH(c) {
+    try {
+        const id = c.req.param('id');
+        const existing = await store.getJob(id);
+        if (!existing) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'JOB_NOT_FOUND',
+                    message: `Job ${id} not found`
+                }
+            }, 404);
+        }
+        const body = await c.req.json();
+        let schedule;
+        try {
+            schedule = normalizeScheduleUpdate(existing.schedule, body.schedule);
+        }
+        catch (validationError) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'INVALID_SCHEDULE',
+                    message: validationError?.message || 'Invalid schedule definition.'
+                }
+            }, 400);
+        }
+        const updated = {
+            ...existing,
+            name: typeof body.name === 'string' ? body.name : existing.name,
+            description: typeof body.description === 'string' ? body.description : existing.description,
+            prompt: typeof body.prompt === 'string' ? body.prompt : existing.prompt,
+            model: typeof body.model === 'string' ? body.model : existing.model,
+            status: normalizeStatusUpdate(existing.status, body.status),
+            schedule,
+            tags: Array.isArray(body.tags) ? body.tags : existing.tags,
+            contextPaths: Array.isArray(body.contextPaths) ? body.contextPaths : existing.contextPaths,
+            metadata: {
+                ...existing.metadata,
+                updatedAt: new Date()
+            }
+        };
+        await store.saveJob(updated);
+        await scheduler.refresh(updated.id);
+        const reloaded = await store.getJob(updated.id);
+        return c.json({
+            success: true,
+            data: reloaded ?? updated
+        });
+    }
+    catch (error) {
+        console.error('Failed to update job:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'UPDATE_JOB_ERROR',
+                message: error?.message ?? 'Unknown error updating job'
+            }
+        }, 500);
+    }
+}
+export async function DELETE(c) {
+    try {
+        const id = c.req.param('id');
+        const deleted = await store.deleteJob(id);
+        if (!deleted) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'JOB_NOT_FOUND',
+                    message: `Job ${id} not found`
+                }
+            }, 404);
+        }
+        await scheduler.unregister(id);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        console.error('Failed to delete job:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'DELETE_JOB_ERROR',
+                message: error?.message ?? 'Unknown error deleting job'
+            }
+        }, 500);
+    }
+}

package/dist/routes/api/v1/jobs/[id]/run/route.d.ts

@@ -0,0 +1,31 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        jobId: string;
+        run: {
+            id: string;
+            jobId: string;
+            trigger: import("@lovelybunch/types").ScheduledJobTrigger;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            startedAt: string;
+            finishedAt?: string;
+            outputPath?: string;
+            summary?: string;
+            error?: string;
+            cliCommand?: string;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

package/dist/routes/api/v1/jobs/[id]/run/route.js

@@ -0,0 +1,37 @@
+import { JobStore } from '../../../../../../lib/jobs/job-store.js';
+import { getGlobalJobScheduler } from '../../../../../../lib/jobs/global-job-scheduler.js';
+const store = new JobStore();
+const scheduler = getGlobalJobScheduler();
+export async function POST(c) {
+    try {
+        const id = c.req.param('id');
+        const job = await store.getJob(id);
+        if (!job) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'JOB_NOT_FOUND',
+                    message: `Job ${id} not found`
+                }
+            }, 404);
+        }
+        const run = await scheduler.runNow(id, 'manual');
+        return c.json({
+            success: true,
+            data: {
+                jobId: id,
+                run
+            }
+        });
+    }
+    catch (error) {
+        console.error('Failed to trigger job run:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'RUN_JOB_ERROR',
+                message: error?.message ?? 'Unknown error running job'
+            }
+        }, 500);
+    }
+}

package/dist/routes/api/v1/jobs/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const jobs: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default jobs;

package/dist/routes/api/v1/jobs/index.js

@@ -0,0 +1,14 @@
+import { Hono } from 'hono';
+import { GET, POST } from './route.js';
+import { GET as getJob, PATCH as patchJob, DELETE as deleteJob } from './[id]/route.js';
+import { POST as runJob } from './[id]/run/route.js';
+import { GET as getStatus } from './status/route.js';
+const jobs = new Hono();
+jobs.get('/', GET);
+jobs.post('/', POST);
+jobs.get('/status', getStatus);
+jobs.get('/:id', getJob);
+jobs.patch('/:id', patchJob);
+jobs.delete('/:id', deleteJob);
+jobs.post('/:id/run', runJob);
+export default jobs;