minionsai 0.1.0

package/dist/server/server/routes/cron.js

@@ -0,0 +1,109 @@
+import { Router } from 'express';
+import { getTask } from '../db/queries.js';
+import { toErrorMessage } from '../errors.js';
+function originTaskId(job) {
+    const origin = job.origin;
+    if (!origin || origin.platform !== 'minions')
+        return null;
+    return typeof origin.chat_id === 'string' && origin.chat_id.trim() ? origin.chat_id : null;
+}
+function attachLinkedTaskId(job) {
+    const taskId = originTaskId(job);
+    return { ...job, linkedTaskIds: taskId ? [taskId] : [] };
+}
+export function createCronRouter(adapter) {
+    const router = Router();
+    router.get('/jobs', async (req, res) => {
+        try {
+            const includeDisabled = req.query.includeDisabled === 'true';
+            const jobs = await adapter.listCronJobs(includeDisabled);
+            res.json({ jobs: jobs.map(attachLinkedTaskId) });
+        }
+        catch (error) {
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes cron worker unavailable') });
+        }
+    });
+    router.get('/jobs/:jobId', async (req, res) => {
+        try {
+            const job = await adapter.getCronJob(req.params.jobId);
+            if (!job)
+                return res.status(404).json({ error: 'Cron job not found' });
+            res.json({ job: attachLinkedTaskId(job) });
+        }
+        catch (error) {
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes cron worker unavailable') });
+        }
+    });
+    router.get('/jobs/:jobId/runs', async (req, res) => {
+        try {
+            const rawLimit = Array.isArray(req.query.limit) ? req.query.limit[0] : req.query.limit;
+            const limit = rawLimit ? Number.parseInt(String(rawLimit), 10) : 20;
+            const runs = await adapter.getCronRuns(req.params.jobId, Number.isFinite(limit) ? limit : 20);
+            res.json({ runs });
+        }
+        catch (error) {
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes cron worker unavailable') });
+        }
+    });
+    router.get('/jobs/:jobId/runs/:runId/content', async (req, res) => {
+        try {
+            const content = await adapter.getCronRunContent(req.params.jobId, req.params.runId);
+            res.json({ content });
+        }
+        catch (error) {
+            const status = error.code === 'not_found' ? 404 : 503;
+            res.status(status).json({ error: toErrorMessage(error, 'Hermes cron worker unavailable') });
+        }
+    });
+    async function jobActionHandler(res, jobId, action) {
+        try {
+            const job = await action(jobId);
+            if (!job)
+                return res.status(404).json({ error: 'Cron job not found' });
+            res.json({ job: attachLinkedTaskId(job) });
+        }
+        catch (error) {
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes cron worker unavailable') });
+        }
+    }
+    router.post('/jobs/:jobId/pause', (req, res) => {
+        const rawReason = req.body?.reason;
+        const reason = typeof rawReason === 'string' && rawReason.trim() ? rawReason.trim() : undefined;
+        jobActionHandler(res, req.params.jobId, (jobId) => adapter.pauseCronJob(jobId, reason));
+    });
+    router.post('/jobs/:jobId/resume', (req, res) => {
+        jobActionHandler(res, req.params.jobId, (jobId) => adapter.resumeCronJob(jobId));
+    });
+    router.post('/jobs/:jobId/run', (req, res) => {
+        jobActionHandler(res, req.params.jobId, (jobId) => adapter.runCronJob(jobId));
+    });
+    router.delete('/jobs/:jobId', async (req, res) => {
+        try {
+            const removed = await adapter.removeCronJob(req.params.jobId);
+            if (!removed)
+                return res.status(404).json({ error: 'Cron job not found' });
+            res.json({ ok: true });
+        }
+        catch (error) {
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes cron worker unavailable') });
+        }
+    });
+    return router;
+}
+export function createTaskCronRouter(adapter) {
+    const router = Router();
+    router.get('/:id/cron-jobs', async (req, res) => {
+        const task = getTask(req.params.id);
+        if (!task)
+            return res.status(404).json({ error: 'Task not found' });
+        try {
+            const jobs = await adapter.listCronJobs(true);
+            const linkedJobs = jobs.filter((job) => originTaskId(job) === task.id);
+            res.json({ jobs: linkedJobs.map(attachLinkedTaskId) });
+        }
+        catch (error) {
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes cron worker unavailable') });
+        }
+    });
+    return router;
+}

package/dist/server/server/routes/files.d.ts

@@ -0,0 +1 @@
+export declare const filesRouter: import("express-serve-static-core").Router;

package/dist/server/server/routes/files.js

@@ -0,0 +1,543 @@
+import { constants, mkdirSync } from 'node:fs';
+import { access, copyFile, lstat, mkdir, open, readdir, readFile, rename, rm, rmdir, stat, unlink, writeFile, } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import archiver from 'archiver';
+import multer from 'multer';
+import { Router } from 'express';
+import { expandHomePrefix } from '../paths.js';
+import { errorCode, isRecord } from '../errors.js';
+const HOME = resolve(homedir());
+const TEXT_SAMPLE_BYTES = 8192;
+const MAX_TEXT_FILE_SIZE = 10 * 1024 * 1024;
+const MAX_TEXT_FILE_SIZE_DISPLAY = '10 MiB';
+const DEFAULT_FILE_BROWSER_PATH = '~/.minions/workspace';
+const UPLOAD_TMP_DIR = join(tmpdir(), 'minions-uploads');
+mkdirSync(UPLOAD_TMP_DIR, { recursive: true });
+const uploadMiddleware = multer({
+    storage: multer.diskStorage({
+        destination: UPLOAD_TMP_DIR,
+        filename: (_req, file, callback) => {
+            callback(null, `${Date.now()}-${randomUUID()}-${basename(file.originalname)}`);
+        },
+    }),
+}).array('files');
+class FileRouteError extends Error {
+    status;
+    code;
+    constructor(status, message, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+export const filesRouter = Router();
+filesRouter.get('/list', async (req, res) => {
+    try {
+        const directoryPath = resolveUserPath(req.query.path, DEFAULT_FILE_BROWSER_PATH);
+        const directoryStats = await stat(directoryPath);
+        if (!directoryStats.isDirectory()) {
+            throw new FileRouteError(400, 'Path is not a directory', 'NOT_DIRECTORY');
+        }
+        const dirents = await readdir(directoryPath, { withFileTypes: true });
+        const entries = await Promise.all(dirents.map((dirent) => entryFromDirent(directoryPath, dirent)));
+        entries.sort(compareEntries);
+        const parentPath = dirname(directoryPath);
+        res.json({
+            path: directoryPath,
+            displayPath: displayPath(directoryPath),
+            parentPath: parentPath === directoryPath ? null : parentPath,
+            entries,
+        });
+    }
+    catch (error) {
+        sendFileError(res, error, 'Failed to list directory');
+    }
+});
+filesRouter.get('/read', async (req, res) => {
+    try {
+        const filePath = resolveRequiredPath(req.query.path);
+        const fileStats = await stat(filePath);
+        if (fileStats.isDirectory()) {
+            throw new FileRouteError(400, 'Cannot open a directory as text', 'IS_DIRECTORY');
+        }
+        if (!fileStats.isFile()) {
+            throw new FileRouteError(400, 'Path is not a regular text file', 'NOT_FILE');
+        }
+        if (fileStats.size > MAX_TEXT_FILE_SIZE) {
+            throw new FileRouteError(413, `File is too large to open as text. Maximum size is ${MAX_TEXT_FILE_SIZE_DISPLAY}.`, 'FILE_TOO_LARGE');
+        }
+        if (await looksBinary(filePath, fileStats.size)) {
+            throw new FileRouteError(415, 'Binary files cannot be opened as text', 'BINARY_FILE');
+        }
+        const content = await readFile(filePath, 'utf8');
+        res.json({
+            path: filePath,
+            displayPath: displayPath(filePath),
+            name: basename(filePath),
+            content,
+            size: fileStats.size,
+            modifiedAt: fileStats.mtimeMs,
+            encoding: 'utf8',
+            fileType: 'text',
+        });
+    }
+    catch (error) {
+        sendFileError(res, error, 'Failed to read file');
+    }
+});
+filesRouter.get('/download', async (req, res) => {
+    try {
+        const targetPath = resolveRequiredPath(req.query.path);
+        const targetStats = await stat(targetPath);
+        const targetName = basename(targetPath) || 'download';
+        if (targetStats.isDirectory()) {
+            res.attachment(`${targetName}.zip`);
+            res.type('application/zip');
+            const archive = archiver('zip', { zlib: { level: 6 } });
+            let handledArchiveError = false;
+            const handleArchiveError = (archiveError) => {
+                if (handledArchiveError)
+                    return;
+                handledArchiveError = true;
+                sendStreamingFileError(res, archiveError, 'Failed to download folder');
+            };
+            archive.on('error', handleArchiveError);
+            archive.pipe(res);
+            archive.directory(targetPath, targetName);
+            archive.finalize().catch(handleArchiveError);
+            return;
+        }
+        if (!targetStats.isFile()) {
+            throw new FileRouteError(400, 'Path is not a downloadable file or folder', 'NOT_DOWNLOADABLE');
+        }
+        res.download(targetPath, targetName, (downloadError) => {
+            if (downloadError)
+                sendStreamingFileError(res, downloadError, 'Failed to download file');
+        });
+    }
+    catch (error) {
+        sendFileError(res, error, 'Failed to download file entry');
+    }
+});
+filesRouter.put('/write', async (req, res) => {
+    try {
+        const body = parseWriteRequest(req.body);
+        const filePath = resolveUserPath(body.path);
+        const currentStats = await stat(filePath);
+        if (currentStats.isDirectory()) {
+            throw new FileRouteError(400, 'Cannot write text to a directory', 'IS_DIRECTORY');
+        }
+        if (!currentStats.isFile()) {
+            throw new FileRouteError(400, 'Path is not a regular file', 'NOT_FILE');
+        }
+        if (typeof body.expectedModifiedAt === 'number'
+            && !body.overwrite
+            && Math.abs(currentStats.mtimeMs - body.expectedModifiedAt) > 1) {
+            throw new FileRouteError(409, 'File changed on disk', 'FILE_CHANGED');
+        }
+        await writeFile(filePath, body.content, 'utf8');
+        const nextStats = await stat(filePath);
+        res.json({
+            path: filePath,
+            displayPath: displayPath(filePath),
+            size: nextStats.size,
+            modifiedAt: nextStats.mtimeMs,
+        });
+    }
+    catch (error) {
+        sendFileError(res, error, 'Failed to write file');
+    }
+});
+filesRouter.post('/create', async (req, res) => {
+    try {
+        const body = parseCreateRequest(req.body);
+        const parentPath = resolveUserPath(body.parentPath);
+        const name = validateFileName(body.name);
+        const targetPath = join(parentPath, name);
+        if (body.type === 'directory') {
+            await mkdir(targetPath);
+        }
+        else {
+            await writeFile(targetPath, body.content ?? '', { encoding: 'utf8', flag: 'wx' });
+        }
+        res.status(201).json({ entry: await entryFromPath(targetPath) });
+    }
+    catch (error) {
+        sendFileError(res, error, 'Failed to create file entry');
+    }
+});
+filesRouter.post('/upload', (req, res) => {
+    uploadMiddleware(req, res, (error) => {
+        if (error) {
+            sendFileError(res, error, 'Failed to upload files');
+            return;
+        }
+        void handleUploadRequest(req, res);
+    });
+});
+filesRouter.patch('/rename', async (req, res) => {
+    try {
+        const body = parseRenameRequest(req.body);
+        const sourcePath = resolveUserPath(body.path);
+        const newName = validateFileName(body.newName);
+        const targetPath = join(dirname(sourcePath), newName);
+        if (await canAccess(targetPath, constants.F_OK)) {
+            throw new FileRouteError(409, 'Target already exists', 'EEXIST');
+        }
+        await rename(sourcePath, targetPath);
+        res.json({ entry: await entryFromPath(targetPath) });
+    }
+    catch (error) {
+        sendFileError(res, error, 'Failed to rename file entry');
+    }
+});
+filesRouter.delete('/', async (req, res) => {
+    try {
+        const body = parseDeleteRequest(req.body);
+        const targetPath = resolveUserPath(body.path);
+        const targetStats = await lstat(targetPath);
+        if (targetStats.isDirectory() && !targetStats.isSymbolicLink()) {
+            if (body.recursive) {
+                await rm(targetPath, { recursive: true, force: false });
+            }
+            else {
+                await rmdir(targetPath);
+            }
+        }
+        else {
+            await unlink(targetPath);
+        }
+        res.json({ ok: true });
+    }
+    catch (error) {
+        sendFileError(res, error, 'Failed to delete file entry');
+    }
+});
+async function handleUploadRequest(req, res) {
+    const uploadedFiles = Array.isArray(req.files) ? req.files : [];
+    try {
+        if (uploadedFiles.length === 0) {
+            throw new FileRouteError(400, 'At least one file is required', 'BAD_REQUEST');
+        }
+        const { targetPath, relativePaths } = parseUploadRequest(req.body, uploadedFiles.length);
+        const targetDirectory = resolveUserPath(targetPath);
+        const directoryStats = await stat(targetDirectory);
+        if (!directoryStats.isDirectory()) {
+            throw new FileRouteError(400, 'Upload target is not a directory', 'NOT_DIRECTORY');
+        }
+        const uploadedRootPaths = new Set();
+        for (const [index, file] of uploadedFiles.entries()) {
+            const segments = sanitizeUploadRelativePath(relativePaths[index] ?? file.originalname);
+            const destinationPath = join(targetDirectory, ...segments);
+            if (!isSameOrChildPath(targetDirectory, destinationPath)) {
+                throw new FileRouteError(400, 'Upload path cannot escape the target directory', 'BAD_REQUEST');
+            }
+            await assertWritableUploadTarget(destinationPath);
+            await mkdir(dirname(destinationPath), { recursive: true });
+            try {
+                await rename(file.path, destinationPath);
+            }
+            catch {
+                await copyFile(file.path, destinationPath);
+            }
+            uploadedRootPaths.add(join(targetDirectory, segments[0]));
+        }
+        const entries = await Promise.all([...uploadedRootPaths].sort((a, b) => a.localeCompare(b)).map((entryPath) => entryFromPath(entryPath)));
+        res.status(201).json({ uploaded: uploadedFiles.length, entries });
+    }
+    catch (error) {
+        sendFileError(res, error, 'Failed to upload files');
+    }
+    finally {
+        await Promise.all(uploadedFiles.map((file) => unlink(file.path).catch(() => undefined)));
+    }
+}
+function parseWriteRequest(value) {
+    if (!isRecord(value))
+        throw new FileRouteError(400, 'Request body is required', 'BAD_REQUEST');
+    if (typeof value.path !== 'string')
+        throw new FileRouteError(400, 'Path is required', 'BAD_REQUEST');
+    if (typeof value.content !== 'string')
+        throw new FileRouteError(400, 'Content is required', 'BAD_REQUEST');
+    assertTextContentSize(value.content);
+    return {
+        path: value.path,
+        content: value.content,
+        expectedModifiedAt: typeof value.expectedModifiedAt === 'number' ? value.expectedModifiedAt : undefined,
+        overwrite: value.overwrite === true,
+    };
+}
+function parseCreateRequest(value) {
+    if (!isRecord(value))
+        throw new FileRouteError(400, 'Request body is required', 'BAD_REQUEST');
+    if (typeof value.parentPath !== 'string')
+        throw new FileRouteError(400, 'Parent path is required', 'BAD_REQUEST');
+    if (typeof value.name !== 'string')
+        throw new FileRouteError(400, 'Name is required', 'BAD_REQUEST');
+    if (value.type !== 'file' && value.type !== 'directory') {
+        throw new FileRouteError(400, 'Type must be file or directory', 'BAD_REQUEST');
+    }
+    let content;
+    if (typeof value.content === 'string') {
+        assertTextContentSize(value.content);
+        content = value.content;
+    }
+    else if (value.content !== undefined) {
+        throw new FileRouteError(400, 'Content must be a string', 'BAD_REQUEST');
+    }
+    return {
+        parentPath: value.parentPath,
+        name: value.name,
+        type: value.type,
+        content,
+    };
+}
+function assertTextContentSize(content) {
+    if (Buffer.byteLength(content, 'utf8') <= MAX_TEXT_FILE_SIZE)
+        return;
+    throw new FileRouteError(413, `Text file content cannot exceed ${MAX_TEXT_FILE_SIZE_DISPLAY}.`, 'FILE_TOO_LARGE');
+}
+function parseUploadRequest(value, fileCount) {
+    if (!isRecord(value))
+        throw new FileRouteError(400, 'Request body is required', 'BAD_REQUEST');
+    if (typeof value.targetPath !== 'string') {
+        throw new FileRouteError(400, 'Upload target path is required', 'BAD_REQUEST');
+    }
+    const relativePaths = stringArrayFromField(value.relativePaths);
+    if (relativePaths.length > 0 && relativePaths.length !== fileCount) {
+        throw new FileRouteError(400, 'Upload path count must match file count', 'BAD_REQUEST');
+    }
+    return { targetPath: value.targetPath, relativePaths };
+}
+function parseRenameRequest(value) {
+    if (!isRecord(value))
+        throw new FileRouteError(400, 'Request body is required', 'BAD_REQUEST');
+    if (typeof value.path !== 'string')
+        throw new FileRouteError(400, 'Path is required', 'BAD_REQUEST');
+    if (typeof value.newName !== 'string')
+        throw new FileRouteError(400, 'New name is required', 'BAD_REQUEST');
+    return { path: value.path, newName: value.newName };
+}
+function parseDeleteRequest(value) {
+    if (!isRecord(value))
+        throw new FileRouteError(400, 'Request body is required', 'BAD_REQUEST');
+    if (typeof value.path !== 'string')
+        throw new FileRouteError(400, 'Path is required', 'BAD_REQUEST');
+    return { path: value.path, recursive: value.recursive === true };
+}
+function resolveRequiredPath(value) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new FileRouteError(400, 'Path is required', 'BAD_REQUEST');
+    }
+    return resolveUserPath(value);
+}
+function resolveUserPath(value, fallback) {
+    if (typeof value !== 'string' || value.length === 0) {
+        if (fallback !== undefined)
+            return resolve(expandHomePrefix(fallback));
+        throw new FileRouteError(400, 'Path is required', 'BAD_REQUEST');
+    }
+    return resolve(expandHomePrefix(value));
+}
+function validateFileName(value) {
+    const name = value.trim();
+    if (!name)
+        throw new FileRouteError(400, 'Name is required', 'BAD_REQUEST');
+    if (name === '.' || name === '..' || name.includes('/') || name.includes('\\')) {
+        throw new FileRouteError(400, 'Name cannot include path separators', 'BAD_REQUEST');
+    }
+    return name;
+}
+function stringArrayFromField(value) {
+    if (value === undefined)
+        return [];
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+        return value;
+    throw new FileRouteError(400, 'Upload paths must be strings', 'BAD_REQUEST');
+}
+function sanitizeUploadRelativePath(value) {
+    const normalized = value.replaceAll('\\', '/');
+    if (!normalized || normalized.startsWith('/')) {
+        throw new FileRouteError(400, 'Upload path must be relative', 'BAD_REQUEST');
+    }
+    const segments = normalized.split('/');
+    if (segments.some((segment) => !segment || segment === '.' || segment === '..')) {
+        throw new FileRouteError(400, 'Upload path contains invalid segments', 'BAD_REQUEST');
+    }
+    return segments;
+}
+async function assertWritableUploadTarget(destinationPath) {
+    try {
+        const destinationStats = await lstat(destinationPath);
+        if (destinationStats.isDirectory()) {
+            throw new FileRouteError(409, 'A directory already exists at the upload target', 'EEXIST');
+        }
+    }
+    catch (error) {
+        if (error instanceof FileRouteError)
+            throw error;
+        if (errorCode(error) !== 'ENOENT')
+            throw error;
+    }
+}
+function isSameOrChildPath(parentPath, childPath) {
+    const childRelativePath = relative(parentPath, childPath);
+    return childRelativePath === '' || (!childRelativePath.startsWith('..') && !isAbsolute(childRelativePath));
+}
+async function entryFromDirent(parentPath, dirent) {
+    const entryPath = join(parentPath, dirent.name);
+    const type = fileEntryType(dirent);
+    return entryFromPath(entryPath, dirent.name, type, type !== 'symlink');
+}
+async function entryFromPath(entryPath, entryName = basename(entryPath), fallbackType = 'other', skipLstat = false) {
+    let linkStats = null;
+    let targetStats = null;
+    const unreachable = {
+        name: entryName,
+        path: entryPath,
+        displayPath: displayPath(entryPath),
+        type: fallbackType,
+        hidden: entryName.startsWith('.'),
+        size: null,
+        modifiedAt: null,
+        readable: false,
+        writable: false,
+    };
+    if (skipLstat) {
+        try {
+            targetStats = await stat(entryPath);
+            linkStats = targetStats;
+        }
+        catch {
+            return unreachable;
+        }
+    }
+    else {
+        try {
+            linkStats = await lstat(entryPath);
+        }
+        catch {
+            return unreachable;
+        }
+        try {
+            targetStats = await stat(entryPath);
+        }
+        catch {
+            targetStats = linkStats;
+        }
+    }
+    const type = skipLstat ? fallbackType : fileEntryType(linkStats);
+    const metadataStats = targetStats ?? linkStats;
+    const [readable, writable] = await Promise.all([
+        canAccess(entryPath, constants.R_OK),
+        canAccess(entryPath, constants.W_OK),
+    ]);
+    return {
+        name: entryName,
+        path: entryPath,
+        displayPath: displayPath(entryPath),
+        type,
+        hidden: entryName.startsWith('.'),
+        size: metadataStats.isDirectory() ? null : metadataStats.size,
+        modifiedAt: metadataStats.mtimeMs,
+        readable,
+        writable,
+    };
+}
+async function canAccess(targetPath, mode) {
+    try {
+        await access(targetPath, mode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function displayPath(absolutePath) {
+    if (absolutePath === HOME)
+        return '~/';
+    const pathRelativeToHome = relative(HOME, absolutePath);
+    if (pathRelativeToHome && !pathRelativeToHome.startsWith('..') && !isAbsolute(pathRelativeToHome)) {
+        return `~/${pathRelativeToHome.split(sep).join('/')}`;
+    }
+    return absolutePath;
+}
+function fileEntryType(entry) {
+    if (entry.isSymbolicLink())
+        return 'symlink';
+    if (entry.isDirectory())
+        return 'directory';
+    if (entry.isFile())
+        return 'file';
+    return 'other';
+}
+const ENTRY_RANK = { directory: 0, file: 1, symlink: 2, other: 3 };
+function compareEntries(a, b) {
+    const typeDifference = (ENTRY_RANK[a.type] ?? 3) - (ENTRY_RANK[b.type] ?? 3);
+    if (typeDifference !== 0)
+        return typeDifference;
+    return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
+}
+async function looksBinary(filePath, size) {
+    if (size === 0)
+        return false;
+    const sampleSize = Math.min(TEXT_SAMPLE_BYTES, size);
+    const buffer = Buffer.alloc(sampleSize);
+    const handle = await open(filePath, 'r');
+    try {
+        const { bytesRead } = await handle.read(buffer, 0, sampleSize, 0);
+        if (bytesRead === 0)
+            return false;
+        let controlBytes = 0;
+        for (let index = 0; index < bytesRead; index += 1) {
+            const byte = buffer[index];
+            if (byte === 0)
+                return true;
+            const isAllowedWhitespace = byte === 9 || byte === 10 || byte === 12 || byte === 13;
+            if ((byte < 32 && !isAllowedWhitespace) || byte === 127)
+                controlBytes += 1;
+        }
+        return controlBytes / bytesRead > 0.2;
+    }
+    finally {
+        await handle.close();
+    }
+}
+function sendFileError(res, error, fallback) {
+    if (error instanceof FileRouteError) {
+        res.status(error.status).json({ error: error.message, code: error.code });
+        return;
+    }
+    const code = errorCode(error);
+    const status = statusForNodeCode(code);
+    const message = error instanceof Error && error.message ? error.message : fallback;
+    res.status(status).json({ error: message, code });
+}
+function sendStreamingFileError(res, error, fallback) {
+    if (res.headersSent) {
+        res.destroy(error instanceof Error ? error : new Error(fallback));
+        return;
+    }
+    sendFileError(res, error, fallback);
+}
+function statusForNodeCode(code) {
+    switch (code) {
+        case 'ENOENT':
+            return 404;
+        case 'EACCES':
+        case 'EPERM':
+            return 403;
+        case 'ENOTDIR':
+        case 'EISDIR':
+            return 400;
+        case 'EEXIST':
+        case 'ENOTEMPTY':
+            return 409;
+        default:
+            return 500;
+    }
+}

package/dist/server/server/routes/skills.d.ts

@@ -0,0 +1 @@
+export declare const skillsRouter: import("express-serve-static-core").Router;

package/dist/server/server/routes/skills.js

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+import { getBundledSkillWithContent, listBundledSkills, toSkillMeta } from '../skills/catalog.js';
+export const skillsRouter = Router();
+skillsRouter.get('/', async (_req, res) => {
+    const skills = await listBundledSkills();
+    res.json({ skills: skills.map(toSkillMeta) });
+});
+skillsRouter.get('/:id/content', async (req, res) => {
+    const result = await getBundledSkillWithContent(req.params.id);
+    if (!result)
+        return res.status(404).json({ error: 'Skill not found' });
+    res.json({ skill: toSkillMeta(result.skill), content: result.content });
+});

package/dist/server/server/routes/tasks.d.ts

@@ -0,0 +1 @@
+export declare const tasksRouter: import("express-serve-static-core").Router;