@minionry/minion 0.7.36

package/dist/server/services/websocket/file-upload-handler.js

@@ -0,0 +1,267 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createWriteStream, existsSync, mkdirSync, rmSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { containsDangerousPatterns, validatePathWithinWorkingDir } from '../pathUtils.js';
+import { getMaxUploadBytes, uploadTooLargeMessage } from '../settings.js';
+import { spacePath } from '../space-layout.js';
+const UPLOAD_TIMEOUT_MS = 120_000;
+export class FileUploadHandler {
+    ctx;
+    activeUploads = new Map();
+    completedUploads = new Map();
+    cleanupInterval;
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.cleanupInterval = setInterval(() => this.cleanupStaleUploads(), 30_000);
+    }
+    getAndClearCompletedUploads(tabId) {
+        const uploads = this.completedUploads.get(tabId) || [];
+        this.completedUploads.delete(tabId);
+        return uploads;
+    }
+    getCompletedUploads(tabId) {
+        return this.completedUploads.get(tabId) || [];
+    }
+    handleUploadStart(ws, send, tabId, data, workingDir, permission) {
+        const { uploadId, fileName, fileSize, mimeType, isImage, totalChunks, targetPath, overwrite } = data;
+        const sendError = (error) => send(ws, {
+            type: 'fileUploadError',
+            tabId,
+            data: { uploadId, error },
+        });
+        const maxUploadBytes = getMaxUploadBytes();
+        if (maxUploadBytes > 0 && fileSize > maxUploadBytes) {
+            sendError(uploadTooLargeMessage(fileSize, maxUploadBytes));
+            return;
+        }
+        const resolved = targetPath !== undefined
+            ? resolveFileTreeTarget({ targetPath, workingDir, permission, overwrite })
+            : resolveAttachmentTarget({ workingDir, tabId, fileName });
+        if (!resolved.ok) {
+            sendError(resolved.error);
+            return;
+        }
+        const stream = createWriteStream(resolved.filePath);
+        stream.on('error', (err) => {
+            sendError(`Upload write failed: ${err instanceof Error ? err.message : String(err)}`);
+            this.cancelUpload(uploadId);
+        });
+        this.activeUploads.set(uploadId, {
+            uploadId,
+            fileName: resolved.fileName,
+            fileSize,
+            mimeType,
+            isImage,
+            totalChunks,
+            receivedChunks: 0,
+            filePath: resolved.filePath,
+            targetRelPath: resolved.targetRelPath,
+            stream,
+            lastActivity: Date.now(),
+        });
+        send(ws, {
+            type: 'fileUploadAck',
+            tabId,
+            data: { uploadId, chunkIndex: -1, status: 'ok' },
+        });
+    }
+    handleUploadChunk(ws, send, tabId, data) {
+        const { uploadId, chunkIndex, content } = data;
+        const upload = this.activeUploads.get(uploadId);
+        if (!upload) {
+            send(ws, {
+                type: 'fileUploadError',
+                tabId,
+                data: { uploadId, error: 'Upload not found or expired' }
+            });
+            return;
+        }
+        try {
+            const buffer = Buffer.from(content, 'base64');
+            upload.receivedChunks++;
+            upload.lastActivity = Date.now();
+            upload.stream.write(buffer, (err) => {
+                if (err)
+                    return;
+                if (!this.activeUploads.has(uploadId))
+                    return;
+                upload.lastActivity = Date.now();
+                send(ws, {
+                    type: 'fileUploadAck',
+                    tabId,
+                    data: { uploadId, chunkIndex, status: 'ok' }
+                });
+            });
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            send(ws, {
+                type: 'fileUploadError',
+                tabId,
+                data: { uploadId, error: `Chunk write failed: ${errorMsg}` }
+            });
+            this.cancelUpload(uploadId);
+        }
+    }
+    handleUploadComplete(ws, send, tabId, data) {
+        const { uploadId } = data;
+        const upload = this.activeUploads.get(uploadId);
+        if (!upload) {
+            send(ws, {
+                type: 'fileUploadError',
+                tabId,
+                data: { uploadId, error: 'Upload not found or expired' }
+            });
+            return;
+        }
+        upload.stream.end(() => {
+            try {
+                const stat = statSync(upload.filePath);
+                if (upload.targetRelPath === undefined) {
+                    const completed = {
+                        uploadId,
+                        fileName: upload.fileName,
+                        filePath: upload.filePath,
+                        isImage: upload.isImage,
+                        mimeType: upload.mimeType,
+                        fileSize: stat.size,
+                    };
+                    const tabUploads = this.completedUploads.get(tabId) || [];
+                    tabUploads.push(completed);
+                    this.completedUploads.set(tabId, tabUploads);
+                }
+                this.activeUploads.delete(uploadId);
+                send(ws, {
+                    type: 'fileUploadReady',
+                    tabId,
+                    data: {
+                        uploadId,
+                        filePath: upload.filePath,
+                        fileName: upload.fileName,
+                        ...(upload.targetRelPath !== undefined ? { targetPath: upload.targetRelPath } : {}),
+                    },
+                });
+                if (upload.targetRelPath !== undefined && this.ctx) {
+                    this.ctx.broadcastToAll({
+                        type: 'fileCreated',
+                        data: {
+                            path: upload.targetRelPath,
+                            name: upload.fileName,
+                            size: stat.size,
+                            modifiedAt: new Date().toISOString(),
+                        },
+                    });
+                }
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                send(ws, {
+                    type: 'fileUploadError',
+                    tabId,
+                    data: { uploadId, error: `File verification failed: ${errorMsg}` }
+                });
+                this.activeUploads.delete(uploadId);
+            }
+        });
+    }
+    handleUploadCancel(_ws, _send, _tabId, data) {
+        this.cancelUpload(data.uploadId);
+    }
+    cancelUpload(uploadId) {
+        const upload = this.activeUploads.get(uploadId);
+        if (!upload)
+            return;
+        try {
+            upload.stream.destroy();
+            if (existsSync(upload.filePath)) {
+                rmSync(upload.filePath, { force: true });
+            }
+        }
+        catch {
+        }
+        this.activeUploads.delete(uploadId);
+    }
+    cleanupStaleUploads() {
+        const now = Date.now();
+        for (const [uploadId, upload] of this.activeUploads) {
+            if (now - upload.lastActivity > UPLOAD_TIMEOUT_MS) {
+                console.warn(`[FileUploadHandler] Upload ${uploadId} timed out, cleaning up`);
+                this.cancelUpload(uploadId);
+            }
+        }
+    }
+    destroy() {
+        clearInterval(this.cleanupInterval);
+        for (const uploadId of this.activeUploads.keys()) {
+            this.cancelUpload(uploadId);
+        }
+    }
+}
+function splitExt(fileName) {
+    const dot = fileName.lastIndexOf('.');
+    if (dot <= 0)
+        return { base: fileName, ext: '' };
+    return { base: fileName.slice(0, dot), ext: fileName.slice(dot) };
+}
+function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+export function resolveFileTreeTarget(opts) {
+    const { targetPath, workingDir, permission, overwrite } = opts;
+    if (permission === 'view') {
+        return { ok: false, error: 'View-only sessions cannot upload files' };
+    }
+    if (containsDangerousPatterns(targetPath)) {
+        return { ok: false, error: 'Invalid characters in target path' };
+    }
+    const validation = validatePathWithinWorkingDir(targetPath, workingDir);
+    if (!validation.valid) {
+        return { ok: false, error: validation.error ?? 'Invalid target path' };
+    }
+    const resolvedPath = validation.resolvedPath;
+    const parent = dirname(resolvedPath);
+    try {
+        ensureDir(parent);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `Failed to create parent directory: ${msg}` };
+    }
+    const lastSlash = targetPath.lastIndexOf('/');
+    const relDir = lastSlash >= 0 ? targetPath.slice(0, lastSlash) : '';
+    const requestedName = lastSlash >= 0 ? targetPath.slice(lastSlash + 1) : targetPath;
+    let finalName = requestedName;
+    let finalAbs = resolvedPath;
+    if (existsSync(finalAbs) && !overwrite) {
+        const { base, ext } = splitExt(requestedName);
+        let counter = 1;
+        do {
+            finalName = `${base} (${counter})${ext}`;
+            finalAbs = join(parent, finalName);
+            counter++;
+        } while (existsSync(finalAbs));
+    }
+    const finalRel = relDir ? `${relDir}/${finalName}` : finalName;
+    return { ok: true, filePath: finalAbs, fileName: finalName, targetRelPath: finalRel };
+}
+function resolveAttachmentTarget(opts) {
+    const { workingDir, tabId, fileName } = opts;
+    const attachDir = spacePath(workingDir, 'tmp', 'attachments', tabId);
+    try {
+        ensureDir(attachDir);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `Failed to create attachment directory: ${msg}` };
+    }
+    let finalName = fileName;
+    let counter = 1;
+    while (existsSync(join(attachDir, finalName))) {
+        const { base, ext } = splitExt(fileName);
+        finalName = `${base}-${counter}${ext}`;
+        counter++;
+    }
+    return { ok: true, filePath: join(attachDir, finalName), fileName: finalName };
+}

package/dist/server/services/websocket/file-utils.js

@@ -0,0 +1,346 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { extname, join, resolve, sep } from 'node:path';
+import { systemPromptsDir } from '../system-prompts.js';
+export const ALWAYS_IGNORE_DIRS = new Set([
+    'node_modules', 'dist', 'dist-ssr', '.git', '__pycache__',
+    '.next', '.turbo', 'build', '.cache', 'coverage',
+    '.parcel-cache', '.nuxt', '.output', '.vercel', '.netlify',
+    '.nyc_output', 'venv', '.venv'
+]);
+export const FILE_TYPE_MAP = {
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.mjs': 'javascript',
+    '.cjs': 'javascript',
+    '.html': 'html',
+    '.htm': 'html',
+    '.css': 'css',
+    '.scss': 'css',
+    '.sass': 'css',
+    '.less': 'css',
+    '.json': 'json',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.xml': 'xml',
+    '.toml': 'config',
+    '.env': 'config',
+    '.gitignore': 'config',
+    '.eslintrc': 'config',
+    '.prettierrc': 'config',
+    '.md': 'markdown',
+    '.mdx': 'markdown',
+    '.txt': 'text',
+    '.rst': 'text',
+    '.png': 'image',
+    '.jpg': 'image',
+    '.jpeg': 'image',
+    '.gif': 'image',
+    '.svg': 'image',
+    '.webp': 'image',
+    '.ico': 'image',
+    '.py': 'python',
+    '.rb': 'ruby',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.java': 'java',
+    '.kt': 'kotlin',
+    '.swift': 'swift',
+    '.c': 'c',
+    '.cpp': 'cpp',
+    '.h': 'c',
+    '.hpp': 'cpp',
+    '.cs': 'csharp',
+    '.php': 'php',
+    '.sh': 'shell',
+    '.bash': 'shell',
+    '.zsh': 'shell',
+    '.fish': 'shell',
+    '.lock': 'lock',
+    '.log': 'log',
+};
+export function getFileType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return FILE_TYPE_MAP[ext] || 'file';
+}
+export function parseGitignore(workingDir) {
+    const gitignorePath = join(workingDir, '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(gitignorePath, 'utf-8');
+        return content
+            .split(/\r?\n/)
+            .filter(line => {
+            const trimmed = line.trim();
+            return trimmed !== '' && !trimmed.startsWith('#');
+        });
+    }
+    catch (error) {
+        console.error('[FileUtils] Error parsing .gitignore:', error);
+        return [];
+    }
+}
+function escapeRegex(ch) {
+    return ch.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+}
+function gitignoreGlobToRegexBody(pattern) {
+    let out = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '\\' && i + 1 < pattern.length) {
+            out += escapeRegex(pattern[++i]);
+            continue;
+        }
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                const afterSlash = i === 0 || pattern[i - 1] === '/';
+                const beforeSlash = pattern[i + 2] === '/';
+                const atEnd = i + 2 >= pattern.length;
+                if (afterSlash && beforeSlash) {
+                    out += '(?:.*/)?';
+                    i += 2;
+                    continue;
+                }
+                if (afterSlash && atEnd) {
+                    out += '.*';
+                    i += 1;
+                    continue;
+                }
+                out += '[^/]*';
+                i += 1;
+                continue;
+            }
+            out += '[^/]*';
+            continue;
+        }
+        if (ch === '?') {
+            out += '[^/]';
+            continue;
+        }
+        if (ch === '[') {
+            const end = pattern.indexOf(']', i + 2);
+            if (end > i) {
+                let body = pattern.slice(i + 1, end);
+                if (body.startsWith('!'))
+                    body = `^${body.slice(1)}`;
+                out += `[${body.replace(/\\/g, '\\\\')}]`;
+                i = end;
+                continue;
+            }
+        }
+        out += escapeRegex(ch);
+    }
+    return out;
+}
+function compileGitignorePattern(rawLine) {
+    let pattern = rawLine.replace(/\r$/, '');
+    if (!pattern.endsWith('\\ '))
+        pattern = pattern.trimEnd();
+    if (pattern === '' || pattern.startsWith('#'))
+        return null;
+    let negated = false;
+    if (pattern.startsWith('!')) {
+        negated = true;
+        pattern = pattern.slice(1);
+    }
+    else if (pattern.startsWith('\\!') || pattern.startsWith('\\#')) {
+        pattern = pattern.slice(1);
+    }
+    let dirOnly = false;
+    if (pattern.endsWith('/')) {
+        dirOnly = true;
+        pattern = pattern.replace(/\/+$/, '');
+    }
+    if (pattern === '')
+        return null;
+    let anchored = false;
+    if (pattern.startsWith('/')) {
+        anchored = true;
+        pattern = pattern.replace(/^\/+/, '');
+    }
+    else if (pattern.includes('/')) {
+        anchored = true;
+    }
+    if (pattern.startsWith('**/')) {
+        anchored = false;
+        pattern = pattern.slice(3);
+    }
+    if (pattern === '')
+        return null;
+    const body = gitignoreGlobToRegexBody(pattern);
+    const prefix = anchored ? '^' : '^(?:.*/)?';
+    return { negated, dirOnly, regex: new RegExp(`${prefix}${body}(/.*)?$`) };
+}
+export class GitignoreRules {
+    rules;
+    constructor(rules) {
+        this.rules = rules;
+    }
+    static parse(content) {
+        const rules = [];
+        for (const line of content.split('\n')) {
+            const rule = compileGitignorePattern(line);
+            if (rule)
+                rules.push(rule);
+        }
+        return new GitignoreRules(rules);
+    }
+    static fromPatterns(patterns) {
+        return GitignoreRules.parse(patterns.join('\n'));
+    }
+    static fromDirectory(dir) {
+        const gitignorePath = join(dir, '.gitignore');
+        try {
+            if (!existsSync(gitignorePath))
+                return null;
+            return GitignoreRules.parse(readFileSync(gitignorePath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    get isEmpty() {
+        return this.rules.length === 0;
+    }
+    match(relativePath, isDirectory) {
+        let decision;
+        for (const rule of this.rules) {
+            const m = rule.regex.exec(relativePath);
+            if (!m)
+                continue;
+            const matchedParent = m[1] !== undefined && m[1] !== '';
+            if (rule.dirOnly && !matchedParent && !isDirectory)
+                continue;
+            decision = !rule.negated;
+        }
+        return decision;
+    }
+}
+const compiledPatternSets = new WeakMap();
+export function isIgnored(path, patterns, isDirectory = true) {
+    let rules = compiledPatternSets.get(patterns);
+    if (!rules) {
+        rules = GitignoreRules.fromPatterns(patterns);
+        compiledPatternSets.set(patterns, rules);
+    }
+    const normalizedPath = path.replace(/\\/g, '/').replace(/^\.?\/+/, '');
+    return rules.match(normalizedPath, isDirectory) === true;
+}
+export function isPathInSafeLocation(fullPath) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const safePatterns = [
+        join(homeDir, 'Desktop'),
+        join(homeDir, 'Downloads'),
+        join(homeDir, 'Pictures'),
+        join(homeDir, 'Documents'),
+        systemPromptsDir() + sep,
+        '/var/folders/',
+        '/tmp/',
+        process.env.TMPDIR || '/tmp'
+    ];
+    return safePatterns.some(safePath => fullPath.startsWith(safePath));
+}
+export function isImageFile(filePath) {
+    const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.tiff', '.ico', '.svg'];
+    const ext = filePath.toLowerCase().split('.').pop();
+    return ext ? imageExtensions.includes(`.${ext}`) : false;
+}
+export function isBinaryFile(filePath) {
+    return isImageFile(filePath) || isPdfFile(filePath);
+}
+function isPdfFile(filePath) {
+    const ext = filePath.toLowerCase().split('.').pop();
+    return ext === 'pdf';
+}
+function readDirectoryContent(fullPath, filePath, fileName) {
+    try {
+        const entries = readdirSync(fullPath, { withFileTypes: true });
+        const listing = entries
+            .filter(e => !e.name.startsWith('.'))
+            .sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory())
+                return -1;
+            if (!a.isDirectory() && b.isDirectory())
+                return 1;
+            return a.name.localeCompare(b.name);
+        })
+            .map(e => e.isDirectory() ? `${e.name}/` : e.name)
+            .join('\n');
+        return { path: filePath, fileName, content: listing, size: listing.length };
+    }
+    catch {
+        return { path: filePath, fileName, content: '', error: 'Cannot read directory' };
+    }
+}
+function getBinaryMimeType(ext) {
+    if (ext === 'svg')
+        return 'image/svg+xml';
+    if (ext === 'jpg')
+        return 'image/jpeg';
+    if (ext === 'pdf')
+        return 'application/pdf';
+    return `image/${ext}`;
+}
+function readBinaryContent(fullPath, filePath, fileName, stats) {
+    const buffer = readFileSync(fullPath);
+    const ext = fullPath.toLowerCase().split('.').pop() || 'png';
+    const mimeType = getBinaryMimeType(ext);
+    return {
+        path: filePath, fileName,
+        content: buffer.toString('base64'),
+        size: stats.size, modifiedAt: stats.mtime.toISOString(),
+        isImage: true, mimeType
+    };
+}
+function readTextContent(fullPath, filePath, fileName, stats) {
+    return {
+        path: filePath, fileName,
+        content: readFileSync(fullPath, 'utf-8'),
+        size: stats.size, modifiedAt: stats.mtime.toISOString()
+    };
+}
+function validateFileAccess(fullPath, filePath, fileName, workingDir) {
+    const normalizedPath = resolve(fullPath);
+    const normalizedWorkingDir = resolve(workingDir);
+    const withinWorkingDir = normalizedPath === normalizedWorkingDir ||
+        normalizedPath.startsWith(normalizedWorkingDir + sep);
+    if (!withinWorkingDir &&
+        !isPathInSafeLocation(normalizedPath)) {
+        return { path: filePath, fileName, content: '', error: 'Access denied: path outside allowed locations' };
+    }
+    if (!existsSync(fullPath)) {
+        return { path: filePath, fileName, content: '', error: 'File not found' };
+    }
+    return null;
+}
+export function readValidatedFile(fullPath, filePath, fileName, stats) {
+    if (stats.isDirectory())
+        return readDirectoryContent(fullPath, filePath, fileName);
+    const isBin = isBinaryFile(fullPath);
+    const MAX_FILE_SIZE = isBin ? 10 * 1024 * 1024 : 1024 * 1024;
+    if (stats.size > MAX_FILE_SIZE) {
+        return { path: filePath, fileName, content: '', size: stats.size, error: `File too large (${Math.round(stats.size / 1024)}KB). Maximum is ${isBin ? '10MB' : '1MB'}.` };
+    }
+    return isBin
+        ? readBinaryContent(fullPath, filePath, fileName, stats)
+        : readTextContent(fullPath, filePath, fileName, stats);
+}
+export function readFileContent(filePath, workingDir) {
+    try {
+        const fullPath = filePath.startsWith('/') ? filePath : join(workingDir, filePath);
+        const fileName = fullPath.split(sep).pop() || filePath;
+        const accessError = validateFileAccess(fullPath, filePath, fileName, workingDir);
+        if (accessError)
+            return accessError;
+        return readValidatedFile(fullPath, filePath, fileName, statSync(fullPath));
+    }
+    catch (error) {
+        console.error('[FileUtils] Error reading file:', error);
+        return { path: filePath, fileName: filePath.split(sep).pop() || filePath, content: '', error: (error instanceof Error ? error.message : String(error)) || 'Failed to read file' };
+    }
+}

package/dist/server/services/websocket/git-branch-handlers.js

@@ -0,0 +1,90 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { checkoutBranch, createBranch, deleteBranch, findOtherWorktreeForBranch, listBranches } from '../git/index.js';
+import { sendGitError } from './git-utils.js';
+export { parseBranchLine, parseUpstreamTrack } from '../git/index.js';
+export async function handleGitListBranches(ctx, ws, tabId, workingDir) {
+    try {
+        const result = await listBranches({ cwd: workingDir });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitBranchList', tabId, data: { branches: result.value.branches, current: result.value.current } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function reportIfBranchCheckedOutElsewhere(ctx, ws, tabId, branch, cwd) {
+    const existingWt = await findOtherWorktreeForBranch({ cwd, branch });
+    if (!existingWt)
+        return false;
+    sendGitError(ctx, ws, tabId, `Branch "${branch}" is already checked out in another worktree`, {
+        code: 'branch_checked_out_elsewhere',
+        worktreePath: existingWt,
+    });
+    return true;
+}
+export async function handleGitCheckout(ctx, ws, msg, tabId, workingDir, _rootWorkingDir) {
+    try {
+        const { branch, create, startPoint, worktreePath } = msg.data || {};
+        if (!branch) {
+            sendGitError(ctx, ws, tabId, 'Branch name is required');
+            return;
+        }
+        const targetDir = typeof worktreePath === 'string' && worktreePath.length > 0
+            ? worktreePath
+            : workingDir;
+        if (!create && await reportIfBranchCheckedOutElsewhere(ctx, ws, tabId, branch, targetDir)) {
+            return;
+        }
+        const result = await checkoutBranch({ cwd: targetDir, branch, create, startPoint });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitCheckedOut', tabId, data: { branch, previous: result.value.previous } });
+        const { handleGitStatus } = await import('./git-handlers.js');
+        handleGitStatus(ctx, ws, tabId, workingDir);
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+export async function handleGitCreateBranch(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { name, startPoint, checkout } = msg.data || {};
+        if (!name) {
+            sendGitError(ctx, ws, tabId, 'Branch name is required');
+            return;
+        }
+        const result = await createBranch({ cwd: workingDir, name, startPoint, checkout });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitBranchCreated', tabId, data: { name: result.value.name, hash: result.value.hash } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+export async function handleGitDeleteBranch(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { name, force } = msg.data || {};
+        if (!name) {
+            sendGitError(ctx, ws, tabId, 'Branch name is required');
+            return;
+        }
+        const result = await deleteBranch({ cwd: workingDir, name, force });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitBranchDeleted', tabId, data: { name: result.value.name } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}