@lovelybunch/api 1.0.69-alpha.1 → 1.0.69-alpha.10

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

@@ -1,7 +1,7 @@
 import { Hono } from 'hono';
 import crypto from 'crypto';
-import { getRepoStatus, listBranches, createBranch, deleteBranch, switchBranch, mergeBranch, pushCurrent, pullCurrent, listWorktrees, addWorktree, removeWorktree, commitInWorktree, pushWorktree, pullWorktree, checkRemoteAuth, getCredentialConfig, storeCredentials, } from '../../../../lib/git.js';
-import { saveGithubToken, clearGithubToken } from '../../../../lib/github-token.js';
+import { getRepoStatus, listBranches, createBranch, deleteBranch, switchBranch, mergeBranch, pushCurrent, pullCurrent, listWorktrees, addWorktree, removeWorktree, commitInWorktree, pushWorktree, pullWorktree, checkRemoteAuth, getCredentialConfig, storeCredentials, getCommitDetails, getFileDiff, setRemoteUrl, } from '../../../../lib/git.js';
+import { saveGithubToken, clearGithubToken, readGithubToken, isGithubTokenValid } from '../../../../lib/github-token.js';
 import { createGithubAuthState, consumeGithubAuthState } from '../../../../lib/github-auth-state.js';
 import { resolveCoconutId, resolveControlPlaneUrl } from '../../../../lib/coconut-context.js';
 import { loadGitSettings, saveGitSettings, isGitAuthMode } from '../../../../lib/git-settings.js';
@@ -78,16 +78,50 @@ app.get('/credential-config', async (c) => {
         return c.json({ success: false, error: { message: e.message } }, 500);
     }
 });
+// Set Remote URL
+app.put('/remote', async (c) => {
+    try {
+        const body = await c.req.json();
+        const remoteUrl = String(body?.remoteUrl || '');
+        if (!remoteUrl) {
+            return c.json({ success: false, error: { message: 'Remote URL is required' } }, 400);
+        }
+        await setRemoteUrl(remoteUrl);
+        // If a GitHub token exists and is valid, store it in the credential helper now that we have a remote
+        try {
+            const tokenRecord = await readGithubToken();
+            if (tokenRecord && isGithubTokenValid(tokenRecord)) {
+                try {
+                    await storeCredentials('x-access-token', tokenRecord.token);
+                    console.log('[git] Successfully stored GitHub token in credential helper after remote creation');
+                }
+                catch (credError) {
+                    console.warn('[git] Failed to store GitHub token in credential helper after remote creation:', credError);
+                    // Don't fail the remote creation if credential storage fails
+                }
+            }
+        }
+        catch (tokenError) {
+            // Ignore token read errors - remote creation should still succeed
+            console.warn('[git] Could not check for GitHub token after remote creation:', tokenError);
+        }
+        return c.json({ success: true, data: { message: 'Remote URL set successfully' } });
+    }
+    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 || '');
+        const remoteUrl = body?.remoteUrl ? String(body.remoteUrl) : undefined;
         if (!username || !password) {
             return c.json({ success: false, error: { message: 'Username and password are required' } }, 400);
         }
-        await storeCredentials(username, password);
+        await storeCredentials(username, password, remoteUrl);
         return c.json({ success: true, data: { message: 'Credentials stored successfully' } });
     }
     catch (e) {
@@ -162,11 +196,21 @@ app.post('/providers/github/token', async (c) => {
             }
         }
         const record = await saveGithubToken(token, expiresAt);
+        // Try to store credentials in the credential helper if a remote exists
         try {
             await storeCredentials('x-access-token', token);
+            console.log('[git] Successfully stored GitHub token in credential helper');
         }
         catch (credError) {
-            console.warn('[git] Failed to install GitHub token into credential store:', credError);
+            // Check if the error is because no remote exists (expected case)
+            const errorMessage = credError?.message || '';
+            if (errorMessage.includes('No git remote configured')) {
+                console.log('[git] GitHub token saved, but no remote configured yet. Token will be stored in credential helper when remote is created.');
+            }
+            else {
+                console.warn('[git] Failed to install GitHub token into credential store:', credError);
+            }
+            // Don't fail token storage if credential helper setup fails - the token is still saved
         }
         return c.json({ success: true, data: { expiresAt: record.expiresAt } });
     }
@@ -340,6 +384,46 @@ app.post('/commits', async (c) => {
         return c.json({ success: false, error: { message: e.message } }, 500);
     }
 });
+// Discard file changes
+app.post('/discard', async (c) => {
+    try {
+        const body = await c.req.json();
+        const filePath = String(body?.file || body?.path || '');
+        if (!filePath) {
+            return c.json({ success: false, error: { message: 'file path required' } }, 400);
+        }
+        const { runGit, getRepoStatus } = await import('../../../../lib/git.js');
+        // Get current status to determine file state
+        const status = await getRepoStatus();
+        const fileChange = status.changes.find((c) => c.path === filePath);
+        if (!fileChange) {
+            return c.json({ success: false, error: { message: 'File not found in uncommitted changes' } }, 404);
+        }
+        const statusCode = fileChange.status.trim();
+        // Handle different file statuses
+        if (statusCode === '??' || statusCode.includes('U')) {
+            // Untracked file - remove it
+            const { unlink } = await import('fs/promises');
+            const { getRepoRoot } = await import('../../../../lib/git.js');
+            const repoRoot = await getRepoRoot();
+            const { join } = await import('path');
+            const fullPath = join(repoRoot, filePath);
+            await unlink(fullPath);
+        }
+        else if (statusCode.includes('D')) {
+            // Deleted file - restore it
+            await runGit(['checkout', '--', filePath]);
+        }
+        else {
+            // Modified or Added file - discard changes
+            await runGit(['checkout', '--', filePath]);
+        }
+        return c.json({ success: true, data: { file: filePath, status: statusCode } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
 // Push / Pull (current)
 app.post('/push', async (c) => {
     try {
@@ -523,4 +607,31 @@ app.post('/worktrees/:name/pull', async (c) => {
         return c.json({ success: false, error: { message: e.message } }, 500);
     }
 });
+// Get commit details
+app.get('/commits/:sha', async (c) => {
+    try {
+        const sha = c.req.param('sha');
+        const details = await getCommitDetails(sha);
+        return c.json({ success: true, data: details });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message || 'Failed to get commit details' } }, 500);
+    }
+});
+// Get file diff for a specific commit
+app.get('/commits/:sha/files/:filepath{.+}', async (c) => {
+    try {
+        const sha = c.req.param('sha');
+        const filepath = c.req.param('filepath');
+        if (!filepath) {
+            return c.json({ success: false, error: { message: 'filepath is required' } }, 400);
+        }
+        const diff = await getFileDiff(sha, filepath);
+        // Return as plain text for easier viewing
+        return c.text(diff);
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message || 'Failed to get file diff' } }, 500);
+    }
+});
 export default app;

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

@@ -47,6 +47,9 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
         }[];
         tags?: string[];
         contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -108,6 +111,9 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
         }[];
         tags?: string[];
         contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

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

@@ -82,6 +82,15 @@ export async function PATCH(c) {
             schedule,
             tags: Array.isArray(body.tags) ? body.tags : existing.tags,
             contextPaths: Array.isArray(body.contextPaths) ? body.contextPaths : existing.contextPaths,
+            agentId: body.agentId !== undefined
+                ? (typeof body.agentId === 'string' && body.agentId ? body.agentId : undefined)
+                : existing.agentId,
+            agentIds: body.agentIds !== undefined
+                ? (Array.isArray(body.agentIds) ? body.agentIds.filter((s) => typeof s === 'string') : undefined)
+                : existing.agentIds,
+            mcpServers: body.mcpServers !== undefined
+                ? (Array.isArray(body.mcpServers) ? body.mcpServers.filter((s) => typeof s === 'string') : undefined)
+                : existing.mcpServers,
             metadata: {
                 ...existing.metadata,
                 updatedAt: new Date()

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

@@ -0,0 +1,14 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

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

@@ -0,0 +1,64 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { JobStore } from '../../../../../../../../lib/jobs/job-store.js';
+import { getProjectRoot } from '../../../../../../../../lib/project-paths.js';
+const store = new JobStore();
+export async function GET(c) {
+    try {
+        const jobId = c.req.param('id');
+        const runId = c.req.param('runId');
+        const job = await store.getJob(jobId);
+        if (!job) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'JOB_NOT_FOUND',
+                    message: `Job ${jobId} not found`
+                }
+            }, 404);
+        }
+        const run = job.runs.find((r) => r.id === runId);
+        if (!run) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'RUN_NOT_FOUND',
+                    message: `Run ${runId} not found for job ${jobId}`
+                }
+            }, 404);
+        }
+        // Construct log path - use outputPath from run if available, otherwise construct it
+        const projectRoot = await getProjectRoot();
+        const logPath = run.outputPath
+            ? path.join(projectRoot, run.outputPath)
+            : path.join(projectRoot, '.nut', 'jobs', 'logs', jobId, `${runId}.log`);
+        try {
+            const logContent = await fs.readFile(logPath, 'utf-8');
+            // Return as plain text for easier viewing
+            return c.text(logContent);
+        }
+        catch (fileError) {
+            if (fileError?.code === 'ENOENT') {
+                return c.json({
+                    success: false,
+                    error: {
+                        code: 'LOG_NOT_FOUND',
+                        message: `Log file not found for run ${runId}`,
+                        logPath: run.outputPath || `(expected at ${logPath})`
+                    }
+                }, 404);
+            }
+            throw fileError;
+        }
+    }
+    catch (error) {
+        console.error('Failed to fetch job run log:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'GET_LOG_ERROR',
+                message: error?.message ?? 'Unknown error retrieving job run log'
+            }
+        }, 500);
+    }
+}

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

@@ -0,0 +1,28 @@
+import { Context } from 'hono';
+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;
+        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]/runs/[runId]/route.js

@@ -0,0 +1,39 @@
+import { JobStore } from '../../../../../../../lib/jobs/job-store.js';
+const store = new JobStore();
+export async function GET(c) {
+    try {
+        const jobId = c.req.param('id');
+        const runId = c.req.param('runId');
+        const job = await store.getJob(jobId);
+        if (!job) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'JOB_NOT_FOUND',
+                    message: `Job ${jobId} not found`
+                }
+            }, 404);
+        }
+        const run = job.runs.find((r) => r.id === runId);
+        if (!run) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'RUN_NOT_FOUND',
+                    message: `Run ${runId} not found for job ${jobId}`
+                }
+            }, 404);
+        }
+        return c.json({ success: true, data: run });
+    }
+    catch (error) {
+        console.error('Failed to fetch job run:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'GET_RUN_ERROR',
+                message: error?.message ?? 'Unknown error retrieving job run'
+            }
+        }, 500);
+    }
+}

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

@@ -2,6 +2,8 @@ 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 getRun } from './[id]/runs/[runId]/route.js';
+import { GET as getRunLog } from './[id]/runs/[runId]/log/route.js';
 import { GET as getStatus } from './status/route.js';
 const jobs = new Hono();
 jobs.get('/', GET);
@@ -11,4 +13,6 @@ jobs.get('/:id', getJob);
 jobs.patch('/:id', patchJob);
 jobs.delete('/:id', deleteJob);
 jobs.post('/:id/run', runJob);
+jobs.get('/:id/runs/:runId', getRun);
+jobs.get('/:id/runs/:runId/log', getRunLog);
 export default jobs;

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

@@ -43,6 +43,9 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
         }[];
         tags?: string[];
         contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
     }[];
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -98,6 +101,9 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
         }[];
         tags?: string[];
         contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
     };
 }, 201, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

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

@@ -122,6 +122,9 @@ export async function POST(c) {
             runs: [],
             tags: Array.isArray(body.tags) ? body.tags : [],
             contextPaths: Array.isArray(body.contextPaths) ? body.contextPaths : [],
+            agentId: body.agentId && typeof body.agentId === 'string' ? body.agentId : undefined,
+            agentIds: Array.isArray(body.agentIds) ? body.agentIds.filter((s) => typeof s === 'string') : undefined,
+            mcpServers: Array.isArray(body.mcpServers) ? body.mcpServers.filter((s) => typeof s === 'string') : undefined,
         };
         await store.saveJob(job);
         await scheduler.refresh(job.id);

package/dist/routes/api/v1/user/settings/route.js

@@ -1,5 +1,8 @@
 import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
 import { loadUserSettings, saveUserSettings } from '../../../../../lib/user-preferences.js';
+import { findGaitDirectory } from '../../../../../lib/gait-path.js';
 const app = new Hono();
 /**
  * GET /api/v1/user/settings
@@ -22,9 +25,9 @@ app.get('/', async (c) => {
 app.put('/', async (c) => {
     try {
         const body = await c.req.json();
-        const { profile, preferences } = body;
-        if (!profile && !preferences) {
-            return c.json({ success: false, error: 'Profile or preferences data required' }, 400);
+        const { profile, preferences, coconut } = body;
+        if (!profile && !preferences && !coconut) {
+            return c.json({ success: false, error: 'Profile, preferences, or coconut data required' }, 400);
         }
         let settings = await loadUserSettings();
         if (profile) {
@@ -41,6 +44,43 @@ app.put('/', async (c) => {
             };
         }
         await saveUserSettings(settings);
+        // If coconut.id is provided, update .nut/config.json
+        if (coconut?.id) {
+            try {
+                const gaitDir = await findGaitDirectory();
+                if (gaitDir) {
+                    const configPath = path.join(gaitDir, 'config.json');
+                    // Load existing config
+                    let config = {};
+                    try {
+                        const content = await fs.readFile(configPath, 'utf-8');
+                        config = JSON.parse(content);
+                    }
+                    catch (error) {
+                        if (error.code === 'ENOENT') {
+                            config = {};
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                    // Ensure .nut directory exists
+                    const configDir = path.dirname(configPath);
+                    await fs.mkdir(configDir, { recursive: true });
+                    // Update coconut.id
+                    if (!config.coconut) {
+                        config.coconut = {};
+                    }
+                    config.coconut.id = coconut.id;
+                    // Save config
+                    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+                }
+            }
+            catch (error) {
+                console.error('Failed to update coconut.id in config.json:', error);
+                // Don't fail the request if config update fails
+            }
+        }
         return c.json({ success: true, data: settings });
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/api",
-  "version": "1.0.69-alpha.1",
+  "version": "1.0.69-alpha.10",
   "type": "module",
   "main": "dist/server-with-static.js",
   "exports": {
@@ -36,9 +36,9 @@
   "dependencies": {
     "@hono/node-server": "^1.13.7",
     "@hono/node-ws": "^1.0.6",
-    "@lovelybunch/core": "^1.0.69-alpha.1",
-    "@lovelybunch/mcp": "^1.0.69-alpha.1",
-    "@lovelybunch/types": "^1.0.69-alpha.1",
+    "@lovelybunch/core": "^1.0.69-alpha.10",
+    "@lovelybunch/mcp": "^1.0.69-alpha.10",
+    "@lovelybunch/types": "^1.0.69-alpha.10",
     "arctic": "^1.9.2",
     "bcrypt": "^5.1.1",
     "cookie": "^0.6.0",