@papercraneai/sandbox-agent 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import express from "express";
+import { createServer } from "http";
+import { WebSocketServer, WebSocket } from "ws";
+import { Tail } from "tail";
 import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
-import { readdir, stat, mkdir, readFile, writeFile, access } from "fs/promises";
+import { readdir, stat, mkdir, readFile, writeFile, access, unlink } from "fs/promises";
 import { join, dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { spawn, execSync } from "child_process";
-import { homedir } from "os";
+import { homedir, networkInterfaces } from "os";
 import { z } from "zod";
 import multer from "multer";
 import * as log from "./logger.js";
@@ -14,6 +17,21 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Read package version at startup
 const pkg = JSON.parse(await readFile(join(__dirname, "..", "package.json"), "utf-8"));
+// Get local network IP address (first non-internal IPv4 address)
+function getLocalNetworkIP() {
+    const nets = networkInterfaces();
+    for (const name of Object.keys(nets)) {
+        for (const net of nets[name] || []) {
+            // Skip internal (loopback) and non-IPv4 addresses
+            if (net.family === "IPv4" && !net.internal) {
+                return net.address;
+            }
+        }
+    }
+    // Fallback to localhost if no network interface found
+    console.warn("Warning: Could not detect local network IP, falling back to localhost");
+    return "localhost";
+}
 // Parse CLI arguments
 function parseArgs() {
     const args = process.argv.slice(2);
@@ -24,7 +42,8 @@ function parseArgs() {
         agentPort: parseInt(process.env.PORT || "3001"),
         devPort: parseInt(process.env.DEV_PORT || "3000"),
         workdir: join(homedir(), ".papercrane", "sandbox"),
-        agentOnly: false
+        agentOnly: false,
+        hostMode: (process.env.HOST_MODE || "localhost")
     };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -49,6 +68,14 @@ function parseArgs() {
         else if (arg === "--agent-only") {
             result.agentOnly = true;
         }
+        else if (arg === "--host-mode" && args[i + 1]) {
+            const mode = args[++i];
+            if (mode !== "localhost" && mode !== "lan") {
+                console.error(`Error: --host-mode must be 'localhost' or 'lan', got '${mode}'`);
+                process.exit(1);
+            }
+            result.hostMode = mode;
+        }
         else if (arg === "--help" || arg === "-h") {
             console.log(`
 sandbox-agent - Claude Agent SDK server for environments
@@ -65,6 +92,7 @@ Options:
   --agent-only            Only run agent API (no template setup, no dev server)
   --port <port>           Agent API port (default: 3001)
   --dev-port <port>       Dev server port, standalone only (default: 3000)
+  --host-mode <mode>      Host for advertised URLs: localhost or lan (default: localhost)
   --register              Register with Papercrane server (requires --token)
   --token <token>         Connection token from Papercrane UI
   --papercrane-url <url>  Papercrane server URL (default: https://fly.papercrane.ai)
@@ -73,6 +101,7 @@ Options:
 Environment Variables:
   PORT                    Agent API port (same as --port)
   DEV_PORT                Dev server port (same as --dev-port)
+  HOST_MODE               Host mode: localhost or lan (same as --host-mode)
   PAPERCRANE_URL          Papercrane server URL (same as --papercrane-url)
 
 Examples:
@@ -218,6 +247,26 @@ export default function RootLayout({
 }
 // Next.js dev server process
 let nextDevProcess = null;
+// WebSocket server for log streaming (set up later in start())
+let logWebSocketServer = null;
+// Strip ANSI escape codes from strings
+const stripAnsi = (str) => str.replace(/\u001b\[[0-9;]*m/g, "");
+// Broadcast a log message to all connected WebSocket clients
+function broadcastLog(level, message, time) {
+    if (!logWebSocketServer)
+        return;
+    const payload = JSON.stringify({
+        type: "log",
+        level,
+        message: stripAnsi(message),
+        time: time || Date.now()
+    });
+    logWebSocketServer.clients.forEach((client) => {
+        if (client.readyState === WebSocket.OPEN) {
+            client.send(payload);
+        }
+    });
+}
 // Start Next.js dev server
 function startNextDevServer(workdir, port) {
     return new Promise((resolve, reject) => {
@@ -232,6 +281,28 @@ function startNextDevServer(workdir, port) {
         nextDevProcess.stdout?.on("data", (data) => {
             const output = data.toString();
             process.stdout.write(`[next] ${output}`);
+            // Broadcast JSON log lines to WebSocket clients
+            for (const line of output.split("\n")) {
+                // Check for compilation success (plain text from Turbopack)
+                if (line.includes("Compiled") && (line.includes("✓") || line.includes("successfully"))) {
+                    broadcastLog(30, line); // info level
+                    continue;
+                }
+                if (line.includes('{"level":')) {
+                    try {
+                        const jsonMatch = line.match(/\{.*\}$/);
+                        if (jsonMatch) {
+                            const parsed = JSON.parse(jsonMatch[0]);
+                            if (parsed.level >= 40 && parsed.msg) {
+                                broadcastLog(parsed.level, parsed.msg, parsed.time);
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore JSON parse errors
+                    }
+                }
+            }
             if (!resolved && (output.includes("Ready") || output.includes("started server"))) {
                 resolved = true;
                 console.log("✓ Next.js dev server started");
@@ -239,7 +310,10 @@ function startNextDevServer(workdir, port) {
             }
         });
         nextDevProcess.stderr?.on("data", (data) => {
-            process.stderr.write(`[next] ${data}`);
+            const output = data.toString();
+            process.stderr.write(`[next] ${output}`);
+            // Broadcast stderr as errors
+            broadcastLog(50, output);
         });
         nextDevProcess.on("error", (err) => {
             if (!resolved) {
@@ -350,17 +424,31 @@ async function buildFileTree(dirPath) {
 app.get("/health", (_req, res) => {
     res.json({ status: "healthy", projectDir: PROJECT_DIR, version: pkg.version });
 });
+// Find the git repo root by traversing up from a starting directory
+async function findGitRoot(startDir) {
+    let dir = resolve(startDir);
+    while (true) {
+        if (await directoryExists(join(dir, ".git"))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null; // reached filesystem root
+        dir = parent;
+    }
+}
 // Pull template updates (git pull + conditional npm install)
 app.post("/pull-template", async (_req, res) => {
     const workdir = getWorkingDirectory();
     try {
-        // Check if workdir is a git repo
-        if (!(await directoryExists(join(workdir, ".git")))) {
-            res.status(400).json({ error: "Working directory is not a git repository" });
+        // Find the git repo root (may be a parent of the working directory)
+        const gitRoot = await findGitRoot(workdir);
+        if (!gitRoot) {
+            res.status(400).json({ error: "Working directory is not inside a git repository" });
             return;
         }
-        // Run git pull
-        const pullOutput = runCommand("git pull", workdir);
+        // Run git pull from the repo root
+        const pullOutput = runCommand("git pull", gitRoot);
         console.log(`git pull output: ${pullOutput}`);
         // Check if already up to date
         if (pullOutput.includes("Already up to date")) {
@@ -371,7 +459,7 @@ app.post("/pull-template", async (_req, res) => {
         // git diff HEAD@{1} --name-only shows what changed in the last pull
         let filesChanged = [];
         try {
-            const diffOutput = runCommand("git diff HEAD@{1} --name-only", workdir);
+            const diffOutput = runCommand("git diff HEAD@{1} --name-only", gitRoot);
             filesChanged = diffOutput.split("\n").filter(f => f.trim());
         }
         catch {
@@ -383,11 +471,11 @@ app.post("/pull-template", async (_req, res) => {
         let npmInstalled = false;
         if (packageJsonChanged) {
             console.log("package.json changed, running npm install...");
-            await runNpmInstall(workdir);
+            await runNpmInstall(gitRoot);
             npmInstalled = true;
         }
         // Ensure scaffold files still exist after pull
-        await ensureAppScaffold(workdir);
+        await ensureAppScaffold(gitRoot);
         res.json({ updated: true, files_changed: filesChanged, npm_installed: npmInstalled });
     }
     catch (error) {
@@ -588,6 +676,186 @@ app.post("/files/upload", upload.array("files", 10), async (req, res) => {
         });
     }
 });
+// File write endpoint - create or overwrite a file with content
+app.post("/files/write", async (req, res) => {
+    try {
+        const { path: filePath, content } = req.body;
+        if (!filePath) {
+            res.status(400).json({ error: "path is required" });
+            return;
+        }
+        if (content === undefined || content === null) {
+            res.status(400).json({ error: "content is required" });
+            return;
+        }
+        // Sanitize path - remove leading slashes and prevent traversal
+        const sanitizedPath = filePath
+            .replace(/^\/+/, "")
+            .split("/")
+            .filter((part) => part !== ".." && part !== ".")
+            .join("/");
+        const fullPath = join(PROJECT_DIR, sanitizedPath);
+        // Security: ensure path is within PROJECT_DIR
+        const resolvedPath = resolve(fullPath);
+        const resolvedProject = resolve(PROJECT_DIR);
+        if (!resolvedPath.startsWith(resolvedProject)) {
+            res.status(403).json({ error: "Access denied: path outside project directory" });
+            return;
+        }
+        // Auto-create parent directories
+        await mkdir(dirname(fullPath), { recursive: true });
+        // Write file
+        await writeFile(fullPath, content, "utf-8");
+        log.info({ path: sanitizedPath, size: content.length }, "File written");
+        res.json({
+            success: true,
+            path: sanitizedPath,
+            fullPath,
+            size: content.length
+        });
+    }
+    catch (error) {
+        log.error({ error: error instanceof Error ? error.message : String(error) }, "File write failed");
+        res.status(500).json({
+            error: error instanceof Error ? error.message : "Write failed"
+        });
+    }
+});
+// File edit endpoint - find and replace text in a file
+app.post("/files/edit", async (req, res) => {
+    try {
+        const { path: filePath, old_string, new_string, replace_all = false } = req.body;
+        if (!filePath) {
+            res.status(400).json({ error: "path is required" });
+            return;
+        }
+        if (!old_string) {
+            res.status(400).json({ error: "old_string is required" });
+            return;
+        }
+        if (new_string === undefined || new_string === null) {
+            res.status(400).json({ error: "new_string is required" });
+            return;
+        }
+        // Sanitize path
+        const sanitizedPath = filePath
+            .replace(/^\/+/, "")
+            .split("/")
+            .filter((part) => part !== ".." && part !== ".")
+            .join("/");
+        const fullPath = join(PROJECT_DIR, sanitizedPath);
+        // Security: ensure path is within PROJECT_DIR
+        const resolvedPath = resolve(fullPath);
+        const resolvedProject = resolve(PROJECT_DIR);
+        if (!resolvedPath.startsWith(resolvedProject)) {
+            res.status(403).json({ error: "Access denied: path outside project directory" });
+            return;
+        }
+        // Read existing file
+        let content;
+        try {
+            content = await readFile(fullPath, "utf-8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                res.status(404).json({ error: "File not found", path: sanitizedPath });
+                return;
+            }
+            throw error;
+        }
+        // Check if old_string exists
+        if (!content.includes(old_string)) {
+            res.status(400).json({
+                error: "old_string not found in file",
+                path: sanitizedPath
+            });
+            return;
+        }
+        // Count occurrences
+        const occurrences = content.split(old_string).length - 1;
+        // If not replace_all and multiple occurrences, error
+        if (!replace_all && occurrences > 1) {
+            res.status(400).json({
+                error: `old_string is not unique (found ${occurrences} times). Provide more context or use replace_all: true`,
+                path: sanitizedPath,
+                occurrences
+            });
+            return;
+        }
+        // Perform replacement
+        const newContent = replace_all
+            ? content.split(old_string).join(new_string)
+            : content.replace(old_string, new_string);
+        // Write back
+        await writeFile(fullPath, newContent, "utf-8");
+        log.info({ path: sanitizedPath, replacements: replace_all ? occurrences : 1 }, "File edited");
+        res.json({
+            success: true,
+            path: sanitizedPath,
+            fullPath,
+            replacements: replace_all ? occurrences : 1
+        });
+    }
+    catch (error) {
+        log.error({ error: error instanceof Error ? error.message : String(error) }, "File edit failed");
+        res.status(500).json({
+            error: error instanceof Error ? error.message : "Edit failed"
+        });
+    }
+});
+// File delete endpoint
+app.delete("/files/delete", async (req, res) => {
+    try {
+        const filePath = req.query.path || req.body?.path;
+        if (!filePath) {
+            res.status(400).json({ error: "path is required" });
+            return;
+        }
+        // Sanitize path
+        const sanitizedPath = filePath
+            .replace(/^\/+/, "")
+            .split("/")
+            .filter((part) => part !== ".." && part !== ".")
+            .join("/");
+        const fullPath = join(PROJECT_DIR, sanitizedPath);
+        // Security: ensure path is within PROJECT_DIR
+        const resolvedPath = resolve(fullPath);
+        const resolvedProject = resolve(PROJECT_DIR);
+        if (!resolvedPath.startsWith(resolvedProject)) {
+            res.status(403).json({ error: "Access denied: path outside project directory" });
+            return;
+        }
+        // Check if file exists and is not a directory
+        try {
+            const stats = await stat(fullPath);
+            if (stats.isDirectory()) {
+                res.status(400).json({ error: "Cannot delete a directory, only files", path: sanitizedPath });
+                return;
+            }
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                res.status(404).json({ error: "File not found", path: sanitizedPath });
+                return;
+            }
+            throw error;
+        }
+        // Delete the file
+        await unlink(fullPath);
+        log.info({ path: sanitizedPath }, "File deleted");
+        res.json({
+            success: true,
+            path: sanitizedPath,
+            fullPath
+        });
+    }
+    catch (error) {
+        log.error({ error: error instanceof Error ? error.message : String(error) }, "File delete failed");
+        res.status(500).json({
+            error: error instanceof Error ? error.message : "Delete failed"
+        });
+    }
+});
 // Helper to encode path for Claude session storage (slashes and dots become dashes)
 function encodeSessionPath(path) {
     return path.replace(/[\/\.]/g, "-");
@@ -879,9 +1147,12 @@ app.post("/chat", async (req, res) => {
         "Read",
         "Write",
         "Edit",
-        "Glob",
         "Grep",
         "Bash",
+        "WebFetch",
+        "WebSearch",
+        "AgentOutput",
+        "KillShell",
         "mcp__client-tools__ShowPreview"
     ];
     const options = {
@@ -981,8 +1252,9 @@ async function registerWithPapercrane() {
     }
     console.log(`Registering with Papercrane server at ${cliArgs.papercraneUrl}...`);
     try {
-        const agentEndpoint = `http://localhost:${cliArgs.agentPort}`;
-        const previewEndpoint = `http://localhost:${cliArgs.devPort}`;
+        const host = cliArgs.hostMode === "lan" ? getLocalNetworkIP() : "localhost";
+        const agentEndpoint = `http://${host}:${cliArgs.agentPort}`;
+        const previewEndpoint = `http://${host}:${cliArgs.devPort}`;
         const res = await fetch(`${cliArgs.papercraneUrl}/api/environments/register`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -1122,8 +1394,56 @@ async function start() {
                 process.exit(1);
             }
         }
+        // Create HTTP server and attach WebSocket
+        const server = createServer(app);
+        logWebSocketServer = new WebSocketServer({ server, path: "/ws/logs" });
+        // Set up PM2 log tailing (only in agent-only mode where PM2 manages the dev server)
+        if (cliArgs.agentOnly) {
+            const pm2LogPath = join(homedir(), ".pm2", "pm2.log");
+            let tail = null;
+            try {
+                tail = new Tail(pm2LogPath, { fromBeginning: false, follow: true });
+                tail.on("line", (line) => {
+                    // Check for compilation success (plain text from Turbopack)
+                    if (line.includes("Compiled") && (line.includes("✓") || line.includes("successfully"))) {
+                        broadcastLog(30, line); // info level
+                        return;
+                    }
+                    // Only process JSON lines (from next-logger)
+                    if (!line.includes('{"level":'))
+                        return;
+                    try {
+                        // Extract JSON from the line (may have PM2 prefix)
+                        const jsonMatch = line.match(/\{.*\}$/);
+                        if (!jsonMatch)
+                            return;
+                        const parsed = JSON.parse(jsonMatch[0]);
+                        // Only forward errors and warnings (level >= 40)
+                        if (parsed.level >= 40 && parsed.msg) {
+                            broadcastLog(parsed.level, parsed.msg, parsed.time);
+                        }
+                    }
+                    catch {
+                        // Ignore JSON parse errors
+                    }
+                });
+                tail.on("error", (err) => {
+                    log.warn({ error: err.message }, "PM2 log tail error");
+                });
+                log.info({ path: pm2LogPath }, "PM2 log tailing started");
+            }
+            catch (err) {
+                log.warn({ error: err instanceof Error ? err.message : String(err), path: pm2LogPath }, "Failed to start PM2 log tailing");
+            }
+        }
+        logWebSocketServer.on("connection", (ws) => {
+            log.debug({}, "WebSocket client connected to /ws/logs");
+            ws.on("close", () => {
+                log.debug({}, "WebSocket client disconnected from /ws/logs");
+            });
+        });
         // Start the agent API server
-        app.listen(PORT, () => {
+        server.listen(PORT, () => {
             log.info({
                 port: PORT,
                 mode,
@@ -1137,6 +1457,7 @@ async function start() {
             console.log(`  Mode: ${mode}`);
             console.log(`  Log level: ${log.getLogLevel()}`);
             console.log(`  Project directory: ${PROJECT_DIR}`);
+            console.log(`  WebSocket logs: ws://localhost:${PORT}/ws/logs`);
             if (!cliArgs.agentOnly) {
                 console.log(`  Dev server: http://localhost:${cliArgs.devPort}`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papercraneai/sandbox-agent",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Claude Agent SDK server for sandbox environments",
   "license": "MIT",
   "type": "module",
@@ -18,6 +18,7 @@
     "start": "node dist/index.js",
     "dev": "tsx watch src/index.ts",
     "dev:local": "PROJECT_DIR=./template/src/app tsx src/index.ts",
+    "prepublishOnly": "npm run build",
     "build": "tsc",
     "typecheck": "tsc --noEmit"
   },
@@ -25,12 +26,16 @@
     "@anthropic-ai/claude-agent-sdk": "^0.2.5",
     "express": "^4.21.1",
     "multer": "^2.0.2",
+    "tail": "^2.2.6",
+    "ws": "^8.19.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
     "@types/multer": "^2.0.0",
     "@types/node": "^22.14.0",
+    "@types/tail": "^2.2.3",
+    "@types/ws": "^8.18.1",
     "tsx": "^4.20.6",
     "typescript": "^5.8.3"
   }