viagen 0.0.57 → 0.1.3

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);
@@ -252,7 +259,9 @@ async function deploySandbox(opts) {
       sandboxId: sandbox2.sandboxId,
       mode: useGit ? "git" : "upload",
       streamLogs: (opts2) => devServer.logs(opts2),
-      stop: () => sandbox2.stop()
+      stop: async () => {
+        await sandbox2.stop();
+      }
     };
   } catch (err) {
     await sandbox2.stop().catch(() => {
@@ -970,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");
@@ -1011,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("");
@@ -1070,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(() => {
@@ -1093,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
@@ -101,16 +101,17 @@ function registerHealthRoutes(server, env, errorRef) {
     const prompt = env["VIAGEN_PROMPT"] || null;
     const taskId = env["VIAGEN_TASK_ID"] || null;
     const environmentId = env["VIAGEN_ENVIRONMENT_ID"] || null;
+    const projectId = env["VIAGEN_PROJECT_ID"] || null;
     res.setHeader("Content-Type", "application/json");
     if (configured) {
-      res.end(JSON.stringify({ status: "ok", configured: true, git, vercel, branch, session, prompt, taskId, environmentId, missing }));
+      res.end(JSON.stringify({ status: "ok", configured: true, git, vercel, branch, session, prompt, taskId, environmentId, projectId, missing }));
     } else {
       res.end(
-        JSON.stringify({ status: "error", configured: false, git, vercel, branch, session, prompt, taskId, environmentId, missing })
+        JSON.stringify({ status: "error", configured: false, git, vercel, branch, session, prompt, taskId, environmentId, projectId, missing })
       );
     }
   });
-  const currentVersion = true ? "0.0.57" : "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) => {
@@ -770,10 +771,10 @@ data: ${JSON.stringify(doneData)}
 `);
           res.end();
         }
-        if (opts.viagenClient && opts.environmentId) {
+        if (opts.viagenClient && opts.projectId) {
           const taskId = opts.env["VIAGEN_TASK_ID"];
           if (taskId && (event.inputTokens || event.outputTokens)) {
-            opts.viagenClient.tasks.update(opts.environmentId, taskId, {
+            opts.viagenClient.tasks.update(opts.projectId, taskId, {
               ...event.inputTokens != null && { inputTokens: event.inputTokens },
               ...event.outputTokens != null && { outputTokens: event.outputTokens }
             }).catch((err) => {
@@ -3798,7 +3799,7 @@ function buildUiHtml(opts) {
 
         // Store task context for history rendering
         healthTaskId = data.taskId || null;
-        healthProjectId = data.environmentId || null;
+        healthProjectId = data.projectId || data.environmentId || null;
 
         // Load chat history from server (source of truth)
         await loadHistory();
@@ -3892,7 +3893,7 @@ function buildUiHtml(opts) {
         if (data.prompt && data.configured && chatLog.length === 0) {
           if (data.taskId) {
             // Task mode: show link instead of raw prompt
-            var taskUrl = 'https://app.viagen.dev/environments/' + data.environmentId + '/tasks/' + data.taskId;
+            var taskUrl = 'https://app.viagen.dev/projects/' + (data.projectId || data.environmentId) + '/tasks/' + data.taskId;
             var div = document.createElement('div');
             div.className = 'msg msg-user';
             div.innerHTML = '<span class="label">Task</span><span class="text">Working on <a href="' + escapeHtml(taskUrl) + '" target="_blank" style="color:#2563eb;text-decoration:underline;">Via Task</a></span>';
@@ -4199,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;
@@ -4229,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');
@@ -4287,6 +4333,39 @@ function parseCookies(header) {
   }
   return cookies;
 }
+function buildWaitPage(targetUrl) {
+  return `<!DOCTYPE html>
+<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: #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('/@vite/client', { credentials: 'same-origin' });
+      if (r.ok) { window.location.replace(target); return; }
+    } catch {}
+    await new Promise(r => setTimeout(r, 500));
+  }
+  // After 30s, navigate anyway \u2014 let the user see whatever error there is
+  window.location.replace(target);
+})();
+</script></body></html>`;
+}
 function createAuthMiddleware(token) {
   return function authMiddleware(req, res, next) {
     const url2 = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
@@ -4294,26 +4373,26 @@ function createAuthMiddleware(token) {
     if (pathMatch && pathMatch[2] === token) {
       const cleanPath = pathMatch[1] || "/";
       const cleanUrl = cleanPath + (url2.search || "");
-      debug("auth", `token URL match (/t/:token) \u2192 redirect to ${cleanUrl}`);
+      debug("auth", `token URL match (/t/:token) \u2192 wait-page redirect to ${cleanUrl}`);
       res.setHeader(
         "Set-Cookie",
         `viagen_session=${token}; HttpOnly; SameSite=Lax; Path=/`
       );
-      res.writeHead(302, { Location: cleanUrl });
-      res.end();
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(buildWaitPage(cleanUrl));
       return;
     }
     const queryToken = url2.searchParams.get("token");
     if (queryToken === token) {
       url2.searchParams.delete("token");
       const cleanUrl = url2.pathname + (url2.search || "");
-      debug("auth", `query token match (?token=) \u2192 redirect to ${cleanUrl}`);
+      debug("auth", `query token match (?token=) \u2192 wait-page redirect to ${cleanUrl}`);
       res.setHeader(
         "Set-Cookie",
         `viagen_session=${token}; HttpOnly; SameSite=Lax; Path=/`
       );
-      res.writeHead(302, { Location: cleanUrl });
-      res.end();
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(buildWaitPage(cleanUrl));
       return;
     }
     if (req.headers.cookie) {
@@ -18657,8 +18736,9 @@ import {
   tool
 } from "@anthropic-ai/claude-agent-sdk";
 function createViagenTools(config2) {
-  const { client, environmentId } = 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",
@@ -18674,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 {
@@ -18682,7 +18763,7 @@ function createViagenTools(config2) {
         }
         const internalStatus = args.status === "review" ? "validating" : args.status === "completed" ? "completed" : args.status;
         try {
-          await client.tasks.update(environmentId, id, {
+          await client.tasks.update(projectId, id, {
             ...internalStatus && { status: internalStatus },
             ...args.prUrl && { prUrl: args.prUrl },
             result: args.result,
@@ -18695,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}` }]
           };
@@ -18703,20 +18787,30 @@ function createViagenTools(config2) {
     ),
     tool(
       "viagen_list_tasks",
-      "List tasks in the current environment. Optionally filter by status.",
+      "List tasks in the current project. Optionally filter by status.",
       {
         status: external_exports.enum(["ready", "running", "validating", "completed", "timed_out"]).optional().describe("Filter tasks by status.")
       },
       async (args) => {
-        const tasks = await client.tasks.list(environmentId, 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(
@@ -18726,42 +18820,89 @@ function createViagenTools(config2) {
         taskId: external_exports.string().describe("The task ID to retrieve.")
       },
       async (args) => {
-        const task = await client.tasks.get(environmentId, 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(
       "viagen_create_task",
-      "Create a new task in the current environment. Use this to create follow-up work.",
+      "Create a new task in the current project. Use this to create follow-up work.",
       {
         prompt: external_exports.string().describe("The task prompt / instructions."),
         branch: external_exports.string().optional().describe("Git branch name for the task."),
         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(environmentId, {
-          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"];
@@ -18791,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 environment (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 environment 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",
@@ -18823,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;
@@ -18900,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: {
@@ -19016,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);
@@ -19049,7 +19487,9 @@ async function deploySandbox(opts) {
       sandboxId: sandbox.sandboxId,
       mode: useGit ? "git" : "upload",
       streamLogs: (opts2) => devServer.logs(opts2),
-      stop: () => sandbox.stop()
+      stop: async () => {
+        await sandbox.stop();
+      }
     };
   } catch (err) {
     await sandbox.stop().catch(() => {
@@ -19078,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) {
@@ -19091,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"}`);
@@ -19103,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 ?? []
@@ -19182,11 +19636,12 @@ ${payload.err.frame || ""}`
       }
       const platformToken = env["VIAGEN_USER_TOKEN"] || env["VIAGEN_AUTH_TOKEN"];
       const platformUrl = env["VIAGEN_PLATFORM_URL"] || "https://app.viagen.dev";
-      const environmentId = env["VIAGEN_ENVIRONMENT_ID"];
+      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({
@@ -19206,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();
@@ -19222,9 +19679,9 @@ ${payload.err.frame || ""}`
             res.end(JSON.stringify({ error: "Method not allowed" }));
             return;
           }
-          if (!viagenClient || !environmentId) {
+          if (!viagenClient || !projectId) {
             res.writeHead(503, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Task creation not configured: missing platform credentials or VIAGEN_ENVIRONMENT_ID" }));
+            res.end(JSON.stringify({ error: "Task creation not configured: missing platform credentials or VIAGEN_PROJECT_ID" }));
             return;
           }
           let body = "";
@@ -19246,7 +19703,7 @@ Page URL: ${pageUrl}`);
               if (screenshot) parts.push("\n[Screenshot attached]");
               parts.push("\n\n[Submitted via viagen preview feedback]");
               const fullPrompt = parts.join("");
-              const task = await viagenClient.tasks.create(environmentId, { prompt: fullPrompt, type: "task" });
+              const task = await viagenClient.tasks.create(projectId, { prompt: fullPrompt, type: "task" });
               if (screenshot && task.id) {
                 try {
                   const [header, b64] = screenshot.split(",");
@@ -19254,7 +19711,7 @@ Page URL: ${pageUrl}`);
                   const binary = Buffer.from(b64, "base64");
                   const blob = new Blob([binary], { type: mime });
                   const ext = mime === "image/png" ? "png" : "jpeg";
-                  await viagenClient.tasks.addAttachment(environmentId, task.id, blob, `screenshot.${ext}`);
+                  await viagenClient.tasks.addAttachment(projectId, task.id, blob, `screenshot.${ext}`);
                   debug("preview", `screenshot attached to task ${task.id}`);
                 } catch (attachErr) {
                   debug("preview", `screenshot attachment failed (non-fatal): ${attachErr}`);
@@ -19276,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 && environmentId);
+      const hasPlatformContext = !!(viagenClient && projectId);
       if (hasPlatformContext) {
         debug("server", "creating viagen MCP tools (platform connected)");
         const viagenMcp = createViagenTools({
           client: viagenClient,
-          environmentId
+          projectId,
+          processManager
         });
         mcpServers = { [viagenMcp.name]: viagenMcp };
       }
@@ -19296,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,
@@ -19314,7 +19794,7 @@ Page URL: ${pageUrl}`);
       registerChatRoutes(server, chatSession, {
         env,
         viagenClient: viagenClient ?? void 0,
-        environmentId
+        projectId
       });
       if (hasEditor) {
         registerFileRoutes(server, {
@@ -19334,8 +19814,8 @@ Page URL: ${pageUrl}`);
             debug("server", "auto-prompt completed");
             logBuffer.push("info", `[viagen] Prompt completed`);
             const currentTaskId = env["VIAGEN_TASK_ID"];
-            if (viagenClient && environmentId && currentTaskId && (event.inputTokens || event.outputTokens)) {
-              viagenClient.tasks.update(environmentId, currentTaskId, {
+            if (viagenClient && projectId && currentTaskId && (event.inputTokens || event.outputTokens)) {
+              viagenClient.tasks.update(projectId, currentTaskId, {
                 ...event.inputTokens != null && { inputTokens: event.inputTokens },
                 ...event.outputTokens != null && { outputTokens: event.outputTokens }
               }).catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viagen",
-  "version": "0.0.57",
+  "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,11 +45,11 @@
     "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": {
     "type": "git",
-    "url": "https://github.com/viagen-dev/viagen"
+    "url": "https://github.com/viagen-dev/viagen-sdk"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Ben Ipsen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.