viagen 0.1.2 → 0.1.3

package/README.md

@@ -0,0 +1,189 @@
+# viagen
+
+A Vite dev server plugin and CLI tool that enables you to use Claude Code in a sandbox — instantly.
+
+## Prerequisites
+
+- [Claude](https://claude.ai/signup) — Max, Pro, or API plan. The setup wizard handles auth.
+- [Vercel](https://vercel.com/signup) — Free plan works. Sandboxes last 45 min on Hobby, 5 hours on Pro.
+- [GitHub CLI](https://cli.github.com) — Enables git clone and push from sandboxes.
+
+## Quick Setup (Claude Code Plugin)
+
+```
+/plugin marketplace add viagen-dev/viagen-claude-plugin
+/plugin install viagen@viagen-marketplace
+```
+
+**Restart Claude Code to load the plugin.**
+
+```
+/viagen-install
+```
+
+The plugin will handle npm installation, vite config updates, and run the setup wizard for you.
+
+## Manual Setup
+
+### Step 1 — Add viagen to your app
+
+```bash
+npm install --save-dev viagen
+```
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+import { viagen } from 'viagen'
+
+export default defineConfig({
+  plugins: [viagen()],
+})
+```
+
+### Step 2 — Setup
+
+```bash
+npx viagen setup
+```
+
+The setup wizard authenticates with Claude, detects your GitHub and Vercel credentials, and captures your git remote info — all written to your local `.env`. This ensures sandboxes clone the correct repo instead of inferring it at runtime.
+
+You can now run `npm run dev` to start the local dev server. At this point you can launch viagen and chat with Claude to make changes to your app.
+
+### Step 3 — Sandbox
+
+```bash
+npx viagen sandbox
+```
+
+Deploys your dev server to a remote Vercel Sandbox — an isolated VM-like environment where Claude can read, write, and push code.
+
+```bash
+# Deploy on a specific branch
+npx viagen sandbox --branch feature/my-thing
+
+# Set a longer timeout (default: 30 min)
+npx viagen sandbox --timeout 60
+
+# Auto-send a prompt on load
+npx viagen sandbox --prompt "build me a landing page"
+
+# Stop a running sandbox
+npx viagen sandbox stop <sandboxId>
+```
+
+
+## Plugin Options
+
+```ts
+viagen({
+  position: 'bottom-right',  // toggle button position
+  model: 'sonnet',           // claude model
+  panelWidth: 375,           // chat panel width in px
+  overlay: true,             // fix button on error overlay
+  ui: true,                  // inject chat panel into pages
+  sandboxFiles: [...],       // copy files manually into sandbox
+  systemPrompt: '...',       // custom system prompt (see below)
+  editable: ['src','conf'],  // files/dirs editable in the UI
+  mcpServers: { ... },       // additional MCP servers for Claude
+})
+```
+
+
+### Custom MCP Servers
+
+Pass additional [MCP server](https://modelcontextprotocol.io) configurations to give Claude access to custom tools:
+
+```ts
+viagen({
+  mcpServers: {
+    'my-db': {
+      command: 'npx',
+      args: ['-y', '@my-org/db-mcp-server'],
+      env: { DATABASE_URL: process.env.DATABASE_URL },
+    },
+  },
+})
+```
+
+These are merged with viagen's built-in platform tools (when connected). User-provided servers take precedence if names collide.
+
+### Editable Files
+
+Add a file editor panel to the chat UI:
+
+```ts
+viagen({
+  editable: ['src/components', 'vite.config.ts']
+})
+```
+
+Paths can be files or directories (directories include all files within). The editor appears as a "Files" tab in the chat panel with a collapsible directory tree, syntax highlighting (TypeScript, JavaScript, CSS, HTML, JSON, Markdown), and image preview.
+
+The default system prompt tells Claude it's embedded in a Vite dev server, that file edits trigger HMR, and how to check server logs. Recent build errors are automatically appended to give Claude context about what went wrong.
+
+To customize the prompt, you can replace it entirely or extend the default:
+
+```ts
+import { viagen, DEFAULT_SYSTEM_PROMPT } from 'viagen'
+
+viagen({
+  // Replace entirely
+  systemPrompt: 'You are a React expert. Only use TypeScript.',
+
+  // Or extend the default
+  systemPrompt: DEFAULT_SYSTEM_PROMPT + '\nAlways use Tailwind for styling.',
+})
+```
+
+## API
+
+Every viagen endpoint is available as an API. Build your own UI, integrate with CI, or script Claude from the command line.
+
+```
+POST /via/chat        — send a message, streamed SSE response
+POST /via/chat/reset  — clear conversation history
+GET  /via/health      — check API key status
+GET  /via/error       — latest build error (if any)
+GET  /via/ui          — standalone chat interface
+GET  /via/iframe      — split view (app + chat side by side)
+GET  /via/files       — list editable files (when configured)
+GET  /via/file?path=  — read file content
+POST /via/file        — write file content { path, content }
+GET  /via/file/raw    — serve raw file (images, etc.) with correct MIME type
+GET  /via/git/status  — list changed files (git status)
+GET  /via/git/diff    — full diff, or single file with ?path=
+GET  /via/git/branch  — current branch, remote URL, open PR info
+GET  /via/logs        — dev server log entries, optional ?since=<timestamp>
+```
+
+When `VIAGEN_AUTH_TOKEN` is set (always on in sandboxes), pass the token as a `Bearer` header, a `/t/:token` path segment, or a `?token=` query param.
+
+```bash
+# With curl
+curl -X POST http://localhost:5173/via/chat \
+  -H "Authorization: Bearer $VIAGEN_AUTH_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"message": "add a hello world route"}'
+
+# Or pass the token in the URL path (sets a session cookie)
+open "http://localhost:5173/via/ui/t/$VIAGEN_AUTH_TOKEN"
+
+# ?token= query param also works (fallback for backwards compat)
+open "http://localhost:5173/via/ui?token=$VIAGEN_AUTH_TOKEN"
+```
+
+## Development
+
+```bash
+npm install
+npm run dev        # Dev server (site)
+npm run build      # Build with tsup
+npm run test       # Run tests
+npm run typecheck  # Type check
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/cli.js

@@ -103,6 +103,11 @@ async function waitForServer(baseUrl, token, devServer) {
 async function deploySandbox(opts) {
   const token = randomUUID();
   const useGit = !!opts.git;
+  const rootDir = opts.rootDir ?? null;
+  const rootPrefix = rootDir ? `${rootDir}/` : "";
+  if (rootDir) {
+    console.log(`  Monorepo root dir: ${rootDir}`);
+  }
   const timeoutMs = (opts.timeoutMinutes ?? 30) * 60 * 1e3;
   const sourceOpts = opts.git ? {
     source: {
@@ -219,21 +224,23 @@ async function deploySandbox(opts) {
     const envLines = Object.entries(envMap).map(([k, v]) => `${k}=${v}`);
     await sandbox2.writeFiles([
       {
-        path: ".env",
+        path: `${rootPrefix}.env`,
         content: Buffer.from(envLines.join("\n"))
       }
     ]);
     const dots = startDots("  Installing dependencies");
-    const install = await sandbox2.runCommand("npm", ["install"]);
+    const installCmd = rootDir ? `cd ${rootDir} && npm install` : "npm install";
+    const install = await sandbox2.runCommand("bash", ["-c", installCmd]);
     dots.stop();
     if (install.exitCode !== 0) {
       const stderr = await install.stderr();
       console.error(stderr);
       throw new Error(`npm install failed (exit ${install.exitCode})`);
     }
+    const devCmd = rootDir ? `cd ${rootDir} && npm run dev` : "npm run dev";
     const devServer = await sandbox2.runCommand({
-      cmd: "npm",
-      args: ["run", "dev"],
+      cmd: "bash",
+      args: ["-c", devCmd],
       detached: true
     });
     const baseUrl = sandbox2.domain(5173);
@@ -972,8 +979,13 @@ async function sandbox(args, options) {
     branch: envBranch || "main",
     userName: envUserName || "viagen",
     userEmail: envUserEmail || "noreply@viagen.dev",
-    isDirty: false
-    // can't know from env, assume clean
+    isDirty: (() => {
+      try {
+        return execSync2("git status --porcelain", { cwd, encoding: "utf-8" }).trim().length > 0;
+      } catch {
+        return false;
+      }
+    })()
   } : getGitInfo(cwd);
   if (envRemoteUrl) {
     console.log("Using git info from .env");
@@ -1013,7 +1025,7 @@ async function sandbox(args, options) {
       userEmail: gitInfo.userEmail,
       token: githubToken
     });
-    if (!envRemoteUrl && gitInfo.isDirty && !branchOverride) {
+    if (gitInfo.isDirty && !branchOverride) {
       console.log("");
       console.log("Your working tree has uncommitted changes.");
       console.log("");
@@ -1072,6 +1084,9 @@ async function sandbox(args, options) {
     console.log(`  Repo:   ${deployGit.remoteUrl}`);
     console.log(`  Branch: ${deployGit.branch}`);
   }
+  if (env["SANDBOX_ROOT_DIR"]) {
+    console.log(`  Root:   ${env["SANDBOX_ROOT_DIR"]}`);
+  }
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   let frameIdx = 0;
   const spinner = setInterval(() => {
@@ -1095,7 +1110,8 @@ async function sandbox(args, options) {
     } : void 0,
     fling: existsSync(join2(homedir(), ".fling", "token")) ? { token: readFileSync2(join2(homedir(), ".fling", "token"), "utf-8").trim() } : void 0,
     timeoutMinutes,
-    prompt
+    prompt,
+    rootDir: env["SANDBOX_ROOT_DIR"] || void 0
   });
   clearInterval(spinner);
   process.stdout.write("\r  \u2713 Sandbox ready!            \n");

package/dist/index.d.ts

@@ -51,6 +51,8 @@ interface DeploySandboxOptions {
     envVars?: Record<string, string>;
     /** Initial prompt to auto-send in the chat UI on load. */
     prompt?: string;
+    /** Subdirectory to use as the working directory (for monorepos). */
+    rootDir?: string;
 }
 interface DeploySandboxResult {
     /** Full URL with auth token in query string. */

package/dist/index.js

@@ -6,8 +6,8 @@ var __export = (target, all) => {
 
 // src/index.ts
 import { execSync as execSync2 } from "child_process";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
 import { loadEnv } from "vite";
 
 // src/logger.ts
@@ -111,7 +111,7 @@ function registerHealthRoutes(server, env, errorRef) {
       );
     }
   });
-  const currentVersion = true ? "0.1.2" : "0.0.0";
+  const currentVersion = true ? "0.1.3" : "0.0.0";
   debug("health", `version resolved: ${currentVersion}`);
   let versionCache = null;
   server.middlewares.use("/via/version", (_req, res) => {
@@ -4200,15 +4200,17 @@ function buildUiHtml(opts) {
 // src/iframe.ts
 function buildIframeHtml(opts) {
   const pw = opts.panelWidth;
+  const appSrc = opts.appUrl ?? "/?_viagen_embed=1";
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="color-scheme" content="light dark">
   <title>viagen</title>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
-    body { display: flex; height: 100vh; background: #ffffff; overflow: hidden; }
+    body { display: flex; height: 100vh; background: #f5f5f5; overflow: hidden; }
     #app-frame { flex: 1; border: none; height: 100%; min-width: 200px; }
     #divider {
       width: 1px;
@@ -4230,24 +4232,67 @@ function buildIframeHtml(opts) {
     #divider:hover, #divider.active { background: #a3a3a3; }
     #chat-frame { width: ${pw}px; border: none; height: 100%; min-width: 280px; background: #ffffff; }
     .dragging iframe { pointer-events: none; }
+    #loading {
+      position: fixed; inset: 0; display: flex; align-items: center; justify-content: center;
+      background: #f5f5f5; color: #666; font-family: system-ui; z-index: 100;
+      transition: opacity 0.3s;
+    }
+    #loading.hidden { opacity: 0; pointer-events: none; }
+    .spinner { width: 20px; height: 20px; border: 2px solid #ddd; border-top-color: #888;
+               border-radius: 50%; animation: spin .6s linear infinite; margin-right: 12px; }
+    @keyframes spin { to { transform: rotate(360deg); } }
+    body.ready { background: #ffffff; }
+    @media (prefers-color-scheme: dark) {
+      body { background: #0a0a0a; }
+      #loading { background: #0a0a0a; color: #888; }
+      .spinner { border-color: #333; border-top-color: #999; }
+      #divider { background: #333; }
+      #divider:hover, #divider.active { background: #555; }
+      #chat-frame { background: #0a0a0a; }
+      body.ready { background: #0a0a0a; }
+    }
   </style>
 </head>
 <body>
-  <iframe id="app-frame" src="/?_viagen_embed=1"></iframe>
+  <div id="loading"><div class="spinner"></div><span>Starting dev server\u2026</span></div>
+  <iframe id="app-frame"></iframe>
   <div id="divider"></div>
-  <iframe id="chat-frame" src="/via/ui"></iframe>
+  <iframe id="chat-frame"></iframe>
   <script>
+    var appFrame = document.getElementById('app-frame');
+    var chatFrame = document.getElementById('chat-frame');
+    var loading = document.getElementById('loading');
+
+    // Wait for Vite to be fully initialized before loading iframes.
+    // We probe /@vite/client which goes through Vite's transform pipeline
+    // and only succeeds after the dev server has finished starting up.
+    // Static middleware routes like /via/ui return 200 instantly (before
+    // Vite is ready), so they can't be used as readiness probes.
+    (async function() {
+      for (var i = 0; i < 120; i++) {
+        try {
+          var r = await fetch('/@vite/client', { credentials: 'same-origin' });
+          if (r.ok) break;
+        } catch(e) {}
+        await new Promise(function(resolve) { setTimeout(resolve, 500); });
+      }
+      // Set iframe srcs \u2014 now Vite should be ready
+      chatFrame.src = '/via/ui';
+      appFrame.src = ${JSON.stringify(appSrc)};
+      // Hide loading overlay once chat frame loads
+      chatFrame.addEventListener('load', function() {
+        loading.classList.add('hidden');
+        document.body.classList.add('ready');
+        chatFrame.contentWindow.postMessage({ type: 'viagen:context', iframe: true }, '*');
+      });
+    })();
+
     // Relay postMessage from app iframe to chat iframe (e.g. "Fix This Error")
     window.addEventListener('message', function(ev) {
       if (ev.data && ev.data.type === 'viagen:send') {
-        document.getElementById('chat-frame').contentWindow.postMessage(ev.data, '*');
+        chatFrame.contentWindow.postMessage(ev.data, '*');
       }
     });
-    // Tell chat iframe it's in split-view mode (hides pop-out button)
-    var chatFrame = document.getElementById('chat-frame');
-    chatFrame.addEventListener('load', function() {
-      chatFrame.contentWindow.postMessage({ type: 'viagen:context', iframe: true }, '*');
-    });
 
     // Drag-resizable divider
     var divider = document.getElementById('divider');
@@ -4293,21 +4338,26 @@ function buildWaitPage(targetUrl) {
 <html><head><meta charset="utf-8"><title>Loading\u2026</title>
 <style>
   body { margin: 0; display: flex; align-items: center; justify-content: center;
-         height: 100vh; background: #0a0a0a; color: #888; font-family: system-ui; }
-  .spinner { width: 20px; height: 20px; border: 2px solid #333; border-top-color: #f97316;
+         height: 100vh; background: #f5f5f5; color: #666; font-family: system-ui; }
+  .spinner { width: 20px; height: 20px; border: 2px solid #ddd; border-top-color: #888;
              border-radius: 50%; animation: spin .6s linear infinite; margin-right: 12px; }
   @keyframes spin { to { transform: rotate(360deg); } }
+  @media (prefers-color-scheme: dark) {
+    body { background: #0a0a0a; color: #888; }
+    .spinner { border-color: #333; border-top-color: #999; }
+  }
 </style></head>
 <body><div class="spinner"></div><span>Starting dev server\u2026</span>
 <script>
 (async () => {
   const target = ${JSON.stringify(targetUrl)};
+  // Probe /@vite/client \u2014 it goes through Vite's transform pipeline and
+  // only succeeds once the dev server is fully initialized. Static routes
+  // like /via/iframe return 200 too early.
   for (let i = 0; i < 60; i++) {
     try {
-      const r = await fetch(target, { credentials: 'same-origin' });
-      const text = await r.text();
-      // Vite is ready when we get a non-empty HTML response
-      if (r.ok && text.length > 0) { window.location.replace(target); return; }
+      const r = await fetch('/@vite/client', { credentials: 'same-origin' });
+      if (r.ok) { window.location.replace(target); return; }
     } catch {}
     await new Promise(r => setTimeout(r, 500));
   }
@@ -18686,8 +18736,9 @@ import {
   tool
 } from "@anthropic-ai/claude-agent-sdk";
 function createViagenTools(config2) {
-  const { client, projectId } = config2;
+  const { client, projectId, processManager } = config2;
   const taskId = process.env["VIAGEN_TASK_ID"];
+  debug("tools", `MCP tools created (projectId: ${projectId}, taskId: ${taskId || "none"})`);
   const tools = [
     tool(
       "viagen_update_task",
@@ -18703,6 +18754,7 @@ function createViagenTools(config2) {
         prReviewStatus: external_exports.string().optional().describe("PR review outcome \u2014 e.g. 'pass', 'flag', or 'fail'.")
       },
       async (args) => {
+        debug("tools", `viagen_update_task called (taskId: ${args.taskId || taskId || "none"}, status: ${args.status || "none"}, projectId: ${projectId})`);
         const id = args.taskId || taskId;
         if (!id) {
           return {
@@ -18724,6 +18776,9 @@ function createViagenTools(config2) {
           };
         } catch (err) {
           const message = err instanceof Error ? err.message : "Unknown error";
+          const status = err?.status;
+          const detail = err?.detail;
+          debug("tools", `viagen_update_task FAILED: ${status || "?"} ${message}${detail ? ` (${detail})` : ""}`);
           return {
             content: [{ type: "text", text: `Error updating task: ${message}` }]
           };
@@ -18737,15 +18792,25 @@ function createViagenTools(config2) {
         status: external_exports.enum(["ready", "running", "validating", "completed", "timed_out"]).optional().describe("Filter tasks by status.")
       },
       async (args) => {
-        const tasks = await client.tasks.list(projectId, args.status);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(tasks, null, 2)
-            }
-          ]
-        };
+        debug("tools", `viagen_list_tasks called (projectId: ${projectId}, status: ${args.status || "all"})`);
+        try {
+          const tasks = await client.tasks.list(projectId, args.status);
+          debug("tools", `viagen_list_tasks returned ${tasks.length} tasks`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(tasks, null, 2)
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Unknown error";
+          debug("tools", `viagen_list_tasks FAILED: ${message}`);
+          return {
+            content: [{ type: "text", text: `Error listing tasks: ${message}` }]
+          };
+        }
       }
     ),
     tool(
@@ -18755,15 +18820,26 @@ function createViagenTools(config2) {
         taskId: external_exports.string().describe("The task ID to retrieve.")
       },
       async (args) => {
-        const task = await client.tasks.get(projectId, args.taskId);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(task, null, 2)
-            }
-          ]
-        };
+        debug("tools", `viagen_get_task called (projectId: ${projectId}, taskId: ${args.taskId})`);
+        try {
+          const task = await client.tasks.get(projectId, args.taskId);
+          debug("tools", `viagen_get_task success (status: ${task.status})`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(task, null, 2)
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Unknown error";
+          const status = err?.status;
+          debug("tools", `viagen_get_task FAILED: ${status || "?"} ${message}`);
+          return {
+            content: [{ type: "text", text: `Error getting task: ${message}` }]
+          };
+        }
       }
     ),
     tool(
@@ -18775,22 +18851,58 @@ function createViagenTools(config2) {
         type: external_exports.enum(["task", "plan"]).optional().describe("Task type: 'task' for code changes, 'plan' for implementation plans.")
       },
       async (args) => {
-        const task = await client.tasks.create(projectId, {
-          prompt: args.prompt,
-          branch: args.branch,
-          type: args.type
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(task, null, 2)
-            }
-          ]
-        };
+        debug("tools", `viagen_create_task called (projectId: ${projectId}, type: ${args.type || "task"}, prompt: "${args.prompt.slice(0, 80)}...")`);
+        try {
+          const task = await client.tasks.create(projectId, {
+            prompt: args.prompt,
+            branch: args.branch,
+            type: args.type
+          });
+          debug("tools", `viagen_create_task success (taskId: ${task.id})`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(task, null, 2)
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Unknown error";
+          const status = err?.status;
+          const detail = err?.detail;
+          debug("tools", `viagen_create_task FAILED: ${status || "?"} ${message}${detail ? ` (${detail})` : ""}`);
+          return {
+            content: [{ type: "text", text: `Error creating task: ${message}` }]
+          };
+        }
       }
     )
   ];
+  if (processManager) {
+    tools.push(
+      tool(
+        "viagen_restart_preview",
+        "Restart the preview server. Use after installing packages, changing configs, or when the preview is broken. Optionally provide a new command to run.",
+        {
+          command: external_exports.string().optional().describe("New command to use for the preview server (e.g. 'npm run build && npm run start'). If omitted, restarts with the current command.")
+        },
+        async (args) => {
+          try {
+            const result = await processManager.restart(args.command);
+            return {
+              content: [{ type: "text", text: result }]
+            };
+          } catch (err) {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            return {
+              content: [{ type: "text", text: `Error restarting preview: ${message}` }]
+            };
+          }
+        }
+      )
+    );
+  }
   return createSdkMcpServer({ name: "viagen", tools });
 }
 var PLAN_MODE_DISALLOWED_TOOLS = ["Edit", "NotebookEdit"];
@@ -18820,23 +18932,313 @@ Constraints:
 - Only create new files inside the plans/ directory.
 - Your plan should include: context, proposed changes (with file paths and descriptions), implementation order, and potential risks.
 `;
-var TASK_TOOLS_PROMPT = `
-You have access to viagen platform tools for task management:
-- viagen_list_tasks: List tasks in this project (optionally filter by status)
-- viagen_get_task: Get full details of a specific task
-- viagen_create_task: Create follow-up tasks for work you identify
-- viagen_update_task: Update a task's status ('review' or 'completed'). Accepts an optional taskId \u2014 defaults to the current task if one is set.
-
-Use these to understand project context and create follow-up work when appropriate.
-`;
+function buildTaskToolsPrompt(opts) {
+  const parts = [];
+  parts.push(`
+## Viagen Platform
+
+You are connected to the viagen development platform. This session is part of a viagen project (ID: ${opts.projectId}).${opts.taskId ? ` You are currently working on task ${opts.taskId}.` : ""}${opts.branch ? ` Current branch: ${opts.branch}.` : ""}
+
+When users ask about the project, tasks, work history, or anything related to the viagen platform \u2014 **always use your viagen MCP tools** to answer. Do NOT try to grep the codebase or guess \u2014 the platform is your source of truth for project and task information.
+
+### Available viagen tools
+
+- **viagen_list_tasks** \u2014 List tasks in this project. Filter by status: ready, running, validating, completed, timed_out. Call this when users ask "what tasks are there?", "what's been done?", "what's pending?", etc.
+- **viagen_get_task** \u2014 Get full details of a specific task including its prompt, status, branch, PR URL, and results.
+- **viagen_create_task** \u2014 Create a new task. Use when you identify follow-up work or when the user asks you to create a task.
+- **viagen_update_task** \u2014 Update a task's status. Use 'review' after creating a PR, 'completed' when fully done. Defaults to the current task if one is set.`);
+  if (opts.hasProcessManager) {
+    parts.push(`
+- **viagen_restart_preview** \u2014 Restart the app preview server. Use after installing packages, changing configs, or when the preview is broken.`);
+  }
+  parts.push(`
+
+### How to respond to platform questions
+
+- "What tasks are there?" \u2192 call viagen_list_tasks, summarize the results conversationally
+- "What's the status of task X?" \u2192 call viagen_get_task with the ID
+- "What work has been done?" \u2192 call viagen_list_tasks with status "completed" or "validating"
+- "What's pending?" \u2192 call viagen_list_tasks with status "ready"
+- "Tell me about this project" \u2192 call viagen_list_tasks (no filter) to give an overview of all work
+
+Always present the results in a friendly, conversational way \u2014 not raw JSON.`);
+  return parts.join("");
+}
+var TASK_TOOLS_PROMPT = buildTaskToolsPrompt({ projectId: "unknown" });
 
 // src/index.ts
 import { createViagen } from "viagen-sdk";
 
+// src/process-manager.ts
+import { spawn } from "child_process";
+import { closeSync, existsSync as existsSync2, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync4, readSync, statSync as statSync2, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+var debug2 = (label, ...args) => debug(`pm:${label}`, ...args);
+var ProcessManager = class {
+  child = null;
+  adoptedPid = null;
+  command;
+  cwd;
+  env;
+  logBuffer;
+  appPort;
+  viagenDir;
+  pidFile;
+  stdoutLog;
+  stderrLog;
+  logTailInterval = null;
+  stdoutOffset = 0;
+  stderrOffset = 0;
+  restarting = false;
+  restartCount = 0;
+  constructor(opts) {
+    this.command = opts.command;
+    this.cwd = opts.cwd;
+    this.env = opts.env ?? {};
+    this.logBuffer = opts.logBuffer;
+    this.appPort = opts.appPort ?? 5173;
+    this.viagenDir = join5(this.cwd, ".viagen");
+    mkdirSync3(this.viagenDir, { recursive: true });
+    this.pidFile = join5(this.viagenDir, "app.pid");
+    this.stdoutLog = join5(this.viagenDir, "app.stdout.log");
+    this.stderrLog = join5(this.viagenDir, "app.stderr.log");
+  }
+  /** Start the app process. If already running (or adopted from a previous session), does nothing. */
+  start() {
+    if (this.child && !this.child.killed) {
+      debug2("start", "process already running (spawned), skipping");
+      return;
+    }
+    const existingPid = this.readPid();
+    if (existingPid && this.isProcessAlive(existingPid)) {
+      debug2("start", `adopting existing app process (pid: ${existingPid})`);
+      this.logBuffer.push("info", `[viagen:pm] App already running from previous session (pid: ${existingPid})`);
+      this.adoptedPid = existingPid;
+      return;
+    }
+    if (existingPid) {
+      debug2("start", `stale pid file (pid: ${existingPid} not alive), removing`);
+      this.removePid();
+    }
+    writeFileSync4(this.stdoutLog, "");
+    writeFileSync4(this.stderrLog, "");
+    this.stdoutOffset = 0;
+    this.stderrOffset = 0;
+    debug2("start", `spawning: ${this.command} (cwd: ${this.cwd}, port: ${this.appPort})`);
+    this.logBuffer.push("info", `[viagen:pm] Starting app: ${this.command} (PORT=${this.appPort})`);
+    const stdoutFd = openSync(this.stdoutLog, "a");
+    const stderrFd = openSync(this.stderrLog, "a");
+    this.child = spawn(this.command, [], {
+      cwd: this.cwd,
+      env: { ...process.env, ...this.env, PORT: String(this.appPort), __VIAGEN_CHILD: "1" },
+      stdio: ["ignore", stdoutFd, stderrFd],
+      shell: true,
+      // Detached so the app survives if the viagen chat server restarts
+      // (e.g. during a viagen dependency update in a sandbox).
+      detached: true
+    });
+    const pid = this.child.pid;
+    debug2("start", `process started (pid: ${pid})`);
+    this.logBuffer.push("info", `[viagen:pm] App process started (pid: ${pid})`);
+    if (pid) {
+      this.writePid(pid);
+    }
+    this.child.unref();
+    this.startLogTail();
+    this.child.on("exit", (code, signal) => {
+      debug2("exit", `process exited (code: ${code}, signal: ${signal})`);
+      this.logBuffer.push(
+        code === 0 ? "info" : "warn",
+        `[viagen:pm] App process exited (code: ${code}, signal: ${signal})`
+      );
+      this.child = null;
+      this.stopLogTail();
+      this.removePid();
+      if (!this.restarting && code !== 0 && code !== null) {
+        this.restartCount++;
+        if (this.restartCount <= 3) {
+          const delay = this.restartCount * 2e3;
+          this.logBuffer.push("warn", `[viagen:pm] Auto-restarting in ${delay / 1e3}s (attempt ${this.restartCount}/3)`);
+          setTimeout(() => this.start(), delay);
+        } else {
+          this.logBuffer.push("error", `[viagen:pm] App crashed ${this.restartCount} times, giving up`);
+        }
+      }
+    });
+    this.child.on("error", (err) => {
+      debug2("error", `spawn error: ${err.message}`);
+      this.logBuffer.push("error", `[viagen:pm] Failed to start app: ${err.message}`);
+      this.child = null;
+      this.stopLogTail();
+      this.removePid();
+    });
+  }
+  /** Stop the app process. Returns when the process has exited. */
+  async stop() {
+    if (this.adoptedPid) {
+      const pid2 = this.adoptedPid;
+      debug2("stop", `killing adopted process (pid: ${pid2})`);
+      this.logBuffer.push("info", `[viagen:pm] Stopping adopted app (pid: ${pid2})`);
+      try {
+        process.kill(-pid2, "SIGTERM");
+      } catch {
+      }
+      this.adoptedPid = null;
+      this.removePid();
+      await new Promise((resolve3) => {
+        const check2 = () => {
+          if (!this.isProcessAlive(pid2)) {
+            resolve3();
+            return;
+          }
+          try {
+            process.kill(-pid2, "SIGKILL");
+          } catch {
+          }
+          resolve3();
+        };
+        setTimeout(check2, 5e3);
+      });
+      return;
+    }
+    if (!this.child || this.child.killed) {
+      debug2("stop", "no process to stop");
+      return;
+    }
+    const pid = this.child.pid;
+    debug2("stop", `killing process (pid: ${pid})`);
+    this.logBuffer.push("info", `[viagen:pm] Stopping app (pid: ${pid})`);
+    return new Promise((resolve3) => {
+      const timeout = setTimeout(() => {
+        debug2("stop", "SIGTERM timeout, sending SIGKILL");
+        if (pid) {
+          try {
+            process.kill(-pid, "SIGKILL");
+          } catch {
+          }
+        }
+      }, 5e3);
+      this.child.once("exit", () => {
+        clearTimeout(timeout);
+        this.child = null;
+        this.removePid();
+        debug2("stop", "process stopped");
+        this.logBuffer.push("info", "[viagen:pm] App stopped");
+        resolve3();
+      });
+      if (pid) {
+        try {
+          process.kill(-pid, "SIGTERM");
+        } catch {
+        }
+      } else {
+        this.child.kill("SIGTERM");
+      }
+    });
+  }
+  /** Restart the app process, optionally with a new command. */
+  async restart(newCommand) {
+    this.restarting = true;
+    this.restartCount = 0;
+    if (newCommand) {
+      debug2("restart", `changing command to: ${newCommand}`);
+      this.logBuffer.push("info", `[viagen:pm] Changing app command to: ${newCommand}`);
+      this.command = newCommand;
+    }
+    debug2("restart", "restarting app process");
+    this.logBuffer.push("info", "[viagen:pm] Restarting app...");
+    await this.stop();
+    this.start();
+    this.restarting = false;
+    return `App restarted with: ${this.command}`;
+  }
+  /** Check if the process is currently running. */
+  get running() {
+    if (this.adoptedPid) return this.isProcessAlive(this.adoptedPid);
+    return this.child !== null && !this.child.killed;
+  }
+  /** Get the current command. */
+  get currentCommand() {
+    return this.command;
+  }
+  // ── Log tailing ───────────────────────────────────────────────
+  /** Poll log files and feed new lines into the log buffer. */
+  startLogTail() {
+    this.stopLogTail();
+    this.logTailInterval = setInterval(() => this.tailLogs(), 1e3);
+  }
+  stopLogTail() {
+    if (this.logTailInterval) {
+      clearInterval(this.logTailInterval);
+      this.logTailInterval = null;
+    }
+    this.tailLogs();
+  }
+  tailLogs() {
+    this.stdoutOffset = this.tailFile(this.stdoutLog, this.stdoutOffset, "info");
+    this.stderrOffset = this.tailFile(this.stderrLog, this.stderrOffset, "error");
+  }
+  /** Read new bytes from a log file starting at offset. Returns new offset. */
+  tailFile(filePath, offset, level) {
+    try {
+      if (!existsSync2(filePath)) return offset;
+      const stat = statSync2(filePath);
+      if (stat.size <= offset) return offset;
+      const buf = Buffer.alloc(stat.size - offset);
+      const fd = openSync(filePath, "r");
+      const bytesRead = readSync(fd, buf, 0, buf.length, offset);
+      closeSync(fd);
+      if (bytesRead > 0) {
+        const lines = buf.toString("utf-8", 0, bytesRead).split("\n").filter(Boolean);
+        for (const line of lines) {
+          debug2(level === "info" ? "stdout" : "stderr", line);
+          this.logBuffer.push(level, `[preview] ${line}`);
+        }
+      }
+      return offset + bytesRead;
+    } catch {
+      return offset;
+    }
+  }
+  // ── PID file helpers ──────────────────────────────────────────
+  writePid(pid) {
+    try {
+      writeFileSync4(this.pidFile, String(pid));
+      debug2("pid", `wrote pid ${pid} to ${this.pidFile}`);
+    } catch (err) {
+      debug2("pid", `failed to write pid file: ${err}`);
+    }
+  }
+  readPid() {
+    try {
+      if (!existsSync2(this.pidFile)) return null;
+      const raw = readFileSync4(this.pidFile, "utf-8").trim();
+      const pid = parseInt(raw, 10);
+      return Number.isFinite(pid) ? pid : null;
+    } catch {
+      return null;
+    }
+  }
+  removePid() {
+    try {
+      if (existsSync2(this.pidFile)) unlinkSync(this.pidFile);
+    } catch {
+    }
+  }
+  isProcessAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
 // src/sandbox.ts
 import { randomUUID } from "crypto";
-import { readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
-import { join as join5, relative as relative2 } from "path";
+import { readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join6, relative as relative2 } from "path";
 import { Sandbox } from "@vercel/sandbox";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -18852,13 +19254,13 @@ function collectFiles2(dir, base) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && SKIP_DIRS.has(entry.name)) continue;
     if (SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = join5(dir, entry.name);
+    const fullPath = join6(dir, entry.name);
     const relPath = relative2(base, fullPath);
     if (entry.isDirectory()) {
       files.push(...collectFiles2(fullPath, base));
     } else if (entry.isFile()) {
       if (SKIP_FILES.has(entry.name)) continue;
-      files.push({ path: relPath, content: readFileSync4(fullPath) });
+      files.push({ path: relPath, content: readFileSync5(fullPath) });
     }
   }
   return files;
@@ -18929,6 +19331,11 @@ async function waitForServer(baseUrl, token, devServer) {
 async function deploySandbox(opts) {
   const token = randomUUID();
   const useGit = !!opts.git;
+  const rootDir = opts.rootDir ?? null;
+  const rootPrefix = rootDir ? `${rootDir}/` : "";
+  if (rootDir) {
+    console.log(`  Monorepo root dir: ${rootDir}`);
+  }
   const timeoutMs = (opts.timeoutMinutes ?? 30) * 60 * 1e3;
   const sourceOpts = opts.git ? {
     source: {
@@ -19045,21 +19452,23 @@ async function deploySandbox(opts) {
     const envLines = Object.entries(envMap).map(([k, v]) => `${k}=${v}`);
     await sandbox.writeFiles([
       {
-        path: ".env",
+        path: `${rootPrefix}.env`,
         content: Buffer.from(envLines.join("\n"))
       }
     ]);
     const dots = startDots("  Installing dependencies");
-    const install = await sandbox.runCommand("npm", ["install"]);
+    const installCmd = rootDir ? `cd ${rootDir} && npm install` : "npm install";
+    const install = await sandbox.runCommand("bash", ["-c", installCmd]);
     dots.stop();
     if (install.exitCode !== 0) {
       const stderr = await install.stderr();
       console.error(stderr);
       throw new Error(`npm install failed (exit ${install.exitCode})`);
     }
+    const devCmd = rootDir ? `cd ${rootDir} && npm run dev` : "npm run dev";
     const devServer = await sandbox.runCommand({
-      cmd: "npm",
-      args: ["run", "dev"],
+      cmd: "bash",
+      args: ["-c", devCmd],
       detached: true
     });
     const baseUrl = sandbox.domain(5173);
@@ -19109,8 +19518,18 @@ function viagen(options) {
     name: "viagen",
     config(_, { mode }) {
       const e = loadEnv(mode, process.cwd(), "");
+      const serverConfig = {};
       if (e["VIAGEN_AUTH_TOKEN"] || e["VIAGEN_USER_TOKEN"]) {
-        return { server: { host: true, allowedHosts: true } };
+        serverConfig.host = true;
+        serverConfig.allowedHosts = true;
+      }
+      if (e["VIAGEN_APP_COMMAND"] && !process.env["__VIAGEN_CHILD"]) {
+        const viagenPort = parseInt(e["VIAGEN_SERVER_PORT"] || "5199", 10);
+        serverConfig.port = viagenPort;
+        serverConfig.strictPort = true;
+      }
+      if (Object.keys(serverConfig).length > 0) {
+        return { server: serverConfig };
       }
     },
     configResolved(config2) {
@@ -19122,6 +19541,10 @@ function viagen(options) {
       debug("init", "plugin initializing");
       debug("init", `projectRoot: ${projectRoot}`);
       debug("init", `mode: ${config2.mode}`);
+      debug("init", `server port: ${config2.server.port}`);
+      debug("init", `VIAGEN_APP_COMMAND: ${env["VIAGEN_APP_COMMAND"] || "(not set)"}`);
+      debug("init", `VIAGEN_APP_PORT: ${env["VIAGEN_APP_PORT"] || "(not set)"}`);
+      debug("init", `__VIAGEN_CHILD: ${process.env["__VIAGEN_CHILD"] || "no"}`);
       debug("init", `ANTHROPIC_API_KEY: ${env["ANTHROPIC_API_KEY"] ? "set (" + env["ANTHROPIC_API_KEY"].slice(0, 8) + "...)" : "NOT SET"}`);
       debug("init", `CLAUDE_ACCESS_TOKEN: ${env["CLAUDE_ACCESS_TOKEN"] ? "set" : "NOT SET"}`);
       debug("init", `GITHUB_TOKEN: ${env["GITHUB_TOKEN"] ? "set" : "NOT SET"}`);
@@ -19134,10 +19557,10 @@ function viagen(options) {
       debug("init", `ui: ${opts.ui}, overlay: ${opts.overlay}, position: ${opts.position}`);
       logBuffer.init(projectRoot);
       wrapLogger(config2.logger, logBuffer);
-      const viagenDir = join6(projectRoot, ".viagen");
-      mkdirSync3(viagenDir, { recursive: true });
-      writeFileSync4(
-        join6(viagenDir, "config.json"),
+      const viagenDir = join7(projectRoot, ".viagen");
+      mkdirSync4(viagenDir, { recursive: true });
+      writeFileSync5(
+        join7(viagenDir, "config.json"),
         JSON.stringify({
           sandboxFiles: options?.sandboxFiles ?? [],
           editable: options?.editable ?? []
@@ -19215,9 +19638,10 @@ ${payload.err.frame || ""}`
       const platformUrl = env["VIAGEN_PLATFORM_URL"] || "https://app.viagen.dev";
       const projectId = env["VIAGEN_PROJECT_ID"];
       let viagenClient = null;
+      const orgId = env["VIAGEN_ORG_ID"];
       if (platformToken) {
-        viagenClient = createViagen({ token: platformToken, baseUrl: platformUrl });
-        debug("server", `platform client created (baseUrl: ${platformUrl})`);
+        viagenClient = createViagen({ token: platformToken, baseUrl: platformUrl, orgId });
+        debug("server", `platform client created (baseUrl: ${platformUrl}, orgId: ${orgId || "none \u2014 will use default org"})`);
       }
       const hasEditor = !!(options?.editable && options.editable.length > 0);
       const clientJs = buildClientScript({
@@ -19237,9 +19661,11 @@ ${payload.err.frame || ""}`
         res.writeHead(302, { Location: "/?_viagen_chat" });
         res.end();
       });
-      server.middlewares.use("/via/iframe", (_req, res) => {
+      server.middlewares.use("/via/iframe", (req, res) => {
+        const url2 = new URL(req.url || "/", "http://localhost");
+        const appUrl = url2.searchParams.get("appUrl") || void 0;
         res.setHeader("Content-Type", "text/html");
-        res.end(buildIframeHtml({ panelWidth: opts.panelWidth }));
+        res.end(buildIframeHtml({ panelWidth: opts.panelWidth, appUrl }));
       });
       if (previewEnabled) {
         const previewJs = buildPreviewScript();
@@ -19307,13 +19733,31 @@ Page URL: ${pageUrl}`);
       });
       const resolvedModel = env["VIAGEN_MODEL"] || opts.model;
       debug("server", `creating ChatSession (model: ${resolvedModel})`);
+      let processManager;
+      const appCommand = env["VIAGEN_APP_COMMAND"];
+      const isChildProcess = process.env["__VIAGEN_CHILD"] === "1";
+      if (isChildProcess) {
+        debug("server", "skipping process manager (running as child process)");
+      } else if (appCommand) {
+        const appPort = parseInt(env["VIAGEN_APP_PORT"] || "5173", 10);
+        debug("server", `preview process manager enabled: "${appCommand}" on port ${appPort}`);
+        logBuffer.push("info", `[viagen] Preview process manager: ${appCommand} (port ${appPort})`);
+        processManager = new ProcessManager({
+          command: appCommand,
+          cwd: projectRoot,
+          logBuffer,
+          appPort
+        });
+        processManager.start();
+      }
       let mcpServers;
       const hasPlatformContext = !!(viagenClient && projectId);
       if (hasPlatformContext) {
         debug("server", "creating viagen MCP tools (platform connected)");
         const viagenMcp = createViagenTools({
           client: viagenClient,
-          projectId
+          projectId,
+          processManager
         });
         mcpServers = { [viagenMcp.name]: viagenMcp };
       }
@@ -19327,7 +19771,12 @@ Page URL: ${pageUrl}`);
         debug("server", "plan mode active \u2014 restricting tools");
         systemPrompt = PLAN_SYSTEM_PROMPT;
       } else if (hasPlatformContext) {
-        systemPrompt = (systemPrompt || "") + TASK_TOOLS_PROMPT;
+        systemPrompt = (systemPrompt || "") + buildTaskToolsPrompt({
+          projectId,
+          taskId: env["VIAGEN_TASK_ID"] || void 0,
+          branch: env["VIAGEN_BRANCH"] || void 0,
+          hasProcessManager: !!processManager
+        });
       }
       const chatSession = new ChatSession({
         env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viagen",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Vite dev server plugin that exposes endpoints for chatting with Claude Code SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -45,7 +45,7 @@
     "agent-browser": "^0.20.12",
     "lucide-react": "^0.564.0",
     "simple-git": "^3.31.1",
-    "viagen-sdk": "^0.1.0"
+    "viagen-sdk": "^0.1.2"
   },
   "license": "MIT",
   "repository": {