vibeman 0.0.13 → 0.0.14

package/dist/api.js

@@ -44302,6 +44302,7 @@ var init_dist_layout = __esm(() => {
     prismaRoot: "prisma",
     prismaSchema: "prisma/schema.prisma",
     resourcesRoot: "resources",
+    nodePtyPackageRoot: "node_modules/node-pty",
     scriptsRoot: "scripts",
     fixtureInitScript: "scripts/init-test-repo.mjs",
     fixtureSeedScript: "scripts/seed-test-fixtures.mjs",
@@ -123103,16 +123104,463 @@ function isAddressInUseError(error48) {
 var MIN_PORT = 1, MAX_PORT = 65535;
 var init_port_utils = () => {};
 
+// ../api/src/services/pty-session.ts
+import { chmodSync, statSync as statSync3 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname6, join as join8 } from "node:path";
+import * as pty from "node-pty";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+function buildShellCandidates() {
+  if (process.platform === "win32") {
+    return ["powershell.exe", "pwsh.exe", "cmd.exe"];
+  }
+  const candidates = new Set;
+  const configured = process.env.SHELL?.trim();
+  if (configured) {
+    candidates.add(configured);
+  }
+  for (const fallbackShell of NON_WINDOWS_FALLBACK_SHELLS) {
+    try {
+      const stats = statSync3(fallbackShell);
+      if (stats.isFile()) {
+        candidates.add(fallbackShell);
+      }
+    } catch {}
+  }
+  return Array.from(candidates);
+}
+function generateId() {
+  return `pty_${randomUUID2()}`;
+}
+function ensureNodePtySpawnHelperExecutable() {
+  if (process.platform !== "darwin")
+    return;
+  const helperCandidates = new Set;
+  try {
+    const packageJsonPath = require2.resolve("node-pty/package.json");
+    helperCandidates.add(join8(dirname6(packageJsonPath), "prebuilds", `darwin-${process.arch}`, "spawn-helper"));
+  } catch {}
+  const bundledDistHelperPath = join8(dirname6(fileURLToPath4(import.meta.url)), "prebuilds", `darwin-${process.arch}`, "spawn-helper");
+  helperCandidates.add(bundledDistHelperPath);
+  for (const helperPath of helperCandidates) {
+    try {
+      const stats = statSync3(helperPath);
+      if ((stats.mode & 73) !== 0) {
+        return;
+      }
+      chmodSync(helperPath, stats.mode | 493);
+      log.info({ helperPath }, "Restored execute bit on node-pty spawn-helper");
+      return;
+    } catch {}
+  }
+  log.warn({ helperPaths: Array.from(helperCandidates) }, "Failed to ensure node-pty spawn-helper is executable");
+}
+function createSession(options2) {
+  const id = generateId();
+  const cols = options2.cols ?? DEFAULT_COLS;
+  const rows = options2.rows ?? DEFAULT_ROWS;
+  const shellCandidates = buildShellCandidates();
+  const env = {
+    ...process.env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    VIBEMAN_TERMINAL: options2.scope
+  };
+  ensureNodePtySpawnHelperExecutable();
+  let proc = null;
+  let resolvedShell = "";
+  let lastError;
+  for (const shell of shellCandidates) {
+    try {
+      proc = pty.spawn(shell, [], {
+        name: "xterm-256color",
+        cols,
+        rows,
+        cwd: options2.cwd,
+        env
+      });
+      resolvedShell = shell;
+      break;
+    } catch (error48) {
+      lastError = error48;
+      log.warn({ shell, error: error48 }, "Failed to spawn PTY with shell candidate");
+    }
+  }
+  if (!proc) {
+    const fallbackText = shellCandidates.length > 0 ? shellCandidates.join(", ") : process.platform === "win32" ? "powershell.exe" : NON_WINDOWS_FALLBACK_SHELLS.join(", ");
+    const suffix = lastError instanceof Error ? `${lastError.name}: ${lastError.message}` : typeof lastError === "string" ? lastError : "unknown error";
+    throw new Error(`Failed to spawn terminal shell. Tried: ${fallbackText}. Last error: ${suffix}`);
+  }
+  const session = {
+    meta: { id, scope: options2.scope, cwd: options2.cwd, createdAt: Date.now() },
+    process: proc,
+    listeners: new Set,
+    exitListeners: new Set,
+    scrollback: [],
+    scrollbackBytes: 0,
+    exited: false
+  };
+  proc.onData((data) => {
+    session.scrollback.push(data);
+    session.scrollbackBytes += data.length;
+    if (session.scrollback.length > SCROLLBACK_LIMIT) {
+      const removed = session.scrollback.splice(0, session.scrollback.length - SCROLLBACK_LIMIT);
+      for (const chunk of removed)
+        session.scrollbackBytes -= chunk.length;
+    }
+    while (session.scrollbackBytes > SCROLLBACK_BYTE_LIMIT && session.scrollback.length > 0) {
+      const removed = session.scrollback.shift();
+      session.scrollbackBytes -= removed.length;
+    }
+    for (const listener of session.listeners) {
+      try {
+        listener(data);
+      } catch {}
+    }
+  });
+  proc.onExit(({ exitCode, signal }) => {
+    log.info({ sessionId: id, exitCode, signal }, "PTY session exited");
+    session.exited = true;
+    const exitInfo = { exitCode, signal };
+    for (const listener of session.exitListeners) {
+      try {
+        listener(exitInfo);
+      } catch {}
+    }
+    session.exitListeners.clear();
+    setTimeout(() => {
+      if (sessions.get(id) === session) {
+        sessions.delete(id);
+        log.debug({ sessionId: id }, "Exited session removed after retention period");
+      }
+    }, EXITED_SESSION_RETENTION_MS);
+  });
+  sessions.set(id, session);
+  log.info({ sessionId: id, scope: options2.scope, cwd: options2.cwd, shell: resolvedShell }, "PTY session created");
+  return session.meta;
+}
+function writeToSession(sessionId, data) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  try {
+    session.process.write(data);
+  } catch (error48) {
+    log.warn({ sessionId, error: error48 }, "Failed to write to PTY session");
+    return false;
+  }
+  return true;
+}
+function resizeSession(sessionId, cols, rows) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  try {
+    session.process.resize(cols, rows);
+  } catch (error48) {
+    log.warn({ sessionId, cols, rows, error: error48 }, "Failed to resize PTY");
+  }
+  return true;
+}
+function destroySession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  try {
+    session.process.kill();
+  } catch {}
+  sessions.delete(sessionId);
+  log.info({ sessionId }, "PTY session destroyed");
+  return true;
+}
+function getSession(sessionId) {
+  return sessions.get(sessionId)?.meta ?? null;
+}
+function addDataListener(sessionId, listener) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  session.listeners.add(listener);
+  return true;
+}
+function removeDataListener(sessionId, listener) {
+  sessions.get(sessionId)?.listeners.delete(listener);
+}
+function addExitListener(sessionId, listener) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  if (session.exited) {
+    try {
+      listener({ exitCode: -1 });
+    } catch {}
+    return true;
+  }
+  session.exitListeners.add(listener);
+  return true;
+}
+function removeExitListener(sessionId, listener) {
+  sessions.get(sessionId)?.exitListeners.delete(listener);
+}
+function getScrollback(sessionId) {
+  return sessions.get(sessionId)?.scrollback ?? [];
+}
+function destroyAllSessions() {
+  for (const [id] of sessions) {
+    destroySession(id);
+  }
+}
+async function gracefulShutdownSessions(timeoutMs = 3000) {
+  const ids = Array.from(sessions.keys());
+  if (ids.length === 0)
+    return;
+  log.info({ count: ids.length }, "Gracefully shutting down PTY sessions");
+  for (const id of ids) {
+    const session = sessions.get(id);
+    if (!session || session.exited)
+      continue;
+    try {
+      session.process.kill();
+    } catch {}
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (sessions.size > 0 && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (sessions.size > 0) {
+    log.warn({ remaining: sessions.size }, "Force destroying remaining PTY sessions");
+    destroyAllSessions();
+  }
+}
+var log, require2, SCROLLBACK_LIMIT = 500, SCROLLBACK_BYTE_LIMIT, DEFAULT_COLS = 120, DEFAULT_ROWS = 30, EXITED_SESSION_RETENTION_MS = 60000, NON_WINDOWS_FALLBACK_SHELLS, sessions;
+var init_pty_session = __esm(() => {
+  init_log();
+  log = logger.child({ module: "pty-session" });
+  require2 = createRequire3(import.meta.url);
+  SCROLLBACK_BYTE_LIMIT = 1024 * 1024;
+  NON_WINDOWS_FALLBACK_SHELLS = ["/bin/bash", "/bin/zsh", "/bin/sh"];
+  sessions = new Map;
+});
+
+// ../api/src/server/terminal-ws.ts
+import { dirname as dirname7, resolve as resolve21, sep as sep6 } from "node:path";
+import { existsSync as existsSync13, statSync as statSync4 } from "node:fs";
+function validateCwd(cwd2, root) {
+  if (!cwd2 || typeof cwd2 !== "string")
+    return null;
+  const resolved = resolve21(cwd2);
+  const resolvedRoot = resolve21(root);
+  const parentDir = dirname7(resolvedRoot) + sep6;
+  const isWithinRoot2 = resolved === resolvedRoot || resolved.startsWith(resolvedRoot + sep6);
+  const isSibling = resolved.startsWith(parentDir);
+  if (!isWithinRoot2 && !isSibling)
+    return null;
+  if (!existsSync13(resolved))
+    return null;
+  try {
+    if (!statSync4(resolved).isDirectory())
+      return null;
+  } catch {
+    return null;
+  }
+  return resolved;
+}
+function createTerminalWebSocketServer(root) {
+  if (root)
+    configuredRoot = root;
+  if (wss)
+    return wss;
+  wss = new import_websocket_server.default({ noServer: true });
+  wss.on("connection", (ws) => {
+    let currentSessionId = null;
+    let dataListener = null;
+    let exitListener = null;
+    const cleanup = () => {
+      if (currentSessionId && dataListener) {
+        removeDataListener(currentSessionId, dataListener);
+      }
+      if (currentSessionId && exitListener) {
+        removeExitListener(currentSessionId, exitListener);
+      }
+      dataListener = null;
+      exitListener = null;
+      currentSessionId = null;
+    };
+    const sendJson = (payload) => {
+      if (ws.readyState === import_websocket.default.OPEN) {
+        ws.send(JSON.stringify(payload));
+      }
+    };
+    const attachToSession = (sessionId) => {
+      cleanup();
+      cancelOrphanDestroy(sessionId);
+      const meta3 = getSession(sessionId);
+      if (!meta3) {
+        sendJson({ type: "error", message: `Session ${sessionId} not found` });
+        return false;
+      }
+      currentSessionId = sessionId;
+      dataListener = (data) => {
+        sendJson({ type: "output", data });
+      };
+      exitListener = (info) => {
+        sendJson({ type: "exited", exitCode: info.exitCode });
+        cleanup();
+      };
+      const scrollback = getScrollback(sessionId);
+      if (scrollback.length > 0) {
+        sendJson({ type: "output", data: scrollback.join("") });
+      }
+      addDataListener(sessionId, dataListener);
+      addExitListener(sessionId, exitListener);
+      return true;
+    };
+    ws.on("message", (raw2) => {
+      let msg;
+      try {
+        msg = JSON.parse(typeof raw2 === "string" ? raw2 : raw2.toString("utf-8"));
+      } catch {
+        sendJson({ type: "error", message: "Invalid JSON" });
+        return;
+      }
+      switch (msg.type) {
+        case "create": {
+          if (!msg.cwd || !msg.scope) {
+            sendJson({ type: "error", message: "Missing required fields: scope, cwd" });
+            return;
+          }
+          const root2 = configuredRoot;
+          if (!root2) {
+            sendJson({ type: "error", message: "Server root not configured" });
+            return;
+          }
+          const validatedCwd = validateCwd(msg.cwd, root2) ?? root2;
+          try {
+            const meta3 = createSession({
+              scope: msg.scope,
+              cwd: validatedCwd,
+              cols: msg.cols,
+              rows: msg.rows
+            });
+            sendJson({ type: "created", sessionId: meta3.id, scope: meta3.scope, cwd: meta3.cwd });
+            attachToSession(meta3.id);
+          } catch (error48) {
+            log2.error({ error: error48, cwd: validatedCwd, scope: msg.scope }, "Failed to create PTY session");
+            sendJson({
+              type: "error",
+              message: `Failed to create terminal session: ${error48 instanceof Error ? error48.message : "unknown error"}`
+            });
+          }
+          break;
+        }
+        case "attach": {
+          if (!msg.sessionId) {
+            sendJson({ type: "error", message: "Missing sessionId" });
+            return;
+          }
+          const attached = attachToSession(msg.sessionId);
+          if (attached) {
+            sendJson({ type: "attached", sessionId: msg.sessionId });
+          }
+          break;
+        }
+        case "input": {
+          if (!currentSessionId) {
+            sendJson({ type: "error", message: "No active session" });
+            return;
+          }
+          if (!writeToSession(currentSessionId, msg.data)) {
+            sendJson({ type: "exited" });
+            cleanup();
+          }
+          break;
+        }
+        case "resize": {
+          if (!currentSessionId)
+            return;
+          if (typeof msg.cols === "number" && typeof msg.rows === "number" && msg.cols > 0 && msg.rows > 0) {
+            resizeSession(currentSessionId, msg.cols, msg.rows);
+          }
+          break;
+        }
+        case "destroy": {
+          if (currentSessionId) {
+            const sid = currentSessionId;
+            cleanup();
+            destroySession(sid);
+            sendJson({ type: "exited" });
+          }
+          break;
+        }
+        default:
+          sendJson({ type: "error", message: `Unknown message type` });
+      }
+    });
+    ws.on("close", () => {
+      const sid = currentSessionId;
+      log2.debug({ sessionId: sid }, "Terminal WebSocket closed");
+      cleanup();
+      if (sid) {
+        scheduleOrphanDestroy(sid);
+      }
+    });
+    ws.on("error", (error48) => {
+      const sid = currentSessionId;
+      log2.warn({ sessionId: sid, error: error48 }, "Terminal WebSocket error");
+      cleanup();
+      if (sid) {
+        scheduleOrphanDestroy(sid);
+      }
+    });
+  });
+  return wss;
+}
+function scheduleOrphanDestroy(sessionId) {
+  if (orphanTimers.has(sessionId))
+    return;
+  const timer = setTimeout(() => {
+    orphanTimers.delete(sessionId);
+    if (getSession(sessionId)) {
+      log2.info({ sessionId }, "Destroying orphaned PTY session after timeout");
+      destroySession(sessionId);
+    }
+  }, ORPHAN_SESSION_TIMEOUT_MS);
+  orphanTimers.set(sessionId, timer);
+}
+function cancelOrphanDestroy(sessionId) {
+  const timer = orphanTimers.get(sessionId);
+  if (timer) {
+    clearTimeout(timer);
+    orphanTimers.delete(sessionId);
+  }
+}
+function handleTerminalUpgrade(req, socket, head) {
+  const server = createTerminalWebSocketServer();
+  server.handleUpgrade(req, socket, head, (ws) => {
+    server.emit("connection", ws, req);
+  });
+}
+var log2, ORPHAN_SESSION_TIMEOUT_MS, orphanTimers, wss = null, configuredRoot = null;
+var init_terminal_ws = __esm(() => {
+  init_wrapper();
+  init_pty_session();
+  init_log();
+  log2 = logger.child({ module: "terminal-ws" });
+  ORPHAN_SESSION_TIMEOUT_MS = 5 * 60 * 1000;
+  orphanTimers = new Map;
+});
+
 // ../api/src/server/http.ts
 var exports_http = {};
 __export(exports_http, {
   startServer: () => startServer
 });
 import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { createReadStream } from "node:fs";
 import { stat as stat2 } from "node:fs/promises";
-import { extname as extname2, resolve as resolve21, sep as sep6 } from "node:path";
+import { extname as extname2, resolve as resolve22, sep as sep7 } from "node:path";
 async function startServer(options2) {
   const startedAt = Date.now();
   const taskFileWatch = createTaskFileWatchService(options2.root);
@@ -123134,7 +123582,7 @@ async function startServer(options2) {
       logger.error(`tRPC request failed ${JSON.stringify(details, (_key, value) => value === undefined ? "[undefined]" : value)}`);
     }
   });
-  const hasUi = Boolean(options2.uiRoot && existsSync13(options2.uiRoot));
+  const hasUi = Boolean(options2.uiRoot && existsSync14(options2.uiRoot));
   const server = createServer2(async (req, res) => {
     const url2 = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
     if (url2.pathname === "/api/health/live") {
@@ -123190,10 +123638,26 @@ async function startServer(options2) {
       res.end(`Server error: ${error48 instanceof Error ? error48.message : "unknown"}`);
     }
   });
-  const log = logger.child({ module: "api" });
+  createTerminalWebSocketServer(options2.root);
+  server.on("upgrade", (req, socket, head) => {
+    const url2 = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (url2.pathname === "/api/terminal") {
+      const remoteAddr = req.socket.remoteAddress ?? "";
+      const isLocalhost2 = remoteAddr === "127.0.0.1" || remoteAddr === "::1" || remoteAddr === "::ffff:127.0.0.1";
+      if (!isLocalhost2) {
+        logger.warn({ remoteAddress: remoteAddr }, "Rejected terminal WebSocket from non-localhost address");
+        socket.destroy();
+        return;
+      }
+      handleTerminalUpgrade(req, socket, head);
+    } else {
+      socket.destroy();
+    }
+  });
+  const log3 = logger.child({ module: "api" });
   const portResolution = await listenWithPortFallback(server, options2.port);
   if (portResolution.fallbackUsed) {
-    log.warn({
+    log3.warn({
       event: "startup.port.conflict",
       requestedPort: portResolution.requestedPort,
       resolvedPort: portResolution.resolvedPort,
@@ -123201,17 +123665,23 @@ async function startServer(options2) {
     });
   }
   const apiUrl = `http://localhost:${portResolution.resolvedPort}`;
-  log.info({
+  log3.info({
     event: "startup.ready",
     apiUrl,
     hint: "Press Ctrl+C to stop"
   }, `Ready: ${apiUrl} (Ctrl+C to stop)`);
   server.on("close", () => {
     taskFileWatch.stop();
-    log.info({
-      event: "startup.closed"
-    }, "API server closed.");
+    destroyAllSessions();
+    log3.info({ event: "startup.closed" }, "API server closed.");
   });
+  const gracefulShutdown = async () => {
+    log3.info({ event: "startup.shutting_down" }, "Graceful shutdown initiated");
+    await gracefulShutdownSessions();
+    server.close();
+  };
+  process.once("SIGINT", () => void gracefulShutdown());
+  process.once("SIGTERM", () => void gracefulShutdown());
   return {
     server,
     port: portResolution.resolvedPort
@@ -123297,8 +123767,8 @@ async function serveVibemanImage(options2) {
     return;
   }
   const requested = decodedPath.replace(/^\//, "");
-  const absoluteTarget = resolve21(rootPath, requested);
-  if (!absoluteTarget.startsWith(imagesDir + sep6)) {
+  const absoluteTarget = resolve22(rootPath, requested);
+  if (!absoluteTarget.startsWith(imagesDir + sep7)) {
     res.statusCode = 404;
     res.setHeader("content-type", "text/plain; charset=utf-8");
     res.end("Not found");
@@ -123364,6 +123834,8 @@ var init_http2 = __esm(() => {
   init_task_file_watch();
   init_port_utils();
   init_health_report();
+  init_terminal_ws();
+  init_pty_session();
   import_serve_handler = __toESM(require_src3(), 1);
 });
 

package/dist/commit.txt

@@ -1 +1 @@
-cf5eb36
+0842e29

package/dist/index.js

@@ -2053,6 +2053,7 @@ var DIST_LAYOUT = {
   prismaRoot: "prisma",
   prismaSchema: "prisma/schema.prisma",
   resourcesRoot: "resources",
+  nodePtyPackageRoot: "node_modules/node-pty",
   scriptsRoot: "scripts",
   fixtureInitScript: "scripts/init-test-repo.mjs",
   fixtureSeedScript: "scripts/seed-test-fixtures.mjs",

package/dist/node_modules/node-pty/LICENSE

@@ -0,0 +1,69 @@
+Copyright (c) 2012-2015, Christopher Jeffrey (https://github.com/chjj/)
+
+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.
+
+
+
+The MIT License (MIT)
+
+Copyright (c) 2016, Daniel Imms (http://www.growingwiththeweb.com)
+
+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.
+
+
+
+MIT License
+
+Copyright (c) 2018 - present Microsoft Corporation
+
+All rights reserved.
+
+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.