@yvhitxcel/opencode-remote 0.15.0

package/dist/core/approval.js

@@ -0,0 +1,95 @@
+// Approval workflow for OpenCode Remote Control
+import { loadConfig } from './config.js';
+const approvalCallbacks = new Map();
+export function createApprovalRequest(session, type, data) {
+    const config = loadConfig();
+    const now = Date.now();
+    const request = {
+        id: crypto.randomUUID(),
+        type,
+        description: data.description,
+        files: data.files,
+        command: data.command,
+        createdAt: now,
+        expiresAt: now + config.approvalTimeoutMs,
+    };
+    // Add to session's pending approvals
+    session.pendingApprovals.push(request);
+    return request;
+}
+export function getPendingApproval(session, requestId) {
+    if (requestId) {
+        return session.pendingApprovals.find(r => r.id === requestId);
+    }
+    return session.pendingApprovals[0]; // Return first pending
+}
+export function resolveApproval(session, requestId, approved) {
+    const index = session.pendingApprovals.findIndex(r => r.id === requestId);
+    if (index === -1) {
+        return { success: false, error: 'Approval request not found' };
+    }
+    const request = session.pendingApprovals[index];
+    // Check if expired
+    if (Date.now() > request.expiresAt) {
+        session.pendingApprovals.splice(index, 1);
+        return { success: false, error: 'Approval request expired', request };
+    }
+    // Remove from pending
+    session.pendingApprovals.splice(index, 1);
+    // Resolve the promise if there's a callback
+    const callback = approvalCallbacks.get(requestId);
+    if (callback) {
+        callback.resolve(approved);
+        approvalCallbacks.delete(requestId);
+    }
+    return { success: true, request };
+}
+export function waitForApproval(request) {
+    return new Promise((resolve, reject) => {
+        approvalCallbacks.set(request.id, { resolve, reject });
+        // Auto-reject on timeout
+        const timeUntilExpiry = request.expiresAt - Date.now();
+        setTimeout(() => {
+            const callback = approvalCallbacks.get(request.id);
+            if (callback) {
+                approvalCallbacks.delete(request.id);
+                callback.resolve(false); // Auto-reject
+            }
+        }, timeUntilExpiry);
+    });
+}
+export function cancelAllApprovals(session) {
+    for (const request of session.pendingApprovals) {
+        const callback = approvalCallbacks.get(request.id);
+        if (callback) {
+            approvalCallbacks.delete(request.id);
+            callback.reject(new Error('Session ended'));
+        }
+    }
+    session.pendingApprovals = [];
+}
+// Format approval request for display
+export function formatApprovalMessage(request) {
+    const lines = [];
+    if (request.type === 'file_edit') {
+        lines.push('📝 Approval needed: Edit files');
+        lines.push('');
+        lines.push('📄 Changes:');
+        if (request.files) {
+            for (const file of request.files) {
+                lines.push(`• ${file.path} (+${file.additions}, -${file.deletions})`);
+            }
+        }
+    }
+    else {
+        lines.push('📝 Approval needed: Run command');
+        lines.push('');
+        lines.push(`🔧 \`${request.command}\``);
+    }
+    lines.push('');
+    lines.push('/approve — allow changes');
+    lines.push('/reject — deny changes');
+    lines.push('/diff — see what will change first');
+    lines.push(`⏱️ Expires in ${Math.round((request.expiresAt - Date.now()) / 60000)} min (auto-reject)`);
+    return lines.join('\n');
+}

package/dist/core/auth.js

@@ -0,0 +1,119 @@
+// Authorization management for OpenCode Remote Control
+// First user to send /start becomes the owner automatically
+const authState = {
+    telegramOwner: null,
+    feishuOwner: null,
+    weixinOwner: null,
+};
+// Auth file path for persistence
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+const AUTH_DIR = join(homedir(), '.opencode-remote');
+const AUTH_FILE = join(AUTH_DIR, 'auth.json');
+function ensureAuthDir() {
+    if (!existsSync(AUTH_DIR)) {
+        mkdirSync(AUTH_DIR, { recursive: true });
+    }
+}
+function loadAuth() {
+    try {
+        if (existsSync(AUTH_FILE)) {
+            const data = JSON.parse(readFileSync(AUTH_FILE, 'utf-8'));
+            authState.telegramOwner = data.telegramOwner || null;
+            authState.feishuOwner = data.feishuOwner || null;
+            authState.weixinOwner = data.weixinOwner || null;
+        }
+    }
+    catch (error) {
+        console.warn('Failed to load auth state, starting fresh:', error);
+    }
+}
+function saveAuth() {
+    try {
+        ensureAuthDir();
+        writeFileSync(AUTH_FILE, JSON.stringify(authState, null, 2));
+    }
+    catch (error) {
+        console.error('Failed to save auth state:', error);
+    }
+}
+// Initialize on module load
+loadAuth();
+export function isAuthorized(platform, userId) {
+    if (platform === 'telegram') {
+        return authState.telegramOwner === userId;
+    }
+    else if (platform === 'feishu') {
+        return authState.feishuOwner === userId;
+    }
+    else {
+        return authState.weixinOwner === userId;
+    }
+}
+export function hasOwner(platform) {
+    if (platform === 'telegram') {
+        return authState.telegramOwner !== null;
+    }
+    else if (platform === 'feishu') {
+        return authState.feishuOwner !== null;
+    }
+    else {
+        return authState.weixinOwner !== null;
+    }
+}
+export function claimOwnership(platform, userId) {
+    if (platform === 'telegram') {
+        if (authState.telegramOwner) {
+            if (authState.telegramOwner === userId) {
+                return { success: true, message: 'already_owner' };
+            }
+            return { success: false, message: 'already_claimed' };
+        }
+        authState.telegramOwner = userId;
+        saveAuth();
+        return { success: true, message: 'claimed' };
+    }
+    else if (platform === 'feishu') {
+        if (authState.feishuOwner) {
+            if (authState.feishuOwner === userId) {
+                return { success: true, message: 'already_owner' };
+            }
+            return { success: false, message: 'already_claimed' };
+        }
+        authState.feishuOwner = userId;
+        saveAuth();
+        return { success: true, message: 'claimed' };
+    }
+    else {
+        // weixin
+        if (authState.weixinOwner) {
+            if (authState.weixinOwner === userId) {
+                return { success: true, message: 'already_owner' };
+            }
+            return { success: false, message: 'already_claimed' };
+        }
+        authState.weixinOwner = userId;
+        saveAuth();
+        return { success: true, message: 'claimed' };
+    }
+}
+export function getOwner(platform) {
+    if (platform === 'telegram') {
+        return authState.telegramOwner;
+    }
+    else if (platform === 'feishu') {
+        return authState.feishuOwner;
+    }
+    else {
+        return authState.weixinOwner;
+    }
+}
+// For debugging/display
+export function getAuthStatus() {
+    return {
+        telegram: authState.telegramOwner !== null,
+        feishu: authState.feishuOwner !== null,
+        weixin: authState.weixinOwner !== null,
+    };
+}

package/dist/core/config.js

@@ -0,0 +1,61 @@
+// OpenCode Remote Control - canonical config loader
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const CONFIG_DIR = join(homedir(), '.opencode-remote');
+const CONFIG_FILE = join(CONFIG_DIR, '.env');
+
+export function loadConfig() {
+  const config = {
+    opencodeServerUrl: 'http://localhost:3000',
+    tunnelUrl: '',
+    sessionIdleTimeoutMs: 1800000,
+    cleanupIntervalMs: 300000,
+    approvalTimeoutMs: 300000,
+  };
+
+  // 1. Read ~/.opencode-remote/.env
+  if (existsSync(CONFIG_FILE)) {
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    const token = content.match(/TELEGRAM_BOT_TOKEN=(.+)/)?.[1]?.trim();
+    if (token && token !== 'your_bot_token_here') config.telegramBotToken = token;
+
+    const appId = content.match(/FEISHU_APP_ID=(.+)/)?.[1]?.trim();
+    if (appId) config.feishuAppId = appId;
+
+    const appSecret = content.match(/FEISHU_APP_SECRET=(.+)/)?.[1]?.trim();
+    if (appSecret) config.feishuAppSecret = appSecret;
+  }
+
+  // 2. Read ./.env (local project, lower priority)
+  const localEnv = join(process.cwd(), '.env');
+  if (existsSync(localEnv)) {
+    const content = readFileSync(localEnv, 'utf-8');
+
+    // Telegram: only if not already set (preserves original behavior)
+    if (!config.telegramBotToken) {
+      const token = content.match(/TELEGRAM_BOT_TOKEN=(.+)/)?.[1]?.trim();
+      if (token && token !== 'your_bot_token_here') config.telegramBotToken = token;
+    }
+
+    // Feishu: always fills (preserves original behavior)
+    const appId = content.match(/FEISHU_APP_ID=(.+)/)?.[1]?.trim();
+    if (appId) config.feishuAppId = appId;
+
+    const appSecret = content.match(/FEISHU_APP_SECRET=(.+)/)?.[1]?.trim();
+    if (appSecret) config.feishuAppSecret = appSecret;
+  }
+
+  // 3. Env vars override everything
+  if (process.env.TELEGRAM_BOT_TOKEN?.trim()) config.telegramBotToken = process.env.TELEGRAM_BOT_TOKEN.trim();
+  if (process.env.FEISHU_APP_ID?.trim()) config.feishuAppId = process.env.FEISHU_APP_ID.trim();
+  if (process.env.FEISHU_APP_SECRET?.trim()) config.feishuAppSecret = process.env.FEISHU_APP_SECRET.trim();
+  if (process.env.OPENCODE_SERVER_URL) config.opencodeServerUrl = process.env.OPENCODE_SERVER_URL;
+  if (process.env.TUNNEL_URL) config.tunnelUrl = process.env.TUNNEL_URL;
+  if (process.env.SESSION_IDLE_TIMEOUT_MS) config.sessionIdleTimeoutMs = parseInt(process.env.SESSION_IDLE_TIMEOUT_MS, 10);
+  if (process.env.CLEANUP_INTERVAL_MS) config.cleanupIntervalMs = parseInt(process.env.CLEANUP_INTERVAL_MS, 10);
+  if (process.env.APPROVAL_TIMEOUT_MS) config.approvalTimeoutMs = parseInt(process.env.APPROVAL_TIMEOUT_MS, 10);
+
+  return config;
+}

package/dist/core/notifications.js

@@ -0,0 +1,134 @@
+// Notification formatting for OpenCode Remote Control
+import { EMOJI } from './types.js';
+export function formatNotification(options) {
+    const lines = [];
+    // Status indicator
+    switch (options.type) {
+        case 'success':
+            lines.push(`${EMOJI.SUCCESS} ${options.title || 'Done'}`);
+            break;
+        case 'error':
+            lines.push(`${EMOJI.ERROR} ${options.title || 'Error'}`);
+            break;
+        case 'loading':
+            lines.push(`${EMOJI.LOADING} ${options.title || 'Thinking...'}`);
+            break;
+        case 'input_needed':
+            lines.push(`${EMOJI.QUESTION} ${options.title || 'Question'}`);
+            break;
+        case 'expired':
+            lines.push(`${EMOJI.EXPIRED} ${options.title || 'Session expired'}`);
+            break;
+        case 'started':
+            lines.push(`${EMOJI.START} ${options.title || 'Ready'}`);
+            break;
+    }
+    // Add blank line if we have more content
+    if (options.details || options.files || options.actions) {
+        lines.push('');
+    }
+    // Files changed
+    if (options.files && options.files.length > 0) {
+        lines.push(`📄 ${options.files.length} files changed:`);
+        for (const file of options.files.slice(0, 5)) {
+            lines.push(`• ${file.path} (+${file.additions}, -${file.deletions})`);
+        }
+        if (options.files.length > 5) {
+            lines.push(`• ... and ${options.files.length - 5} more`);
+        }
+    }
+    // Details
+    if (options.details) {
+        lines.push(options.details);
+    }
+    // Actions
+    if (options.actions && options.actions.length > 0) {
+        lines.push('');
+        lines.push(options.actions.join(' • '));
+    }
+    return lines.join('\n');
+}
+// Pre-built message templates
+export const TEMPLATES = {
+    botStarted: () => formatNotification({
+        type: 'started',
+        title: 'OpenCode Remote Control ready',
+        actions: ['💬 Send a prompt to start', '/help — commands', '/status — connection']
+    }),
+    sessionExpired: () => formatNotification({
+        type: 'expired',
+        title: 'Session expired (30 min idle)',
+        actions: ['💬 Send new message to start fresh']
+    }),
+    taskCompleted: (files) => formatNotification({
+        type: 'success',
+        files,
+        actions: ['💬 Reply to continue', '/files — details']
+    }),
+    taskFailed: (error) => formatNotification({
+        type: 'error',
+        title: error.slice(0, 50),
+        details: 'The task failed. OpenCode is still running.',
+        actions: ['💬 Try rephrasing', '/reset — start fresh']
+    }),
+    needsInput: (question, options) => formatNotification({
+        type: 'input_needed',
+        title: question,
+        details: options ? options.map((o, i) => `${i + 1}. ${o}`).join('\n') : undefined,
+        actions: options ? ['Reply with number'] : undefined
+    }),
+    openCodeOffline: () => formatNotification({
+        type: 'error',
+        title: 'OpenCode is offline',
+        details: 'Cannot connect to OpenCode server.',
+        actions: ['🔄 /retry — check again', '/status — diagnostics']
+    }),
+    thinking: () => formatNotification({
+        type: 'loading',
+        title: 'Thinking...'
+    }),
+    approved: () => formatNotification({
+        type: 'success',
+        title: 'Approved — changes applied'
+    }),
+    rejected: () => formatNotification({
+        type: 'success',
+        title: 'Rejected — changes discarded'
+    }),
+    approvalTimeout: () => formatNotification({
+        type: 'error',
+        title: 'Approval timed out (5 min)',
+        details: 'Changes were automatically rejected.',
+    }),
+};
+// Split message for Telegram's 4096 char limit
+export function splitMessage(text, maxLength = 4000) {
+    if (text.length <= maxLength) {
+        return [text];
+    }
+    const messages = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxLength) {
+            messages.push(remaining);
+            break;
+        }
+        // Find a good break point
+        let breakPoint = remaining.lastIndexOf('\n', maxLength);
+        if (breakPoint < maxLength * 0.5) {
+            breakPoint = remaining.lastIndexOf(' ', maxLength);
+        }
+        if (breakPoint < maxLength * 0.5) {
+            breakPoint = maxLength;
+        }
+        messages.push(remaining.slice(0, breakPoint));
+        remaining = remaining.slice(breakPoint).trim();
+    }
+    // Add continuation indicator
+    if (messages.length > 1) {
+        for (let i = 0; i < messages.length - 1; i++) {
+            messages[i] += '\n\n... (continued)';
+        }
+    }
+    return messages;
+}

package/dist/core/qiniu.js

@@ -0,0 +1,267 @@
+// 七牛云上传工具 - 使用 AWS SigV4 签名 (S3 兼容接口)
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const qiniu = require('qiniu');
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { createHmac, createHash } from 'crypto';
+import { join, basename, extname } from 'path';
+
+// 七牛云配置 - 从环境变量读取，禁止硬编码
+function getQiniuConfig() {
+    const accessKey = process.env.QINIU_ACCESS_KEY;
+    const secretKey = process.env.QINIU_SECRET_KEY;
+    const bucket = process.env.QINIU_BUCKET;
+    const domain = process.env.QINIU_DOMAIN;
+    const region = process.env.QINIU_REGION || 'cn-east-1';
+    if (!accessKey || !secretKey || !bucket || !domain) {
+        throw new Error('七牛云未配置：请设置 QINIU_ACCESS_KEY, QINIU_SECRET_KEY, QINIU_BUCKET, QINIU_DOMAIN 环境变量');
+    }
+    return { accessKey, secretKey, bucket, domain, region };
+}
+
+let _qiniuConfig = null;
+function getConfig() {
+    if (!_qiniuConfig) _qiniuConfig = getQiniuConfig();
+    return _qiniuConfig;
+}
+
+function getMac() {
+    const cfg = getConfig();
+    return new qiniu.auth.digest.Mac(cfg.accessKey, cfg.secretKey);
+}
+
+const configQiniu = new qiniu.conf.Config();
+const zoneKey = `Zone_z${process.env.QINIU_REGION === 'cn-east-1' ? '0' : '1'}`;
+configQiniu.zone = qiniu.zone[zoneKey] || qiniu.zone.Zone_z0;
+
+// AWS SigV4 签名 for S3 兼容 API
+function getSignedUrl(key, expires = 3600) {
+    const cfg = getConfig();
+    const host = cfg.domain.replace(/^https?:\/\//, '');
+    const amzDate = new Date().toISOString().replace(/[:-]|\.\d{3}/g, '');
+    const dateStamp = amzDate.slice(0, 8);
+    const credential = `${cfg.accessKey}/${dateStamp}/${cfg.region}/s3/aws4_request`;
+
+    const params = {
+        'X-Amz-Algorithm': 'AWS4-HMAC-SHA256',
+        'X-Amz-Credential': credential,
+        'X-Amz-Date': amzDate,
+        'X-Amz-Expires': expires.toString(),
+        'X-Amz-SignedHeaders': 'host'
+    };
+    const sortedKeys = Object.keys(params).sort();
+    const canonicalQueryString = sortedKeys
+        .map(k => `${encodeURIComponent(k)}=${encodeURIComponent(params[k])}`)
+        .join('&');
+
+    const canonicalUri = '/' + key;
+    const canonicalHeaders = `host:${host}\n`;
+    const signedHeaders = 'host';
+    const payloadHash = 'UNSIGNED-PAYLOAD';
+
+    const canonicalRequest = [
+        'GET', canonicalUri, canonicalQueryString,
+        canonicalHeaders, signedHeaders, payloadHash
+    ].join('\n');
+
+    const algorithm = 'AWS4-HMAC-SHA256';
+    const credentialScope = `${dateStamp}/${cfg.region}/s3/aws4_request`;
+    const hashedRequest = createHash('sha256').update(canonicalRequest).digest('hex');
+    const stringToSign = [algorithm, amzDate, credentialScope, hashedRequest].join('\n');
+
+    const kDate = createHmac('sha256', 'AWS4' + cfg.secretKey).update(dateStamp).digest();
+    const kRegion = createHmac('sha256', kDate).update(cfg.region).digest();
+    const kService = createHmac('sha256', kRegion).update('s3').digest();
+    const kSigning = createHmac('sha256', kService).update('aws4_request').digest();
+    const signature = createHmac('sha256', kSigning).update(stringToSign).digest('hex');
+
+    return `${cfg.domain}/${key}?${canonicalQueryString}&X-Amz-Signature=${signature}`;
+}
+
+export function getSignedUrlExport(key, expires = 3600) {
+    return getSignedUrl(key, expires);
+}
+
+// 从七牛云删除文件
+export async function deleteFromQiniu(key) {
+    const cfg = getConfig();
+    const mac = getMac();
+    const bucketManager = new qiniu.rs.BucketManager(mac, configQiniu);
+
+    return new Promise((resolve, reject) => {
+        bucketManager.delete(cfg.bucket, key, (err, ret) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(ret);
+        });
+    });
+}
+
+// 获取云端文件信息（包括 hash）
+export async function getFileStat(key) {
+    const cfg = getConfig();
+    const mac = getMac();
+    const bucketManager = new qiniu.rs.BucketManager(mac, configQiniu);
+
+    return new Promise((resolve, reject) => {
+        bucketManager.stat(cfg.bucket, key, (err, ret) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(ret);
+        });
+    });
+}
+
+// 上传文件到七牛云（从服务器获取MD5，相同则跳过，不同则删除旧文件后重新上传）
+export async function uploadToQiniu(filePath, customKey = null) {
+    if (!existsSync(filePath)) {
+        throw new Error(`文件不存在: ${filePath}`);
+    }
+
+    const fileName = customKey || basename(filePath);
+    const key = `uploads/${fileName}`;
+
+    // 计算本地文件 MD5
+    const fileBuffer = readFileSync(filePath);
+    const localMd5 = createHash('md5').update(fileBuffer).digest('hex');
+
+    // 从服务器获取文件 MD5
+    let serverMd5 = null;
+    try {
+        const stat = await getFileStat(key);
+        serverMd5 = stat.md5;
+    } catch (e) {
+        console.debug('[qiniu] File stat check (expected if not exists):', e.message);
+    }
+
+    // 如果 MD5 相同，跳过上传
+    if (serverMd5 === localMd5) {
+        const downloadUrl = getSignedUrl(key, 86400);
+        return {
+            key: key,
+            hash: localMd5,
+            url: downloadUrl,
+            skipped: true
+        };
+    }
+
+    // MD5 不同，先删除云端旧文件
+    if (serverMd5) {
+        try {
+            await deleteFromQiniu(key);
+        } catch (e) {
+            console.debug('[qiniu] Delete old file (expected if missing):', e.message);
+        }
+    }
+
+    // 上传新文件
+    const cfg = getConfig();
+    const mac = getMac();
+    const putPolicy = new qiniu.rs.PutPolicy({ scope: cfg.bucket });
+    putPolicy.fsizeMin = 1;
+    putPolicy.fsizeLimit = 1024 * 1024 * 1024;
+
+    const uploadToken = putPolicy.uploadToken(mac);
+    const formUploader = new qiniu.form_up.FormUploader(configQiniu);
+    const putExtra = new qiniu.form_up.PutExtra();
+
+    return new Promise((resolve, reject) => {
+        formUploader.put(uploadToken, key, fileBuffer, putExtra, (err, ret) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            const downloadUrl = getSignedUrl(key, 86400);
+            resolve({
+                key: key,
+                hash: ret.hash,
+                url: downloadUrl,
+                skipped: false
+            });
+        });
+    });
+}
+
+// 扫描目录查找构建产物
+export function findBuildOutputs(projectDir, maxDepth = 5) {
+    if (!projectDir || !existsSync(projectDir)) {
+        return [];
+    }
+
+    const extensions = [
+        '.apk', '.aab', '.ipa', '.exe', '.msi', '.dmg', '.pkg', '.deb', '.rpm', '.AppImage',
+    ];
+
+    const searchDirPatterns = [
+        '', 'build', 'build/outputs', 'build/outputs/apk', 'build/outputs/bundle',
+        'dist', 'dist/install', 'dist/win-unpacked', 'dist/mac',
+        'out', 'out/release', 'out/debug', 'target/release', 'target/debug',
+        'release', 'android/app/build/outputs', 'android/app/build/outputs/apk',
+        'android/build/outputs', 'android/build/outputs/apk', 'ios/build/Build/Products',
+    ];
+
+    const results = [];
+    const searchedDirs = new Set();
+
+    function searchDir(dir, depth) {
+        if (depth > maxDepth || searchedDirs.has(dir)) return;
+        searchedDirs.add(dir);
+
+        if (!existsSync(dir) || !statSync(dir).isDirectory()) return;
+
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+
+                if (entry.isDirectory()) {
+                    if (!['node_modules', '.git', '.svn', 'venv', 'env', '__pycache__', '.cache', 'coverage', '.next', '.nuxt'].includes(entry.name)) {
+                        searchDir(fullPath, depth + 1);
+                    }
+                } else if (entry.isFile()) {
+                    const ext = extname(entry.name).toLowerCase();
+                    if (!extensions.includes(ext)) continue;
+
+                    try {
+                        const stat = statSync(fullPath);
+                        if (stat.size < 1024) continue;
+
+                        results.push({
+                            path: fullPath,
+                            name: entry.name,
+                            size: stat.size,
+                            time: stat.mtime.getTime(),
+                            relativePath: fullPath.replace(projectDir, '').replace(/^[\\\/]/, '')
+                        });
+                    } catch (e) {}
+                }
+            }
+        } catch (e) {}
+    }
+
+    for (const pattern of searchDirPatterns) {
+        const searchPath = pattern ? join(projectDir, pattern) : projectDir;
+        if (existsSync(searchPath)) {
+            searchDir(searchPath, 0);
+        }
+    }
+
+    if (results.length === 0) {
+        searchDir(projectDir, 0);
+    }
+
+    results.sort((a, b) => b.time - a.time);
+    return results;
+}
+
+export function formatSize(bytes) {
+    if (bytes < 1024) return bytes + ' B';
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+    if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+    return (bytes / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+}