teleportation-cli 1.1.5 → 1.2.1

package/lib/teleport/session-capture.js

@@ -0,0 +1,282 @@
+/**
+ * Session Capture
+ *
+ * Captures the current state of a local coding session for teleportation.
+ * Captures git state, uncommitted changes, and session metadata.
+ *
+ * @module lib/teleport/session-capture
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { readFile, stat } from 'fs/promises';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+
+const execAsync = promisify(exec);
+
+/**
+ * Session state structure
+ * @typedef {Object} SessionState
+ * @property {string} sessionId - Teleportation session ID
+ * @property {GitState} git - Git repository state
+ * @property {string} [patch] - Base64-encoded uncommitted changes
+ * @property {string} cwd - Current working directory
+ * @property {Object} meta - Session metadata
+ */
+
+/**
+ * Git state structure
+ * @typedef {Object} GitState
+ * @property {string} repoUrl - Git remote URL (origin)
+ * @property {string} branch - Current branch name
+ * @property {string} commitSha - Current commit SHA
+ * @property {boolean} isDirty - Has uncommitted changes
+ * @property {boolean} hasUntracked - Has untracked files
+ * @property {string[]} stagedFiles - List of staged files
+ * @property {string[]} modifiedFiles - List of modified files
+ */
+
+/**
+ * Capture the current session state for teleportation.
+ *
+ * @param {string} sessionId - Session identifier
+ * @param {Object} [options={}] - Capture options
+ * @param {string} [options.cwd] - Working directory (defaults to process.cwd())
+ * @param {boolean} [options.includeUntracked=false] - Include untracked files in patch
+ * @param {string} [options.claudeSessionId] - Claude session ID for transcript lookup
+ * @returns {Promise<SessionState>} Captured session state
+ * @throws {Error} If not in a git repository or capture fails
+ */
+export async function captureSessionState(sessionId, options = {}) {
+  const cwd = options.cwd || process.cwd();
+
+  // Verify we're in a git repository
+  const isGitRepo = await isGitRepository(cwd);
+  if (!isGitRepo) {
+    throw new Error(`Not a git repository: ${cwd}`);
+  }
+
+  // Capture git state
+  const git = await captureGitState(cwd);
+
+  // Capture uncommitted changes as a patch
+  let patch = null;
+  if (git.isDirty || (options.includeUntracked && git.hasUntracked)) {
+    patch = await captureUncommittedChanges(cwd, options.includeUntracked);
+  }
+
+  // Build session state
+  const state = {
+    sessionId,
+    git,
+    patch,
+    cwd,
+    meta: {
+      capturedAt: new Date().toISOString(),
+      hostname: process.env.HOSTNAME || 'unknown',
+      platform: process.platform,
+      nodeVersion: process.version,
+    },
+  };
+
+  // Add Claude session info if available
+  if (options.claudeSessionId) {
+    state.meta.claudeSessionId = options.claudeSessionId;
+  }
+
+  return state;
+}
+
+/**
+ * Check if a directory is a git repository.
+ *
+ * @param {string} cwd - Directory to check
+ * @returns {Promise<boolean>} True if git repository
+ */
+export async function isGitRepository(cwd) {
+  try {
+    await execAsync('git rev-parse --is-inside-work-tree', { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Capture git repository state.
+ *
+ * @param {string} cwd - Repository directory
+ * @returns {Promise<GitState>} Git state
+ * @throws {Error} If git commands fail
+ */
+export async function captureGitState(cwd) {
+  // Get remote URL
+  let repoUrl;
+  try {
+    const { stdout } = await execAsync('git remote get-url origin', { cwd });
+    repoUrl = stdout.trim();
+  } catch {
+    throw new Error('No git remote "origin" configured');
+  }
+
+  // Get current branch
+  let branch;
+  try {
+    const { stdout } = await execAsync('git symbolic-ref --short HEAD', { cwd });
+    branch = stdout.trim();
+  } catch {
+    // Might be in detached HEAD state
+    try {
+      const { stdout } = await execAsync('git rev-parse --short HEAD', { cwd });
+      throw new Error(`Detached HEAD state at ${stdout.trim()}. Please checkout a branch before teleporting.`);
+    } catch (e) {
+      if (e.message.includes('Detached HEAD')) throw e;
+      throw new Error('Unable to determine current branch');
+    }
+  }
+
+  // Get current commit SHA
+  const { stdout: commitSha } = await execAsync('git rev-parse HEAD', { cwd });
+
+  // Check for uncommitted changes
+  const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd });
+  const statusLines = statusOutput.trim().split('\n').filter(Boolean);
+
+  const stagedFiles = [];
+  const modifiedFiles = [];
+  const untrackedFiles = [];
+
+  for (const line of statusLines) {
+    const index = line[0];
+    const workTree = line[1];
+    const file = line.slice(3);
+
+    if (index !== ' ' && index !== '?') {
+      stagedFiles.push(file);
+    }
+    if (workTree === 'M' || workTree === 'D') {
+      modifiedFiles.push(file);
+    }
+    if (index === '?' && workTree === '?') {
+      untrackedFiles.push(file);
+    }
+  }
+
+  return {
+    repoUrl,
+    branch,
+    commitSha: commitSha.trim(),
+    isDirty: stagedFiles.length > 0 || modifiedFiles.length > 0,
+    hasUntracked: untrackedFiles.length > 0,
+    stagedFiles,
+    modifiedFiles,
+    untrackedFiles,
+  };
+}
+
+/**
+ * Capture uncommitted changes as a base64-encoded patch.
+ *
+ * @param {string} cwd - Repository directory
+ * @param {boolean} [includeUntracked=false] - Include untracked files
+ * @returns {Promise<string|null>} Base64-encoded patch or null if no changes
+ */
+export async function captureUncommittedChanges(cwd, includeUntracked = false) {
+  let patch = '';
+
+  // Get staged changes
+  try {
+    const { stdout: staged } = await execAsync('git diff --cached', { cwd });
+    patch += staged;
+  } catch {
+    // No staged changes
+  }
+
+  // Get unstaged changes
+  try {
+    const { stdout: unstaged } = await execAsync('git diff', { cwd });
+    patch += unstaged;
+  } catch {
+    // No unstaged changes
+  }
+
+  // Optionally include untracked files
+  if (includeUntracked) {
+    try {
+      // Get list of untracked files
+      const { stdout: untrackedList } = await execAsync(
+        'git ls-files --others --exclude-standard',
+        { cwd }
+      );
+      const untrackedFiles = untrackedList.trim().split('\n').filter(Boolean);
+
+      // Create patches for untracked files (as new file diffs)
+      for (const file of untrackedFiles) {
+        try {
+          const content = await readFile(join(cwd, file), 'utf-8');
+          const lines = content.split('\n');
+          patch += `diff --git a/${file} b/${file}\n`;
+          patch += `new file mode 100644\n`;
+          patch += `--- /dev/null\n`;
+          patch += `+++ b/${file}\n`;
+          patch += `@@ -0,0 +1,${lines.length} @@\n`;
+          patch += lines.map(l => `+${l}`).join('\n') + '\n';
+        } catch {
+          // Skip files that can't be read
+        }
+      }
+    } catch {
+      // No untracked files
+    }
+  }
+
+  if (!patch.trim()) {
+    return null;
+  }
+
+  // Encode as base64 for safe transport
+  return Buffer.from(patch).toString('base64');
+}
+
+/**
+ * Find Claude session transcript path.
+ *
+ * @param {string} claudeSessionId - Claude session ID (UUID)
+ * @param {string} [projectSlug] - Project slug (defaults to cwd-based slug)
+ * @returns {Promise<string|null>} Path to transcript file or null if not found
+ */
+export async function findClaudeTranscript(claudeSessionId, projectSlug) {
+  const home = homedir();
+  const claudeDir = join(home, '.claude', 'projects');
+
+  // If project slug provided, check that directly
+  if (projectSlug) {
+    const transcriptPath = join(claudeDir, projectSlug, `${claudeSessionId}.jsonl`);
+    try {
+      await stat(transcriptPath);
+      return transcriptPath;
+    } catch {
+      return null;
+    }
+  }
+
+  // Otherwise, try to find by session ID across all projects
+  // This is a fallback - we'd need to search directories
+  return null;
+}
+
+/**
+ * Get the project slug for the current directory.
+ * Claude Code uses hyphenated paths like "-Users-kefentse-dev-project".
+ *
+ * @param {string} cwd - Current working directory
+ * @returns {string} Project slug
+ */
+export function getProjectSlug(cwd) {
+  // Claude Code converts path to slug by replacing / with -
+  // e.g., /Users/kefentse/dev/project -> -Users-kefentse-dev-project
+  return cwd.replace(/\//g, '-');
+}
+
+export default captureSessionState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teleportation-cli",
-  "version": "1.1.5",
+  "version": "1.2.1",
   "description": "Remote approval system for Claude Code - approve AI coding changes from your phone",
   "type": "module",
   "main": "teleportation-cli.cjs",
@@ -38,6 +38,8 @@
     "test:e2e": "bun --bun vitest run tests/e2e",
     "test:unit": "bun --bun vitest run tests/unit",
     "test:integration": "bun --bun vitest run tests/integration",
+    "test:local": "RELAY_URL=http://localhost:3030 bun --bun vitest run tests/integration",
+    "test:prod": "RELAY_URL=https://api.teleportation.dev bun --bun vitest run tests/integration",
     "test:production": "bun --bun vitest run tests/production",
     "dev:relay": "cd relay && bun run dev",
     "dev:mobile": "cd mobile-ui && bun run dev",
@@ -64,6 +66,8 @@
     "vitest": "^4.0.9"
   },
   "dependencies": {
-    "dotenv": "^17.2.3"
+    "@derivativelabs/agent-process": "github:dundas/agent-process",
+    "dotenv": "^17.2.3",
+    "uhr": "github:dundas/uhr"
   }
 }