colonynote 0.0.0 → 1.0.0-beta.12

package/dist/server/api.js

@@ -0,0 +1,593 @@
+import { Hono } from 'hono';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { saveConfig, DEFAULT_SENSITIVE_PATHS } from '../config.js';
+import { minimatch } from 'minimatch';
+function isAllowed(pathStr, config) {
+    const resolved = path.resolve(pathStr);
+    return config.roots.some(root => resolved.startsWith(path.resolve(root.path)));
+}
+function validateRoot(rootPath, config) {
+    const resolved = path.resolve(rootPath);
+    const root = config.roots.find(r => path.resolve(r.path) === resolved);
+    return root ? path.resolve(root.path) : null;
+}
+function checkSensitivePath(inputPath) {
+    const basename = path.basename(inputPath);
+    for (const pattern of DEFAULT_SENSITIVE_PATHS) {
+        if (minimatch(basename, pattern, { nocase: true, dot: true }))
+            return true;
+    }
+    return false;
+}
+function checkNestedPath(newPath, existingRoots) {
+    const resolved = path.resolve(newPath);
+    for (const root of existingRoots) {
+        const existing = path.resolve(root.path);
+        if (resolved === existing)
+            return { isNested: true, conflictWith: root.path, reason: 'duplicate' };
+        if (resolved.startsWith(existing + path.sep))
+            return { isNested: true, conflictWith: root.path, reason: 'child' };
+        if (existing.startsWith(resolved + path.sep))
+            return { isNested: true, conflictWith: root.path, reason: 'parent' };
+    }
+    return { isNested: false };
+}
+function findRootForPath(filePath, config) {
+    for (const root of config.roots) {
+        const rootPath = path.resolve(root.path);
+        const relativePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const fullPath = path.join(rootPath, relativePath);
+        if ((fullPath.startsWith(rootPath + path.sep) || fullPath === rootPath) && existsSync(fullPath)) {
+            return rootPath;
+        }
+    }
+    return null;
+}
+function hasAllowedExtension(filename, extensions) {
+    const ext = path.extname(filename).toLowerCase();
+    return extensions.includes(ext);
+}
+async function walkDirectory(dir, rootPath, config, matcher) {
+    const nodes = [];
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const isDir = entry.isDirectory();
+            if (!config.showHiddenFiles && entry.name.startsWith('.'))
+                continue;
+            if (matcher.isIgnored(fullPath, isDir))
+                continue;
+            if (isDir) {
+                const children = await walkDirectory(fullPath, rootPath, config, matcher);
+                nodes.push({
+                    name: entry.name,
+                    path: fullPath.replace(rootPath, '').replace(/\\/g, '/') || '/',
+                    type: 'directory',
+                    rootPath,
+                    children,
+                });
+            }
+            else if (entry.isFile()) {
+                if (hasAllowedExtension(entry.name, config.allowedExtensions)) {
+                    nodes.push({
+                        name: entry.name,
+                        path: fullPath.replace(rootPath, '').replace(/\\/g, '/') || '/',
+                        type: 'file',
+                        rootPath,
+                    });
+                }
+            }
+        }
+    }
+    catch (e) {
+        // Re-throw error if this is the root directory, otherwise ignore
+        if (dir === rootPath) {
+            throw e;
+        }
+    }
+    nodes.sort((a, b) => {
+        if (a.type === 'directory' && b.type === 'file')
+            return -1;
+        if (a.type === 'file' && b.type === 'directory')
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    return nodes;
+}
+export function createFileRouter(config, matcher) {
+    const router = new Hono();
+    router.get('/config', async (c) => {
+        return c.json({
+            showHiddenFiles: config.showHiddenFiles,
+            allowedExtensions: config.allowedExtensions,
+            ignore: config.ignore,
+        });
+    });
+    router.patch('/config', async (c) => {
+        try {
+            const body = await c.req.json();
+            const allowedFields = ['showHiddenFiles', 'allowedExtensions', 'ignore'];
+            const updates = {};
+            for (const key of allowedFields) {
+                if (key in body) {
+                    updates[key] = body[key];
+                }
+            }
+            saveConfig(config);
+            if (typeof updates.showHiddenFiles === 'boolean') {
+                config.showHiddenFiles = updates.showHiddenFiles;
+            }
+            if (Array.isArray(updates.allowedExtensions)) {
+                config.allowedExtensions = updates.allowedExtensions;
+            }
+            if (updates.ignore) {
+                if (typeof updates.ignore.enableIgnoreFiles === 'boolean') {
+                    config.ignore.enableIgnoreFiles = updates.ignore.enableIgnoreFiles;
+                }
+                if (Array.isArray(updates.ignore.ignoreFileNames)) {
+                    config.ignore.ignoreFileNames = updates.ignore.ignoreFileNames;
+                }
+                if (Array.isArray(updates.ignore.patterns)) {
+                    config.ignore.patterns = updates.ignore.patterns;
+                    matcher.updateGlobalPatterns(updates.ignore.patterns);
+                }
+                matcher.clearCache();
+            }
+            return c.json({ success: true, config: { showHiddenFiles: config.showHiddenFiles, allowedExtensions: config.allowedExtensions, ignore: config.ignore } });
+        }
+        catch (e) {
+            console.error('Failed to update config:', e);
+            return c.json({ error: 'Failed to update config' }, 500);
+        }
+    });
+    // Root management routes
+    router.get('/roots', async (c) => {
+        return c.json({ roots: config.roots });
+    });
+    router.post('/roots', async (c) => {
+        try {
+            const body = await c.req.json();
+            const newPath = body.path;
+            if (!newPath)
+                return c.json({ error: 'Path is required' }, 400);
+            try {
+                const stat = await fs.stat(newPath);
+                if (!stat.isDirectory())
+                    return c.json({ error: 'Path must be a directory' }, 400);
+            }
+            catch {
+                return c.json({ error: 'Path does not exist' }, 400);
+            }
+            if (checkSensitivePath(newPath))
+                return c.json({ error: 'Sensitive path not allowed' }, 400);
+            const nested = checkNestedPath(newPath, config.roots);
+            if (nested.isNested)
+                return c.json({ error: 'Nested path not allowed', conflictWith: nested.conflictWith, reason: nested.reason }, 400);
+            const newRoot = { path: path.resolve(newPath), exclude: body.exclude };
+            config.roots.push(newRoot);
+            saveConfig(config);
+            return c.json({ success: true, root: newRoot });
+        }
+        catch (e) {
+            return c.json({ error: 'Failed to add root' }, 500);
+        }
+    });
+    router.delete('/roots', async (c) => {
+        const pathParam = c.req.query('path');
+        if (!pathParam)
+            return c.json({ error: 'path parameter required' }, 400);
+        const idx = config.roots.findIndex(r => path.resolve(r.path) === path.resolve(pathParam));
+        if (idx === -1)
+            return c.json({ error: 'Root not found' }, 404);
+        config.roots.splice(idx, 1);
+        saveConfig(config);
+        return c.json({ success: true });
+    });
+    router.patch('/roots', async (c) => {
+        try {
+            const body = await c.req.json();
+            const { path: rootPath, exclude } = body;
+            if (!rootPath)
+                return c.json({ error: 'Path is required' }, 400);
+            const root = config.roots.find(r => path.resolve(r.path) === path.resolve(rootPath));
+            if (!root)
+                return c.json({ error: 'Root not found' }, 404);
+            if (exclude !== undefined)
+                root.exclude = exclude;
+            saveConfig(config);
+            return c.json({ success: true, root });
+        }
+        catch (e) {
+            return c.json({ error: 'Failed to update root' }, 500);
+        }
+    });
+    router.get('/roots/search', async (c) => {
+        const query = c.req.query('q') || '';
+        if (!query.trim())
+            return c.json({ matches: [] });
+        const matches = [];
+        let searchRoot;
+        let searchTerm;
+        if (query.startsWith('/')) {
+            const normalizedQuery = path.normalize(query);
+            const lastSlashIndex = normalizedQuery.lastIndexOf('/');
+            if (lastSlashIndex <= 0) {
+                searchRoot = '/';
+                searchTerm = normalizedQuery.slice(1);
+            }
+            else {
+                const dirPart = normalizedQuery.slice(0, lastSlashIndex) || '/';
+                const basePart = normalizedQuery.slice(lastSlashIndex + 1);
+                if (existsSync(dirPart) && (await fs.stat(dirPart)).isDirectory()) {
+                    searchRoot = dirPart;
+                    searchTerm = basePart;
+                }
+                else {
+                    searchRoot = path.dirname(dirPart);
+                    searchTerm = basePart;
+                }
+            }
+        }
+        else {
+            searchRoot = os.homedir();
+            searchTerm = query;
+        }
+        const pattern = `*${searchTerm}*`;
+        async function traverse(dir, depth) {
+            if (depth > 3 || matches.length >= 20)
+                return;
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (matches.length >= 20)
+                        break;
+                    if (entry.name.startsWith('.'))
+                        continue;
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory() && !checkSensitivePath(fullPath)) {
+                        if (minimatch(entry.name, pattern, { nocase: true }))
+                            matches.push(fullPath);
+                        await traverse(fullPath, depth + 1);
+                    }
+                }
+            }
+            catch { }
+        }
+        await traverse(searchRoot, 0);
+        return c.json({ matches });
+    });
+    router.get('/', async (c) => {
+        try {
+            const groups = await Promise.all(config.roots.map(async (root) => {
+                try {
+                    return {
+                        root,
+                        files: await walkDirectory(root.path, root.path, config, matcher)
+                    };
+                }
+                catch (e) {
+                    return {
+                        root,
+                        files: [],
+                        error: e instanceof Error ? e.message : 'Failed to read directory'
+                    };
+                }
+            }));
+            return c.json({ groups });
+        }
+        catch (e) {
+            return c.json({ error: 'Failed to read directory' }, 500);
+        }
+    });
+    router.get('/content', async (c) => {
+        const pathsParam = c.req.query('paths');
+        if (!pathsParam) {
+            return c.json({ error: 'paths parameter is required' }, 400);
+        }
+        const paths = pathsParam.split(',').filter(Boolean);
+        const results = [];
+        for (const filePath of paths) {
+            const rootParam = c.req.query('root');
+            let rootPath;
+            if (rootParam) {
+                rootPath = path.resolve(rootParam);
+                if (!config.roots.some(r => path.resolve(r.path) === rootPath)) {
+                    return c.json({ error: 'Invalid root' }, 400);
+                }
+            }
+            else {
+                rootPath = findRootForPath(filePath, config);
+            }
+            if (!rootPath)
+                return c.json({ error: 'Access denied' }, 403);
+            const relativePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+            const fullPath = path.join(rootPath, relativePath);
+            if (!isAllowed(fullPath, config)) {
+                continue;
+            }
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isFile()) {
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    results.push({
+                        path: filePath,
+                        name: path.basename(filePath),
+                        content,
+                    });
+                }
+            }
+            catch (e) {
+                // skip files that can't be read
+            }
+        }
+        return c.json({ files: results });
+    });
+    router.get('/*', async (c) => {
+        const filePath = c.req.path.replace(/^\/api\/files/, '') || '/';
+        // Handle root path - return grouped file tree
+        if (filePath === '/' || filePath === '') {
+            try {
+                const groups = await Promise.all(config.roots.map(async (root) => {
+                    try {
+                        return {
+                            root,
+                            files: await walkDirectory(root.path, root.path, config, matcher)
+                        };
+                    }
+                    catch (e) {
+                        return {
+                            root,
+                            files: [],
+                            error: e instanceof Error ? e.message : 'Failed to read directory'
+                        };
+                    }
+                }));
+                return c.json({ groups });
+            }
+            catch (e) {
+                return c.json({ error: 'Failed to read directory' }, 500);
+            }
+        }
+        // Handle root parameter from query string
+        const rootParam = c.req.query('root');
+        let rootPath;
+        if (rootParam) {
+            rootPath = path.resolve(rootParam);
+            if (!config.roots.some(r => path.resolve(r.path) === rootPath)) {
+                return c.json({ error: 'Invalid root' }, 400);
+            }
+        }
+        else {
+            rootPath = findRootForPath(filePath, config);
+        }
+        if (!rootPath)
+            return c.json({ error: 'Access denied' }, 403);
+        const relativePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const fullPath = path.join(rootPath, relativePath);
+        if (!isAllowed(fullPath, config)) {
+            return c.json({ error: 'Access denied' }, 403);
+        }
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory()) {
+                const files = await walkDirectory(fullPath, rootPath, config, matcher);
+                return c.json({ files });
+            }
+        }
+        catch (e) {
+            // not a directory
+        }
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            return c.text(content);
+        }
+        catch (e) {
+            return c.json({ error: 'File not found' }, 404);
+        }
+    });
+    router.post('/copy', async (c) => {
+        try {
+            const body = await c.req.json();
+            let { sourcePath, targetPath, sourceRoot, targetRoot } = body;
+            if (!sourcePath || !targetPath) {
+                return c.json({ error: 'sourcePath and targetPath required' }, 400);
+            }
+            if (!sourceRoot || !targetRoot) {
+                return c.json({ error: 'sourceRoot and targetRoot required' }, 400);
+            }
+            const validatedSourceRoot = validateRoot(sourceRoot, config);
+            const validatedTargetRoot = validateRoot(targetRoot, config);
+            if (!validatedSourceRoot)
+                return c.json({ error: 'Invalid source root' }, 400);
+            if (!validatedTargetRoot)
+                return c.json({ error: 'Invalid target root' }, 400);
+            const srcFullPath = path.join(validatedSourceRoot, sourcePath);
+            let tgtFullPath = path.join(validatedTargetRoot, targetPath);
+            const stat = await fs.stat(srcFullPath);
+            const targetExists = await fs.access(tgtFullPath).then(() => true).catch(() => false);
+            if (targetExists) {
+                const ext = path.extname(targetPath);
+                const base = path.basename(targetPath, ext);
+                const dir = path.dirname(targetPath);
+                targetPath = `${dir}/${base} (copy)${ext}`;
+                tgtFullPath = path.join(validatedTargetRoot, targetPath);
+            }
+            if (stat.isDirectory()) {
+                await fs.cp(srcFullPath, tgtFullPath, { recursive: true });
+            }
+            else {
+                await fs.copyFile(srcFullPath, tgtFullPath);
+            }
+            return c.json({ success: true, newPath: targetPath });
+        }
+        catch (e) {
+            console.error('Copy error:', e);
+            return c.json({ error: 'Failed to copy' }, 500);
+        }
+    });
+    router.post('/*', async (c) => {
+        const filePath = c.req.path.replace(/^\/api\/files/, '') || '/';
+        const rootParam = c.req.query('root');
+        let rootPath;
+        if (rootParam) {
+            rootPath = validateRoot(rootParam, config);
+            if (!rootPath)
+                return c.json({ error: 'Invalid root' }, 400);
+        }
+        else {
+            rootPath = findRootForPath(filePath, config);
+            if (!rootPath)
+                return c.json({ error: 'Access denied' }, 403);
+        }
+        const relativePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const fullPath = path.join(rootPath, relativePath);
+        if (!isAllowed(fullPath, config)) {
+            return c.json({ error: 'Access denied' }, 403);
+        }
+        const contentType = c.req.header('Content-Type') || '';
+        if (contentType.includes('application/json')) {
+            const body = await c.req.json();
+            if (body.type === 'create') {
+                const parentPath = body.parentPath || '';
+                const name = body.name;
+                let parentRootPath;
+                if (body.root) {
+                    parentRootPath = validateRoot(body.root, config);
+                    if (!parentRootPath) {
+                        return c.json({ error: 'Invalid root' }, 400);
+                    }
+                }
+                else {
+                    parentRootPath = findRootForPath(parentPath, config);
+                    if (!parentRootPath)
+                        return c.json({ error: 'Access denied' }, 403);
+                }
+                const targetPath = path.join(parentRootPath, parentPath, name);
+                if (!isAllowed(targetPath, config)) {
+                    return c.json({ error: 'Access denied' }, 403);
+                }
+                try {
+                    if (body.isDirectory) {
+                        await fs.mkdir(targetPath, { recursive: true });
+                    }
+                    else {
+                        if (!hasAllowedExtension(name, config.allowedExtensions)) {
+                            return c.json({ error: 'File type not allowed' }, 400);
+                        }
+                        await fs.writeFile(targetPath, '', 'utf-8');
+                    }
+                    return c.json({ success: true, path: targetPath.replace(parentRootPath, '') });
+                }
+                catch (e) {
+                    return c.json({ error: 'Failed to create' }, 500);
+                }
+            }
+        }
+        try {
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            const content = await c.req.text();
+            await fs.writeFile(fullPath, content, 'utf-8');
+            return c.json({ success: true });
+        }
+        catch (e) {
+            return c.json({ error: 'Failed to save file' }, 500);
+        }
+    });
+    router.put('/*', async (c) => {
+        try {
+            const body = await c.req.json();
+            const { oldPath, newPath, isDirectory, sourceRoot, targetRoot } = body;
+            if (!oldPath || !newPath) {
+                return c.json({ error: 'oldPath and newPath are required' }, 400);
+            }
+            if (!sourceRoot || !targetRoot) {
+                return c.json({ error: 'sourceRoot and targetRoot are required' }, 400);
+            }
+            const validatedSourceRoot = validateRoot(sourceRoot, config);
+            const validatedTargetRoot = validateRoot(targetRoot, config);
+            if (!validatedSourceRoot)
+                return c.json({ error: 'Invalid source root' }, 400);
+            if (!validatedTargetRoot)
+                return c.json({ error: 'Invalid target root' }, 400);
+            const oldFullPath = path.join(validatedSourceRoot, oldPath);
+            const newFullPath = path.join(validatedTargetRoot, newPath);
+            if (!isAllowed(oldFullPath, config) || !isAllowed(newFullPath, config)) {
+                return c.json({ error: 'Access denied' }, 403);
+            }
+            if (isDirectory) {
+                const stat = await fs.stat(oldFullPath);
+                if (!stat.isDirectory()) {
+                    return c.json({ error: 'Source is not a directory' }, 400);
+                }
+            }
+            else {
+                const ext = path.extname(newPath).toLowerCase();
+                if (!hasAllowedExtension(newPath, config.allowedExtensions)) {
+                    return c.json({ error: 'File type not allowed' }, 400);
+                }
+            }
+            try {
+                await fs.rename(oldFullPath, newFullPath);
+            }
+            catch (err) {
+                if (err instanceof Error && 'code' in err && err.code === 'EXDEV') {
+                    // Cross-filesystem move - copy then delete
+                    if (isDirectory) {
+                        await fs.cp(oldFullPath, newFullPath, { recursive: true });
+                        await fs.rm(oldFullPath, { recursive: true });
+                    }
+                    else {
+                        await fs.copyFile(oldFullPath, newFullPath);
+                        await fs.unlink(oldFullPath);
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+            return c.json({ success: true, newPath });
+        }
+        catch (e) {
+            console.error('Rename/Move error:', e);
+            return c.json({ error: 'Failed to rename or move' }, 500);
+        }
+    });
+    router.delete('/*', async (c) => {
+        const filePath = c.req.path.replace(/^\/api\/files/, '') || '/';
+        const rootParam = c.req.query('root');
+        let rootPath;
+        if (rootParam) {
+            rootPath = validateRoot(rootParam, config);
+            if (!rootPath)
+                return c.json({ error: 'Invalid root' }, 400);
+        }
+        else {
+            rootPath = findRootForPath(filePath, config);
+            if (!rootPath)
+                return c.json({ error: 'Access denied' }, 403);
+        }
+        const relativePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const fullPath = path.join(rootPath, relativePath);
+        if (!isAllowed(fullPath, config)) {
+            return c.json({ error: 'Access denied' }, 403);
+        }
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory()) {
+                await fs.rm(fullPath, { recursive: true });
+            }
+            else {
+                await fs.unlink(fullPath);
+            }
+            return c.json({ success: true });
+        }
+        catch (e) {
+            return c.json({ error: 'Failed to delete' }, 500);
+        }
+    });
+    return router;
+}

package/dist/server/app.js

@@ -0,0 +1,21 @@
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { createFileRouter } from './api.js';
+import { IgnoreMatcher } from './ignore.js';
+export function createApp(config) {
+    const app = new Hono();
+    const ignoreConfig = {
+        enableIgnoreFiles: config.ignore.enableIgnoreFiles,
+        ignoreFileNames: config.ignore.ignoreFileNames,
+        globalPatterns: config.ignore.patterns,
+    };
+    const matcher = new IgnoreMatcher(config.roots[0]?.path || process.cwd(), ignoreConfig);
+    app.use('*', cors());
+    app.use('*', async (c, next) => {
+        c.set('config', config);
+        await next();
+    });
+    const fileRouter = createFileRouter(config, matcher);
+    app.route('/api/files', fileRouter);
+    return { app, matcher };
+}