teleportation-cli 1.0.0

package/lib/session/metadata.js

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+/**
+ * Session metadata extraction module
+ * Extracts project information, git status, and other context
+ */
+
+import { execSync } from 'child_process';
+import { basename, dirname, join } from 'path';
+import { homedir, hostname, userInfo } from 'os';
+import { stat, readFile } from 'fs/promises';
+
+/**
+ * Extract project name from git repository or fall back to directory name
+ */
+export async function getProjectName(cwd) {
+  try {
+    // Try to get git remote URL
+    const gitRemote = execSync('git config --get remote.origin.url', {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    
+    if (gitRemote) {
+      // Extract repo name from URL (handles both SSH and HTTPS)
+      const match = gitRemote.match(/(?:.*\/)?([^\/]+?)(?:\.git)?$/);
+      if (match && match[1]) {
+        return match[1];
+      }
+    }
+  } catch (e) {
+    // Not a git repo or git command failed
+  }
+  
+  // Fall back to directory name
+  return basename(cwd);
+}
+
+/**
+ * Get current git branch name
+ */
+export function getCurrentBranch(cwd) {
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    return branch || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get current git commit hash (short)
+ */
+export function getCommitHash(cwd) {
+  try {
+    const hash = execSync('git rev-parse --short HEAD', {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    return hash || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get last edited file from git status
+ */
+export function getLastEditedFile(cwd) {
+  try {
+    // Get modified files from git status
+    const status = execSync('git status --porcelain', {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    
+    if (status) {
+      // Get the first modified file
+      const lines = status.split('\n').filter(line => line.trim());
+      if (lines.length > 0) {
+        // Format: " M file.js" or "MM file.js" etc.
+        // Git status porcelain format: XY filename (X = index, Y = working tree)
+        // Format is exactly: "XY filename" where XY is 2 chars, then space, then filename
+        // Note: line may have leading space, so we need to handle both cases
+        const line = lines[0];
+        // Find the space after XY and take everything after it
+        // Match: optional leading space, then 2 chars (XY), then whitespace, then filename
+        const match = line.match(/^\s*.{2}\s+(.+)$/);
+        if (match && match[1]) {
+          return match[1].trim();
+        }
+        // Fallback: find first space after position 2 and take everything after it
+        const trimmed = line.trim();
+        if (trimmed.length > 2) {
+          const spaceIndex = trimmed.indexOf(' ', 2);
+          if (spaceIndex > 0 && spaceIndex < trimmed.length - 1) {
+            return trimmed.substring(spaceIndex + 1).trim();
+          }
+        }
+      }
+    }
+    
+    // Try to get the most recently modified file from git log
+    const lastFile = execSync('git diff --name-only HEAD~1 HEAD 2>/dev/null || git ls-files -m | head -1', {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      shell: true
+    }).trim();
+    
+    return lastFile || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get recent commit messages (last N commits)
+ */
+export function getRecentCommits(cwd, count = 3) {
+  try {
+    const log = execSync(`git log -${count} --pretty=format:"%h|%s"`, {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    
+    if (!log) return [];
+    
+    return log.split('\n').map(line => {
+      const [hash, ...messageParts] = line.split('|');
+      return {
+        hash: hash || '',
+        message: messageParts.join('|') || ''
+      };
+    });
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Extract current task from recent commit messages
+ * Looks for patterns like "feat:", "fix:", "task:", etc.
+ */
+export function getCurrentTask(cwd) {
+  try {
+    const commits = getRecentCommits(cwd, 1);
+    if (commits.length > 0 && commits[0].message) {
+      const message = commits[0].message;
+      
+      // Try to extract task from commit message
+      // Patterns: "feat: description", "fix: description", "task: description"
+      const match = message.match(/^(feat|fix|task|chore|docs|refactor|test|perf|style):\s*(.+)/i);
+      if (match && match[2]) {
+        return match[2].trim();
+      }
+      
+      // Return first line of commit message
+      return message.split('\n')[0].trim();
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Check if directory is a git repository
+ */
+export function isGitRepo(cwd) {
+  try {
+    execSync('git rev-parse --git-dir', {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get system information
+ */
+export function getSystemInfo() {
+  return {
+    hostname: hostname(),
+    username: userInfo().username,
+    platform: process.platform,
+    nodeVersion: process.version
+  };
+}
+
+/**
+ * Get current Claude model being used
+ * Checks in order: ANTHROPIC_MODEL env var > CLAUDE_MODEL env var > settings.json
+ */
+export async function getCurrentModel() {
+  // Priority 1: Environment variables
+  const envModel = process.env.ANTHROPIC_MODEL || process.env.CLAUDE_MODEL;
+  if (envModel) {
+    return envModel;
+  }
+
+  // Priority 2: Read from ~/.claude/settings.json
+  try {
+    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    const settingsContent = await readFile(settingsPath, 'utf8');
+    const settings = JSON.parse(settingsContent);
+    if (settings.model) {
+      return settings.model;
+    }
+  } catch (e) {
+    // Settings file doesn't exist or doesn't have model - that's ok
+  }
+
+  // No explicit model configured - return null (will use session default)
+  return null;
+}
+
+/**
+ * Extract all session metadata for a given working directory
+ */
+export async function extractSessionMetadata(cwd) {
+  const systemInfo = getSystemInfo();
+  const isGit = isGitRepo(cwd);
+  const currentModel = await getCurrentModel();
+
+  const metadata = {
+    session_id: null, // Will be set by caller
+    project_name: await getProjectName(cwd),
+    working_directory: cwd,
+    last_file_edited: isGit ? getLastEditedFile(cwd) : null,
+    current_branch: isGit ? getCurrentBranch(cwd) : null,
+    commit_hash: isGit ? getCommitHash(cwd) : null,
+    recent_commits: isGit ? getRecentCommits(cwd, 3) : [],
+    current_task: isGit ? getCurrentTask(cwd) : null,
+    current_model: currentModel, // Claude model being used in this session
+    hostname: systemInfo.hostname,
+    username: systemInfo.username,
+    platform: systemInfo.platform,
+    node_version: systemInfo.nodeVersion,
+    is_git_repo: isGit
+    // Note: started_at is intentionally NOT set here - it should only be set once
+    // when the session is first created in the relay server, not on re-registration
+  };
+
+  return metadata;
+}
+

package/lib/session/mute-checker.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * Session mute status checker
+ * Checks if a session is muted and caches the result
+ */
+
+// Simple in-memory cache for mute status
+// Key: session_id, Value: { muted: boolean, timestamp: number }
+const muteCache = new Map();
+const CACHE_TTL = 60000; // 1 minute cache TTL
+
+/**
+ * Check if a session is muted
+ * @param {string} sessionId - Session ID to check
+ * @param {string} relayApiUrl - Relay API URL
+ * @param {string} relayApiKey - Relay API key for authentication
+ * @returns {Promise<boolean>} - True if session is muted, false otherwise
+ */
+export async function isSessionMuted(sessionId, relayApiUrl, relayApiKey) {
+  if (!sessionId || !relayApiUrl || !relayApiKey) {
+    return false; // Default to not muted if missing info
+  }
+
+  // Check cache first
+  const cached = muteCache.get(sessionId);
+  if (cached && (Date.now() - cached.timestamp) < CACHE_TTL) {
+    return cached.muted;
+  }
+
+  // Fetch from API
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 5000); // 5-second timeout
+  
+  try {
+    const response = await fetch(`${relayApiUrl}/api/sessions/${sessionId}`, {
+      headers: {
+        'Authorization': `Bearer ${relayApiKey}`,
+        'Content-Type': 'application/json'
+      },
+      signal: controller.signal
+    });
+
+    if (response.ok) {
+      const session = await response.json();
+      const muted = session.muted === true || session.meta?.muted === true;
+      
+      // Cache the result
+      muteCache.set(sessionId, {
+        muted,
+        timestamp: Date.now()
+      });
+      
+      return muted;
+    } else if (response.status === 404) {
+      // Session not found - default to not muted
+      return false;
+    } else {
+      // API error - use cached value if available, otherwise default to not muted
+      if (cached) {
+        return cached.muted;
+      }
+      return false;
+    }
+  } catch (error) {
+    // Network error or timeout - use cached value if available, otherwise default to not muted
+    if (error.name === 'AbortError') {
+      // Timeout occurred
+      if (cached) {
+        return cached.muted;
+      }
+      return false;
+    }
+    if (cached) {
+      return cached.muted;
+    }
+    // If no cache and API fails, default to not muted (fail open)
+    return false;
+  } finally {
+    // Always clear timeout to prevent memory leaks
+    clearTimeout(timeoutId);
+  }
+}
+
+/**
+ * Clear mute status cache for a session
+ * @param {string} sessionId - Session ID to clear from cache
+ */
+export function clearMuteCache(sessionId) {
+  if (sessionId) {
+    muteCache.delete(sessionId);
+  }
+}
+
+/**
+ * Clear all mute status cache
+ */
+export function clearAllMuteCache() {
+  muteCache.clear();
+}
+
+/**
+ * Get cache statistics (for debugging)
+ */
+export function getCacheStats() {
+  return {
+    size: muteCache.size,
+    entries: Array.from(muteCache.entries()).map(([id, data]) => ({
+      sessionId: id,
+      muted: data.muted,
+      age: Date.now() - data.timestamp
+    }))
+  };
+}
+

package/lib/session-registry/manager.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+/**
+ * Session Registry Module
+ * Tracks active coding sessions, their worktrees, and potential conflicts
+ */
+
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { getRepoRoot } from '../worktree/manager.js';
+
+const REGISTRY_DIR = join(homedir(), '.teleportation', 'session-registry');
+const REGISTRY_FILE = join(REGISTRY_DIR, 'sessions.json');
+
+/**
+ * Session entry structure
+ * @typedef {Object} SessionEntry
+ * @property {string} id - Session ID
+ * @property {string} agent - Agent type (claude-code, windsurf, cursor, etc.)
+ * @property {string} worktreePath - Path to worktree
+ * @property {string} branch - Branch name
+ * @property {string} repoRoot - Repository root path
+ * @property {number} startedAt - Timestamp when session started
+ * @property {number} lastActiveAt - Last activity timestamp
+ * @property {string} status - Session status (active, paused, completed)
+ * @property {Array<string>} modifiedFiles - List of modified files
+ */
+
+/**
+ * Load the session registry
+ * @returns {Promise<Array<SessionEntry>>}
+ */
+async function loadRegistry() {
+  await mkdir(REGISTRY_DIR, { recursive: true });
+
+  if (!existsSync(REGISTRY_FILE)) {
+    return [];
+  }
+
+  try {
+    const content = await readFile(REGISTRY_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`Failed to load registry: ${error.message}`);
+    return [];
+  }
+}
+
+/**
+ * Save the session registry
+ * @param {Array<SessionEntry>} sessions
+ * @returns {Promise<void>}
+ */
+async function saveRegistry(sessions) {
+  await mkdir(REGISTRY_DIR, { recursive: true, mode: 0o700 });
+  await writeFile(REGISTRY_FILE, JSON.stringify(sessions, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Register a new session
+ * @param {string} sessionId - Unique session identifier
+ * @param {string} agent - Agent type
+ * @param {string} worktreePath - Path to worktree
+ * @param {string} branch - Branch name
+ * @returns {Promise<SessionEntry>}
+ */
+export async function registerSession(sessionId, agent, worktreePath, branch) {
+  const sessions = await loadRegistry();
+
+  // Check if session already exists
+  const existing = sessions.find(s => s.id === sessionId);
+  if (existing) {
+    throw new Error(`Session ${sessionId} is already registered`);
+  }
+
+  const repoRoot = getRepoRoot();
+  const session = {
+    id: sessionId,
+    agent,
+    worktreePath,
+    branch,
+    repoRoot,
+    startedAt: Date.now(),
+    lastActiveAt: Date.now(),
+    status: 'active',
+    modifiedFiles: []
+  };
+
+  sessions.push(session);
+  await saveRegistry(sessions);
+
+  return session;
+}
+
+/**
+ * Update session activity
+ * @param {string} sessionId - Session identifier
+ * @param {Array<string>} modifiedFiles - Optional list of modified files
+ * @returns {Promise<void>}
+ */
+export async function updateSessionActivity(sessionId, modifiedFiles = null) {
+  const sessions = await loadRegistry();
+  const session = sessions.find(s => s.id === sessionId);
+
+  if (!session) {
+    throw new Error(`Session ${sessionId} not found`);
+  }
+
+  session.lastActiveAt = Date.now();
+  if (modifiedFiles !== null) {
+    session.modifiedFiles = modifiedFiles;
+  }
+
+  await saveRegistry(sessions);
+}
+
+/**
+ * Mark session as completed
+ * @param {string} sessionId - Session identifier
+ * @returns {Promise<void>}
+ */
+export async function completeSession(sessionId) {
+  const sessions = await loadRegistry();
+  const session = sessions.find(s => s.id === sessionId);
+
+  if (!session) {
+    throw new Error(`Session ${sessionId} not found`);
+  }
+
+  session.status = 'completed';
+  session.lastActiveAt = Date.now();
+
+  await saveRegistry(sessions);
+}
+
+/**
+ * Pause a session
+ * @param {string} sessionId - Session identifier
+ * @returns {Promise<void>}
+ */
+export async function pauseSession(sessionId) {
+  const sessions = await loadRegistry();
+  const session = sessions.find(s => s.id === sessionId);
+
+  if (!session) {
+    throw new Error(`Session ${sessionId} not found`);
+  }
+
+  session.status = 'paused';
+  session.lastActiveAt = Date.now();
+
+  await saveRegistry(sessions);
+}
+
+/**
+ * Resume a paused session
+ * @param {string} sessionId - Session identifier
+ * @returns {Promise<void>}
+ */
+export async function resumeSession(sessionId) {
+  const sessions = await loadRegistry();
+  const session = sessions.find(s => s.id === sessionId);
+
+  if (!session) {
+    throw new Error(`Session ${sessionId} not found`);
+  }
+
+  session.status = 'active';
+  session.lastActiveAt = Date.now();
+
+  await saveRegistry(sessions);
+}
+
+/**
+ * Remove a session from the registry
+ * @param {string} sessionId - Session identifier
+ * @returns {Promise<void>}
+ */
+export async function unregisterSession(sessionId) {
+  const sessions = await loadRegistry();
+  const filtered = sessions.filter(s => s.id !== sessionId);
+
+  if (filtered.length === sessions.length) {
+    throw new Error(`Session ${sessionId} not found`);
+  }
+
+  await saveRegistry(filtered);
+}
+
+/**
+ * List all sessions
+ * @param {string} status - Optional status filter
+ * @returns {Promise<Array<SessionEntry>>}
+ */
+export async function listSessions(status = null) {
+  const sessions = await loadRegistry();
+
+  if (status) {
+    return sessions.filter(s => s.status === status);
+  }
+
+  return sessions;
+}
+
+/**
+ * Get session by ID
+ * @param {string} sessionId - Session identifier
+ * @returns {Promise<SessionEntry|null>}
+ */
+export async function getSession(sessionId) {
+  const sessions = await loadRegistry();
+  return sessions.find(s => s.id === sessionId) || null;
+}
+
+/**
+ * Get active sessions in the current repository
+ * @returns {Promise<Array<SessionEntry>>}
+ */
+export async function getActiveSessionsInRepo() {
+  const repoRoot = getRepoRoot();
+  const sessions = await loadRegistry();
+
+  return sessions.filter(s => s.repoRoot === repoRoot && s.status === 'active');
+}
+
+/**
+ * Detect potential conflicts between sessions
+ * @param {string} sessionId - Session identifier to check
+ * @returns {Promise<Array<{sessionId: string, conflictingFiles: Array<string>}>>}
+ */
+export async function detectConflicts(sessionId) {
+  const session = await getSession(sessionId);
+  if (!session) {
+    throw new Error(`Session ${sessionId} not found`);
+  }
+
+  const activeSessions = await getActiveSessionsInRepo();
+  const conflicts = [];
+
+  for (const other of activeSessions) {
+    if (other.id === sessionId) {
+      continue;
+    }
+
+    // Check for overlapping modified files
+    const conflictingFiles = session.modifiedFiles.filter(file =>
+      other.modifiedFiles.includes(file)
+    );
+
+    if (conflictingFiles.length > 0) {
+      conflicts.push({
+        sessionId: other.id,
+        agent: other.agent,
+        branch: other.branch,
+        conflictingFiles
+      });
+    }
+  }
+
+  return conflicts;
+}
+
+/**
+ * Clean up stale sessions (inactive for > 24 hours)
+ * @returns {Promise<number>} Number of sessions cleaned up
+ */
+export async function cleanupStaleSessions() {
+  const sessions = await loadRegistry();
+  const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
+
+  const active = sessions.filter(s => {
+    // Keep completed sessions and recently active ones
+    if (s.status === 'completed') {
+      return s.lastActiveAt > oneDayAgo;
+    }
+    return s.lastActiveAt > oneDayAgo;
+  });
+
+  const removed = sessions.length - active.length;
+
+  if (removed > 0) {
+    await saveRegistry(active);
+  }
+
+  return removed;
+}
+
+/**
+ * Get session statistics
+ * @returns {Promise<{total: number, active: number, paused: number, completed: number}>}
+ */
+export async function getSessionStats() {
+  const sessions = await loadRegistry();
+
+  return {
+    total: sessions.length,
+    active: sessions.filter(s => s.status === 'active').length,
+    paused: sessions.filter(s => s.status === 'paused').length,
+    completed: sessions.filter(s => s.status === 'completed').length
+  };
+}