@edgedive/cli 0.2.1 → 0.3.0

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(() => {});
-  }
-}

package/src/utils/git-utils.ts

@@ -1,179 +0,0 @@
-import { promisify } from 'util';
-import { exec as execCb } from 'child_process';
-import * as path from 'path';
-import * as fs from 'fs/promises';
-
-const exec = promisify(execCb);
-
-export interface RepoVerification {
-  rootPath: string;
-  remoteUrl: string;
-}
-
-function parseGithubRemote(remoteUrl: string): { owner: string; repo: string } | null {
-  const patterns = [/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/.]+)(?:\.git)?$/];
-
-  for (const pattern of patterns) {
-    const match = remoteUrl.match(pattern);
-    if (match && match.groups) {
-      return {
-        owner: match.groups.owner.toLowerCase(),
-        repo: match.groups.repo.toLowerCase(),
-      };
-    }
-  }
-
-  return null;
-}
-
-async function runGit(command: string, cwd: string): Promise<string> {
-  const { stdout } = await exec(`git ${command}`, { cwd });
-  return stdout.trim();
-}
-
-export class GitUtils {
-  static async getRepoRoot(cwd: string): Promise<string> {
-    return runGit('rev-parse --show-toplevel', cwd);
-  }
-
-  static async verifyRepoMatches(
-    expectedOwner: string,
-    expectedName: string,
-    cwd: string
-  ): Promise<RepoVerification> {
-    const rootPath = await this.getRepoRoot(cwd);
-    const remoteUrl = await runGit('remote get-url origin', rootPath);
-
-    const parsed = parseGithubRemote(remoteUrl);
-    if (!parsed) {
-      throw new Error(
-        'Could not parse the origin remote URL. Ensure this repository is linked to GitHub.'
-      );
-    }
-
-    const matchesOwner = parsed.owner === expectedOwner.toLowerCase();
-    const matchesRepo = parsed.repo === expectedName.toLowerCase();
-
-    if (!matchesOwner || !matchesRepo) {
-      throw new Error(
-        `This repository (${parsed.owner}/${parsed.repo}) does not match the PR source ${expectedOwner}/${expectedName}.`
-      );
-    }
-
-    return { rootPath, remoteUrl };
-  }
-
-  static async ensureBranchCheckedOut(branch: string, rootPath: string): Promise<void> {
-    // Get current branch
-    const currentBranch = await runGit('rev-parse --abbrev-ref HEAD', rootPath);
-
-    // Check if local branch exists
-    const localBranchExists = await exec(`git rev-parse --verify ${branch}`, { cwd: rootPath })
-      .then(() => true)
-      .catch(() => false);
-
-    // Try to fetch from remote (non-blocking - remote branch may not exist yet)
-    let remoteBranchExists = false;
-    try {
-      await runGit(`fetch origin ${branch}`, rootPath);
-      // Verify the remote branch exists
-      await runGit(`rev-parse --verify origin/${branch}`, rootPath);
-      remoteBranchExists = true;
-    } catch {
-      // Remote branch doesn't exist or fetch failed, continue anyway
-      remoteBranchExists = false;
-    }
-
-    // If already on the target branch
-    if (currentBranch === branch) {
-      // Pull from remote if it exists
-      if (remoteBranchExists) {
-        await runGit(`pull origin ${branch}`, rootPath);
-      }
-      return;
-    }
-
-    // If local branch exists, check it out
-    if (localBranchExists) {
-      await runGit(`checkout ${branch}`, rootPath);
-      // Pull from remote if it exists
-      if (remoteBranchExists) {
-        await runGit(`pull origin ${branch}`, rootPath);
-      }
-      return;
-    }
-
-    // Local branch doesn't exist, create it
-    if (remoteBranchExists) {
-      // Create from remote
-      await runGit(`checkout -b ${branch} origin/${branch}`, rootPath);
-    } else {
-      // Remote doesn't exist, create from current HEAD
-      await runGit(`checkout -b ${branch}`, rootPath);
-    }
-  }
-
-  /**
-   * Ensure a branch exists in a git worktree at a sibling directory.
-   * Returns the path to the worktree.
-   */
-  static async ensureBranchInWorktree(branch: string, rootPath: string): Promise<string> {
-    // Sanitize branch name for directory: replace slashes with dashes
-    const sanitizedBranchName = branch.replace(/\//g, '-');
-
-    // Calculate worktree path as sibling directory
-    const parentDir = path.dirname(rootPath);
-    const worktreePath = path.join(parentDir, sanitizedBranchName);
-
-    // Check if worktree already exists
-    try {
-      await fs.access(worktreePath);
-      // Worktree directory exists, verify it's a valid git worktree
-      try {
-        await runGit('rev-parse --git-dir', worktreePath);
-        // It's a valid git directory, return the path
-        return worktreePath;
-      } catch {
-        // Directory exists but is not a git worktree
-        throw new Error(
-          `Directory ${worktreePath} already exists but is not a git worktree. ` +
-            `Please remove it or choose a different branch name.`
-        );
-      }
-    } catch {
-      // Worktree doesn't exist, we'll create it
-    }
-
-    // Check if local branch exists
-    const localBranchExists = await exec(`git rev-parse --verify ${branch}`, { cwd: rootPath })
-      .then(() => true)
-      .catch(() => false);
-
-    // Try to fetch from remote
-    let remoteBranchExists = false;
-    try {
-      await runGit(`fetch origin ${branch}`, rootPath);
-      await runGit(`rev-parse --verify origin/${branch}`, rootPath);
-      remoteBranchExists = true;
-    } catch {
-      remoteBranchExists = false;
-    }
-
-    // Create worktree based on what exists
-    if (localBranchExists) {
-      // Local branch exists, create worktree from it
-      await runGit(`worktree add "${worktreePath}" ${branch}`, rootPath);
-    } else if (remoteBranchExists) {
-      // Remote branch exists, create worktree tracking it
-      await runGit(
-        `worktree add --track -b ${branch} "${worktreePath}" origin/${branch}`,
-        rootPath
-      );
-    } else {
-      // Neither exists, create new branch in worktree from current HEAD
-      await runGit(`worktree add -b ${branch} "${worktreePath}"`, rootPath);
-    }
-
-    return worktreePath;
-  }
-}

package/src/utils/session-downloader.ts

@@ -1,56 +0,0 @@
-/**
- * Utility for downloading agent session files from S3
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import axios from 'axios';
-import { LOCAL_CONFIG, TIMEOUTS } from '../constants.js';
-import type { TakeoverResponse } from '../api/client.js';
-
-export class SessionDownloader {
-  private sanitizeWorkspacePath(workspacePath: string): string {
-    return workspacePath.replace(/[\\/_.]/g, '-');
-  }
-
-  private getClaudeProjectDir(workspacePath: string): string {
-    const homeDir = os.homedir();
-    const sanitized = this.sanitizeWorkspacePath(workspacePath);
-    return path.join(homeDir, LOCAL_CONFIG.CLAUDE_DIR, LOCAL_CONFIG.CLAUDE_PROJECTS_DIR, sanitized);
-  }
-
-  private async downloadFile(url: string, targetPath: string): Promise<void> {
-    try {
-      const response = await axios.get(url, {
-        responseType: 'arraybuffer',
-        timeout: TIMEOUTS.DEFAULT_REQUEST_MS,
-      });
-
-      await fs.writeFile(targetPath, Buffer.from(response.data));
-    } catch (error: any) {
-      throw new Error(`Failed to download file to ${targetPath}: ${error.message}`);
-    }
-  }
-
-  async downloadSession(
-    sessionData: TakeoverResponse,
-    workspacePath: string
-  ): Promise<{ claudeSessionId: string; claudeSessionPath: string }> {
-    let claudeSessionId = sessionData.session_id;
-
-    if (!sessionData.download_urls.claude_session) {
-      throw new Error('No Claude session file available for this agent session.');
-    }
-
-    const claudeProjectDir = this.getClaudeProjectDir(workspacePath);
-    await fs.mkdir(claudeProjectDir, { recursive: true });
-
-    const claudeSessionPath = path.join(claudeProjectDir, `${claudeSessionId}.jsonl`);
-    await this.downloadFile(sessionData.download_urls.claude_session, claudeSessionPath);
-
-    console.log(`\n📁 Restored Claude session to: ${claudeSessionPath}\n`);
-
-    return { claudeSessionId, claudeSessionPath };
-  }
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022"],
-    "moduleResolution": "node",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}