colonynote 0.0.0 → 1.0.0-beta.10

package/dist/server/api.js

@@ -0,0 +1,266 @@
+import { Hono } from 'hono';
+import fs from 'fs/promises';
+import path from 'path';
+import { saveUserConfig } from '../config.js';
+function isAllowed(pathStr, config) {
+    const resolved = path.resolve(pathStr);
+    return resolved.startsWith(path.resolve(config.root));
+}
+function hasAllowedExtension(filename, extensions) {
+    const ext = path.extname(filename).toLowerCase();
+    return extensions.includes(ext);
+}
+async function walkDirectory(dir, 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, config, matcher);
+                nodes.push({
+                    name: entry.name,
+                    path: fullPath.replace(config.root, '').replace(/\\/g, '/'),
+                    type: 'directory',
+                    children,
+                });
+            }
+            else if (entry.isFile()) {
+                if (hasAllowedExtension(entry.name, config.allowedExtensions)) {
+                    nodes.push({
+                        name: entry.name,
+                        path: fullPath.replace(config.root, '').replace(/\\/g, '/'),
+                        type: 'file',
+                    });
+                }
+            }
+        }
+    }
+    catch (e) {
+        // ignore errors
+    }
+    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];
+                }
+            }
+            saveUserConfig(config.root, updates);
+            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);
+        }
+    });
+    router.get('/', async (c) => {
+        try {
+            const files = await walkDirectory(config.root, config, matcher);
+            return c.json({ files });
+        }
+        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 fullPath = path.join(config.root, filePath);
+            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/, '') || '/';
+        const fullPath = path.join(config.root, filePath);
+        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);
+                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('/*', 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);
+        }
+        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;
+                const targetPath = path.join(config.root, 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(config.root, '') });
+                }
+                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) => {
+        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;
+            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 (!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);
+                }
+                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);
+                }
+                await fs.rename(oldFullPath, newFullPath);
+            }
+            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 fullPath = path.join(config.root, filePath);
+        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.root, 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 };
+}

package/dist/server/ignore.js

@@ -0,0 +1,210 @@
+import path from 'path';
+import fs from 'fs';
+import { minimatch } from 'minimatch';
+/**
+ * 默认忽略配置
+ */
+export const defaultIgnoreConfig = {
+    enableIgnoreFiles: true,
+    ignoreFileNames: ['.colonynoteignore', '.gitignore'],
+    globalPatterns: [],
+};
+/**
+ * 忽略匹配器 - 管理所有忽略规则并提供匹配功能
+ */
+export class IgnoreMatcher {
+    ignoreFiles = new Map();
+    globalRules = [];
+    rootPath;
+    config;
+    constructor(rootPath, config = defaultIgnoreConfig) {
+        this.rootPath = path.resolve(rootPath);
+        this.config = config;
+        this.globalRules = this.parsePatterns(config.globalPatterns, this.rootPath);
+    }
+    /**
+     * 解析忽略模式字符串为规则对象
+     */
+    parsePatterns(patterns, basePath) {
+        const rules = [];
+        for (const rawPattern of patterns) {
+            // 跳过空行和注释
+            const trimmed = rawPattern.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const isNegation = trimmed.startsWith('!');
+            const isDirectory = trimmed.endsWith('/');
+            // 处理模式字符串
+            let pattern = trimmed;
+            // 处理否定模式：移除开头的 !
+            if (isNegation) {
+                pattern = pattern.slice(1);
+            }
+            // 处理目录标记：暂时保留，匹配时再处理
+            const cleanPattern = isDirectory ? pattern.slice(0, -1) : pattern;
+            // 判断是否为绝对路径模式（以 / 开头）
+            const isAbsolute = cleanPattern.startsWith('/');
+            const rule = {
+                pattern: cleanPattern,
+                rawPattern: trimmed,
+                isNegation,
+                isDirectory,
+                basePath,
+                isAbsolute,
+            };
+            rules.push(rule);
+        }
+        return rules;
+    }
+    /**
+     * 加载指定路径的 .ignore 文件
+     */
+    loadIgnoreFile(filePath) {
+        try {
+            if (!fs.existsSync(filePath))
+                return false;
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split(/\r?\n/);
+            const basePath = path.dirname(filePath);
+            const ignoreFile = {
+                filePath,
+                basePath,
+                rules: this.parsePatterns(lines, basePath),
+            };
+            this.ignoreFiles.set(filePath, ignoreFile);
+            return true;
+        }
+        catch (e) {
+            console.error(`Failed to load ignore file ${filePath}:`, e);
+            return false;
+        }
+    }
+    /**
+     * 就近查找并加载 .ignore 文件
+     * 从 targetPath 向上查找，直到 rootPath
+     */
+    findAndLoadIgnoreFiles(targetPath) {
+        if (!this.config.enableIgnoreFiles)
+            return;
+        let currentPath = path.resolve(targetPath);
+        // 如果是文件，从其父目录开始查找
+        try {
+            const stat = fs.statSync(currentPath);
+            if (stat.isFile()) {
+                currentPath = path.dirname(currentPath);
+            }
+        }
+        catch {
+            // 路径不存在，假设是目录
+        }
+        while (currentPath.startsWith(this.rootPath) && currentPath.length >= this.rootPath.length) {
+            for (const fileName of this.config.ignoreFileNames) {
+                const ignoreFilePath = path.join(currentPath, fileName);
+                // 避免重复加载
+                if (!this.ignoreFiles.has(ignoreFilePath)) {
+                    this.loadIgnoreFile(ignoreFilePath);
+                }
+            }
+            // 向上一级目录
+            const parentPath = path.dirname(currentPath);
+            if (parentPath === currentPath)
+                break; // 已到达根目录
+            currentPath = parentPath;
+        }
+    }
+    /**
+     * 检查单个规则是否匹配目标路径
+     */
+    matchRule(rule, targetPath, isDirectory) {
+        const relativePath = path.relative(rule.basePath, targetPath);
+        if (rule.isAbsolute) {
+            const patternWithoutSlash = rule.pattern.replace(/^\//, '');
+            if (relativePath === patternWithoutSlash ||
+                relativePath.startsWith(patternWithoutSlash + path.sep)) {
+                return true;
+            }
+            return minimatch(relativePath, patternWithoutSlash, { dot: true });
+        }
+        if (!rule.pattern.includes('/')) {
+            const basename = path.basename(targetPath);
+            if (rule.isDirectory) {
+                if (minimatch(basename, rule.pattern, { dot: true })) {
+                    return true;
+                }
+                const parts = relativePath.split(path.sep);
+                for (let i = 0; i < parts.length; i++) {
+                    if (minimatch(parts[i], rule.pattern, { dot: true })) {
+                        return true;
+                    }
+                }
+            }
+            else {
+                if (minimatch(basename, rule.pattern, { dot: true })) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return minimatch(relativePath, rule.pattern, { dot: true });
+    }
+    /**
+     * 检查路径是否被忽略
+     * 返回 true 表示应该忽略，false 表示不忽略
+     */
+    isIgnored(targetPath, isDirectory = false) {
+        const absolutePath = path.resolve(targetPath);
+        // 确保路径在 root 内
+        if (!absolutePath.startsWith(this.rootPath))
+            return false;
+        // 就近查找并加载 .ignore 文件
+        this.findAndLoadIgnoreFiles(absolutePath);
+        // 收集所有相关规则（按优先级排序）
+        // 规则优先级：就近的 .ignore 文件 > 上层的 .ignore 文件 > 全局配置
+        const allRules = [];
+        // 1. 添加全局规则（最低优先级）
+        allRules.push(...this.globalRules);
+        // 2. 添加 .ignore 文件规则（按目录层级从根到当前）
+        const sortedIgnoreFiles = Array.from(this.ignoreFiles.values())
+            .sort((a, b) => {
+            // 按 basePath 深度排序：根目录优先级低，近目录优先级高
+            const depthA = a.basePath.split(path.sep).length;
+            const depthB = b.basePath.split(path.sep).length;
+            return depthA - depthB;
+        });
+        for (const ignoreFile of sortedIgnoreFiles) {
+            // 只考虑影响当前路径的规则文件
+            if (absolutePath.startsWith(ignoreFile.basePath)) {
+                allRules.push(...ignoreFile.rules);
+            }
+        }
+        // 3. 应用规则（后出现的规则优先级更高）
+        let shouldIgnore = false;
+        for (const rule of allRules) {
+            if (this.matchRule(rule, absolutePath, isDirectory)) {
+                // 否定规则取消忽略
+                if (rule.isNegation) {
+                    shouldIgnore = false;
+                }
+                else {
+                    shouldIgnore = true;
+                }
+            }
+        }
+        return shouldIgnore;
+    }
+    /**
+     * 清除缓存的 .ignore 文件（用于重新加载）
+     */
+    clearCache() {
+        this.ignoreFiles.clear();
+    }
+    updateGlobalPatterns(patterns) {
+        this.globalRules = this.parsePatterns(patterns, this.rootPath);
+    }
+    /**
+     * 获取已加载的 .ignore 文件列表
+     */
+    getLoadedIgnoreFiles() {
+        return Array.from(this.ignoreFiles.keys());
+    }
+}

package/dist/server/index.js

@@ -0,0 +1,107 @@
+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 { setupWatcher } from './watcher.js';
+import { IgnoreMatcher } from './ignore.js';
+import { WebSocketServer, WebSocket } from 'ws';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientDir = path.join(__dirname, '..', 'client');
+async function main() {
+    const config = await loadConfig();
+    const matcher = new IgnoreMatcher(config.root, {
+        enableIgnoreFiles: config.ignore.enableIgnoreFiles,
+        ignoreFileNames: config.ignore.ignoreFileNames,
+        globalPatterns: config.ignore.patterns,
+    });
+    const app = new Hono();
+    app.use('*', cors());
+    const fileRouter = createFileRouter(config, matcher);
+    app.route('/api/files', fileRouter);
+    app.get('/assets/*', async (c) => {
+        const filePath = c.req.path.replace('/assets', '');
+        const fullPath = path.join(clientDir, 'assets', filePath);
+        try {
+            const content = fs.readFileSync(fullPath);
+            const ext = path.extname(filePath);
+            const contentType = ext === '.js' ? 'application/javascript' : ext === '.css' ? 'text/css' : 'text/plain';
+            return new Response(content, { headers: { 'Content-Type': contentType } });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    app.get('/logo.png', async (c) => {
+        const fullPath = path.join(clientDir, 'logo.png');
+        try {
+            const content = fs.readFileSync(fullPath);
+            return new Response(content, { headers: { 'Content-Type': 'image/png' } });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    app.get('/favicon.ico', async (c) => {
+        const fullPath = path.join(clientDir, 'favicon.ico');
+        try {
+            const content = fs.readFileSync(fullPath);
+            return new Response(content, { headers: { 'Content-Type': 'image/x-icon' } });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    app.get('*', async (c) => {
+        const indexPath = path.join(clientDir, 'index.html');
+        try {
+            const content = fs.readFileSync(indexPath, 'utf-8');
+            return new Response(content, {
+                headers: { 'Content-Type': 'text/html' },
+            });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    const server = serve({
+        fetch: app.fetch,
+        port: config.port,
+        hostname: config.host,
+    });
+    const clients = new Set();
+    const wss = new WebSocketServer({ noServer: true });
+    wss.on('connection', (ws) => {
+        clients.add(ws);
+        ws.on('close', () => clients.delete(ws));
+    });
+    server.on('upgrade', (request, socket, head) => {
+        if (request.url === '/ws') {
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                wss.emit('connection', ws, request);
+            });
+        }
+    });
+    setupWatcher(config, matcher, {
+        onFileChange: (event, filePath) => {
+            const relativePath = filePath.replace(config.root, '');
+            const message = JSON.stringify({ type: 'file:change', event, path: relativePath });
+            clients.forEach((client) => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.send(message);
+                }
+            });
+        },
+    });
+    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`);
+}
+main().catch((e) => {
+    console.error('Failed to start:', e);
+    process.exit(1);
+});

package/dist/server/watcher.js

@@ -0,0 +1,47 @@
+import chokidar from 'chokidar';
+import fs from 'fs';
+export function setupWatcher(config, matcher, callbacks) {
+    const watcher = chokidar.watch(config.root, {
+        ignored: (filePath) => {
+            if (!config.showHiddenFiles && (filePath.includes('/.') || filePath.startsWith('.')))
+                return true;
+            try {
+                const stat = fs.statSync(filePath);
+                if (matcher.isIgnored(filePath, stat.isDirectory()))
+                    return true;
+            }
+            catch {
+                if (matcher.isIgnored(filePath, false))
+                    return true;
+            }
+            const ext = filePath.split('.').pop()?.toLowerCase() || '';
+            if (ext && !config.allowedExtensions.includes('.' + ext) && !filePath.includes('/')) {
+                return false;
+            }
+            return false;
+        },
+        persistent: true,
+        ignoreInitial: true,
+        depth: 99,
+    });
+    watcher
+        .on('add', (path) => {
+        if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
+            callbacks.onFileChange('add', path);
+        }
+    })
+        .on('change', (path) => {
+        if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
+            callbacks.onFileChange('change', path);
+        }
+    })
+        .on('unlink', (path) => {
+        if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
+            callbacks.onFileChange('unlink', path);
+        }
+    })
+        .on('addDir', (path) => callbacks.onFileChange('addDir', path))
+        .on('unlinkDir', (path) => callbacks.onFileChange('unlinkDir', path))
+        .on('error', (error) => console.error('Watcher error:', error));
+    return watcher;
+}