atoo-studio 0.0.1 → 0.0.2

package/dist/src/handlers/projects.js

@@ -0,0 +1,895 @@
+import { Router } from 'express';
+import fs from 'fs';
+import fsp from 'fs/promises';
+import path from 'path';
+import archiver from 'archiver';
+import { db } from '../state/db.js';
+import { getFileTree, readFileContent } from '../services/fs-browser.js';
+import { getRemoteFileTree, readRemoteFileContent } from '../services/remote-fs-browser.js';
+import * as gitOps from '../services/git-ops.js';
+import * as remoteGitOps from '../services/remote-git-ops.js';
+import { sshManager } from '../services/ssh-manager.js';
+import { watchProject, unwatchProject, reconcileWorktrees } from '../services/project-watcher.js';
+export const projectsRouter = Router();
+// Helper: get project context (local or remote)
+function getProjectContext(projectId) {
+    const project = db.getProject(projectId);
+    if (!project)
+        return null;
+    if (project.ssh_connection_id) {
+        return { cwd: project.remote_path || project.path, connectionId: project.ssh_connection_id };
+    }
+    return { cwd: project.path };
+}
+// ═══════════════════════════════════════════════════
+// PROJECT ENDPOINTS
+// ═══════════════════════════════════════════════════
+// Convenience: list all projects across all environments
+projectsRouter.get('/api/projects', async (_req, res) => {
+    const projects = db.listAllProjects();
+    const withGit = await Promise.all(projects.map(async (p) => {
+        let isGit = false;
+        try {
+            await fsp.access(path.join(p.path, '.git'));
+            isGit = true;
+        }
+        catch { }
+        return { ...p, isGit };
+    }));
+    res.json(withGit);
+});
+projectsRouter.delete('/api/projects/:id', (req, res) => {
+    const deleted = db.deleteProject(req.params.id);
+    if (!deleted)
+        return res.status(404).json({ error: 'Project not found' });
+    res.json({ success: true });
+});
+// Get environments a project is linked to
+projectsRouter.get('/api/projects/:id/environments', (req, res) => {
+    const project = db.getProject(req.params.id);
+    if (!project)
+        return res.status(404).json({ error: 'Project not found' });
+    const envs = db.getEnvironmentsForProject(req.params.id);
+    res.json(envs);
+});
+// Sessions filtered by project cwd
+projectsRouter.get('/api/projects/:id/sessions', (req, res) => {
+    const project = db.getProject(req.params.id);
+    if (!project)
+        return res.status(404).json({ error: 'Project not found' });
+    res.json([]);
+});
+// ═══════════════════════════════════════════════════
+// FILE ENDPOINTS
+// ═══════════════════════════════════════════════════
+projectsRouter.get('/api/projects/:id/files', async (req, res) => {
+    const ctx = getProjectContext(req.params.id);
+    if (!ctx)
+        return res.status(404).json({ error: 'Project not found' });
+    try {
+        const rootPath = req.query.rootPath || ctx.cwd;
+        const showHidden = req.query.showHidden === 'true';
+        const maxDepth = req.query.maxDepth != null ? parseInt(req.query.maxDepth, 10) : undefined;
+        if (ctx.connectionId) {
+            const tree = await getRemoteFileTree(ctx.connectionId, rootPath);
+            res.json(tree);
+        }
+        else {
+            const tree = await getFileTree(rootPath, 0, showHidden, maxDepth);
+            res.json(tree);
+            // Start watching when project root is first accessed (lazy — avoids watching all projects on startup)
+            if (!req.query.rootPath && !ctx.connectionId) {
+                setImmediate(() => watchProject(req.params.id, ctx.cwd));
+            }
+        }
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/files', async (req, res) => {
+    const filePath = req.query.path;
+    const connId = req.query.ssh_connection_id;
+    if (!filePath)
+        return res.status(400).json({ error: 'path query parameter required' });
+    try {
+        if (connId) {
+            const { content, lang } = await readRemoteFileContent(connId, filePath);
+            res.json({ content, lang, path: filePath });
+        }
+        else {
+            const resolved = path.resolve(filePath);
+            const result = readFileContent(resolved);
+            res.json({ content: result.content, lang: result.lang, path: resolved, isBinary: result.isBinary, size: result.size });
+        }
+    }
+    catch (err) {
+        res.status(404).json({ error: err.message });
+    }
+});
+// Serve raw file bytes (for images, hex view, etc.)
+projectsRouter.get('/api/files/raw', (req, res) => {
+    const filePath = req.query.path;
+    if (!filePath)
+        return res.status(400).json({ error: 'path required' });
+    try {
+        const resolved = path.resolve(filePath);
+        if (!fs.existsSync(resolved))
+            return res.status(404).json({ error: 'not found' });
+        const stat = fs.statSync(resolved);
+        // For hex view: support range requests for chunked loading
+        const offset = parseInt(req.query.offset) || 0;
+        const length = parseInt(req.query.length) || 0;
+        if (length > 0) {
+            // Return a chunk as base64 for hex viewer
+            const fd = fs.openSync(resolved, 'r');
+            const buf = Buffer.alloc(Math.min(length, 1024 * 1024)); // cap at 1MB per chunk
+            const bytesRead = fs.readSync(fd, buf, 0, buf.length, offset);
+            fs.closeSync(fd);
+            return res.json({ data: buf.subarray(0, bytesRead).toString('base64'), size: stat.size, bytesRead });
+        }
+        // Stream full file with correct content type
+        const ext = path.extname(resolved).toLowerCase().replace('.', '');
+        const mimeMap = {
+            png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif',
+            webp: 'image/webp', svg: 'image/svg+xml', bmp: 'image/bmp', ico: 'image/x-icon',
+            avif: 'image/avif', tiff: 'image/tiff', tif: 'image/tiff',
+            pdf: 'application/pdf', zip: 'application/zip', gz: 'application/gzip',
+            mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg',
+            mp4: 'video/mp4', webm: 'video/webm',
+            woff: 'font/woff', woff2: 'font/woff2', ttf: 'font/ttf', otf: 'font/otf',
+            json: 'application/json', xml: 'application/xml',
+            html: 'text/html', css: 'text/css', js: 'text/javascript', txt: 'text/plain',
+        };
+        const ct = mimeMap[ext] || 'application/octet-stream';
+        res.setHeader('Content-Type', ct);
+        res.setHeader('Content-Length', stat.size);
+        fs.createReadStream(resolved).pipe(res);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// Stream a directory as a zip file (for drag-out folder download)
+projectsRouter.get('/api/files/zip', (req, res) => {
+    const dirPath = req.query.path;
+    if (!dirPath)
+        return res.status(400).json({ error: 'path required' });
+    try {
+        const resolved = path.resolve(dirPath);
+        if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+            return res.status(404).json({ error: 'directory not found' });
+        }
+        const dirName = path.basename(resolved);
+        res.setHeader('Content-Type', 'application/zip');
+        res.setHeader('Content-Disposition', `attachment; filename="${dirName}.zip"`);
+        const archive = archiver('zip', { zlib: { level: 5 } });
+        archive.on('error', (err) => res.status(500).end());
+        archive.pipe(res);
+        archive.directory(resolved, false);
+        archive.finalize();
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// Write bytes at specific offsets (hex editor save)
+projectsRouter.patch('/api/files/raw', (req, res) => {
+    const { path: filePath, edits } = req.body;
+    if (!filePath || !Array.isArray(edits))
+        return res.status(400).json({ error: 'path and edits[] required' });
+    try {
+        const resolved = path.resolve(filePath);
+        const fd = fs.openSync(resolved, 'r+');
+        for (const edit of edits) {
+            const buf = Buffer.from([edit.value & 0xFF]);
+            fs.writeSync(fd, buf, 0, 1, edit.offset);
+        }
+        fs.closeSync(fd);
+        const stat = fs.statSync(resolved);
+        res.json({ success: true, size: stat.size });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// Search bytes in file (hex editor search)
+projectsRouter.post('/api/files/raw/search', (req, res) => {
+    const { path: filePath, pattern, fromOffset = 0, maxResults = 100 } = req.body;
+    if (!filePath || !pattern)
+        return res.status(400).json({ error: 'path and pattern required' });
+    try {
+        const resolved = path.resolve(filePath);
+        const needle = Buffer.from(pattern, 'base64');
+        if (needle.length === 0)
+            return res.json({ matches: [] });
+        const stat = fs.statSync(resolved);
+        const fd = fs.openSync(resolved, 'r');
+        const matches = [];
+        const scanChunk = 256 * 1024;
+        let pos = fromOffset;
+        while (pos < stat.size && matches.length < maxResults) {
+            const readLen = Math.min(scanChunk + needle.length - 1, stat.size - pos);
+            const buf = Buffer.alloc(readLen);
+            const bytesRead = fs.readSync(fd, buf, 0, readLen, pos);
+            const data = buf.subarray(0, bytesRead);
+            let idx = 0;
+            while (idx <= data.length - needle.length && matches.length < maxResults) {
+                const found = data.indexOf(needle, idx);
+                if (found === -1)
+                    break;
+                matches.push(pos + found);
+                idx = found + 1;
+            }
+            pos += scanChunk;
+        }
+        fs.closeSync(fd);
+        res.json({ matches, size: stat.size });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.put('/api/files', async (req, res) => {
+    const { path: filePath, content, ssh_connection_id } = req.body;
+    if (!filePath || typeof content !== 'string') {
+        return res.status(400).json({ error: 'path and content are required' });
+    }
+    try {
+        if (ssh_connection_id) {
+            await sshManager.sftpWriteFile(ssh_connection_id, filePath, content);
+            res.json({ success: true, path: filePath });
+        }
+        else {
+            const resolved = path.resolve(filePath);
+            fs.writeFileSync(resolved, content, 'utf-8');
+            res.json({ success: true, path: resolved });
+        }
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/files/rename', async (req, res) => {
+    const { from, to, ssh_connection_id } = req.body;
+    if (!from || !to)
+        return res.status(400).json({ error: 'from and to are required' });
+    try {
+        if (ssh_connection_id) {
+            await sshManager.sftpRename(ssh_connection_id, from, to);
+        }
+        else {
+            fs.renameSync(path.resolve(from), path.resolve(to));
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/files/create', async (req, res) => {
+    const { path: filePath, type, ssh_connection_id } = req.body;
+    if (!filePath)
+        return res.status(400).json({ error: 'path is required' });
+    try {
+        if (ssh_connection_id) {
+            if (type === 'dir') {
+                await sshManager.exec(ssh_connection_id, `mkdir -p '${filePath.replace(/'/g, "'\\''")}'`);
+            }
+            else {
+                const dir = filePath.substring(0, filePath.lastIndexOf('/'));
+                if (dir)
+                    await sshManager.exec(ssh_connection_id, `mkdir -p '${dir.replace(/'/g, "'\\''")}'`);
+                await sshManager.sftpWriteFile(ssh_connection_id, filePath, '');
+            }
+        }
+        else {
+            const resolved = path.resolve(filePath);
+            if (type === 'dir') {
+                fs.mkdirSync(resolved, { recursive: true });
+            }
+            else {
+                fs.mkdirSync(path.dirname(resolved), { recursive: true });
+                fs.writeFileSync(resolved, '');
+            }
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.delete('/api/files', async (req, res) => {
+    const filePath = req.query.path;
+    const connId = req.query.ssh_connection_id;
+    if (!filePath)
+        return res.status(400).json({ error: 'path query parameter required' });
+    try {
+        if (connId) {
+            await sshManager.exec(connId, `rm -rf '${filePath.replace(/'/g, "'\\''")}'`);
+        }
+        else {
+            const resolved = path.resolve(filePath);
+            const stat = fs.statSync(resolved);
+            if (stat.isDirectory()) {
+                fs.rmSync(resolved, { recursive: true, force: true });
+            }
+            else {
+                fs.unlinkSync(resolved);
+            }
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/files/move', async (req, res) => {
+    const { from, to, ssh_connection_id } = req.body;
+    if (!from || !to)
+        return res.status(400).json({ error: 'from and to are required' });
+    try {
+        if (ssh_connection_id) {
+            await sshManager.sftpRename(ssh_connection_id, from, to);
+        }
+        else {
+            fs.renameSync(path.resolve(from), path.resolve(to));
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// Binary file save (for screenshots etc.)
+projectsRouter.post('/api/files/binary', async (req, res) => {
+    const { path: filePath, data, ssh_connection_id } = req.body;
+    if (!filePath || !data) {
+        return res.status(400).json({ error: 'path and data (base64) are required' });
+    }
+    try {
+        const buf = Buffer.from(data, 'base64');
+        if (ssh_connection_id) {
+            await sshManager.sftpWriteFile(ssh_connection_id, filePath, buf.toString('binary'));
+        }
+        else {
+            const resolved = path.resolve(filePath);
+            fs.mkdirSync(path.dirname(resolved), { recursive: true });
+            fs.writeFileSync(resolved, buf);
+        }
+        res.json({ success: true, path: filePath });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// Streaming file upload — bypasses body-parser, handles files of any size
+projectsRouter.post('/api/files/upload', (req, res) => {
+    const filePath = req.query.path;
+    const sshConnectionId = req.query.ssh_connection_id;
+    if (!filePath) {
+        return res.status(400).json({ error: 'path query parameter is required' });
+    }
+    if (sshConnectionId) {
+        // For SSH: collect into buffer then write via SFTP
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', async () => {
+            try {
+                const buf = Buffer.concat(chunks);
+                await sshManager.sftpWriteFile(sshConnectionId, filePath, buf.toString('binary'));
+                res.json({ success: true, path: filePath });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        req.on('error', (err) => res.status(500).json({ error: err.message }));
+    }
+    else {
+        // Stream directly to disk
+        try {
+            const resolved = path.resolve(filePath);
+            fs.mkdirSync(path.dirname(resolved), { recursive: true });
+            const ws = fs.createWriteStream(resolved);
+            req.pipe(ws);
+            ws.on('finish', () => res.json({ success: true, path: filePath }));
+            ws.on('error', (err) => res.status(500).json({ error: err.message }));
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    }
+});
+// Screenshot via Puppeteer
+let screenshotBrowser = null;
+projectsRouter.post('/api/screenshot', async (req, res) => {
+    const { url, width = 1280, height = 720, fullPage = false } = req.body;
+    if (!url)
+        return res.status(400).json({ error: 'url is required' });
+    try {
+        const puppeteer = await import('puppeteer');
+        if (!screenshotBrowser) {
+            screenshotBrowser = await puppeteer.default.launch({
+                headless: true,
+                args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
+            });
+        }
+        const page = await screenshotBrowser.newPage();
+        await page.setViewport({ width, height, deviceScaleFactor: 1 });
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: 15000 });
+        const image = await page.screenshot({ fullPage, encoding: 'base64', type: 'png' });
+        await page.close();
+        res.json({ image, width, height });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// ═══════════════════════════════════════════════════
+// GIT ENDPOINTS (scoped to project cwd)
+// ═══════════════════════════════════════════════════
+function getProjectCwd(req, res) {
+    const project = db.getProject(req.params.id);
+    if (!project) {
+        res.status(404).json({ error: 'Project not found' });
+        return null;
+    }
+    const cwd = req.query.cwd || (project.ssh_connection_id ? (project.remote_path || project.path) : project.path);
+    if (project.ssh_connection_id) {
+        return { cwd, connectionId: project.ssh_connection_id };
+    }
+    return { cwd };
+}
+projectsRouter.get('/api/projects/:id/git/status', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const status = ctx.connectionId
+            ? await remoteGitOps.gitStatus(ctx.connectionId, ctx.cwd)
+            : await gitOps.gitStatus(ctx.cwd);
+        res.json(status);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/log', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const branch = req.query.branch;
+        const count = parseInt(req.query.count) || 30;
+        const log = ctx.connectionId
+            ? await remoteGitOps.gitLog(ctx.connectionId, ctx.cwd, branch, count)
+            : await gitOps.gitLog(ctx.cwd, branch, count);
+        res.json(log);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/commit-files', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const hash = req.query.hash;
+        if (!hash)
+            return res.status(400).json({ error: 'hash query parameter required' });
+        const files = ctx.connectionId
+            ? await remoteGitOps.gitCommitFiles(ctx.connectionId, ctx.cwd, hash)
+            : await gitOps.gitCommitFiles(ctx.cwd, hash);
+        res.json(files);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/branches', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const result = ctx.connectionId
+            ? await remoteGitOps.gitBranches(ctx.connectionId, ctx.cwd)
+            : await gitOps.gitBranches(ctx.cwd);
+        res.json(result);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/remotes', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const remotes = ctx.connectionId
+            ? await remoteGitOps.gitRemotes(ctx.connectionId, ctx.cwd)
+            : await gitOps.gitRemotes(ctx.cwd);
+        res.json(remotes);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/stash', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const stashes = ctx.connectionId
+            ? await remoteGitOps.gitStashList(ctx.connectionId, ctx.cwd)
+            : await gitOps.gitStashList(ctx.cwd);
+        res.json(stashes);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/show', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const file = req.query.file;
+        const ref = req.query.ref || 'HEAD';
+        if (!file)
+            return res.status(400).json({ error: 'file parameter required' });
+        const content = ctx.connectionId
+            ? await remoteGitOps.gitShowFile(ctx.connectionId, ctx.cwd, file, ref)
+            : await gitOps.gitShowFile(ctx.cwd, file, ref);
+        res.json({ content });
+    }
+    catch (err) {
+        res.status(404).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/diff', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const file = req.query.file;
+        const diff = ctx.connectionId
+            ? await remoteGitOps.gitDiff(ctx.connectionId, ctx.cwd, file)
+            : await gitOps.gitDiff(ctx.cwd, file);
+        res.json({ diff });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/blame', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const file = req.query.file;
+        if (!file)
+            return res.status(400).json({ error: 'file parameter required' });
+        const blame = ctx.connectionId
+            ? await remoteGitOps.gitBlame(ctx.connectionId, ctx.cwd, file)
+            : await gitOps.gitBlame(ctx.cwd, file);
+        res.json({ blame });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/file-log', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const file = req.query.file;
+        if (!file)
+            return res.status(400).json({ error: 'file parameter required' });
+        const log = ctx.connectionId
+            ? await remoteGitOps.gitFileLog(ctx.connectionId, ctx.cwd, file)
+            : await gitOps.gitFileLog(ctx.cwd, file);
+        res.json(log);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/checkout', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { branch } = req.body;
+        if (!branch)
+            return res.status(400).json({ error: 'branch is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitCheckout(ctx.connectionId, ctx.cwd, branch)
+            : await gitOps.gitCheckout(ctx.cwd, branch);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/commit', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { message } = req.body;
+        if (!message)
+            return res.status(400).json({ error: 'message is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitCommit(ctx.connectionId, ctx.cwd, message)
+            : await gitOps.gitCommit(ctx.cwd, message);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/push', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        ctx.connectionId
+            ? await remoteGitOps.gitPush(ctx.connectionId, ctx.cwd)
+            : await gitOps.gitPush(ctx.cwd);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/stash', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        ctx.connectionId
+            ? await remoteGitOps.gitStash(ctx.connectionId, ctx.cwd)
+            : await gitOps.gitStash(ctx.cwd);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/stash/apply', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { id } = req.body;
+        if (!id)
+            return res.status(400).json({ error: 'id is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitStashApply(ctx.connectionId, ctx.cwd, id)
+            : await gitOps.gitStashApply(ctx.cwd, id);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/stash/drop', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { id } = req.body;
+        if (!id)
+            return res.status(400).json({ error: 'id is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitStashDrop(ctx.connectionId, ctx.cwd, id)
+            : await gitOps.gitStashDrop(ctx.cwd, id);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/branch', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { name } = req.body;
+        if (!name)
+            return res.status(400).json({ error: 'name is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitCreateBranch(ctx.connectionId, ctx.cwd, name)
+            : await gitOps.gitCreateBranch(ctx.cwd, name);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/fetch', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        ctx.connectionId
+            ? await remoteGitOps.gitFetch(ctx.connectionId, ctx.cwd)
+            : await gitOps.gitFetch(ctx.cwd);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/remotes', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { name, url } = req.body;
+        if (!name || !url)
+            return res.status(400).json({ error: 'name and url are required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitAddRemote(ctx.connectionId, ctx.cwd, name, url)
+            : await gitOps.gitAddRemote(ctx.cwd, name, url);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.delete('/api/projects/:id/git/remotes/:name', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        ctx.connectionId
+            ? await remoteGitOps.gitRemoveRemote(ctx.connectionId, ctx.cwd, req.params.name)
+            : await gitOps.gitRemoveRemote(ctx.cwd, req.params.name);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.put('/api/projects/:id/git/remotes/:name', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { url } = req.body;
+        if (!url)
+            return res.status(400).json({ error: 'url is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitEditRemote(ctx.connectionId, ctx.cwd, req.params.name, url)
+            : await gitOps.gitEditRemote(ctx.cwd, req.params.name, url);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/revert', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { file } = req.body;
+        ctx.connectionId
+            ? await remoteGitOps.gitRevert(ctx.connectionId, ctx.cwd, file)
+            : await gitOps.gitRevert(ctx.cwd, file);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/stage', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { file } = req.body;
+        if (!file)
+            return res.status(400).json({ error: 'file is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitStageFile(ctx.connectionId, ctx.cwd, file)
+            : await gitOps.gitStageFile(ctx.cwd, file);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/unstage', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { file } = req.body;
+        if (!file)
+            return res.status(400).json({ error: 'file is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitUnstageFile(ctx.connectionId, ctx.cwd, file)
+            : await gitOps.gitUnstageFile(ctx.cwd, file);
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.get('/api/projects/:id/git/worktrees', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const worktrees = ctx.connectionId
+            ? await remoteGitOps.gitWorktreeList(ctx.connectionId, ctx.cwd)
+            : await gitOps.gitWorktreeList(ctx.cwd);
+        res.json(worktrees);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.post('/api/projects/:id/git/worktrees', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const { path: wtPath, branch, newBranch } = req.body;
+        if (!wtPath)
+            return res.status(400).json({ error: 'path is required' });
+        ctx.connectionId
+            ? await remoteGitOps.gitWorktreeAdd(ctx.connectionId, ctx.cwd, wtPath, branch, newBranch)
+            : await gitOps.gitWorktreeAdd(ctx.cwd, wtPath, branch, newBranch);
+        // Reconcile will auto-create the linked project via the watcher,
+        // but also do it immediately so the response is ready
+        if (!ctx.connectionId) {
+            reconcileWorktrees(req.params.id, ctx.cwd);
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+projectsRouter.delete('/api/projects/:id/git/worktrees', async (req, res) => {
+    const ctx = getProjectCwd(req, res);
+    if (!ctx)
+        return;
+    try {
+        const worktreePath = req.query.path;
+        const deleteBranch = req.query.deleteBranch;
+        if (!worktreePath)
+            return res.status(400).json({ error: 'path query parameter required' });
+        // Find and remove the linked child project
+        const childProject = db.findProjectByPath(worktreePath);
+        if (childProject) {
+            unwatchProject(childProject.id);
+            db.deleteProject(childProject.id);
+        }
+        ctx.connectionId
+            ? await remoteGitOps.gitWorktreeRemove(ctx.connectionId, ctx.cwd, worktreePath)
+            : await gitOps.gitWorktreeRemove(ctx.cwd, worktreePath);
+        // Optionally delete the associated branch
+        if (deleteBranch) {
+            try {
+                ctx.connectionId
+                    ? await remoteGitOps.gitBranchDelete(ctx.connectionId, ctx.cwd, deleteBranch)
+                    : await gitOps.gitBranchDelete(ctx.cwd, deleteBranch);
+            }
+            catch (branchErr) {
+                // Non-fatal: worktree was removed but branch deletion failed
+                return res.json({ success: true, branchDeleteError: branchErr.message });
+            }
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});