@burdenoff/vibe-agent 1.0.0 → 1.0.2

package/dist/routes/files.js

@@ -1,14 +1,16 @@
-import { promises as fs, readFileSync } from 'fs';
-import path from 'path';
+import { promises as fs, readFileSync } from "fs";
+import path from "path";
 export const fileRoutes = async (fastify) => {
     // Read file
-    fastify.post('/read', async (request, reply) => {
-        const { path: filePath, projectId, connectionId } = request.body;
+    fastify.post("/read", async (request, reply) => {
+        const { path: filePath, projectId, connectionId, } = request.body;
         try {
             // Security check - prevent directory traversal
             const normalizedPath = path.normalize(filePath);
-            if (normalizedPath.includes('..')) {
-                return reply.code(403).send({ error: 'Directory traversal not allowed' });
+            if (normalizedPath.includes("..")) {
+                return reply
+                    .code(403)
+                    .send({ error: "Directory traversal not allowed" });
             }
             // Check for sensitive files
             const sensitivePatterns = [
@@ -18,10 +20,12 @@ export const fileRoutes = async (fastify) => {
                 /id_rsa/,
                 /\.ssh\//,
                 /\.git\/config$/,
-                /\.npmrc$/
+                /\.npmrc$/,
             ];
-            if (sensitivePatterns.some(pattern => pattern.test(normalizedPath))) {
-                return reply.code(403).send({ error: 'Access to sensitive files not allowed' });
+            if (sensitivePatterns.some((pattern) => pattern.test(normalizedPath))) {
+                return reply
+                    .code(403)
+                    .send({ error: "Access to sensitive files not allowed" });
             }
             if (connectionId) {
                 // Read remote file via SSH
@@ -29,81 +33,85 @@ export const fileRoutes = async (fastify) => {
             }
             else {
                 // Read local file
-                const content = await fs.readFile(normalizedPath, 'utf-8');
+                const content = await fs.readFile(normalizedPath, "utf-8");
                 // Emit file read event
-                fastify.io.emit('file:read', {
+                fastify.io.emit("file:read", {
                     path: normalizedPath,
                     projectId,
-                    size: content.length
+                    size: content.length,
                 });
                 return {
                     content,
                     path: normalizedPath,
-                    size: content.length
+                    size: content.length,
                 };
             }
         }
         catch (error) {
             const nodeError = error;
-            if (nodeError.code === 'ENOENT') {
-                return reply.code(404).send({ error: 'File not found' });
+            if (nodeError.code === "ENOENT") {
+                return reply.code(404).send({ error: "File not found" });
             }
-            if (nodeError.code === 'EACCES') {
-                return reply.code(403).send({ error: 'Permission denied' });
+            if (nodeError.code === "EACCES") {
+                return reply.code(403).send({ error: "Permission denied" });
             }
             return reply.code(500).send({
-                error: 'Failed to read file',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to read file",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Write file
-    fastify.post('/write', async (request, reply) => {
-        const { path: filePath, content, projectId } = request.body;
+    fastify.post("/write", async (request, reply) => {
+        const { path: filePath, content, projectId, } = request.body;
         try {
             // Security check - prevent directory traversal
             const normalizedPath = path.normalize(filePath);
-            if (normalizedPath.includes('..')) {
-                return reply.code(403).send({ error: 'Directory traversal not allowed' });
+            if (normalizedPath.includes("..")) {
+                return reply
+                    .code(403)
+                    .send({ error: "Directory traversal not allowed" });
             }
             // Create directory if it doesn't exist
             const dir = path.dirname(normalizedPath);
             await fs.mkdir(dir, { recursive: true });
             // Write file
-            await fs.writeFile(normalizedPath, content, 'utf-8');
+            await fs.writeFile(normalizedPath, content, "utf-8");
             // Get file stats
             const stats = await fs.stat(normalizedPath);
             // Emit file write event
-            fastify.io.emit('file:write', {
+            fastify.io.emit("file:write", {
                 path: normalizedPath,
                 projectId,
-                size: stats.size
+                size: stats.size,
             });
             return {
                 success: true,
                 path: normalizedPath,
-                size: stats.size
+                size: stats.size,
             };
         }
         catch (error) {
             const nodeError = error;
-            if (nodeError.code === 'EACCES') {
-                return reply.code(403).send({ error: 'Permission denied' });
+            if (nodeError.code === "EACCES") {
+                return reply.code(403).send({ error: "Permission denied" });
             }
             return reply.code(500).send({
-                error: 'Failed to write file',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to write file",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // List directory
-    fastify.post('/list', async (request, reply) => {
+    fastify.post("/list", async (request, reply) => {
         const { path: dirPath, connectionId } = request.body;
         try {
             // Security check - prevent directory traversal
             const normalizedPath = path.normalize(dirPath);
-            if (normalizedPath.includes('..')) {
-                return reply.code(403).send({ error: 'Directory traversal not allowed' });
+            if (normalizedPath.includes("..")) {
+                return reply
+                    .code(403)
+                    .send({ error: "Directory traversal not allowed" });
             }
             if (connectionId) {
                 // List remote directory via SSH
@@ -111,7 +119,9 @@ export const fileRoutes = async (fastify) => {
             }
             else {
                 // List local directory
-                const entries = await fs.readdir(normalizedPath, { withFileTypes: true });
+                const entries = await fs.readdir(normalizedPath, {
+                    withFileTypes: true,
+                });
                 const files = await Promise.all(entries.map(async (entry) => {
                     const fullPath = path.join(normalizedPath, entry.name);
                     let stats;
@@ -125,94 +135,115 @@ export const fileRoutes = async (fastify) => {
                     return {
                         name: entry.name,
                         path: fullPath,
-                        type: entry.isDirectory() ? 'directory' :
-                            entry.isFile() ? 'file' :
-                                entry.isSymbolicLink() ? 'symlink' : 'other',
+                        type: entry.isDirectory()
+                            ? "directory"
+                            : entry.isFile()
+                                ? "file"
+                                : entry.isSymbolicLink()
+                                    ? "symlink"
+                                    : "other",
                         size: stats?.size || 0,
                         modified: stats?.mtime || null,
-                        permissions: stats?.mode || null
+                        permissions: stats?.mode || null,
                     };
                 }));
                 // Sort: directories first, then files
                 files.sort((a, b) => {
-                    if (a.type === 'directory' && b.type !== 'directory')
+                    if (a.type === "directory" && b.type !== "directory")
                         return -1;
-                    if (a.type !== 'directory' && b.type === 'directory')
+                    if (a.type !== "directory" && b.type === "directory")
                         return 1;
                     return a.name.localeCompare(b.name);
                 });
                 return {
                     path: normalizedPath,
                     files,
-                    count: files.length
+                    count: files.length,
                 };
             }
         }
         catch (error) {
             const nodeError = error;
-            if (nodeError.code === 'ENOENT') {
-                return reply.code(404).send({ error: 'Directory not found' });
+            if (nodeError.code === "ENOENT") {
+                return reply.code(404).send({ error: "Directory not found" });
             }
-            if (nodeError.code === 'ENOTDIR') {
-                return reply.code(400).send({ error: 'Path is not a directory' });
+            if (nodeError.code === "ENOTDIR") {
+                return reply.code(400).send({ error: "Path is not a directory" });
             }
-            if (nodeError.code === 'EACCES') {
-                return reply.code(403).send({ error: 'Permission denied' });
+            if (nodeError.code === "EACCES") {
+                return reply.code(403).send({ error: "Permission denied" });
             }
             return reply.code(500).send({
-                error: 'Failed to list directory',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to list directory",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Check if path exists
-    fastify.post('/exists', async (request, reply) => {
+    fastify.post("/exists", async (request, reply) => {
         const { path: checkPath } = request.body;
         try {
             // Security check - prevent directory traversal
             const normalizedPath = path.normalize(checkPath);
-            if (normalizedPath.includes('..')) {
-                return reply.code(403).send({ error: 'Directory traversal not allowed' });
+            if (normalizedPath.includes("..")) {
+                return reply
+                    .code(403)
+                    .send({ error: "Directory traversal not allowed" });
             }
             await fs.access(normalizedPath);
             const stats = await fs.stat(normalizedPath);
             return {
                 exists: true,
                 path: normalizedPath,
-                type: stats.isDirectory() ? 'directory' :
-                    stats.isFile() ? 'file' : 'other',
+                type: stats.isDirectory()
+                    ? "directory"
+                    : stats.isFile()
+                        ? "file"
+                        : "other",
                 size: stats.size,
-                modified: stats.mtime
+                modified: stats.mtime,
             };
         }
         catch (error) {
             const nodeError = error;
-            if (nodeError.code === 'ENOENT') {
+            if (nodeError.code === "ENOENT") {
                 return {
                     exists: false,
-                    path: path.normalize(checkPath)
+                    path: path.normalize(checkPath),
                 };
             }
             return reply.code(500).send({
-                error: 'Failed to check path',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to check path",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Delete file or directory
-    fastify.post('/delete', async (request, reply) => {
+    fastify.post("/delete", async (request, reply) => {
         const { path: deletePath } = request.body;
         try {
             // Security check - prevent directory traversal
             const normalizedPath = path.normalize(deletePath);
-            if (normalizedPath.includes('..')) {
-                return reply.code(403).send({ error: 'Directory traversal not allowed' });
+            if (normalizedPath.includes("..")) {
+                return reply
+                    .code(403)
+                    .send({ error: "Directory traversal not allowed" });
             }
             // Additional security check for important paths
-            const protectedPaths = ['/', '/etc', '/usr', '/bin', '/sbin', '/var', '/opt'];
+            const protectedPaths = [
+                "/",
+                "/etc",
+                "/usr",
+                "/bin",
+                "/sbin",
+                "/var",
+                "/opt",
+            ];
             if (protectedPaths.includes(normalizedPath) ||
-                protectedPaths.some(p => normalizedPath.startsWith(p + '/'))) {
-                return reply.code(403).send({ error: 'Cannot delete system directories' });
+                protectedPaths.some((p) => normalizedPath.startsWith(p + "/"))) {
+                return reply
+                    .code(403)
+                    .send({ error: "Cannot delete system directories" });
             }
             const stats = await fs.stat(normalizedPath);
             if (stats.isDirectory()) {
@@ -222,49 +253,51 @@ export const fileRoutes = async (fastify) => {
                 await fs.unlink(normalizedPath);
             }
             // Emit file delete event
-            fastify.io.emit('file:delete', {
+            fastify.io.emit("file:delete", {
                 path: normalizedPath,
-                type: stats.isDirectory() ? 'directory' : 'file'
+                type: stats.isDirectory() ? "directory" : "file",
             });
             return {
                 success: true,
-                path: normalizedPath
+                path: normalizedPath,
             };
         }
         catch (error) {
             const nodeError = error;
-            if (nodeError.code === 'ENOENT') {
-                return reply.code(404).send({ error: 'Path not found' });
+            if (nodeError.code === "ENOENT") {
+                return reply.code(404).send({ error: "Path not found" });
             }
-            if (nodeError.code === 'EACCES') {
-                return reply.code(403).send({ error: 'Permission denied' });
+            if (nodeError.code === "EACCES") {
+                return reply.code(403).send({ error: "Permission denied" });
             }
             return reply.code(500).send({
-                error: 'Failed to delete path',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to delete path",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Read README file
-    fastify.post('/readme', async (request, reply) => {
+    fastify.post("/readme", async (request, reply) => {
         const { path: projectPath, connectionId } = request.body;
         try {
             // Security check - prevent directory traversal
             const normalizedPath = path.normalize(projectPath);
-            if (normalizedPath.includes('..')) {
-                return reply.code(403).send({ error: 'Directory traversal not allowed' });
+            if (normalizedPath.includes("..")) {
+                return reply
+                    .code(403)
+                    .send({ error: "Directory traversal not allowed" });
             }
             // README file variants to check
             const readmeVariants = [
-                'README.md',
-                'readme.md',
-                'README.MD',
-                'README',
-                'readme',
-                'README.txt',
-                'readme.txt',
-                'README.rst',
-                'readme.rst'
+                "README.md",
+                "readme.md",
+                "README.MD",
+                "README",
+                "readme",
+                "README.txt",
+                "readme.txt",
+                "README.rst",
+                "readme.rst",
             ];
             if (connectionId) {
                 // Check remote README
@@ -275,25 +308,25 @@ export const fileRoutes = async (fastify) => {
                 for (const variant of readmeVariants) {
                     const readmePath = path.join(normalizedPath, variant);
                     try {
-                        const content = await fs.readFile(readmePath, 'utf-8');
+                        const content = await fs.readFile(readmePath, "utf-8");
                         return {
                             content,
                             path: readmePath,
                             variant,
-                            size: content.length
+                            size: content.length,
                         };
                     }
                     catch {
                         // Continue to next variant
                     }
                 }
-                return reply.code(404).send({ error: 'No README file found' });
+                return reply.code(404).send({ error: "No README file found" });
             }
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to read README',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to read README",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
@@ -302,46 +335,47 @@ export const fileRoutes = async (fastify) => {
 async function readRemoteFile(fastify, connectionId, filePath, reply) {
     const connectionConfig = fastify.db.getSSHConnection(connectionId);
     if (!connectionConfig) {
-        return reply.code(404).send({ error: 'SSH connection not found' });
+        return reply.code(404).send({ error: "SSH connection not found" });
     }
-    const { Client } = await import('ssh2');
+    const { Client } = await import("ssh2");
     const conn = new Client();
     return new Promise((resolve) => {
-        conn.on('ready', () => {
+        conn.on("ready", () => {
             conn.sftp((err, sftp) => {
                 if (err) {
                     conn.end();
                     return resolve(reply.code(500).send({
-                        error: 'Failed to establish SFTP connection',
-                        details: err.message
+                        error: "Failed to establish SFTP connection",
+                        details: err.message,
                     }));
                 }
                 sftp.readFile(filePath, (err, buffer) => {
                     conn.end();
                     if (err) {
                         const sshError = err;
-                        if (sshError.code === 2) { // ENOENT
-                            return resolve(reply.code(404).send({ error: 'File not found' }));
+                        if (sshError.code === 2) {
+                            // ENOENT
+                            return resolve(reply.code(404).send({ error: "File not found" }));
                         }
                         return resolve(reply.code(500).send({
-                            error: 'Failed to read remote file',
-                            details: err.message
+                            error: "Failed to read remote file",
+                            details: err.message,
                         }));
                     }
-                    const content = buffer.toString('utf-8');
+                    const content = buffer.toString("utf-8");
                     resolve({
                         content,
                         path: filePath,
                         connectionId,
-                        size: content.length
+                        size: content.length,
                     });
                 });
             });
         });
-        conn.on('error', (err) => {
+        conn.on("error", (err) => {
             resolve(reply.code(500).send({
-                error: 'SSH connection failed',
-                details: err.message
+                error: "SSH connection failed",
+                details: err.message,
             }));
         });
         // Connect with appropriate auth
@@ -359,78 +393,85 @@ async function readRemoteFile(fastify, connectionId, filePath, reply) {
         conn.connect(connectConfig);
     });
 }
-// Helper function to list remote directory  
+// Helper function to list remote directory
 async function listRemoteDirectory(fastify, connectionId, dirPath, reply) {
     const connectionConfig = fastify.db.getSSHConnection(connectionId);
     if (!connectionConfig) {
-        return reply.code(404).send({ error: 'SSH connection not found' });
+        return reply.code(404).send({ error: "SSH connection not found" });
     }
-    const { Client } = await import('ssh2');
+    const { Client } = await import("ssh2");
     const conn = new Client();
     return new Promise((resolve) => {
-        conn.on('ready', () => {
+        conn.on("ready", () => {
             conn.exec(`ls -la "${dirPath}"`, (err, stream) => {
                 if (err) {
                     conn.end();
                     return resolve(reply.code(500).send({
-                        error: 'Failed to execute remote command',
-                        details: err.message
+                        error: "Failed to execute remote command",
+                        details: err.message,
                     }));
                 }
-                let output = '';
-                let errorOutput = '';
-                stream.on('data', (data) => {
+                let output = "";
+                let errorOutput = "";
+                stream.on("data", (data) => {
                     output += data.toString();
                 });
-                stream.stderr.on('data', (data) => {
+                stream.stderr.on("data", (data) => {
                     errorOutput += data.toString();
                 });
-                stream.on('close', (code) => {
+                stream.on("close", (code) => {
                     conn.end();
                     if (code !== 0) {
-                        if (errorOutput.includes('No such file or directory')) {
-                            return resolve(reply.code(404).send({ error: 'Directory not found' }));
+                        if (errorOutput.includes("No such file or directory")) {
+                            return resolve(reply.code(404).send({ error: "Directory not found" }));
                         }
                         return resolve(reply.code(500).send({
-                            error: 'Failed to list directory',
-                            details: errorOutput
+                            error: "Failed to list directory",
+                            details: errorOutput,
                         }));
                     }
                     // Parse ls output
-                    const lines = output.split('\n').filter(line => line.trim());
-                    const files = lines.slice(1).map(line => {
+                    const lines = output.split("\n").filter((line) => line.trim());
+                    const files = lines
+                        .slice(1)
+                        .map((line) => {
+                        // Skip "total" line
                         const parts = line.split(/\s+/);
                         if (parts.length >= 9) {
                             const permissions = parts[0];
                             const size = parseInt(parts[4], 10);
-                            const name = parts.slice(8).join(' ');
+                            const name = parts.slice(8).join(" ");
                             return {
                                 name,
                                 path: path.join(dirPath, name),
-                                type: permissions.startsWith('d') ? 'directory' :
-                                    permissions.startsWith('l') ? 'symlink' : 'file',
+                                type: permissions.startsWith("d")
+                                    ? "directory"
+                                    : permissions.startsWith("l")
+                                        ? "symlink"
+                                        : "file",
                                 size,
                                 permissions: parts[0],
                                 owner: parts[2],
                                 group: parts[3],
-                                modified: `${parts[5]} ${parts[6]} ${parts[7]}`
+                                modified: `${parts[5]} ${parts[6]} ${parts[7]}`,
                             };
                         }
                         return null;
-                    }).filter(f => f && f.name !== '.' && f.name !== '..');
+                    })
+                        .filter((f) => f && f.name !== "." && f.name !== "..");
                     resolve({
                         path: dirPath,
                         connectionId,
                         files,
-                        count: files.length
+                        count: files.length,
                     });
                 });
             });
         });
-        conn.on('error', (err) => {
+        conn.on("error", (err) => {
             resolve(reply.code(500).send({
-                error: 'SSH connection failed',
-                details: err.message
+                error: "SSH connection failed",
+                details: err.message,
             }));
         });
         // Connect with appropriate auth
@@ -452,7 +493,7 @@ async function listRemoteDirectory(fastify, connectionId, dirPath, reply) {
 async function findRemoteReadme(fastify, connectionId, dirPath, variants, reply) {
     const connectionConfig = fastify.db.getSSHConnection(connectionId);
     if (!connectionConfig) {
-        return reply.code(404).send({ error: 'SSH connection not found' });
+        return reply.code(404).send({ error: "SSH connection not found" });
     }
     // Try each variant
     for (const variant of variants) {
@@ -466,6 +507,6 @@ async function findRemoteReadme(fastify, connectionId, dirPath, variants, reply)
             continue;
         }
     }
-    return reply.code(404).send({ error: 'No README file found' });
+    return reply.code(404).send({ error: "No README file found" });
 }
 //# sourceMappingURL=files.js.map