teleportation-cli 1.0.0

package/.claude/hooks/session_start.mjs

@@ -0,0 +1,308 @@
+#!/usr/bin/env bun
+
+import { stdin, exit, env } from 'node:process';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+import { existsSync, statSync, writeFileSync, mkdirSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Import metadata extraction (lazy loaded to avoid slowing down startup)
+let extractSessionMetadata = null;
+async function getSessionMetadata(cwd) {
+  if (!extractSessionMetadata) {
+    // Try multiple possible paths for the metadata module
+    const possiblePaths = [
+      // Installed location (copied during `teleportation on`)
+      join(homedir(), '.teleportation', 'lib', 'session', 'metadata.js'),
+      // Development mode - relative to hooks directory
+      join(__dirname, '..', '..', 'lib', 'session', 'metadata.js'),
+      // If hook is still in project directory
+      join(process.cwd(), 'lib', 'session', 'metadata.js')
+    ];
+
+    // Check existsSync first to avoid expensive import failures
+    for (const metadataPath of possiblePaths) {
+      if (!existsSync(metadataPath)) continue;
+      try {
+        const metadataModule = await import(metadataPath);
+        extractSessionMetadata = metadataModule.extractSessionMetadata;
+        if (extractSessionMetadata) break;
+      } catch {
+        // Try next path
+        continue;
+      }
+    }
+
+    if (!extractSessionMetadata) {
+      if (env.DEBUG) console.error(`[SessionStart] Metadata module not found`);
+      return {};
+    }
+  }
+  try {
+    return await extractSessionMetadata(cwd);
+  } catch (e) {
+    if (env.DEBUG) console.error(`[SessionStart] Failed to extract metadata: ${e.message}`);
+    return {};
+  }
+}
+
+const readStdin = () => new Promise((resolve, reject) => {
+  let data='';
+  stdin.setEncoding('utf8');
+  stdin.on('data', c => data += c);
+  stdin.on('end', () => resolve(data));
+  stdin.on('error', reject);
+});
+
+const fetchWithTimeout = (url, opts, timeoutMs = 2000) => {
+  return Promise.race([
+    fetch(url, opts),
+    new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeoutMs))
+  ]);
+};
+
+// Session marker file to track when this Claude Code session started
+const TELEPORTATION_DIR = join(homedir(), '.teleportation');
+const SESSION_MARKER_FILE = join(TELEPORTATION_DIR, '.session_marker');
+const CREDENTIALS_FILE = join(TELEPORTATION_DIR, 'credentials');
+
+/**
+ * Check if credentials were modified after the session started.
+ * If a session marker exists and credentials are newer, user needs to restart.
+ */
+function checkRestartNeeded() {
+  try {
+    if (!existsSync(SESSION_MARKER_FILE) || !existsSync(CREDENTIALS_FILE)) {
+      return { needsRestart: false };
+    }
+
+    const markerMtime = statSync(SESSION_MARKER_FILE).mtimeMs;
+    const credsMtime = statSync(CREDENTIALS_FILE).mtimeMs;
+
+    if (credsMtime > markerMtime) {
+      return {
+        needsRestart: true,
+        reason: 'Credentials changed after session started',
+        markerTime: new Date(markerMtime).toISOString(),
+        credsTime: new Date(credsMtime).toISOString()
+      };
+    }
+
+    return { needsRestart: false };
+  } catch (e) {
+    if (env.DEBUG) console.error(`[SessionStart] Restart check error: ${e.message}`);
+    return { needsRestart: false };
+  }
+}
+
+/**
+ * Update the session marker file with current timestamp.
+ * Called when a session starts to track when this Claude Code instance began.
+ */
+function updateSessionMarker(sessionId) {
+  try {
+    if (!existsSync(TELEPORTATION_DIR)) {
+      mkdirSync(TELEPORTATION_DIR, { recursive: true, mode: 0o700 });
+    }
+    const markerData = JSON.stringify({
+      timestamp: Date.now(),
+      sessionId: sessionId,
+      startedAt: new Date().toISOString()
+    });
+    writeFileSync(SESSION_MARKER_FILE, markerData, { mode: 0o600 });
+    if (env.DEBUG) console.error(`[SessionStart] Session marker updated`);
+  } catch (e) {
+    if (env.DEBUG) console.error(`[SessionStart] Failed to update session marker: ${e.message}`);
+  }
+}
+
+(async () => {
+  let input = {};
+  try {
+    const raw = await readStdin();
+    input = JSON.parse(raw || '{}');
+  } catch {}
+
+  let { session_id, cwd } = input || {};
+  const claude_session_id = session_id;
+
+  // Check if credentials changed since last session start - user may need to restart
+  const restartCheck = checkRestartNeeded();
+  if (restartCheck.needsRestart) {
+    // Output a warning to stderr (shown to user)
+    console.error('\n⚠️  Teleportation credentials changed after this session started.');
+    console.error('   Restart Claude Code to apply the new credentials.\n');
+    if (env.DEBUG) {
+      console.error(`   Session started: ${restartCheck.markerTime}`);
+      console.error(`   Credentials updated: ${restartCheck.credsTime}`);
+    }
+  }
+
+  // Update session marker with current time (for future restart detection)
+  updateSessionMarker(session_id);
+
+  // Load config from encrypted credentials, legacy config file, or env vars
+  let config;
+  try {
+    const { loadConfig } = await import('./config-loader.mjs');
+    config = await loadConfig();
+  } catch (e) {
+    // Fallback to environment variables if config loader fails
+    config = {
+      relayApiUrl: env.RELAY_API_URL || '',
+      relayApiKey: env.RELAY_API_KEY || ''
+    };
+  }
+
+  const RELAY_API_URL = config.relayApiUrl || '';
+  const RELAY_API_KEY = config.relayApiKey || '';
+  const DAEMON_PORT = config.daemonPort || env.TELEPORTATION_DAEMON_PORT || '3050';
+  const DAEMON_ENABLED = config.daemonEnabled !== false && env.TELEPORTATION_DAEMON_ENABLED !== 'false';
+
+  // Auto-start daemon if enabled
+  if (DAEMON_ENABLED && session_id && RELAY_API_URL && RELAY_API_KEY) {
+    try {
+      // Check if daemon is already running
+      const daemonUrl = `http://127.0.0.1:${DAEMON_PORT}`;
+      let daemonRunning = false;
+
+      try {
+        const healthResponse = await fetchWithTimeout(`${daemonUrl}/health`, {}, 1000);
+        daemonRunning = healthResponse.ok;
+      } catch {}
+
+      // Start daemon if not running
+      if (!daemonRunning) {
+        // Try multiple locations to find daemon script
+        const possibleLocations = [
+          // 1. Installed location (copied during `teleportation on`)
+          join(homedir(), '.teleportation', 'daemon', 'teleportation-daemon.js'),
+          // 2. Development mode - relative to hooks directory
+          join(__dirname, '..', '..', 'lib', 'daemon', 'teleportation-daemon.js'),
+          // 3. Environment variable override
+          env.TELEPORTATION_DAEMON_SCRIPT
+        ].filter(Boolean);
+
+        // Import fs/promises once outside the loop
+        const { access } = await import('fs/promises');
+        let daemonScript = null;
+        for (const location of possibleLocations) {
+          try {
+            await access(location);
+            daemonScript = location;
+            break;
+          } catch {
+            // Try next location
+          }
+        }
+
+        if (!daemonScript) {
+          if (env.DEBUG) {
+            console.error('[SessionStart] Daemon script not found. Tried:', possibleLocations);
+          }
+          // Continue without daemon
+          try { process.stdout.write(JSON.stringify({ suppressOutput: true })); } catch {}
+          return exit(0);
+        }
+
+        // Retry daemon start with exponential backoff
+        let retries = 3;
+        let daemonStarted = false;
+
+        while (retries > 0 && !daemonStarted) {
+          try {
+            // Spawn daemon process
+            spawn(process.execPath, [daemonScript], {
+              detached: true,
+              stdio: 'ignore',
+              env: {
+                ...process.env,
+                TELEPORTATION_DAEMON: 'true',
+                RELAY_API_URL,
+                RELAY_API_KEY,
+                TELEPORTATION_DAEMON_PORT: DAEMON_PORT
+              }
+            }).unref();
+
+            // Wait for daemon to start with increasing delays
+            const waitTime = 500 * (4 - retries); // 500ms, 1000ms, 1500ms
+            await new Promise(r => setTimeout(r, waitTime));
+
+            // Verify daemon is actually running
+            try {
+              const healthCheck = await fetchWithTimeout(`${daemonUrl}/health`, {}, 2000);
+              if (healthCheck.ok) {
+                daemonStarted = true;
+                if (env.DEBUG) {
+                  console.error('[SessionStart] Daemon started successfully');
+                }
+                break;
+              }
+            } catch (healthError) {
+              if (env.DEBUG) {
+                console.error(`[SessionStart] Health check failed: ${healthError.message}`);
+              }
+            }
+
+            retries--;
+            if (retries === 0 && !daemonStarted) {
+              if (env.DEBUG) {
+                console.error('[SessionStart] Failed to start daemon after 3 attempts');
+              }
+              // Set flag to disable daemon for this session
+              process.env.TELEPORTATION_DAEMON_DISABLED = 'true';
+            }
+          } catch (spawnError) {
+            retries--;
+            if (env.DEBUG) {
+              console.error(`[SessionStart] Daemon spawn error (${3 - retries}/3):`, spawnError.message);
+            }
+            if (retries > 0) {
+              // Exponential backoff between retries
+              await new Promise(r => setTimeout(r, 1000 * (4 - retries)));
+            }
+          }
+        }
+      }
+
+      // Register session with daemon (with metadata)
+      try {
+        // Extract session metadata (project, branch, hostname, current_model, etc.)
+        const meta = await getSessionMetadata(cwd || process.cwd());
+
+        if (env.DEBUG && meta.current_model) {
+          console.error(`[SessionStart] Captured model: ${meta.current_model}`);
+        }
+
+        await fetchWithTimeout(`${daemonUrl}/sessions/register`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ session_id, claude_session_id, cwd, meta })
+        }, 2000);
+
+        if (env.DEBUG) {
+          console.error(`[SessionStart] Session registered with daemon: ${session_id}`);
+          console.error(`[SessionStart] Metadata: ${JSON.stringify(meta)}`);
+        }
+      } catch (regError) {
+        if (env.DEBUG) {
+          console.error(`[SessionStart] Failed to register session with daemon:`, regError.message);
+        }
+      }
+    } catch (daemonError) {
+      // Don't fail session start if daemon fails
+      if (env.DEBUG) {
+        console.error('[SessionStart] Daemon error:', daemonError.message);
+      }
+    }
+  }
+
+  // Session registration with relay happens on first message (in pre_tool_use hook)
+  // This hook just starts the daemon infrastructure
+  try { process.stdout.write(JSON.stringify({ suppressOutput: true })); } catch {}
+  return exit(0);
+})();

package/.claude/hooks/stop.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env bun
+/**
+ * Stop Hook
+ * 
+ * This hook fires when Claude Code finishes responding.
+ * 
+ * Purpose:
+ * 1. Check for pending messages from the mobile app (existing functionality)
+ * 2. Extract Claude's last response from the transcript and log it to timeline
+ */
+
+import { stdin, stdout, stderr, exit, env } from 'node:process';
+import { readFile } from 'node:fs/promises';
+import { appendFileSync } from 'node:fs';
+
+const readStdin = () => new Promise((resolve, reject) => {
+  let data = '';
+  stdin.setEncoding('utf8');
+  stdin.on('data', c => data += c);
+  stdin.on('end', () => resolve(data));
+  stdin.on('error', reject);
+});
+
+// More lenient session ID validation - accepts any alphanumeric string with hyphens
+const isValidSessionId = (id) => {
+  return id && typeof id === 'string' && /^[a-zA-Z0-9-]+$/.test(id) && id.length >= 8;
+};
+
+// Max length for assistant response preview (characters)
+const ASSISTANT_RESPONSE_MAX_LENGTH = 2000;
+
+// Retry configuration
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+
+/**
+ * Fetch JSON with retry logic
+ */
+const fetchJsonWithRetry = async (url, opts, log, retries = 0) => {
+  try {
+    const res = await fetch(url, opts);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return res.json();
+  } catch (error) {
+    if (retries < MAX_RETRIES) {
+      log(`Retry ${retries + 1}/${MAX_RETRIES} after error: ${error.message}`);
+      await new Promise(r => setTimeout(r, RETRY_DELAY_MS * (retries + 1)));
+      return fetchJsonWithRetry(url, opts, log, retries + 1);
+    }
+    throw error;
+  }
+};
+
+/**
+ * Extract the last assistant message from the transcript
+ * The transcript is a JSON file with conversation messages
+ * @returns {Object|null} - { text: string, model: string|null } or null
+ */
+const extractLastAssistantMessage = async (transcriptPath, log) => {
+  try {
+    if (!transcriptPath) {
+      log('No transcript_path provided');
+      return null;
+    }
+
+    // Read file directly - handle errors instead of TOCTOU-vulnerable access() check
+    let content;
+    try {
+      content = await readFile(transcriptPath, 'utf8');
+    } catch (e) {
+      // Handle file access errors specifically
+      if (e.code === 'ENOENT') {
+        log(`Transcript file not found: ${transcriptPath}`);
+        return null;
+      }
+      if (e.code === 'EACCES' || e.code === 'EPERM') {
+        log(`Permission denied reading transcript: ${transcriptPath}`);
+        return null;
+      }
+      log(`Error reading transcript: ${e.code || e.message}`);
+      return null;
+    }
+    let transcript;
+
+    // Try parsing as JSON array first
+    try {
+      transcript = JSON.parse(content);
+      log('Parsed transcript as JSON array');
+    } catch (e) {
+      // Try parsing as JSONL (newline-delimited JSON)
+      log('JSON parse failed, trying JSONL format');
+      const lines = content.trim().split('\n').filter(l => l.trim());
+      transcript = lines.map(line => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+      log(`Parsed transcript as JSONL (${transcript.length} messages)`);
+    }
+
+    if (!Array.isArray(transcript)) {
+      log(`Transcript is not an array: ${typeof transcript}`);
+      return null;
+    }
+
+    log(`Transcript has ${transcript.length} messages`);
+
+    // Find the last assistant message
+    // Messages typically have: { role: 'assistant' | 'user', content: string | array, model?: string }
+    for (let i = transcript.length - 1; i >= 0; i--) {
+      const msg = transcript[i];
+
+      // Check for assistant role (various possible formats)
+      const role = msg.role || msg.type || '';
+      if (role === 'assistant' || role === 'model' || msg.isAssistant) {
+        // Extract content (could be string or array of content blocks)
+        let text = '';
+
+        if (typeof msg.content === 'string') {
+          text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          // Content blocks format: [{ type: 'text', text: '...' }, ...]
+          text = msg.content
+            .filter(block => block.type === 'text' && block.text)
+            .map(block => block.text)
+            .join('\n\n'); // Use double newline for paragraph separation
+        } else if (msg.text) {
+          text = msg.text;
+        } else if (msg.message) {
+          // Don't stringify objects - only use if it's a string
+          text = typeof msg.message === 'string' ? msg.message : '';
+        }
+
+        if (text && text.trim()) {
+          // Extract model if available
+          const model = msg.model || null;
+          log(`Found assistant message (${text.length} chars, model: ${model || 'not specified'})`);
+          return { text: text.trim(), model };
+        }
+      }
+    }
+
+    log('No assistant message found in transcript');
+    return null;
+  } catch (e) {
+    log(`Error reading transcript: ${e.message}`);
+    return null;
+  }
+};
+
+(async () => {
+  const hookLogFile = env.TELEPORTATION_HOOK_LOG || '/tmp/teleportation-hook.log';
+  const log = (msg) => {
+    const timestamp = new Date().toISOString();
+    try {
+      // Use sync for logging to ensure messages are written even if hook exits quickly
+      appendFileSync(hookLogFile, `[${timestamp}] [Stop] ${msg}\n`);
+    } catch (e) {}
+  };
+
+  log('=== Stop Hook invoked ===');
+
+  const raw = await readStdin();
+  let input;
+  try { 
+    input = JSON.parse(raw || '{}'); 
+  } catch (e) {
+    log(`ERROR: Invalid JSON: ${e.message}`);
+    return exit(0);
+  }
+
+  const { session_id, transcript_path, stop_hook_active } = input || {};
+  log(`Session: ${session_id}, Transcript: ${transcript_path}, stop_hook_active: ${stop_hook_active}`);
+
+  // Load config
+  let config;
+  try {
+    const { loadConfig } = await import('./config-loader.mjs');
+    config = await loadConfig();
+  } catch (e) {
+    config = {
+      relayApiUrl: env.RELAY_API_URL || '',
+      relayApiKey: env.RELAY_API_KEY || '',
+    };
+  }
+
+  const RELAY_API_URL = env.RELAY_API_URL || config.relayApiUrl || '';
+  const RELAY_API_KEY = env.RELAY_API_KEY || config.relayApiKey || '';
+
+  if (!session_id || !RELAY_API_URL || !RELAY_API_KEY) {
+    log('Missing session_id or relay config - skipping');
+    return exit(0);
+  }
+
+  // Validate session_id
+  if (!isValidSessionId(session_id)) {
+    log(`ERROR: Invalid session_id format: ${session_id}`);
+    return exit(0);
+  }
+
+  // 1. Extract and log Claude's last response to timeline
+  // Skip if this is a continuation from a previous stop hook (stop_hook_active=true)
+  // to avoid logging duplicate responses
+  if (!stop_hook_active) {
+    try {
+      const result = await extractLastAssistantMessage(transcript_path, log);
+
+      if (result && result.text) {
+        const { text, model } = result;
+
+        // Truncate for timeline storage
+        const preview = text.length > ASSISTANT_RESPONSE_MAX_LENGTH
+          ? text.slice(0, ASSISTANT_RESPONSE_MAX_LENGTH) + '...'
+          : text;
+
+        await fetchJsonWithRetry(`${RELAY_API_URL}/api/timeline`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${RELAY_API_KEY}`
+          },
+          body: JSON.stringify({
+            session_id,
+            type: 'assistant_response',
+            data: {
+              message: preview,
+              model: model, // Include the model field
+              full_length: text.length,
+              truncated: text.length > ASSISTANT_RESPONSE_MAX_LENGTH
+            }
+          })
+        }, log);
+        log(`Logged assistant response to timeline (${preview.length} chars, model: ${model || 'not specified'})`);
+      }
+    } catch (e) {
+      log(`Failed to log assistant response after ${MAX_RETRIES} retries: ${e.message}`);
+      // Don't fail the hook - continue with other functionality
+    }
+  } else {
+    log('Skipping assistant response log (stop_hook_active=true)');
+  }
+
+  // 2. Check for pending messages from mobile app (existing functionality)
+  try {
+    const res = await fetch(`${RELAY_API_URL}/api/messages/pending?session_id=${encodeURIComponent(session_id)}`, {
+      headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
+    });
+    if (res.ok) {
+      const msg = await res.json();
+      if (msg && msg.id && msg.text) {
+        log(`Found pending message: ${String(msg.text).slice(0, 50)}...`);
+        try {
+          await fetch(`${RELAY_API_URL}/api/messages/${msg.id}/ack`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
+          });
+        } catch {}
+
+        const out = {
+          decision: 'block',
+          reason: msg.text,
+          hookSpecificOutput: { hookEventName: 'Stop' },
+          suppressOutput: true
+        };
+        stdout.write(JSON.stringify(out));
+        return exit(0);
+      }
+    }
+  } catch (e) {
+    log(`Error checking pending messages: ${e.message}`);
+  }
+
+  log('Stop hook completed');
+  return exit(0);
+})();

package/.claude/hooks/user_prompt_submit.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env bun
+
+/**
+ * UserPromptSubmit Hook
+ * Fires when the user submits a prompt to Claude Code
+ * Used to detect /model command and log it to timeline
+ */
+
+import { stdin, stdout, exit, env } from 'node:process';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+const readStdin = () => new Promise((resolve, reject) => {
+  let data = '';
+  stdin.setEncoding('utf8');
+  stdin.on('data', chunk => data += chunk);
+  stdin.on('end', () => resolve(data));
+  stdin.on('error', reject);
+});
+
+(async () => {
+  let input = {};
+  try {
+    const raw = await readStdin();
+    input = JSON.parse(raw || '{}');
+  } catch (e) {
+    // Invalid JSON - exit gracefully
+    try { stdout.write(JSON.stringify({ suppressOutput: true })); } catch {}
+    return exit(0);
+  }
+
+  const { session_id, prompt } = input;
+
+  // Check if user is running /model command
+  if (prompt && typeof prompt === 'string') {
+    const trimmed = prompt.trim().toLowerCase();
+
+    if (trimmed === '/model' || trimmed.startsWith('/model ')) {
+      // User is switching models - log this intent
+      // The actual model change will be detected in pre_tool_use hook
+
+      // Write a marker file to indicate model change is in progress
+      try {
+        const { writeFile } = await import('fs/promises');
+        const MODEL_CHANGE_MARKER = join(tmpdir(), `teleportation-model-changing-${session_id}.txt`);
+        await writeFile(MODEL_CHANGE_MARKER, Date.now().toString(), { mode: 0o600 });
+
+        if (env.DEBUG) {
+          console.error(`[UserPromptSubmit] Detected /model command for session ${session_id}`);
+        }
+      } catch (e) {
+        // Non-critical - just a marker file
+      }
+
+      // Load config and log to timeline
+      try {
+        const { loadConfig } = await import('./config-loader.mjs');
+        const config = await loadConfig();
+        const RELAY_API_URL = config.relayApiUrl;
+        const RELAY_API_KEY = config.relayApiKey;
+
+        if (RELAY_API_URL && RELAY_API_KEY) {
+          await fetch(`${RELAY_API_URL}/api/timeline/log`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': `Bearer ${RELAY_API_KEY}`
+            },
+            body: JSON.stringify({
+              session_id,
+              event_type: 'model_change_requested',
+              data: {
+                command: prompt,
+                timestamp: Date.now()
+              }
+            })
+          });
+        }
+      } catch (e) {
+        // Non-critical - timeline logging is optional
+        if (env.DEBUG) {
+          console.error(`[UserPromptSubmit] Failed to log model change request: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  // Always suppress output from this hook
+  try { stdout.write(JSON.stringify({ suppressOutput: true })); } catch {}
+  return exit(0);
+})();

package/LICENSE

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