@agentmeshhq/agent 0.1.9 → 0.1.11

package/src/cli/start.ts

@@ -13,6 +13,7 @@ export interface StartOptions {
   model?: string;
   foreground?: boolean;
   noContext?: boolean;
+  autoSetup?: boolean;
 }
 
 export async function start(options: StartOptions): Promise<void> {
@@ -44,6 +45,7 @@ export async function start(options: StartOptions): Promise<void> {
       const daemon = new AgentDaemon({
         ...options,
         restoreContext: !options.noContext,
+        autoSetup: options.autoSetup,
       });
       await daemon.start();
       // Keep process alive
@@ -67,6 +69,7 @@ export async function start(options: StartOptions): Promise<void> {
   if (options.workdir) args.push("--workdir", options.workdir);
   if (options.model) args.push("--model", options.model);
   if (options.noContext) args.push("--no-context");
+  if (options.autoSetup) args.push("--auto-setup");
 
   // Spawn detached background process
   const child = spawn("node", [cliPath, ...args], {

package/src/cli/status.ts

@@ -1,6 +1,5 @@
 import pc from "picocolors";
 import { loadConfig, loadState } from "../config/loader.js";
-import { getRunnerDisplayName } from "../core/runner.js";
 import { getSessionName, sessionExists } from "../core/tmux.js";
 
 interface HealthResponse {
@@ -61,10 +60,14 @@ export async function status(): Promise<void> {
   console.log(`  Total:    ${pc.dim(String(state.agents.length))}`);
 
   if (runningAgents.length > 0) {
-    console.log(`  Active:`);
-    for (const agent of runningAgents) {
-      const modelInfo = agent.runtimeModel ? ` [${agent.runtimeModel}]` : "";
-      console.log(`    - ${pc.cyan(agent.name)}${pc.dim(modelInfo)}`);
+    console.log(`  Names:    ${pc.dim(runningAgents.map((a) => a.name).join(", "))}`);
+
+    // Show models for running agents
+    const modelsInfo = runningAgents
+      .filter((a) => a.runtimeModel)
+      .map((a) => `${a.name}:${a.runtimeModel}`);
+    if (modelsInfo.length > 0) {
+      console.log(`  Models:   ${pc.dim(modelsInfo.join(", "))}`);
     }
   }
 

package/src/cli/whoami.ts

@@ -1,7 +1,8 @@
 import pc from "picocolors";
 import { loadConfig, loadState } from "../config/loader.js";
-import { getRunnerDisplayName, type RunnerType } from "../core/runner.js";
-import { decodeToken, getTokenExpiry } from "../utils/jwt.js";
+import type { RunnerType } from "../config/schema.js";
+import { getRunnerDisplayName } from "../core/runner.js";
+import { getTokenExpiry } from "../utils/jwt.js";
 
 export async function whoami(agentName?: string): Promise<void> {
   const config = loadConfig();
@@ -24,20 +25,23 @@ export async function whoami(agentName?: string): Promise<void> {
       const expiry = getTokenExpiry(envToken);
       const expiryStr = formatExpiry(expiry);
 
-      // Find the agent in state to get model info
+      // Try to find agent in state for runtime info
       const agentState = state.agents.find((a) => a.agentId === envAgentId);
 
       console.log(pc.bold("Current Agent"));
       console.log(`  ID:        ${pc.cyan(envAgentId)}`);
       console.log(`  Workspace: ${pc.dim(config.workspace)}`);
+      console.log(`  Token:     ${expiryStr}`);
+      console.log(`  Hub:       ${pc.dim(config.hubUrl)}`);
+
+      // Show runtime model info if available
       if (agentState?.runtimeModel) {
         const runnerName = agentState.runnerType
-          ? getRunnerDisplayName(agentState.runnerType)
+          ? getRunnerDisplayName(agentState.runnerType as RunnerType)
           : "Unknown";
-        console.log(`  Model:     ${pc.cyan(agentState.runtimeModel)} (${pc.dim(runnerName)})`);
+        console.log(`  Model:     ${pc.cyan(agentState.runtimeModel)}`);
+        console.log(`  Runner:    ${pc.dim(runnerName)}`);
       }
-      console.log(`  Token:     ${expiryStr}`);
-      console.log(`  Hub:       ${pc.dim(config.hubUrl)}`);
       return;
     }
 
@@ -59,11 +63,13 @@ export async function whoami(agentName?: string): Promise<void> {
       console.log(`  ${pc.cyan(agent.name)}`);
       console.log(`    ID:      ${pc.dim(agent.agentId)}`);
       console.log(`    Status:  ${running ? pc.green("running") : pc.yellow("stopped")}`);
+      console.log(`    Token:   ${expiryStr}`);
       if (agent.runtimeModel) {
-        const runnerName = agent.runnerType ? getRunnerDisplayName(agent.runnerType) : "Unknown";
+        const runnerName = agent.runnerType
+          ? getRunnerDisplayName(agent.runnerType as RunnerType)
+          : "Unknown";
         console.log(`    Model:   ${pc.dim(agent.runtimeModel)} (${runnerName})`);
       }
-      console.log(`    Token:   ${expiryStr}`);
       console.log();
     }
     return;
@@ -85,14 +91,19 @@ export async function whoami(agentName?: string): Promise<void> {
   console.log(`  ID:        ${pc.cyan(agent.agentId)}`);
   console.log(`  Workspace: ${pc.dim(config.workspace)}`);
   console.log(`  Status:    ${running ? pc.green("running") : pc.yellow("stopped")}`);
-  if (agent.runtimeModel) {
-    const runnerName = agent.runnerType ? getRunnerDisplayName(agent.runnerType) : "Unknown";
-    console.log(`  Model:     ${pc.cyan(agent.runtimeModel)} (${pc.dim(runnerName)})`);
-  }
   console.log(`  Token:     ${expiryStr}`);
   console.log(`  Session:   ${pc.dim(agent.tmuxSession || "none")}`);
   console.log(`  Started:   ${pc.dim(agent.startedAt || "unknown")}`);
   console.log(`  Hub:       ${pc.dim(config.hubUrl)}`);
+
+  // Show runtime model info
+  if (agent.runtimeModel) {
+    const runnerName = agent.runnerType
+      ? getRunnerDisplayName(agent.runnerType as RunnerType)
+      : "Unknown";
+    console.log(`  Model:     ${pc.cyan(agent.runtimeModel)}`);
+    console.log(`  Runner:    ${pc.dim(runnerName)}`);
+  }
 }
 
 function formatExpiry(expiry: Date | null): string {

package/src/config/schema.ts

@@ -39,6 +39,8 @@ export interface AgentState {
   tmuxSession: string;
   startedAt: string;
   token?: string;
+  workdir?: string;
+  assignedProject?: string;
   /** The effective runtime model (resolved from CLI > agent > defaults) */
   runtimeModel?: string;
   /** The runner type (opencode, claude, custom) */

package/src/core/daemon.ts

@@ -1,8 +1,11 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import {
   addAgentToState,
   getAgentState,
   loadConfig,
-  loadState,
   removeAgentFromState,
   updateAgentInState,
 } from "../config/loader.js";
@@ -10,8 +13,13 @@ import type { AgentConfig, Config } from "../config/schema.js";
 import { loadContext, loadOrCreateContext, saveContext } from "../context/index.js";
 import { Heartbeat } from "./heartbeat.js";
 import { handleWebSocketEvent, injectRestoredContext, injectStartupMessage } from "./injector.js";
-import { checkInbox, registerAgent } from "./registry.js";
-import { buildRunnerConfig, getRunnerDisplayName, type RunnerConfig } from "./runner.js";
+import { checkInbox, fetchAssignments, registerAgent } from "./registry.js";
+import {
+  buildRunnerConfig,
+  detectRunner,
+  getRunnerDisplayName,
+  type RunnerConfig,
+} from "./runner.js";
 import {
   captureSessionContext,
   createSession,
@@ -30,6 +38,8 @@ export interface DaemonOptions {
   daemonize?: boolean;
   /** Whether to restore context from previous session (default: true) */
   restoreContext?: boolean;
+  /** Auto-clone repository for project assignments */
+  autoSetup?: boolean;
 }
 
 export class AgentDaemon {
@@ -42,7 +52,9 @@ export class AgentDaemon {
   private token: string | null = null;
   private agentId: string | null = null;
   private isRunning = false;
+  private assignedProject: string | undefined;
   private shouldRestoreContext: boolean;
+  private autoSetup: boolean;
 
   constructor(options: DaemonOptions) {
     const config = loadConfig();
@@ -53,6 +65,7 @@ export class AgentDaemon {
     this.config = config;
     this.agentName = options.name;
     this.shouldRestoreContext = options.restoreContext !== false;
+    this.autoSetup = options.autoSetup === true;
 
     // Find or create agent config
     let agentConfig = config.agents.find((a) => a.name === options.name);
@@ -84,46 +97,6 @@ export class AgentDaemon {
     const runnerName = getRunnerDisplayName(this.runnerConfig.type);
     console.log(`Runner: ${runnerName}`);
     console.log(`Effective model: ${this.runnerConfig.model}`);
-
-    // Check workdir conflicts - prevent multiple agents from using same directory
-    this.checkWorkdirConflict(agentConfig.workdir);
-  }
-
-  /**
-   * Checks if another agent is already using the specified workdir
-   */
-  private checkWorkdirConflict(workdir?: string): void {
-    if (!workdir) return;
-
-    const state = loadState();
-    const conflictingAgent = state.agents.find((a) => {
-      // Skip self
-      if (a.name === this.agentName) return false;
-
-      // Check if agent is actually running
-      if (!a.pid) return false;
-      try {
-        process.kill(a.pid, 0); // Check if process exists
-      } catch {
-        return false; // Process not running
-      }
-
-      // Check if session exists and has same workdir
-      // We need to check the config for this agent's workdir
-      const otherAgentConfig = this.config.agents.find((c) => c.name === a.name);
-      if (otherAgentConfig?.workdir === workdir) {
-        return true;
-      }
-
-      return false;
-    });
-
-    if (conflictingAgent) {
-      throw new Error(
-        `Workdir conflict: Agent "${conflictingAgent.name}" is already using "${workdir}".\n` +
-          `Use a different --workdir or stop the other agent first.`,
-      );
-    }
   }
 
   async start(): Promise<void> {
@@ -134,6 +107,27 @@ export class AgentDaemon {
 
     console.log(`Starting agent: ${this.agentName}`);
 
+    // Register with hub first (needed for assignment check)
+    console.log("Registering with AgentMesh hub...");
+    const existingState = getAgentState(this.agentName);
+
+    const registration = await registerAgent({
+      url: this.config.hubUrl,
+      apiKey: this.config.apiKey,
+      workspace: this.config.workspace,
+      agentId: existingState?.agentId || this.agentConfig.agentId,
+      agentName: this.agentName,
+      model: this.agentConfig.model || this.config.defaults.model,
+    });
+
+    this.agentId = registration.agentId;
+    this.token = registration.token;
+
+    console.log(`Registered as: ${this.agentId}`);
+
+    // Check assignments and auto-setup workdir if needed (before creating tmux session)
+    await this.checkAssignments();
+
     // Check if session already exists
     const sessionName = getSessionName(this.agentName);
     const sessionAlreadyExists = sessionExists(sessionName);
@@ -141,11 +135,13 @@ export class AgentDaemon {
     // Create tmux session if it doesn't exist
     if (!sessionAlreadyExists) {
       console.log(`Creating tmux session: ${sessionName}`);
+
+      // Include runner env vars (e.g., OPENCODE_MODEL) at session creation
       const created = createSession(
         this.agentName,
         this.agentConfig.command,
         this.agentConfig.workdir,
-        this.runnerConfig.env, // Pass runner env vars (e.g., OPENCODE_MODEL)
+        this.runnerConfig.env, // Apply model env at process start
       );
 
       if (!created) {
@@ -154,29 +150,9 @@ export class AgentDaemon {
     } else {
       console.log(`Reconnecting to existing session: ${sessionName}`);
       // Update environment for existing session
-      if (Object.keys(this.runnerConfig.env).length > 0) {
-        updateSessionEnvironment(this.agentName, this.runnerConfig.env);
-      }
+      updateSessionEnvironment(this.agentName, this.runnerConfig.env);
     }
 
-    // Register with hub
-    console.log("Registering with AgentMesh hub...");
-    const existingState = getAgentState(this.agentName);
-
-    const registration = await registerAgent({
-      url: this.config.hubUrl,
-      apiKey: this.config.apiKey,
-      workspace: this.config.workspace,
-      agentId: existingState?.agentId || this.agentConfig.agentId,
-      agentName: this.agentName,
-      model: this.agentConfig.model || this.config.defaults.model,
-    });
-
-    this.agentId = registration.agentId;
-    this.token = registration.token;
-
-    console.log(`Registered as: ${this.agentId}`);
-
     // Inject environment variables into tmux session
     console.log("Injecting environment variables...");
     updateSessionEnvironment(this.agentName, {
@@ -184,7 +160,7 @@ export class AgentDaemon {
       AGENTMESH_AGENT_ID: this.agentId,
     });
 
-    // Save state
+    // Save state including runtime model info
     addAgentToState({
       name: this.agentName,
       agentId: this.agentId,
@@ -192,6 +168,8 @@ export class AgentDaemon {
       tmuxSession: sessionName,
       startedAt: new Date().toISOString(),
       token: this.token,
+      workdir: this.agentConfig.workdir,
+      assignedProject: this.assignedProject,
       runtimeModel: this.runnerConfig.model,
       runnerType: this.runnerConfig.type,
     });
@@ -376,4 +354,172 @@ Nudge agent:
       console.error("Failed to save agent context:", error);
     }
   }
+
+  /**
+   * Fetches assignments from HQ and validates workdir setup
+   * Uses project.workdir from HQ as source of truth, falls back to helpful instructions
+   */
+  private async checkAssignments(): Promise<void> {
+    if (!this.token) return;
+
+    try {
+      console.log("Fetching project assignments from HQ...");
+      const assignments = await fetchAssignments(this.config.hubUrl, this.token);
+
+      if (assignments.length === 0) {
+        console.log("No project assignments found.");
+        return;
+      }
+
+      console.log(`Found ${assignments.length} assignment(s):`);
+      for (const assignment of assignments) {
+        const repoInfo = assignment.repo ? ` -> ${assignment.repo.full_name}` : "";
+        const workdirInfo = assignment.project.workdir ? ` [${assignment.project.workdir}]` : "";
+        console.log(`  - ${assignment.project.name} (${assignment.role})${repoInfo}${workdirInfo}`);
+      }
+
+      this.assignedProject = assignments[0]?.project.name;
+
+      // If no CLI workdir specified, try to use project.workdir from HQ
+      if (!this.agentConfig.workdir) {
+        const assignmentWithWorkdir = assignments.find((a) => a.project.workdir);
+        if (assignmentWithWorkdir?.project.workdir) {
+          console.log(
+            `Using workdir from project settings: ${assignmentWithWorkdir.project.workdir}`,
+          );
+          this.agentConfig.workdir = assignmentWithWorkdir.project.workdir;
+          return;
+        }
+
+        // No project.workdir set, check if we have a repo assignment
+        const repoAssignment = assignments.find((a) => a.repo !== null);
+        if (repoAssignment) {
+          const repo = repoAssignment.repo!;
+          const expandedPath = path.join(
+            os.homedir(),
+            ".agentmesh",
+            "workspaces",
+            this.config.workspace,
+            repoAssignment.project.code.toLowerCase(),
+            this.agentName,
+          );
+          const suggestedPath = `~/.agentmesh/workspaces/${this.config.workspace}/${repoAssignment.project.code.toLowerCase()}/${this.agentName}`;
+
+          // If --auto-setup is enabled, automatically clone the repo
+          if (this.autoSetup) {
+            this.agentConfig.workdir = this.setupWorkspace(
+              expandedPath,
+              repo.url,
+              repo.default_branch,
+              repoAssignment.project.name,
+            );
+            return;
+          }
+
+          console.error(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⚠️  WORKDIR REQUIRED
+
+You have a project assignment with a repository, but no workdir is configured.
+
+Project:  ${repoAssignment.project.name}
+Repo:     ${repo.full_name}
+Branch:   ${repo.default_branch}
+
+Option 1: Set workdir in project settings (recommended)
+  - Go to AgentMesh HQ → Projects → ${repoAssignment.project.name} → Settings
+  - Set the workdir field to the local path
+
+Option 2: Set up workspace manually and pass --workdir:
+
+  mkdir -p ${suggestedPath}
+  git clone ${repo.url} ${suggestedPath}
+  cd ${suggestedPath} && git checkout ${repo.default_branch}
+
+Then start the agent with:
+
+  agentmesh start -n ${this.agentName} --workdir ${suggestedPath}
+
+Option 3: Use --auto-setup to automatically clone the repository:
+
+  agentmesh start -n ${this.agentName} --auto-setup
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+          // No session to clean up - we haven't created it yet
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      // Non-fatal: log and continue (HQ might not have assignments feature yet)
+      console.log("Could not fetch assignments:", (error as Error).message);
+    }
+  }
+
+  /**
+   * Sets up workspace by cloning repository or using existing clone
+   * Returns the absolute path to the workspace
+   */
+  private setupWorkspace(
+    workspacePath: string,
+    repoUrl: string,
+    defaultBranch: string,
+    projectName: string,
+  ): string {
+    console.log(
+      `\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+    );
+    console.log(`🔧 AUTO-SETUP: Setting up workspace for ${projectName}`);
+    console.log(
+      `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`,
+    );
+
+    // Check if directory already exists and is a git repo
+    const gitDir = path.join(workspacePath, ".git");
+    if (fs.existsSync(gitDir)) {
+      console.log(`✓ Workspace already exists: ${workspacePath}`);
+      console.log(`  Updating from remote...`);
+
+      try {
+        // Fetch and checkout the branch
+        execSync(`git fetch origin`, { cwd: workspacePath, stdio: "inherit" });
+        execSync(`git checkout ${defaultBranch}`, { cwd: workspacePath, stdio: "inherit" });
+        execSync(`git pull origin ${defaultBranch}`, { cwd: workspacePath, stdio: "inherit" });
+        console.log(`✓ Workspace updated successfully\n`);
+      } catch (error) {
+        console.warn(`⚠ Could not update workspace: ${(error as Error).message}`);
+        console.log(`  Continuing with existing state...\n`);
+      }
+
+      return workspacePath;
+    }
+
+    // Create parent directories
+    const parentDir = path.dirname(workspacePath);
+    if (!fs.existsSync(parentDir)) {
+      console.log(`Creating directory: ${parentDir}`);
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+
+    // Clone the repository
+    console.log(`Cloning repository...`);
+    console.log(`  URL: ${repoUrl}`);
+    console.log(`  Path: ${workspacePath}`);
+    console.log(`  Branch: ${defaultBranch}\n`);
+
+    try {
+      execSync(`git clone --branch ${defaultBranch} "${repoUrl}" "${workspacePath}"`, {
+        stdio: "inherit",
+      });
+      console.log(`\n✓ Repository cloned successfully`);
+    } catch (error) {
+      console.error(`\n✗ Failed to clone repository: ${(error as Error).message}`);
+      console.error(`\nMake sure you have access to the repository and SSH keys are configured.`);
+      // No session to clean up - we haven't created it yet
+      process.exit(1);
+    }
+
+    console.log(`✓ Workspace ready: ${workspacePath}\n`);
+    return workspacePath;
+  }
 }

package/src/core/registry.ts

@@ -27,9 +27,7 @@ export interface InboxItem {
   created_at: string;
 }
 
-export async function registerAgent(
-  options: RegisterOptions
-): Promise<RegisterResult> {
+export async function registerAgent(options: RegisterOptions): Promise<RegisterResult> {
   const agentId = options.agentId || randomUUID();
 
   const response = await fetch(`${options.url}/api/v1/agents/register`, {
@@ -65,32 +63,27 @@ export async function registerAgent(
 export async function checkInbox(
   url: string,
   workspace: string,
-  token: string
+  token: string,
 ): Promise<InboxItem[]> {
-  const response = await fetch(
-    `${url}/api/v1/workspaces/${workspace}/inbox`,
-    {
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
-    }
-  );
+  const response = await fetch(`${url}/api/v1/workspaces/${workspace}/inbox`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
 
   if (!response.ok) {
     throw new Error(`Failed to check inbox: ${response.status}`);
   }
 
   const data = await response.json();
-  return (data.data || []).filter(
-    (item: InboxItem) => item.status === "pending"
-  );
+  return (data.data || []).filter((item: InboxItem) => item.status === "pending");
 }
 
 export async function sendNudge(
   url: string,
   agentId: string,
   message: string,
-  token: string
+  token: string,
 ): Promise<boolean> {
   const response = await fetch(`${url}/api/v1/agents/${agentId}/nudge`, {
     method: "POST",
@@ -103,3 +96,51 @@ export async function sendNudge(
 
   return response.ok;
 }
+
+// ============================================================================
+// Agent Self-Discovery
+// ============================================================================
+
+export interface ProjectAssignment {
+  assignment_id: string;
+  role: string;
+  status: string;
+  notes: string | null;
+  priority: number;
+  created_at: string;
+  project: {
+    project_id: string;
+    name: string;
+    code: string;
+    description: string | null;
+    workdir: string | null;
+  };
+  repo: {
+    repo_id: string;
+    provider: string;
+    full_name: string;
+    url: string;
+    default_branch: string;
+  } | null;
+}
+
+/**
+ * Fetch the agent's project assignments from HQ
+ */
+export async function fetchAssignments(url: string, token: string): Promise<ProjectAssignment[]> {
+  const response = await fetch(`${url}/api/v1/agents/me/assignments`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      return []; // No assignments
+    }
+    throw new Error(`Failed to fetch assignments: ${response.status}`);
+  }
+
+  const data = (await response.json()) as { data: ProjectAssignment[] };
+  return data.data || [];
+}

package/src/core/tmux.ts

@@ -1,4 +1,4 @@
-import { type ChildProcess, execSync, spawn } from "node:child_process";
+import { type ChildProcess, execFileSync, execSync, spawn } from "node:child_process";
 
 const SESSION_PREFIX = "agentmesh-";
 
@@ -64,7 +64,7 @@ export function createSession(
 
     args.push(fullCommand);
 
-    execSync(`tmux ${args.join(" ")}`);
+    execFileSync("tmux", args);
 
     // Also set session environment for any subsequent processes/refreshes
     if (env) {
@@ -82,7 +82,7 @@ export function setSessionEnvironment(sessionName: string, env: SessionEnv): boo
   try {
     for (const [key, value] of Object.entries(env)) {
       if (value !== undefined && value !== "") {
-        execSync(`tmux set-environment -t "${sessionName}" ${key} "${value}"`);
+        execFileSync("tmux", ["set-environment", "-t", sessionName, key, value]);
       }
     }
     return true;

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 therajushahi
-
-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.