@plusplusoneplusplus/coc 1.0.0

package/dist/server/tasks-write-handler.js

@@ -0,0 +1,667 @@
+"use strict";
+/**
+ * Tasks REST API Handler — write/mutation routes.
+ *
+ * HTTP API routes for task write operations (create, rename, delete,
+ * move, archive) for a given workspace.
+ *
+ * No VS Code dependencies - uses only Node.js built-in modules.
+ * Cross-platform compatible (Linux/Mac/Windows).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTaskWriteRoutes = registerTaskWriteRoutes;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const forge_1 = require("@plusplusoneplusplus/forge");
+const api_handler_1 = require("./api-handler");
+const handler_utils_1 = require("./shared/handler-utils");
+const fs_utils_1 = require("./shared/fs-utils");
+const task_root_resolver_1 = require("./task-root-resolver");
+const tasks_handler_utils_1 = require("./tasks-handler-utils");
+// ============================================================================
+// Write Route Registration
+// ============================================================================
+/**
+ * Register task write (mutation) API routes on the given route table.
+ * Mutates the `routes` array in-place.
+ */
+function registerTaskWriteRoutes(routes, store, dataDir) {
+    // ------------------------------------------------------------------
+    // POST /api/workspaces/:id/tasks — Create task file or folder
+    // ------------------------------------------------------------------
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/workspaces\/([^/]+)\/tasks$/,
+        handler: async (req, res, match) => {
+            const ws = await (0, handler_utils_1.resolveWorkspaceOrFail)(store, match, res);
+            if (!ws)
+                return;
+            const body = await (0, handler_utils_1.parseBodyOrReject)(req, res);
+            if (body === null)
+                return;
+            const { name, type, folder, parent, docType } = body || {};
+            if (!name || typeof name !== 'string' || !name.trim()) {
+                return (0, api_handler_1.sendError)(res, 400, 'Missing required field: name');
+            }
+            const tasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: ws.rootPath, workspaceId: ws.id }).absolutePath;
+            if (type === 'folder') {
+                // Create folder
+                const resolvedParent = (0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, parent || '');
+                if (!resolvedParent) {
+                    return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+                }
+                const folderPath = path.join(resolvedParent, name.trim());
+                if (!(0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, path.relative(tasksFolder, folderPath))) {
+                    return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+                }
+                try {
+                    await fs.promises.mkdir(folderPath, { recursive: true });
+                    const relPath = path.relative(tasksFolder, folderPath);
+                    (0, api_handler_1.sendJSON)(res, 201, { path: relPath, name: name.trim(), type: 'folder' });
+                }
+                catch (err) {
+                    return (0, api_handler_1.sendError)(res, 500, 'Failed to create folder: ' + (err.message || 'Unknown error'));
+                }
+            }
+            else {
+                // Create task file
+                const resolvedDir = (0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, folder || '');
+                if (!resolvedDir) {
+                    return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+                }
+                const sanitizedName = name.trim();
+                const fileName = docType
+                    ? `${sanitizedName}.${docType}.md`
+                    : `${sanitizedName}.md`;
+                const filePath = path.join(resolvedDir, fileName);
+                if (!(0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, path.relative(tasksFolder, filePath))) {
+                    return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+                }
+                // Check for collision
+                try {
+                    await fs.promises.access(filePath);
+                    return (0, api_handler_1.sendError)(res, 409, 'File already exists');
+                }
+                catch {
+                    // Expected: file does not exist
+                }
+                const frontmatter = '---\nstatus: pending\n---\n\n# ' + sanitizedName + '\n';
+                try {
+                    await fs.promises.mkdir(resolvedDir, { recursive: true });
+                    await fs.promises.writeFile(filePath, frontmatter, 'utf-8');
+                    const relPath = path.relative(tasksFolder, filePath);
+                    (0, api_handler_1.sendJSON)(res, 201, { path: relPath, name: sanitizedName, type: 'file' });
+                }
+                catch (err) {
+                    return (0, api_handler_1.sendError)(res, 500, 'Failed to create task: ' + (err.message || 'Unknown error'));
+                }
+            }
+        },
+    });
+    // ------------------------------------------------------------------
+    // PATCH /api/workspaces/:id/tasks/content — Write task file content
+    // ------------------------------------------------------------------
+    routes.push({
+        method: 'PATCH',
+        pattern: /^\/api\/workspaces\/([^/]+)\/tasks\/content$/,
+        handler: async (req, res, match) => {
+            const ws = await (0, handler_utils_1.resolveWorkspaceOrFail)(store, match, res);
+            if (!ws)
+                return;
+            const body = await (0, handler_utils_1.parseBodyOrReject)(req, res);
+            if (body === null)
+                return;
+            const { path: filePath, content } = body || {};
+            if (!filePath || typeof filePath !== 'string') {
+                return (0, api_handler_1.sendError)(res, 400, 'Missing required field: path');
+            }
+            if (typeof content !== 'string') {
+                return (0, api_handler_1.sendError)(res, 400, 'Missing required field: content');
+            }
+            const tasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: ws.rootPath, workspaceId: ws.id }).absolutePath;
+            const resolvedPath = (0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, filePath);
+            if (!resolvedPath) {
+                return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+            }
+            // File must already exist — no creation via write-back
+            try {
+                const stat = await fs.promises.stat(resolvedPath);
+                if (!stat.isFile()) {
+                    return (0, api_handler_1.sendError)(res, 400, 'Path is not a file');
+                }
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    return (0, api_handler_1.sendError)(res, 404, 'File not found');
+                }
+                return (0, api_handler_1.sendError)(res, 500, 'Failed to access file');
+            }
+            try {
+                await fs.promises.writeFile(resolvedPath, content, 'utf-8');
+                (0, api_handler_1.sendJSON)(res, 200, { path: filePath, updated: true });
+            }
+            catch (err) {
+                return (0, api_handler_1.sendError)(res, 500, 'Failed to write file: ' + (err.message || 'Unknown error'));
+            }
+        },
+    });
+    // ------------------------------------------------------------------
+    // PATCH /api/workspaces/:id/tasks — Rename or update status
+    // ------------------------------------------------------------------
+    routes.push({
+        method: 'PATCH',
+        pattern: /^\/api\/workspaces\/([^/]+)\/tasks$/,
+        handler: async (req, res, match) => {
+            const ws = await (0, handler_utils_1.resolveWorkspaceOrFail)(store, match, res);
+            if (!ws)
+                return;
+            const body = await (0, handler_utils_1.parseBodyOrReject)(req, res);
+            if (body === null)
+                return;
+            const tasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: ws.rootPath, workspaceId: ws.id }).absolutePath;
+            const { path: itemPath } = body || {};
+            if (!itemPath || typeof itemPath !== 'string') {
+                return (0, api_handler_1.sendError)(res, 400, 'Missing required field: path');
+            }
+            let resolvedPath = (0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, itemPath);
+            if (!resolvedPath) {
+                // Allow workspace .md files (plain md files use absolute paths)
+                const wsResolved = (0, tasks_handler_utils_1.resolveAndValidatePath)(ws.rootPath, itemPath);
+                if (!wsResolved || !wsResolved.endsWith('.md')) {
+                    return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside workspace');
+                }
+                resolvedPath = wsResolved;
+            }
+            // Distinguish rename vs status update
+            if (body.status !== undefined) {
+                // Status update
+                const { status } = body;
+                if (!forge_1.VALID_TASK_STATUSES.includes(status)) {
+                    return (0, api_handler_1.sendError)(res, 400, 'Invalid status. Must be one of: ' + forge_1.VALID_TASK_STATUSES.join(', '));
+                }
+                try {
+                    const stat = await fs.promises.stat(resolvedPath);
+                    if (!stat.isFile()) {
+                        return (0, api_handler_1.sendError)(res, 400, 'Status can only be set on files');
+                    }
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        return (0, api_handler_1.sendError)(res, 404, 'File not found');
+                    }
+                    return (0, api_handler_1.sendError)(res, 500, 'Failed to access file');
+                }
+                try {
+                    let content = await fs.promises.readFile(resolvedPath, 'utf-8');
+                    const fmRegex = /^---\n([\s\S]*?)\n---/;
+                    const fmMatch = content.match(fmRegex);
+                    if (fmMatch) {
+                        let frontmatter = fmMatch[1];
+                        if (/^status:\s*.+$/m.test(frontmatter)) {
+                            frontmatter = frontmatter.replace(/^status:\s*.+$/m, `status: ${status}`);
+                        }
+                        else {
+                            frontmatter += `\nstatus: ${status}`;
+                        }
+                        content = content.replace(fmRegex, `---\n${frontmatter}\n---`);
+                    }
+                    else {
+                        // No frontmatter: prepend it
+                        content = `---\nstatus: ${status}\n---\n${content}`;
+                    }
+                    await fs.promises.writeFile(resolvedPath, content, 'utf-8');
+                    (0, api_handler_1.sendJSON)(res, 200, { path: itemPath, status });
+                }
+                catch (err) {
+                    return (0, api_handler_1.sendError)(res, 500, 'Failed to update status: ' + (err.message || 'Unknown error'));
+                }
+            }
+            else if (body.newName !== undefined) {
+                // Rename
+                const { newName } = body;
+                if (!newName || typeof newName !== 'string' || !newName.trim()) {
+                    return (0, api_handler_1.sendError)(res, 400, 'Missing required field: newName');
+                }
+                // Reject names containing characters invalid in file/folder names
+                // Note: double quotes are sanitized to single quotes rather than rejected
+                const INVALID_NAME_CHARS = /[/\\:*?<>|]/;
+                if (INVALID_NAME_CHARS.test(newName.trim())) {
+                    return (0, api_handler_1.sendError)(res, 400, 'New name contains invalid characters: / \\ : * ? < > |');
+                }
+                // Replace double quotes (invalid on Windows) with single quotes
+                const sanitizedName = newName.trim().replace(/"/g, "'");
+                try {
+                    const stat = await fs.promises.stat(resolvedPath);
+                    const dir = path.dirname(resolvedPath);
+                    if (stat.isDirectory()) {
+                        // Rename directory
+                        const newPath = path.join(dir, sanitizedName);
+                        if (!(0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, path.relative(tasksFolder, newPath))) {
+                            return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+                        }
+                        try {
+                            await fs.promises.access(newPath);
+                            return (0, api_handler_1.sendError)(res, 409, 'A file or folder with that name already exists');
+                        }
+                        catch { /* expected */ }
+                        await fs.promises.rename(resolvedPath, newPath);
+                        const relPath = path.relative(tasksFolder, newPath);
+                        (0, api_handler_1.sendJSON)(res, 200, { path: relPath, name: sanitizedName });
+                    }
+                    else {
+                        // Check if this is part of a document group
+                        const basename = path.basename(resolvedPath);
+                        const ext = path.extname(basename); // .md
+                        const nameWithoutExt = basename.slice(0, -ext.length); // e.g., "task1.plan"
+                        // Detect document group: name.docType.md pattern
+                        const docTypeParts = nameWithoutExt.split('.');
+                        const isDocGroup = docTypeParts.length >= 2;
+                        const baseGroupName = isDocGroup ? docTypeParts[0] : nameWithoutExt;
+                        if (isDocGroup) {
+                            // Find all files matching the document group
+                            const entries = await fs.promises.readdir(dir);
+                            const groupFiles = entries.filter(e => e.startsWith(baseGroupName + '.') && e.endsWith('.md'));
+                            // Check for collision on new name
+                            const newGroupFiles = entries.filter(e => e.startsWith(sanitizedName + '.') && e.endsWith('.md'));
+                            if (newGroupFiles.length > 0) {
+                                return (0, api_handler_1.sendError)(res, 409, 'A document group with that name already exists');
+                            }
+                            // Rename all files in the group
+                            for (const file of groupFiles) {
+                                const suffix = file.slice(baseGroupName.length); // e.g., ".plan.md"
+                                const newFileName = sanitizedName + suffix;
+                                const oldFilePath = path.join(dir, file);
+                                const newFilePath = path.join(dir, newFileName);
+                                await fs.promises.rename(oldFilePath, newFilePath);
+                            }
+                            const relPath = path.relative(tasksFolder, path.join(dir, sanitizedName + docTypeParts.slice(1).map(p => '.' + p).join('') + ext));
+                            (0, api_handler_1.sendJSON)(res, 200, { path: relPath, name: sanitizedName });
+                        }
+                        else {
+                            // Single file rename
+                            const newFileName = sanitizedName + ext;
+                            const newPath = path.join(dir, newFileName);
+                            if (!(0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, path.relative(tasksFolder, newPath))) {
+                                return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+                            }
+                            try {
+                                await fs.promises.access(newPath);
+                                return (0, api_handler_1.sendError)(res, 409, 'A file with that name already exists');
+                            }
+                            catch { /* expected */ }
+                            await fs.promises.rename(resolvedPath, newPath);
+                            const relPath = path.relative(tasksFolder, newPath);
+                            (0, api_handler_1.sendJSON)(res, 200, { path: relPath, name: sanitizedName });
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        return (0, api_handler_1.sendError)(res, 404, 'File or folder not found');
+                    }
+                    // If already sent a response (409), don't send again
+                    if (res.writableEnded)
+                        return;
+                    return (0, api_handler_1.sendError)(res, 500, 'Failed to rename: ' + (err.message || 'Unknown error'));
+                }
+            }
+            else {
+                return (0, api_handler_1.sendError)(res, 400, 'Body must contain either "status" or "newName"');
+            }
+        },
+    });
+    // ------------------------------------------------------------------
+    // DELETE /api/workspaces/:id/tasks — Delete task file or folder
+    // ------------------------------------------------------------------
+    routes.push({
+        method: 'DELETE',
+        pattern: /^\/api\/workspaces\/([^/]+)\/tasks$/,
+        handler: async (req, res, match) => {
+            const ws = await (0, handler_utils_1.resolveWorkspaceOrFail)(store, match, res);
+            if (!ws)
+                return;
+            const body = await (0, handler_utils_1.parseBodyOrReject)(req, res);
+            if (body === null)
+                return;
+            const { path: itemPath } = body || {};
+            if (!itemPath || typeof itemPath !== 'string') {
+                return (0, api_handler_1.sendError)(res, 400, 'Missing required field: path');
+            }
+            const tasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: ws.rootPath, workspaceId: ws.id }).absolutePath;
+            const resolvedPath = (0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, itemPath);
+            if (!resolvedPath) {
+                return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+            }
+            try {
+                const stat = await fs.promises.stat(resolvedPath);
+                if (stat.isDirectory()) {
+                    await fs.promises.rm(resolvedPath, { recursive: true });
+                }
+                else {
+                    await fs.promises.unlink(resolvedPath);
+                }
+                res.writeHead(204);
+                res.end();
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    return (0, api_handler_1.sendError)(res, 404, 'File or folder not found');
+                }
+                return (0, api_handler_1.sendError)(res, 500, 'Failed to delete: ' + (err.message || 'Unknown error'));
+            }
+        },
+    });
+    // ------------------------------------------------------------------
+    // POST /api/workspaces/:id/tasks/move — Move file or folder
+    // ------------------------------------------------------------------
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/workspaces\/([^/]+)\/tasks\/move$/,
+        handler: async (req, res, match) => {
+            const ws = await (0, handler_utils_1.resolveWorkspaceOrFail)(store, match, res);
+            if (!ws)
+                return;
+            const id = ws.id;
+            const body = await (0, handler_utils_1.parseBodyOrReject)(req, res);
+            if (body === null)
+                return;
+            const { sourcePath, destinationFolder, destinationWorkspaceId } = body || {};
+            if (!sourcePath || typeof sourcePath !== 'string') {
+                return (0, api_handler_1.sendError)(res, 400, 'Missing required field: sourcePath');
+            }
+            if (typeof destinationFolder !== 'string') {
+                return (0, api_handler_1.sendError)(res, 400, 'Missing required field: destinationFolder');
+            }
+            // Resolve destination workspace (cross-workspace move)
+            const isCrossWorkspace = typeof destinationWorkspaceId === 'string' && destinationWorkspaceId !== id;
+            let destWs = ws;
+            if (isCrossWorkspace) {
+                const destWorkspaces = await store.getWorkspaces();
+                const found = destWorkspaces.find(w => w.id === destinationWorkspaceId);
+                if (!found) {
+                    return (0, api_handler_1.sendError)(res, 404, 'Destination workspace not found');
+                }
+                destWs = found;
+            }
+            const sourceTasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: ws.rootPath, workspaceId: ws.id }).absolutePath;
+            const destTasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: destWs.rootPath, workspaceId: destWs.id }).absolutePath;
+            const resolvedSource = (0, tasks_handler_utils_1.resolveAndValidatePath)(sourceTasksFolder, sourcePath);
+            if (!resolvedSource) {
+                return (0, api_handler_1.sendError)(res, 403, 'Access denied: source path is outside tasks folder');
+            }
+            const resolvedDest = destinationFolder
+                ? (0, tasks_handler_utils_1.resolveAndValidatePath)(destTasksFolder, destinationFolder)
+                : destTasksFolder;
+            if (!resolvedDest) {
+                return (0, api_handler_1.sendError)(res, 403, 'Access denied: destination path is outside tasks folder');
+            }
+            // Verify source exists
+            try {
+                await fs.promises.stat(resolvedSource);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    return (0, api_handler_1.sendError)(res, 404, 'Source file or folder not found');
+                }
+                return (0, api_handler_1.sendError)(res, 500, 'Failed to access source');
+            }
+            // Verify destination is a directory (create tasks folder if cross-workspace and missing)
+            try {
+                const destStat = await fs.promises.stat(resolvedDest);
+                if (!destStat.isDirectory()) {
+                    return (0, api_handler_1.sendError)(res, 400, 'Destination is not a directory');
+                }
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    if (isCrossWorkspace && resolvedDest === destTasksFolder) {
+                        await fs.promises.mkdir(resolvedDest, { recursive: true });
+                    }
+                    else {
+                        return (0, api_handler_1.sendError)(res, 404, 'Destination folder not found');
+                    }
+                }
+                else {
+                    return (0, api_handler_1.sendError)(res, 500, 'Failed to access destination');
+                }
+            }
+            // Prevent moving into itself or a descendant (same-workspace only)
+            const sourceName = path.basename(resolvedSource);
+            const targetPath = path.join(resolvedDest, sourceName);
+            if (!isCrossWorkspace) {
+                if (resolvedDest === path.dirname(resolvedSource)) {
+                    return (0, api_handler_1.sendError)(res, 400, 'Source is already in the destination folder');
+                }
+                if ((0, forge_1.isWithinDirectory)(resolvedDest, resolvedSource)) {
+                    return (0, api_handler_1.sendError)(res, 400, 'Cannot move a folder into itself or its descendant');
+                }
+            }
+            if (!(0, tasks_handler_utils_1.resolveAndValidatePath)(destTasksFolder, path.relative(destTasksFolder, targetPath))) {
+                return (0, api_handler_1.sendError)(res, 403, 'Access denied: target path is outside tasks folder');
+            }
+            let finalTarget = await (0, fs_utils_1.resolveCollision)(targetPath);
+            try {
+                await fs.promises.rename(resolvedSource, finalTarget);
+                const newRelPath = path.relative(destTasksFolder, finalTarget);
+                (0, api_handler_1.sendJSON)(res, 200, { path: newRelPath, name: path.basename(finalTarget) });
+            }
+            catch (err) {
+                // EXDEV: cross-device rename not supported — fallback to copy + delete
+                if (err.code === 'EXDEV') {
+                    try {
+                        await (0, tasks_handler_utils_1.copyRecursive)(resolvedSource, finalTarget);
+                        await fs.promises.rm(resolvedSource, { recursive: true, force: true });
+                        const newRelPath = path.relative(destTasksFolder, finalTarget);
+                        (0, api_handler_1.sendJSON)(res, 200, { path: newRelPath, name: path.basename(finalTarget) });
+                    }
+                    catch (copyErr) {
+                        return (0, api_handler_1.sendError)(res, 500, 'Failed to move (cross-device): ' + (copyErr.message || 'Unknown error'));
+                    }
+                }
+                else {
+                    return (0, api_handler_1.sendError)(res, 500, 'Failed to move: ' + (err.message || 'Unknown error'));
+                }
+            }
+        },
+    });
+    // ------------------------------------------------------------------
+    // POST /api/workspaces/:id/tasks/archive — Archive or unarchive
+    // ------------------------------------------------------------------
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/workspaces\/([^/]+)\/tasks\/archive$/,
+        handler: async (req, res, match) => {
+            const ws = await (0, handler_utils_1.resolveWorkspaceOrFail)(store, match, res);
+            if (!ws)
+                return;
+            const body = await (0, handler_utils_1.parseBodyOrReject)(req, res);
+            if (body === null)
+                return;
+            const { path: itemPath, action } = body || {};
+            if (!itemPath || typeof itemPath !== 'string') {
+                return (0, api_handler_1.sendError)(res, 400, 'Missing required field: path');
+            }
+            if (action !== 'archive' && action !== 'unarchive') {
+                return (0, api_handler_1.sendError)(res, 400, 'Invalid action. Must be "archive" or "unarchive"');
+            }
+            const tasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: ws.rootPath, workspaceId: ws.id }).absolutePath;
+            const archiveFolder = path.join(tasksFolder, 'archive');
+            const resolvedPath = (0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, itemPath);
+            if (!resolvedPath) {
+                return (0, api_handler_1.sendError)(res, 403, 'Access denied: path is outside tasks folder');
+            }
+            try {
+                await fs.promises.stat(resolvedPath);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    return (0, api_handler_1.sendError)(res, 404, 'File or folder not found');
+                }
+                return (0, api_handler_1.sendError)(res, 500, 'Failed to access path');
+            }
+            try {
+                if (action === 'archive') {
+                    // Move from tasks folder to archive/, preserving relative structure
+                    const relFromTasks = path.relative(tasksFolder, resolvedPath);
+                    let destPath = await (0, fs_utils_1.resolveCollision)(path.join(archiveFolder, relFromTasks));
+                    await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+                    await fs.promises.rename(resolvedPath, destPath);
+                    const newRelPath = path.relative(tasksFolder, destPath);
+                    // Determine if this is a file or folder
+                    let itemType;
+                    try {
+                        const s = await fs.promises.stat(destPath);
+                        itemType = s.isDirectory() ? 'folder' : 'file';
+                    }
+                    catch {
+                        itemType = 'file';
+                    }
+                    // Write undo record (overwrite any existing)
+                    const undoRecord = {
+                        timestamp: new Date().toISOString(),
+                        type: itemType,
+                        originalPath: relFromTasks.replace(/\\/g, '/'),
+                        archivedPath: newRelPath.replace(/\\/g, '/'),
+                    };
+                    const undoFile = path.join(tasksFolder, forge_1.ARCHIVE_UNDO_FILE);
+                    await fs.promises.writeFile(undoFile, JSON.stringify(undoRecord, null, 2), 'utf-8');
+                    (0, api_handler_1.sendJSON)(res, 200, { path: newRelPath });
+                }
+                else {
+                    // Unarchive: move from archive/ back to tasks root
+                    const relFromArchive = path.relative(archiveFolder, resolvedPath);
+                    if (relFromArchive.startsWith('..')) {
+                        return (0, api_handler_1.sendError)(res, 400, 'Path is not inside the archive folder');
+                    }
+                    let destPath = await (0, fs_utils_1.resolveCollision)(path.join(tasksFolder, relFromArchive));
+                    await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+                    await fs.promises.rename(resolvedPath, destPath);
+                    const newRelPath = path.relative(tasksFolder, destPath);
+                    // Clear undo record on manual unarchive
+                    const undoFile = path.join(tasksFolder, forge_1.ARCHIVE_UNDO_FILE);
+                    try {
+                        await fs.promises.unlink(undoFile);
+                    }
+                    catch { /* ignore if absent */ }
+                    (0, api_handler_1.sendJSON)(res, 200, { path: newRelPath });
+                }
+            }
+            catch (err) {
+                return (0, api_handler_1.sendError)(res, 500, 'Failed to ' + action + ': ' + (0, fs_utils_1.getErrorMessage)(err));
+            }
+        },
+    });
+    // ------------------------------------------------------------------
+    // GET /api/workspaces/:id/tasks/undo-archive — Undo status
+    // ------------------------------------------------------------------
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/workspaces\/([^/]+)\/tasks\/undo-archive$/,
+        handler: async (req, res, match) => {
+            const ws = await (0, handler_utils_1.resolveWorkspaceOrFail)(store, match, res);
+            if (!ws)
+                return;
+            const tasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: ws.rootPath, workspaceId: ws.id }).absolutePath;
+            const undoFile = path.join(tasksFolder, forge_1.ARCHIVE_UNDO_FILE);
+            try {
+                const raw = await fs.promises.readFile(undoFile, 'utf-8');
+                const record = JSON.parse(raw);
+                (0, api_handler_1.sendJSON)(res, 200, { available: true, record: { type: record.type, originalPath: record.originalPath, timestamp: record.timestamp } });
+            }
+            catch {
+                (0, api_handler_1.sendJSON)(res, 200, { available: false });
+            }
+        },
+    });
+    // ------------------------------------------------------------------
+    // POST /api/workspaces/:id/tasks/undo-archive — Perform undo
+    // ------------------------------------------------------------------
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/workspaces\/([^/]+)\/tasks\/undo-archive$/,
+        handler: async (req, res, match) => {
+            const ws = await (0, handler_utils_1.resolveWorkspaceOrFail)(store, match, res);
+            if (!ws)
+                return;
+            const tasksFolder = (0, task_root_resolver_1.resolveTaskRoot)({ dataDir, rootPath: ws.rootPath, workspaceId: ws.id }).absolutePath;
+            const undoFile = path.join(tasksFolder, forge_1.ARCHIVE_UNDO_FILE);
+            let record;
+            try {
+                const raw = await fs.promises.readFile(undoFile, 'utf-8');
+                record = JSON.parse(raw);
+            }
+            catch {
+                return (0, api_handler_1.sendError)(res, 404, 'Nothing to undo');
+            }
+            if (!record.originalPath || !record.archivedPath) {
+                return (0, api_handler_1.sendError)(res, 400, 'Invalid undo record');
+            }
+            const archivedAbsPath = path.join(tasksFolder, record.archivedPath);
+            const originalAbsPath = path.join(tasksFolder, record.originalPath);
+            // Validate paths are inside tasksFolder
+            if (!(0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, record.archivedPath) || !(0, tasks_handler_utils_1.resolveAndValidatePath)(tasksFolder, record.originalPath)) {
+                return (0, api_handler_1.sendError)(res, 403, 'Access denied: undo record contains paths outside tasks folder');
+            }
+            // Ensure source still exists
+            try {
+                await fs.promises.stat(archivedAbsPath);
+            }
+            catch {
+                return (0, api_handler_1.sendError)(res, 404, 'Archived path no longer exists');
+            }
+            // Check for collision at original path
+            try {
+                await fs.promises.stat(originalAbsPath);
+                return (0, api_handler_1.sendError)(res, 409, 'Original path already exists — cannot undo');
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT') {
+                    return (0, api_handler_1.sendError)(res, 500, 'Failed to check original path');
+                }
+            }
+            try {
+                await fs.promises.mkdir(path.dirname(originalAbsPath), { recursive: true });
+                await fs.promises.rename(archivedAbsPath, originalAbsPath);
+                await fs.promises.unlink(undoFile);
+                (0, api_handler_1.sendJSON)(res, 200, { success: true, restoredPath: record.originalPath });
+            }
+            catch (err) {
+                return (0, api_handler_1.sendError)(res, 500, 'Failed to undo archive: ' + (err.message || 'Unknown error'));
+            }
+        },
+    });
+}
+//# sourceMappingURL=tasks-write-handler.js.map