teleportation-cli 1.1.5 → 1.2.1

package/lib/daemon/utils.js

@@ -0,0 +1,91 @@
+/**
+ * Daemon Utilities
+ * 
+ * Helper functions extracted from teleportation-daemon.js
+ */
+
+import { join } from 'path';
+import { appendFileSync } from 'fs';
+
+/**
+ * Cross-platform debug logging utility
+ */
+export function debugLog(filename, message, options = {}) {
+  const { enabled, logDir } = options;
+  if (!enabled) return;
+
+  try {
+    const logPath = join(logDir || '/tmp', filename);
+    appendFileSync(logPath, `[${new Date().toISOString()}] ${message}\n`);
+  } catch (error) {
+    console.error(`[daemon] Failed to write debug log: ${error.message}`);
+  }
+}
+
+/**
+ * Truncate output for logging and storage
+ */
+export function truncateOutput(output, label) {
+  const MAX_OUTPUT_SIZE = 100_000; // 100KB
+  if (!output || output.length <= MAX_OUTPUT_SIZE) return output;
+  
+  console.log(`[daemon] Truncating ${label} (${output.length} -> ${MAX_OUTPUT_SIZE} chars)`);
+  return output.slice(0, MAX_OUTPUT_SIZE) + `\n\n... (output truncated, total size: ${output.length} characters) ...`;
+}
+
+/**
+ * Sanitize for log (remove sensitive info)
+ */
+export function sanitizeForLog(data) {
+  if (!data) return data;
+  // Simple sanitization - in a real app, use a more robust library
+  return String(data).replace(/Bearer\s+[a-zA-Z0-9._-]+/g, 'Bearer [REDACTED]');
+}
+
+/**
+ * Validation helpers
+ */
+export function validateSessionId(session_id) {
+  if (!session_id || typeof session_id !== 'string') {
+    throw new Error('session_id must be a non-empty string');
+  }
+  if (session_id.length > 256) {
+    throw new Error('session_id too long (max 256 characters)');
+  }
+  // Allow @ and . for user@host format
+  if (!/^[a-zA-Z0-9_@.-]+$/.test(session_id)) {
+    throw new Error('session_id contains invalid characters (only alphanumeric, dash, underscore, @, . allowed)');
+  }
+  return session_id;
+}
+
+export function validateApprovalId(approval_id) {
+  if (!approval_id || typeof approval_id !== 'string') {
+    throw new Error('approval_id must be a non-empty string');
+  }
+  if (approval_id.length > 256) {
+    throw new Error('approval_id too long (max 256 characters)');
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(approval_id)) {
+    throw new Error('approval_id contains invalid characters');
+  }
+  return approval_id;
+}
+
+export function validateToolName(tool_name) {
+  if (!tool_name || typeof tool_name !== 'string') {
+    throw new Error('tool_name must be a non-empty string');
+  }
+  return tool_name;
+}
+
+/**
+ * Build tool execution prompt
+ */
+export function buildToolPrompt(tool_name, tool_input) {
+  const input = tool_input || {};
+  return JSON.stringify({
+    tool: tool_name,
+    parameters: input
+  });
+}

package/lib/install/installer.js

@@ -79,6 +79,25 @@ export function checkClaudeCode() {
   };
 }
 
+/**
+ * Check if Gemini CLI is installed
+ */
+export function checkGeminiCli() {
+  try {
+    const geminiPath = execSync('which gemini', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (geminiPath) {
+      return { valid: true, path: geminiPath };
+    }
+  } catch (e) {
+    // Gemini not found
+  }
+  
+  return {
+    valid: false,
+    error: 'Gemini CLI not found in PATH.'
+  };
+}
+
 /**
  * Ensure required directories exist
  */
@@ -91,7 +110,8 @@ export async function ensureDirectories() {
     settingsDir,
     hooksDir,
     join(HOME_DIR, '.teleportation'),
-    join(HOME_DIR, '.teleportation', 'daemon')
+    join(HOME_DIR, '.teleportation', 'daemon'),
+    join(HOME_DIR, '.gemini', 'hooks')
   ];
 
   for (const dir of dirs) {
@@ -121,8 +141,43 @@ export async function verifyHooks(sourceHooksDir) {
     'notification.mjs',
     'user_prompt_submit.mjs',  // Handles /model command detection
     'config-loader.mjs',
-    'session-register.mjs',
-    'heartbeat.mjs'  // Spawned by session-register.mjs, needs to be in hooks directory
+    'session-register.mjs'
+  ];
+
+  const found = [];
+  const missing = [];
+
+  for (const hook of hooks) {
+    const hookPath = join(sourceHooksDir, hook);
+    try {
+      await stat(hookPath);
+      // Set executable permissions (755)
+      try {
+        await chmod(hookPath, 0o755);
+      } catch (_) {
+        // Ignore chmod errors
+      }
+      found.push(hook);
+    } catch (e) {
+      if (e.code === 'ENOENT') {
+        missing.push(hook);
+      }
+    }
+  }
+
+  return { found, missing };
+}
+
+/**
+ * Verify Gemini hooks exist in source directory
+ */
+export async function verifyGeminiHooks(sourceHooksDir) {
+  const hooks = [
+    'before_tool.mjs',
+    'after_tool.mjs',
+    'session_start.mjs',
+    'session_end.mjs',
+    'after_agent.mjs'
   ];
 
   const found = [];
@@ -186,6 +241,72 @@ export async function installHooks(sourceHooksDir) {
   };
 }
 
+/**
+ * Install Gemini hooks to ~/.gemini/hooks and update settings
+ */
+export async function installGeminiHooks(sourceGeminiHooksDir) {
+  const result = await verifyGeminiHooks(sourceGeminiHooksDir);
+  const destHooksDir = join(HOME_DIR, '.gemini', 'hooks');
+  const copyFailed = [];
+
+  try {
+    await mkdir(destHooksDir, { recursive: true });
+  } catch (e) {
+    if (e.code !== 'EEXIST') {
+      throw e;
+    }
+  }
+
+  // Copy hooks
+  for (const hook of result.found) {
+    const sourcePath = join(sourceGeminiHooksDir, hook);
+    const destPath = join(destHooksDir, hook);
+    try {
+      await copyFile(sourcePath, destPath);
+      await chmod(destPath, 0o755);
+    } catch (e) {
+      copyFailed.push({ file: hook, error: e.message });
+    }
+  }
+
+  // Update ~/.gemini/settings.json
+  const settingsPath = join(HOME_DIR, '.gemini', 'settings.json');
+  let settings = {};
+  
+  try {
+    if (await stat(settingsPath).catch(() => false)) {
+      const content = await readFile(settingsPath, 'utf8');
+      settings = JSON.parse(content);
+    }
+  } catch (e) {
+    // Ignore error, start with empty settings
+  }
+
+  // Merge hooks config
+  settings.tools = { ...settings.tools, enableHooks: true };
+  settings.hooks = settings.hooks || {};
+  
+  const hooksConfig = {
+    BeforeTool: [{ command: `node ${join(destHooksDir, 'before_tool.mjs')}`, timeout: 65000 }],
+    AfterTool: [{ command: `node ${join(destHooksDir, 'after_tool.mjs')}`, timeout: 10000 }],
+    SessionStart: [{ command: `node ${join(destHooksDir, 'session_start.mjs')}`, timeout: 15000 }],
+    AfterAgent: [{ command: `node ${join(destHooksDir, 'after_agent.mjs')}`, timeout: 15000 }],
+    SessionEnd: [{ command: `node ${join(destHooksDir, 'session_end.mjs')}`, timeout: 10000 }]
+  };
+
+  // Standardize: Ensure BeforeAgent is also set if needed (parity with Claude's UserPromptSubmit)
+  // For now, we follow the PRD-0024 spec
+  Object.assign(settings.hooks, hooksConfig);
+
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2));
+
+  return {
+    installed: result.found,
+    failed: result.missing.map(hook => ({ file: hook, error: 'File not found' })).concat(copyFailed),
+    settingsPath
+  };
+}
+
 /**
  * Copy daemon files to ~/.teleportation/daemon/
  */
@@ -195,7 +316,6 @@ export async function installDaemon() {
 
   const daemonFiles = [
     'teleportation-daemon.js',
-    'pid-manager.js',
     'lifecycle.js'
   ];
 
@@ -311,7 +431,7 @@ export async function installLibFiles() {
     { subdir: 'auth', files: ['credentials.js', 'api-key.js'] },
     { subdir: 'session', files: ['metadata.js'] },
     { subdir: 'config', files: ['manager.js'] },
-    { subdir: 'daemon', files: ['lifecycle.js', 'pid-manager.js'] }  // Required for heartbeat daemon auto-start
+    { subdir: 'daemon', files: ['lifecycle.js', 'transcript-ingestion.js'] }  // Required for daemon auto-start and real-time transcript ingestion
   ];
 
   const installed = [];
@@ -503,26 +623,70 @@ export async function verifyInstallation() {
  * - Hooks stay in PROJECT/.claude/hooks/ (source files, just verify they exist)
  * - Settings created in PROJECT/.claude/settings.json with absolute paths
  * - Daemon copied to ~/.teleportation/daemon/ (shared across projects)
+ * 
+ * Global installation (Gemini):
+ * - Gemini hooks copied to ~/.gemini/hooks/
+ * - Global ~/.gemini/settings.json updated
+ * 
+ * @param {string} sourceHooksDir - Source directory for Claude hooks
+ * @param {Object} [options] - Installation options
+ * @param {boolean} [options.includeClaude] - Force include Claude hooks (overrides detection)
+ * @param {boolean} [options.includeGemini] - Force include Gemini hooks (overrides detection)
  */
-export async function install(sourceHooksDir) {
+export async function install(sourceHooksDir, options = {}) {
   // Pre-flight checks
   const nodeCheck = checkNodeVersion();
   if (!nodeCheck.valid) {
     throw new Error(nodeCheck.error);
   }
 
+  // Check available CLIs
   const claudeCheck = checkClaudeCode();
-  if (!claudeCheck.valid) {
-    throw new Error(claudeCheck.error);
+  const geminiCheck = checkGeminiCli();
+  
+  // Resolve what to install based on options and detection
+  const shouldInstallClaude = options.includeClaude !== undefined 
+    ? options.includeClaude 
+    : claudeCheck.valid;
+    
+  const shouldInstallGemini = options.includeGemini !== undefined 
+    ? options.includeGemini 
+    : geminiCheck.valid;
+
+  if (!shouldInstallClaude && !shouldInstallGemini) {
+    if (options.includeClaude === false && options.includeGemini === false) {
+      throw new Error('No targets selected for installation.');
+    }
+    throw new Error('Neither Claude Code nor Gemini CLI found. Please install one of them first, or specify a target.');
   }
 
   // Create directories
   await ensureDirectories();
 
-  // Install hooks (verify and copy to destination)
-  const hookResult = await installHooks(sourceHooksDir);
-  if (hookResult.failed.length > 0) {
-    throw new Error(`Failed to install hooks: ${hookResult.failed.map(f => f.file).join(', ')}`);
+  let hooksInstalled = 0;
+  let geminiHooksInstalled = 0;
+
+  // 1. Install Claude hooks
+  if (shouldInstallClaude) {
+    const hookResult = await installHooks(sourceHooksDir);
+    if (hookResult.failed.length > 0) {
+      throw new Error(`Failed to install Claude hooks: ${hookResult.failed.map(f => f.file).join(', ')}`);
+    }
+    hooksInstalled = hookResult.installed.length;
+    // Create project-level settings with absolute paths for Claude
+    await createSettings();
+  }
+
+  // 2. Install Gemini hooks
+  if (shouldInstallGemini) {
+    // Determine Gemini hooks source directory (sibling to .claude/hooks)
+    const sourceGeminiHooksDir = join(dirname(sourceHooksDir), '..', '.gemini', 'hooks');
+    const geminiResult = await installGeminiHooks(sourceGeminiHooksDir);
+    if (geminiResult.failed.length > 0) {
+      console.warn(`Warning: Some Gemini hooks failed to install: ${geminiResult.failed.map(f => f.file).join(', ')}`);
+    } else {
+      geminiHooksInstalled = geminiResult.installed.length;
+    }
   }
 
   // Install daemon (still goes to ~/.teleportation/daemon/)
@@ -544,21 +708,21 @@ export async function install(sourceHooksDir) {
     console.warn(`Warning: Some lib files failed to install: ${libResult.failed.map(f => f.file).join(', ')}`);
   }
 
-  // Create project-level settings with absolute paths
-  await createSettings();
-
   // Write version file
   await writeVersionFile();
 
-  // Verify
-  const verification = await verifyInstallation();
-  if (!verification.valid) {
-    throw new Error(`Installation verification failed: ${verification.error}`);
+  // Verify (only checking Claude verification if Claude is installed)
+  if (claudeCheck.valid) {
+    const verification = await verifyInstallation();
+    if (!verification.valid) {
+      throw new Error(`Installation verification failed: ${verification.error}`);
+    }
   }
 
   return {
     success: true,
-    hooksInstalled: hookResult.installed.length,
+    hooksInstalled,
+    geminiHooksInstalled,
     daemonInstalled: daemonResult.installed.length,
     libFilesInstalled: libResult.installed.length,
     settingsFile: getProjectSettings(),

package/lib/install/uhr-installer.js

@@ -0,0 +1,136 @@
+/**
+ * UHR (Universal Hook Registry) installer wrapper for Teleportation.
+ *
+ * Provides functions to install and uninstall teleportation hooks via the UHR CLI.
+ * Falls back gracefully when UHR is not available -- callers can check with
+ * `isUhrAvailable()` and use direct installation (installer.js) as a fallback.
+ *
+ * The manifest file (teleportation.uhr.json) uses `__HOOKS_DIR__` as a placeholder
+ * in hook commands. This module replaces that placeholder with the actual absolute
+ * path to the hooks directory before passing the manifest to UHR.
+ *
+ * @module lib/install/uhr-installer
+ */
+
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+/**
+ * Check if the UHR CLI is available on this system.
+ *
+ * Checks two locations:
+ *   1. `uhr` on the system PATH (via `which uhr`)
+ *   2. `node_modules/.bin/uhr` (local project install)
+ *
+ * @returns {Promise<boolean>} true if UHR CLI is reachable
+ */
+export async function isUhrAvailable() {
+  // Check PATH first
+  try {
+    execSync('which uhr', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return true;
+  } catch (_) {
+    // Not in PATH
+  }
+
+  // Check local node_modules
+  try {
+    const localBin = join('node_modules', '.bin', 'uhr');
+    const file = Bun.file(localBin);
+    return await file.exists();
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Install hooks via the UHR CLI.
+ *
+ * Reads the manifest at `manifestPath`, replaces every occurrence of the
+ * `__HOOKS_DIR__` placeholder with the absolute `hooksDir` path, writes a
+ * temporary manifest, and runs `uhr install <tempManifest>`.
+ *
+ * @param {string} manifestPath - Absolute path to the UHR manifest file (e.g. teleportation.uhr.json)
+ * @param {string} hooksDir     - Absolute path to the hooks directory
+ * @param {object} [options]    - Reserved for future use (e.g. dryRun)
+ * @returns {Promise<{success: true, warnings: string[]} | {success: false, reason: string}>}
+ */
+export async function installViaUhr(manifestPath, hooksDir, options = {}) {
+  // 1. Read the manifest
+  let manifestText;
+  try {
+    const file = Bun.file(manifestPath);
+    manifestText = await file.text();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, reason: `Failed to read manifest file: ${msg}` };
+  }
+
+  // 2. Parse to validate JSON
+  let manifest;
+  try {
+    manifest = JSON.parse(manifestText);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, reason: `Failed to parse manifest JSON: ${msg}` };
+  }
+
+  // 3. Replace __HOOKS_DIR__ placeholder with the actual absolute path
+  const templated = JSON.stringify(manifest, null, 2).replaceAll('__HOOKS_DIR__', hooksDir);
+
+  // 4. Write to a temp file
+  const tempManifestPath = join(tmpdir(), `teleportation-uhr-${Date.now()}.json`);
+  try {
+    await Bun.write(tempManifestPath, templated);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, reason: `Failed to write temp manifest: ${msg}` };
+  }
+
+  // 5. Run uhr install
+  const warnings = [];
+  try {
+    const output = execSync(`uhr install ${tempManifestPath}`, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 30000,
+    });
+
+    // Collect any warning lines from stdout
+    if (output) {
+      const lines = output.split('\n').filter(Boolean);
+      for (const line of lines) {
+        if (/warn/i.test(line)) {
+          warnings.push(line.trim());
+        }
+      }
+    }
+
+    return { success: true, warnings };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, reason: msg || 'uhr install failed' };
+  }
+}
+
+/**
+ * Uninstall hooks via the UHR CLI.
+ *
+ * Runs `uhr uninstall <serviceName>` to remove previously installed hooks.
+ *
+ * @param {string} serviceName - The service name to uninstall (e.g. "teleportation")
+ * @returns {Promise<{success: boolean}>}
+ */
+export async function uninstallViaUhr(serviceName) {
+  try {
+    execSync(`uhr uninstall ${serviceName}`, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 30000,
+    });
+    return { success: true };
+  } catch (_) {
+    return { success: false };
+  }
+}

package/lib/remote/providers/base-provider.js

@@ -404,4 +404,50 @@ export class BaseProvider {
       errors,
     };
   }
+
+  /**
+   * Check provider health and connectivity.
+   *
+   * Tests connection to the provider's API and returns health status.
+   * Subclasses should override this to add provider-specific checks.
+   *
+   * @returns {Promise<Object>} Health check result
+   * @returns {boolean} return.healthy - Whether the provider is healthy
+   * @returns {string} return.provider - Provider name
+   * @returns {Object} [return.details] - Additional health details
+   * @returns {string} [return.error] - Error message if unhealthy
+   */
+  async checkHealth() {
+    // Default implementation - subclasses should override
+    return {
+      healthy: true,
+      provider: this.constructor.name,
+      details: {
+        message: 'Health check not implemented for this provider',
+      },
+    };
+  }
+
+  /**
+   * Get provider capabilities.
+   *
+   * Returns information about what this provider supports.
+   * Subclasses should override to provide accurate capabilities.
+   *
+   * @returns {Object} Provider capabilities
+   * @returns {boolean} return.supportsCheckpoints - Can create/restore checkpoints
+   * @returns {boolean} return.supportsSnapshots - Can create/restore snapshots
+   * @returns {boolean} return.supportsHibernation - Can hibernate/wake machines
+   * @returns {boolean} return.supportsAutoStop - Supports auto-stop when idle
+   * @returns {number} [return.checkpointTime] - Estimated checkpoint time in ms
+   * @returns {number} [return.coldStartTime] - Estimated cold start time in ms
+   */
+  getCapabilities() {
+    return {
+      supportsCheckpoints: false,
+      supportsSnapshots: false,
+      supportsHibernation: false,
+      supportsAutoStop: false,
+    };
+  }
 }

package/lib/remote/providers/daytona-provider.js

@@ -273,6 +273,8 @@ for i in 1 2 3 4 5; do
 done
 
 # Start teleportation daemon
+# Mark this as a cloud session so the frontend can show the cloud badge
+export TELEPORTATION_IS_CLOUD=true
 bun teleportation-cli.cjs daemon start --session-id ${safeSessionId} --task ${safeTask}
 `.trim();
   }
@@ -503,4 +505,60 @@ bun teleportation-cli.cjs daemon start --session-id ${safeSessionId} --task ${sa
 
     return response.json();
   }
+
+  /**
+   * Get provider capabilities
+   *
+   * @returns {Object} Provider capabilities
+   */
+  getCapabilities() {
+    return {
+      supportsCheckpoints: false,
+      supportsSnapshots: true,
+      supportsHibernation: false,
+      supportsAutoStop: true,
+      autoStopTimeout: 1800000, // 30 minutes default
+      provider: 'daytona',
+    };
+  }
+
+  /**
+   * Check provider health
+   *
+   * @returns {Promise<Object>} Health check result
+   */
+  async checkHealth() {
+    try {
+      // Try to list workspaces - if this works, the API is healthy
+      const url = `${this.apiUrl}/workspace`;
+      const response = await this._fetchWithTimeout(url, {
+        method: 'GET',
+        headers: this._headers(),
+      }, 10000); // 10 second timeout for health check
+
+      if (!response.ok) {
+        return {
+          healthy: false,
+          provider: 'daytona',
+          error: `API returned status ${response.status}`,
+        };
+      }
+
+      return {
+        healthy: true,
+        provider: 'daytona',
+        details: {
+          apiUrl: this.apiUrl,
+          profileId: this.profileId,
+          timestamp: new Date().toISOString(),
+        },
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: 'daytona',
+        error: error.message,
+      };
+    }
+  }
 }