colonynote 1.0.0-beta.10 → 1.0.0-beta.13

package/dist/server/api.js

@@ -1,16 +1,56 @@
 import { Hono } from 'hono';
 import fs from 'fs/promises';
+import { existsSync } from 'fs';
 import path from 'path';
-import { saveUserConfig } from '../config.js';
+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 resolved.startsWith(path.resolve(config.root));
+    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, config, matcher) {
+async function walkDirectory(dir, rootPath, config, matcher) {
     const nodes = [];
     try {
         const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -22,11 +62,12 @@ async function walkDirectory(dir, config, matcher) {
             if (matcher.isIgnored(fullPath, isDir))
                 continue;
             if (isDir) {
-                const children = await walkDirectory(fullPath, config, matcher);
+                const children = await walkDirectory(fullPath, rootPath, config, matcher);
                 nodes.push({
                     name: entry.name,
-                    path: fullPath.replace(config.root, '').replace(/\\/g, '/'),
+                    path: fullPath.replace(rootPath, '').replace(/\\/g, '/') || '/',
                     type: 'directory',
+                    rootPath,
                     children,
                 });
             }
@@ -34,15 +75,19 @@ async function walkDirectory(dir, config, matcher) {
                 if (hasAllowedExtension(entry.name, config.allowedExtensions)) {
                     nodes.push({
                         name: entry.name,
-                        path: fullPath.replace(config.root, '').replace(/\\/g, '/'),
+                        path: fullPath.replace(rootPath, '').replace(/\\/g, '/') || '/',
                         type: 'file',
+                        rootPath,
                     });
                 }
             }
         }
     }
     catch (e) {
-        // ignore errors
+        // 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')
@@ -72,7 +117,7 @@ export function createFileRouter(config, matcher) {
                     updates[key] = body[key];
                 }
             }
-            saveUserConfig(config.root, updates);
+            saveConfig(config);
             if (typeof updates.showHiddenFiles === 'boolean') {
                 config.showHiddenFiles = updates.showHiddenFiles;
             }
@@ -99,10 +144,140 @@ export function createFileRouter(config, matcher) {
             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 files = await walkDirectory(config.root, config, matcher);
-            return c.json({ files });
+            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);
@@ -116,7 +291,21 @@ export function createFileRouter(config, matcher) {
         const paths = pathsParam.split(',').filter(Boolean);
         const results = [];
         for (const filePath of paths) {
-            const fullPath = path.join(config.root, filePath);
+            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;
             }
@@ -139,14 +328,53 @@ export function createFileRouter(config, matcher) {
     });
     router.get('/*', async (c) => {
         const filePath = c.req.path.replace(/^\/api\/files/, '') || '/';
-        const fullPath = path.join(config.root, filePath);
+        // 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, config, matcher);
+                const files = await walkDirectory(fullPath, rootPath, config, matcher);
                 return c.json({ files });
             }
         }
@@ -161,9 +389,62 @@ export function createFileRouter(config, matcher) {
             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 fullPath = path.join(config.root, filePath);
+        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);
         }
@@ -173,7 +454,19 @@ export function createFileRouter(config, matcher) {
             if (body.type === 'create') {
                 const parentPath = body.parentPath || '';
                 const name = body.name;
-                const targetPath = path.join(config.root, parentPath, 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);
                 }
@@ -187,7 +480,7 @@ export function createFileRouter(config, matcher) {
                         }
                         await fs.writeFile(targetPath, '', 'utf-8');
                     }
-                    return c.json({ success: true, path: targetPath.replace(config.root, '') });
+                    return c.json({ success: true, path: targetPath.replace(parentRootPath, '') });
                 }
                 catch (e) {
                     return c.json({ error: 'Failed to create' }, 500);
@@ -205,19 +498,23 @@ export function createFileRouter(config, matcher) {
         }
     });
     router.put('/*', async (c) => {
-        const filePath = c.req.path.replace(/^\/api\/files/, '') || '/';
-        const fullPath = path.join(config.root, filePath);
-        if (!isAllowed(fullPath, config)) {
-            return c.json({ error: 'Access denied' }, 403);
-        }
         try {
             const body = await c.req.json();
-            const { oldPath, newPath, isDirectory } = body;
+            const { oldPath, newPath, isDirectory, sourceRoot, targetRoot } = body;
             if (!oldPath || !newPath) {
                 return c.json({ error: 'oldPath and newPath are required' }, 400);
             }
-            const oldFullPath = path.join(config.root, oldPath);
-            const newFullPath = path.join(config.root, newPath);
+            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);
             }
@@ -226,15 +523,32 @@ export function createFileRouter(config, matcher) {
                 if (!stat.isDirectory()) {
                     return c.json({ error: 'Source is not a directory' }, 400);
                 }
-                await fs.rename(oldFullPath, newFullPath);
             }
             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) {
@@ -244,7 +558,20 @@ export function createFileRouter(config, matcher) {
     });
     router.delete('/*', async (c) => {
         const filePath = c.req.path.replace(/^\/api\/files/, '') || '/';
-        const fullPath = path.join(config.root, filePath);
+        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);
         }

package/dist/server/app.js

@@ -9,7 +9,7 @@ export function createApp(config) {
         ignoreFileNames: config.ignore.ignoreFileNames,
         globalPatterns: config.ignore.patterns,
     };
-    const matcher = new IgnoreMatcher(config.root, ignoreConfig);
+    const matcher = new IgnoreMatcher(config.roots[0]?.path || process.cwd(), ignoreConfig);
     app.use('*', cors());
     app.use('*', async (c, next) => {
         c.set('config', config);

package/dist/server/index.js

@@ -2,7 +2,7 @@ import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
 import { createFileRouter } from './api.js';
-import { loadConfig } from '../config.js';
+import { loadConfig, DEFAULT_PORT, DEFAULT_HOST } from '../config.js';
 import { setupWatcher } from './watcher.js';
 import { IgnoreMatcher } from './ignore.js';
 import { WebSocketServer, WebSocket } from 'ws';
@@ -11,9 +11,17 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const clientDir = path.join(__dirname, '..', 'client');
+function findRootForPath(filePath, config) {
+    for (const root of config.roots) {
+        if (filePath.startsWith(root.path)) {
+            return root.path;
+        }
+    }
+    return config.roots[0]?.path || '';
+}
 async function main() {
     const config = await loadConfig();
-    const matcher = new IgnoreMatcher(config.root, {
+    const matcher = new IgnoreMatcher(config.roots[0]?.path || process.cwd(), {
         enableIgnoreFiles: config.ignore.enableIgnoreFiles,
         ignoreFileNames: config.ignore.ignoreFileNames,
         globalPatterns: config.ignore.patterns,
@@ -69,8 +77,8 @@ async function main() {
     });
     const server = serve({
         fetch: app.fetch,
-        port: config.port,
-        hostname: config.host,
+        port: DEFAULT_PORT,
+        hostname: DEFAULT_HOST,
     });
     const clients = new Set();
     const wss = new WebSocketServer({ noServer: true });
@@ -86,9 +94,10 @@ async function main() {
         }
     });
     setupWatcher(config, matcher, {
-        onFileChange: (event, filePath) => {
-            const relativePath = filePath.replace(config.root, '');
-            const message = JSON.stringify({ type: 'file:change', event, path: relativePath });
+        onFileChange: (rootPath, event, filePath) => {
+            const actualRootPath = findRootForPath(filePath, config);
+            const relativePath = filePath.replace(actualRootPath, '');
+            const message = JSON.stringify({ type: 'file:change', event, path: relativePath, rootPath: actualRootPath });
             clients.forEach((client) => {
                 if (client.readyState === WebSocket.OPEN) {
                     client.send(message);
@@ -97,9 +106,9 @@ async function main() {
         },
     });
     console.log(`\n  ColonyNote is running!\n`);
-    console.log(`  Local:   http://localhost:${config.port}`);
-    console.log(`  Network: http://${config.host}:${config.port}`);
-    console.log(`  Root:    ${config.root}\n`);
+    console.log(`  Local:   http://localhost:${DEFAULT_PORT}`);
+    console.log(`  Network: http://${DEFAULT_HOST}:${DEFAULT_PORT}`);
+    console.log(`  Roots:   ${config.roots.map(r => r.path).join(', ')}\n`);
 }
 main().catch((e) => {
     console.error('Failed to start:', e);

package/dist/server/watcher.js

@@ -1,7 +1,8 @@
 import chokidar from 'chokidar';
 import fs from 'fs';
 export function setupWatcher(config, matcher, callbacks) {
-    const watcher = chokidar.watch(config.root, {
+    const rootPaths = config.roots.map(r => r.path);
+    const watcher = chokidar.watch(rootPaths, {
         ignored: (filePath) => {
             if (!config.showHiddenFiles && (filePath.includes('/.') || filePath.startsWith('.')))
                 return true;
@@ -22,26 +23,40 @@ export function setupWatcher(config, matcher, callbacks) {
         },
         persistent: true,
         ignoreInitial: true,
-        depth: 99,
+        depth: 3,
     });
     watcher
         .on('add', (path) => {
         if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
-            callbacks.onFileChange('add', path);
+            const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+            const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+            callbacks.onFileChange(rootPath, 'add', path);
         }
     })
         .on('change', (path) => {
         if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
-            callbacks.onFileChange('change', path);
+            const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+            const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+            callbacks.onFileChange(rootPath, 'change', path);
         }
     })
         .on('unlink', (path) => {
         if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
-            callbacks.onFileChange('unlink', path);
+            const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+            const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+            callbacks.onFileChange(rootPath, 'unlink', path);
         }
     })
-        .on('addDir', (path) => callbacks.onFileChange('addDir', path))
-        .on('unlinkDir', (path) => callbacks.onFileChange('unlinkDir', path))
+        .on('addDir', (path) => {
+        const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+        const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+        callbacks.onFileChange(rootPath, 'addDir', path);
+    })
+        .on('unlinkDir', (path) => {
+        const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+        const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+        callbacks.onFileChange(rootPath, 'unlinkDir', path);
+    })
         .on('error', (error) => console.error('Watcher error:', error));
     return watcher;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "colonynote",
-  "version": "1.0.0-beta.10",
+  "version": "1.0.0-beta.13",
   "engines": {
     "node": ">=18"
   },
@@ -65,6 +65,9 @@
     "chokidar": "^4.0.3",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "colonynote": "1.0.0-beta.10",
+    "commander": "^14.0.3",
     "flexsearch": "^0.8.212",
     "hono": "^4.12.9",
     "katex": "^0.16.40",

package/dist/client/assets/_basePickBy-CpIFiPmc.js

@@ -1 +0,0 @@
-import{e as x,c as O,g as m,k as P,h as p,j as w,l as c,m as A,n as I,t as N,o as _}from"./_baseUniq-C06JezLB.js";import{aU as g,aC as $,aV as E,aW as F,aX as M,aY as l,aZ as B,a_ as T,a$ as y,b0 as S}from"./index-CI8fw8c4.js";var C=/\s/;function G(n){for(var r=n.length;r--&&C.test(n.charAt(r)););return r}var H=/^\s+/;function L(n){return n&&n.slice(0,G(n)+1).replace(H,"")}var o=NaN,R=/^[-+]0x[0-9a-f]+$/i,W=/^0b[01]+$/i,X=/^0o[0-7]+$/i,Y=parseInt;function q(n){if(typeof n=="number")return n;if(x(n))return o;if(g(n)){var r=typeof n.valueOf=="function"?n.valueOf():n;n=g(r)?r+"":r}if(typeof n!="string")return n===0?n:+n;n=L(n);var t=W.test(n);return t||X.test(n)?Y(n.slice(2),t?2:8):R.test(n)?o:+n}var v=1/0,z=17976931348623157e292;function K(n){if(!n)return n===0?n:0;if(n=q(n),n===v||n===-v){var r=n<0?-1:1;return r*z}return n===n?n:0}function U(n){var r=K(n),t=r%1;return r===r?t?r-t:r:0}function fn(n){var r=n==null?0:n.length;return r?O(n):[]}var b=Object.prototype,Z=b.hasOwnProperty,dn=$(function(n,r){n=Object(n);var t=-1,i=r.length,a=i>2?r[2]:void 0;for(a&&E(r[0],r[1],a)&&(i=1);++t<i;)for(var f=r[t],e=F(f),s=-1,d=e.length;++s<d;){var u=e[s],h=n[u];(h===void 0||M(h,b[u])&&!Z.call(n,u))&&(n[u]=f[u])}return n});function un(n){var r=n==null?0:n.length;return r?n[r-1]:void 0}function D(n){return function(r,t,i){var a=Object(r);if(!l(r)){var f=m(t);r=P(r),t=function(s){return f(a[s],s,a)}}var e=n(r,t,i);return e>-1?a[f?r[e]:e]:void 0}}var J=Math.max;function Q(n,r,t){var i=n==null?0:n.length;if(!i)return-1;var a=t==null?0:U(t);return a<0&&(a=J(i+a,0)),p(n,m(r),a)}var hn=D(Q);function V(n,r){var t=-1,i=l(n)?Array(n.length):[];return w(n,function(a,f,e){i[++t]=r(a,f,e)}),i}function gn(n,r){var t=B(n)?c:V;return t(n,m(r))}var j=Object.prototype,k=j.hasOwnProperty;function nn(n,r){return n!=null&&k.call(n,r)}function mn(n,r){return n!=null&&A(n,r,nn)}function rn(n,r){return n<r}function tn(n,r,t){for(var i=-1,a=n.length;++i<a;){var f=n[i],e=r(f);if(e!=null&&(s===void 0?e===e&&!x(e):t(e,s)))var s=e,d=f}return d}function on(n){return n&&n.length?tn(n,T,rn):void 0}function an(n,r,t,i){if(!g(n))return n;r=I(r,n);for(var a=-1,f=r.length,e=f-1,s=n;s!=null&&++a<f;){var d=N(r[a]),u=t;if(d==="__proto__"||d==="constructor"||d==="prototype")return n;if(a!=e){var h=s[d];u=void 0,u===void 0&&(u=g(h)?h:y(r[a+1])?[]:{})}S(s,d,u),s=s[d]}return n}function vn(n,r,t){for(var i=-1,a=r.length,f={};++i<a;){var e=r[i],s=_(n,e);t(s,e)&&an(f,I(e,n),s)}return f}export{rn as a,tn as b,V as c,vn as d,on as e,fn as f,hn as g,mn as h,dn as i,U as j,un as l,gn as m,K as t};