@edgedive/cli 0.2.1 → 0.3.1

package/src/commands/local.ts

@@ -1,286 +0,0 @@
-/**
- * Local command - download agent session for local development
- */
-
-import chalk from 'chalk';
-import { ConfigManager } from '../config/config-manager.js';
-import { EdgediveApiClient, type TakeoverResponse } from '../api/client.js';
-import { SessionDownloader } from '../utils/session-downloader.js';
-import { GitUtils } from '../utils/git-utils.js';
-import { launchClaudeSession } from '../utils/claude-launcher.js';
-
-interface LocalOptions {
-  prUrl?: string;
-  issueUrl?: string;
-  threadUrl?: string;
-  taskUrl?: string;
-  sessionUrl?: string;
-  worktree?: boolean;
-}
-
-export async function localCommand({
-  prUrl,
-  issueUrl,
-  threadUrl,
-  taskUrl,
-  sessionUrl,
-  worktree,
-}: LocalOptions): Promise<void> {
-  const configManager = new ConfigManager();
-  const apiClient = new EdgediveApiClient(configManager);
-  const downloader = new SessionDownloader();
-
-  try {
-    console.log(chalk.bold('\n🔧 Edgedive Local Session Setup\n'));
-
-    // Check for Windows platform
-    if (process.platform === 'win32') {
-      console.log(chalk.red('❌ Windows is not currently supported for the local command.\n'));
-      console.log(chalk.yellow('Please use macOS or Linux to work on sessions locally.\n'));
-      process.exit(1);
-    }
-
-    // Check if authenticated
-    if (!(await configManager.isAuthenticated())) {
-      console.log(chalk.red('❌ You are not logged in.\n'));
-      console.log(chalk.yellow('Please run: edgedive login\n'));
-      process.exit(1);
-    }
-
-    if (!prUrl && !issueUrl && !threadUrl && !taskUrl && !sessionUrl) {
-      console.log(chalk.red('❌ Missing session identifier.\n'));
-      console.log(
-        chalk.yellow(
-          'Provide one of:\n' +
-            '  --pr-url https://github.com/owner/repo/pull/123\n' +
-            '  --issue-url https://linear.app/...\n' +
-            '  --thread-url https://workspace.slack.com/archives/C12345/p1234567890123456\n' +
-            '  --task-url https://app.asana.com/0/PROJECT_ID/TASK_ID\n' +
-            '  --session-url https://app.edgedive.com/agent-sessions?session={session_id}\n'
-        )
-      );
-      process.exit(1);
-    }
-
-    let sessionData;
-
-    if (prUrl) {
-      // Validate PR URL format
-      const prUrlPattern = /^https?:\/\/github\.com\/([^\/]+)\/([^\/]+)\/pull\/(\d+)/;
-      if (!prUrlPattern.test(prUrl)) {
-        console.log(chalk.red('❌ Invalid PR URL format.\n'));
-        console.log(chalk.yellow('Expected format: https://github.com/owner/repo/pull/123\n'));
-        process.exit(1);
-      }
-
-      console.log(chalk.dim(`PR URL: ${prUrl}\n`));
-      console.log('🔍 Fetching session information...\n');
-      sessionData = await apiClient.getTakeoverByPrUrl(prUrl);
-    } else if (issueUrl) {
-      console.log(chalk.dim(`Linear Issue URL: ${issueUrl}\n`));
-      console.log('🔍 Fetching session information...\n');
-      sessionData = await apiClient.getTakeoverByLinearIssueUrl(issueUrl);
-    } else if (taskUrl) {
-      // Validate it's an Asana URL — let the server handle detailed format parsing
-      const asanaTaskPattern = /^https?:\/\/app\.asana\.com\//;
-      if (!asanaTaskPattern.test(taskUrl)) {
-        console.log(
-          chalk.red(
-            '❌ Invalid Asana task URL. Expected a URL starting with https://app.asana.com/\n'
-          )
-        );
-        process.exit(1);
-      }
-
-      console.log(chalk.dim(`Asana Task URL: ${taskUrl}\n`));
-      console.log('🔍 Fetching session information...\n');
-      sessionData = await apiClient.getTakeoverByAsanaTaskUrl(taskUrl);
-    } else if (sessionUrl) {
-      // Validate session URL format
-      const sessionUrlPattern = /^https?:\/\/[^\/]+\/agent-sessions\?session=([a-f0-9-]+)/i;
-      if (!sessionUrlPattern.test(sessionUrl)) {
-        console.log(chalk.red('❌ Invalid session URL format.\n'));
-        console.log(
-          chalk.yellow(
-            'Expected format: https://app.edgedive.com/agent-sessions?session={session_id}\n'
-          )
-        );
-        process.exit(1);
-      }
-
-      console.log(chalk.dim(`Session URL: ${sessionUrl}\n`));
-      console.log('🔍 Fetching session information...\n');
-      sessionData = await apiClient.getTakeoverBySessionUrl(sessionUrl);
-    } else {
-      // Validate Slack thread URL format
-      const slackThreadPattern = /^https?:\/\/[^\/]+\.slack\.com\/archives\/([A-Z0-9]+)\/p(\d{16})/;
-      if (!slackThreadPattern.test(threadUrl!)) {
-        console.log(chalk.red('❌ Invalid Slack thread URL format.\n'));
-        console.log(
-          chalk.yellow(
-            'Expected format: https://workspace.slack.com/archives/C12345/p1234567890123456\n'
-          )
-        );
-        process.exit(1);
-      }
-
-      console.log(chalk.dim(`Slack Thread URL: ${threadUrl}\n`));
-      console.log('🔍 Fetching session information...\n');
-      sessionData = await apiClient.getTakeoverBySlackThreadUrl(threadUrl!);
-    }
-
-    console.log(chalk.green('✅ Found agent session!\n'));
-    if (sessionData.github_pr?.url) {
-      console.log(chalk.dim(`PR URL: ${sessionData.github_pr.url}`));
-    }
-    console.log(chalk.bold('Session Information:'));
-    console.log(chalk.dim(`  Session ID: ${sessionData.session_id}`));
-    console.log(chalk.dim(`  Agent Type: ${sessionData.agent_type}`));
-    console.log(chalk.dim(`  Status: ${sessionData.status}`));
-    console.log(
-      chalk.dim(`  Repository: ${sessionData.repository.owner}/${sessionData.repository.name}`)
-    );
-    console.log(chalk.dim(`  Branch: ${sessionData.repository.branch}`));
-
-    if (sessionData.linear_issue) {
-      console.log(chalk.dim(`  Linear Issue: ${sessionData.linear_issue.identifier}`));
-      console.log(chalk.dim(`  Linear URL: ${sessionData.linear_issue.url}`));
-    }
-
-    if (sessionData.asana_task) {
-      console.log(chalk.dim(`  Asana Task: ${sessionData.asana_task.url}`));
-    }
-
-    // Verify current repository matches PR source
-    const cwd = process.cwd();
-    let repoInfo;
-
-    try {
-      repoInfo = await GitUtils.verifyRepoMatches(
-        sessionData.repository.owner,
-        sessionData.repository.name,
-        cwd
-      );
-    } catch (error: any) {
-      console.error(chalk.red(`\n❌ ${error.message}\n`));
-      console.log(
-        chalk.yellow('Run this command from within the target repository checked out locally.')
-      );
-      process.exit(1);
-    }
-
-    console.log(chalk.green(`✅ Using repository at ${repoInfo.rootPath}`));
-
-    // Ensure PR branch is checked out locally or in a worktree
-    let workingPath = repoInfo.rootPath;
-    try {
-      if (worktree) {
-        workingPath = await GitUtils.ensureBranchInWorktree(
-          sessionData.repository.branch,
-          repoInfo.rootPath
-        );
-        console.log(
-          chalk.green(
-            `✅ Created worktree for branch ${sessionData.repository.branch} at ${workingPath}`
-          )
-        );
-      } else {
-        await GitUtils.ensureBranchCheckedOut(sessionData.repository.branch, repoInfo.rootPath);
-        console.log(chalk.green(`✅ Checked out branch ${sessionData.repository.branch}`));
-      }
-    } catch (error: any) {
-      console.error(
-        chalk.red(
-          `\n❌ Failed to ${worktree ? 'create worktree for' : 'checkout'} branch ${sessionData.repository.branch}: ${error.message}\n`
-        )
-      );
-      console.log(chalk.yellow('Resolve the git issue above and rerun the local command.'));
-      process.exit(1);
-    }
-
-    // Download session files into Claude projects directory
-    // Use workingPath so the session goes to the correct directory (worktree path if --worktree is used)
-    const { claudeSessionId, claudeSessionPath } = await downloader.downloadSession(
-      sessionData,
-      workingPath
-    );
-
-    console.log(chalk.blue(`\n🚀 Launching Claude session ${claudeSessionId}...\n`));
-
-    try {
-      const sessionEndInfo = await launchClaudeSession(claudeSessionId, workingPath);
-      console.log(chalk.green('\n✅ Claude session closed. Happy debugging!\n'));
-
-      // Upload Claude session file back to server
-      // Use the session info from the SessionEnd hook if available, otherwise fall back to original path
-      await uploadClaudeSessionFile(
-        apiClient,
-        sessionData,
-        sessionEndInfo || { claudeSessionPath }
-      );
-    } catch (error: any) {
-      console.error(chalk.red(`\n❌ Failed to start Claude automatically: ${error.message}\n`));
-      console.log(
-        chalk.yellow(
-          `You can resume manually with: claude -r ${claudeSessionId} (from ${workingPath})`
-        )
-      );
-      process.exit(1);
-    }
-  } catch (error: any) {
-    console.error(chalk.red(`\n❌ Local command failed: ${error.message}\n`));
-
-    if (error.message.includes('401') || error.message.includes('Unauthorized')) {
-      console.log(chalk.yellow('Your session may have expired. Please run: edgedive login\n'));
-    }
-
-    process.exit(1);
-  }
-}
-
-/**
- * Upload Claude session file back to Edgedive after local development
- */
-async function uploadClaudeSessionFile(
-  apiClient: EdgediveApiClient,
-  sessionData: TakeoverResponse,
-  sessionInfo: { transcript_path?: string; claudeSessionPath?: string }
-): Promise<void> {
-  try {
-    const fs = (await import('fs/promises')).default;
-
-    // Use transcript_path from SessionEnd hook if available, otherwise fall back to original path
-    const sessionFilePath = sessionInfo.transcript_path || sessionInfo.claudeSessionPath;
-
-    if (!sessionFilePath) {
-      console.log(chalk.yellow('⚠️  No Claude session file path available, skipping upload'));
-      return;
-    }
-
-    // Check if file exists
-    try {
-      await fs.access(sessionFilePath);
-    } catch {
-      console.log(
-        chalk.yellow(`⚠️  Claude session file not found at ${sessionFilePath}, skipping upload`)
-      );
-      return;
-    }
-
-    console.log(chalk.blue('📤 Uploading Claude session...'));
-
-    // Read file content
-    const fileContent = await fs.readFile(sessionFilePath);
-
-    // Upload to server
-    await apiClient.uploadClaudeSession(sessionData.session_id, fileContent);
-
-    console.log(chalk.green('✅ Claude session uploaded successfully\n'));
-  } catch (error: any) {
-    // Don't fail the whole command if upload fails
-    console.error(chalk.yellow(`⚠️  Failed to upload Claude session: ${error.message}`));
-    console.error(
-      chalk.yellow('   Your local changes are safe, but were not synced to the server.\n')
-    );
-  }
-}

package/src/commands/login.ts

@@ -1,48 +0,0 @@
-/**
- * Login command - initiates OAuth flow
- */
-
-import chalk from 'chalk';
-import { ConfigManager } from '../config/config-manager.js';
-import { OAuthFlow } from '../auth/oauth-flow.js';
-
-export async function loginCommand(): Promise<void> {
-  const configManager = new ConfigManager();
-  const oauthFlow = new OAuthFlow(configManager);
-
-  try {
-    console.log(chalk.bold('\n🚀 Edgedive CLI Login\n'));
-
-    // Check if already authenticated
-    if (await configManager.isAuthenticated()) {
-      console.log(chalk.yellow('✓ You are already logged in!'));
-      console.log(chalk.dim(`Config: ${configManager.getConfigPath()}\n`));
-
-      const { default: inquirer } = await import('inquirer');
-      const { reauth } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'reauth',
-          message: 'Do you want to re-authenticate?',
-          default: false,
-        },
-      ]);
-
-      if (!reauth) {
-        process.exit(0);
-      }
-    }
-
-    // Start OAuth flow
-    const tokenResponse = await oauthFlow.authorize();
-
-    console.log(chalk.green.bold('✅ Successfully logged in!\n'));
-    console.log(chalk.dim(`Token type: ${tokenResponse.token_type}`));
-    console.log(chalk.dim(`Expires in: ${Math.floor(tokenResponse.expires_in / 86400)} days`));
-    console.log(chalk.dim(`Config saved to: ${configManager.getConfigPath()}\n`));
-    process.exit(0);
-  } catch (error: any) {
-    console.error(chalk.red(`\n❌ Login failed: ${error.message}\n`));
-    process.exit(1);
-  }
-}

package/src/commands/logout.ts

@@ -1,29 +0,0 @@
-/**
- * Logout command - removes stored credentials
- */
-
-import chalk from 'chalk';
-import { ConfigManager } from '../config/config-manager.js';
-
-export async function logoutCommand(): Promise<void> {
-  const configManager = new ConfigManager();
-
-  try {
-    console.log(chalk.bold('\n👋 Edgedive CLI Logout\n'));
-
-    // Check if authenticated
-    if (!(await configManager.isAuthenticated())) {
-      console.log(chalk.yellow('You are not logged in.\n'));
-      return;
-    }
-
-    // Delete config
-    await configManager.delete();
-
-    console.log(chalk.green('✅ Successfully logged out!\n'));
-    console.log(chalk.dim(`Removed config from: ${configManager.getConfigPath()}\n`));
-  } catch (error: any) {
-    console.error(chalk.red(`\n❌ Logout failed: ${error.message}\n`));
-    process.exit(1);
-  }
-}

package/src/config/config-manager.ts

@@ -1,120 +0,0 @@
-/**
- * Configuration manager for storing OAuth tokens and CLI settings
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { LOCAL_CONFIG } from '../constants.js';
-
-export interface EdgediveConfig {
-  accessToken?: string;
-  tokenType?: string;
-  expiresAt?: number;
-  scope?: string;
-  refreshToken?: string;
-}
-
-export class ConfigManager {
-  private configPath: string;
-
-  constructor() {
-    const homeDir = os.homedir();
-    const configDir = path.join(homeDir, LOCAL_CONFIG.CONFIG_DIR);
-    this.configPath = path.join(configDir, LOCAL_CONFIG.CONFIG_FILE);
-  }
-
-  /**
-   * Load configuration from disk
-   */
-  async load(): Promise<EdgediveConfig> {
-    try {
-      const data = await fs.readFile(this.configPath, 'utf-8');
-      return JSON.parse(data);
-    } catch (error: any) {
-      if (error.code === 'ENOENT') {
-        return {}; // File doesn't exist, return empty config
-      }
-      throw new Error(`Failed to load config: ${error.message}`);
-    }
-  }
-
-  /**
-   * Save configuration to disk
-   */
-  async save(config: EdgediveConfig): Promise<void> {
-    try {
-      const configDir = path.dirname(this.configPath);
-      await fs.mkdir(configDir, { recursive: true, mode: 0o700 });
-      await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), { mode: 0o600 });
-    } catch (error: any) {
-      throw new Error(`Failed to save config: ${error.message}`);
-    }
-  }
-
-  /**
-   * Delete configuration file
-   */
-  async delete(): Promise<void> {
-    try {
-      await fs.unlink(this.configPath);
-    } catch (error: any) {
-      if (error.code !== 'ENOENT') {
-        throw new Error(`Failed to delete config: ${error.message}`);
-      }
-    }
-  }
-
-  /**
-   * Check if user is authenticated
-   */
-  async isAuthenticated(): Promise<boolean> {
-    const config = await this.load();
-
-    // If we have an access token that's not expired, we're authenticated
-    if (config.accessToken && (!config.expiresAt || config.expiresAt > Date.now())) {
-      return true;
-    }
-
-    // If we have a refresh token, we can refresh, so consider authenticated
-    if (config.refreshToken) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Get access token (even if expired - let the API client handle refresh)
-   */
-  async getAccessToken(): Promise<string | null> {
-    const config = await this.load();
-    return config.accessToken || null;
-  }
-
-  /**
-   * Get refresh token
-   */
-  async getRefreshToken(): Promise<string | null> {
-    const config = await this.load();
-    return config.refreshToken || null;
-  }
-
-  /**
-   * Check if token is expired or will expire soon (within 5 minutes)
-   */
-  isTokenExpiringSoon(config: EdgediveConfig): boolean {
-    if (!config.expiresAt) {
-      return false;
-    }
-    // Consider token expiring if less than 5 minutes remaining
-    return config.expiresAt < Date.now() + 5 * 60 * 1000;
-  }
-
-  /**
-   * Get configuration directory path
-   */
-  getConfigPath(): string {
-    return this.configPath;
-  }
-}

package/src/constants.ts

@@ -1,34 +0,0 @@
-import 'dotenv/config';
-
-/**
- * Edgedive CLI Constants
- */
-
-// OAuth configuration
-export const OAUTH_CONFIG = {
-  CLIENT_ID: 'edgedive-cli',
-  REDIRECT_URI: 'http://localhost:8765/callback',
-  CALLBACK_PORT: 8765,
-};
-
-// API configuration
-export const API_CONFIG = {
-  BASE_URL: process.env.EDGEDIVE_API_URL || 'https://api.edgedive.com',
-  AUTHORIZE_PATH: '/api/oauth/authorize',
-  TOKEN_PATH: '/api/oauth/token',
-  TAKEOVER_PATH: '/api/agents/agent-sessions/takeover',
-};
-
-// Local configuration
-export const LOCAL_CONFIG = {
-  CONFIG_DIR: '.edgedive',
-  CONFIG_FILE: 'config.json',
-  CLAUDE_DIR: '.claude',
-  CLAUDE_PROJECTS_DIR: 'projects',
-};
-
-// HTTP timeouts
-export const TIMEOUTS = {
-  DEFAULT_REQUEST_MS: 30000,
-  CALLBACK_SERVER_MS: 300000, // 5 minutes for OAuth flow
-};

package/src/index.ts

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Edgedive CLI - Local agent session management
- */
-
-import { Command } from 'commander';
-import dotenv from 'dotenv';
-import { createRequire } from 'module';
-
-const require = createRequire(import.meta.url);
-const packageJson = require('../package.json');
-
-dotenv.config();
-import { loginCommand } from './commands/login.js';
-import { logoutCommand } from './commands/logout.js';
-import { localCommand } from './commands/local.js';
-
-const program = new Command();
-
-program
-  .name('edgedive')
-  .description('Edgedive CLI for local agent session management')
-  .version(packageJson.version);
-
-program
-  .command('login')
-  .description('Authenticate with Edgedive via OAuth')
-  .action(async () => {
-    await loginCommand();
-  });
-
-program
-  .command('logout')
-  .description('Remove stored credentials')
-  .action(async () => {
-    await logoutCommand();
-  });
-
-program
-  .command('local')
-  .description('Prepare an agent session locally')
-  .option('--pr-url <prUrl>', 'GitHub PR URL to load locally')
-  .option('--issue-url <issueUrl>', 'Linear issue URL to load locally')
-  .option('--thread-url <threadUrl>', 'Slack thread URL to load locally')
-  .option('--task-url <taskUrl>', 'Asana task URL to load locally')
-  .option('--session-url <sessionUrl>', 'Session share URL to load locally')
-  .option('--worktree', 'Create branch in a worktree instead of checking out')
-  .action(
-    async (options: {
-      prUrl?: string;
-      issueUrl?: string;
-      threadUrl?: string;
-      taskUrl?: string;
-      sessionUrl?: string;
-      worktree?: boolean;
-    }) => {
-      await localCommand(options);
-    }
-  );
-
-program.parse();

package/src/utils/claude-launcher.ts

@@ -1,94 +0,0 @@
-import { spawn } from 'child_process';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-
-const getUserShell = (): string => process.env.SHELL || '/bin/zsh';
-
-export interface SessionEndInfo {
-  session_id: string;
-  transcript_path: string;
-}
-
-/**
- * Creates a temporary SessionEnd hook script to capture final session information
- * This allows us to get the actual session ID after Claude exits, even if it was compacted
- */
-async function createSessionEndHook(outputPath: string): Promise<string> {
-  const hookScript = `#!/bin/bash
-# SessionEnd hook to capture final session info for Edgedive upload
-# Reads session data from stdin and writes to a file
-
-# Read the JSON payload from stdin
-payload=$(cat)
-
-# Write to output file
-echo "$payload" > "${outputPath}"
-`;
-
-  const hookPath = path.join(os.tmpdir(), `edgedive-session-end-hook-${Date.now()}.sh`);
-  await fs.writeFile(hookPath, hookScript, { mode: 0o755 });
-  return hookPath;
-}
-
-export async function launchClaudeSession(
-  claudeSessionId: string,
-  workspacePath: string
-): Promise<SessionEndInfo | null> {
-  const sessionInfoPath = path.join(os.tmpdir(), `edgedive-session-info-${Date.now()}.json`);
-  let hookPath: string | null = null;
-
-  try {
-    // Create the SessionEnd hook
-    hookPath = await createSessionEndHook(sessionInfoPath);
-
-    await new Promise<void>((resolve, reject) => {
-      const shell = getUserShell();
-      // Set the CLAUDE_SESSION_END_HOOK environment variable to our hook script
-      const child = spawn(shell, ['-i', '-c', `claude -r ${claudeSessionId} --settings '{"includeCoAuthoredBy": false}'`], {
-        cwd: workspacePath,
-        stdio: 'inherit',
-        env: {
-          ...process.env,
-          CLAUDE_SESSION_END_HOOK: hookPath!,
-        },
-      });
-
-      child.on('error', (error: any) => {
-        if (error.code === 'ENOENT') {
-          reject(
-            new Error(
-              '`claude` command not found. Install the Claude CLI and ensure it is available on your PATH.'
-            )
-          );
-        } else {
-          reject(error);
-        }
-      });
-
-      child.on('exit', (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`claude -r exited with code ${code}`));
-        }
-      });
-    });
-
-    // Read the session info captured by the hook
-    try {
-      const sessionInfoJson = await fs.readFile(sessionInfoPath, 'utf-8');
-      const sessionInfo = JSON.parse(sessionInfoJson) as SessionEndInfo;
-      return sessionInfo;
-    } catch (error) {
-      // Hook didn't write session info - return null
-      return null;
-    }
-  } finally {
-    // Cleanup temporary files
-    if (hookPath) {
-      await fs.unlink(hookPath).catch(() => {});
-    }
-    await fs.unlink(sessionInfoPath).catch(() => {});
-  }
-}