devs-cli 0.1.4__tar.gz → 0.1.5__tar.gz

{devs_cli-0.1.4/devs_cli.egg-info → devs_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devs-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: DevContainer Management Tool - Manage multiple named devcontainers for any project
 Author: Dan Lester
 License-Expression: MIT

{devs_cli-0.1.4 → devs_cli-0.1.5}/devs/cli.py

@@ -509,6 +509,188 @@ def _handle_claude_auth(api_key: str, debug: bool) -> None:
         sys.exit(1)
 
 
+@cli.command()
+@click.argument('dev_name', required=False)
+@click.argument('prompt', required=False)
+@click.option('--auth', is_flag=True, help='Set up Codex authentication for devcontainers')
+@click.option('--api-key', help='OpenAI API key to authenticate with (use with --auth)')
+@click.option('--reset-workspace', is_flag=True, help='Reset workspace contents before execution')
+@click.option('--live', is_flag=True, help='Start container with current directory mounted as workspace')
+@click.option('--env', multiple=True, help='Environment variables to pass to container (format: VAR=value)')
+@debug_option
+def codex(dev_name: str, prompt: str, auth: bool, api_key: str, reset_workspace: bool, live: bool, env: tuple, debug: bool) -> None:
+    """Execute OpenAI Codex CLI in devcontainer or set up authentication.
+
+    DEV_NAME: Development environment name
+    PROMPT: Prompt to send to Codex
+
+    Example: devs codex sally "Summarize this codebase"
+    Example: devs codex sally "Fix the tests" --reset-workspace
+    Example: devs codex sally "Fix the tests" --live  # Run with current directory
+    Example: devs codex sally "Start the server" --env QUART_PORT=5001
+    Example: devs codex --auth                        # Interactive authentication
+    Example: devs codex --auth --api-key <YOUR_KEY>   # API key authentication
+    """
+    # Handle authentication mode
+    if auth:
+        _handle_codex_auth(api_key=api_key, debug=debug)
+        return
+
+    # Validate required arguments for execution mode
+    if not dev_name or not prompt:
+        raise click.UsageError("DEV_NAME and PROMPT are required unless using --auth")
+
+    check_dependencies()
+    project = get_project()
+
+    # Load environment variables from DEVS.yml and merge with CLI --env flags
+    devs_env = DevsConfigLoader.load_env_vars(dev_name, project.info.name)
+    cli_env = parse_env_vars(env) if env else {}
+    extra_env = merge_env_vars(devs_env, cli_env) if devs_env or cli_env else None
+
+    if extra_env:
+        console.print(f"🔧 Environment variables: {', '.join(f'{k}={v}' for k, v in extra_env.items())}")
+
+    container_manager = ContainerManager(project, config)
+    workspace_manager = WorkspaceManager(project, config)
+
+    try:
+        # Ensure workspace exists (handles live mode and reset internally)
+        workspace_dir = workspace_manager.create_workspace(dev_name, reset_contents=reset_workspace, live=live)
+        # Ensure container is running
+        container_manager.ensure_container_running(
+            dev_name=dev_name,
+            workspace_dir=workspace_dir,
+            force_rebuild=False,
+            debug=debug,
+            live=live,
+            extra_env=extra_env
+        )
+
+        # Execute Codex
+        console.print(f"🤖 Executing Codex in {dev_name}...")
+        if reset_workspace and not live:
+            console.print("🗑️  Workspace contents reset")
+        console.print(f"📝 Prompt: {prompt}")
+        console.print("")
+
+        success, output, error = container_manager.exec_codex(
+            dev_name=dev_name,
+            workspace_dir=workspace_dir,
+            prompt=prompt,
+            debug=debug,
+            stream=True,
+            live=live,
+            extra_env=extra_env
+        )
+
+        console.print("")  # Add spacing after streamed output
+        if success:
+            console.print("✅ Codex execution completed")
+        else:
+            console.print("❌ Codex execution failed")
+            if error:
+                console.print("")
+                console.print("🚫 Error:")
+                console.print(error)
+            sys.exit(1)
+
+    except (ContainerError, WorkspaceError) as e:
+        console.print(f"❌ Error executing Codex in {dev_name}: {e}")
+        sys.exit(1)
+
+
+def _handle_codex_auth(api_key: str, debug: bool) -> None:
+    """Handle Codex authentication setup.
+
+    This configures Codex authentication that will be shared across
+    all devcontainers for this project. The authentication is stored
+    on the host and bind-mounted into containers.
+    """
+    try:
+        # Ensure Codex config directory exists
+        config.ensure_directories()
+
+        console.print("🔐 Setting up Codex authentication...")
+        console.print(f"   Configuration will be saved to: {config.codex_config_dir}")
+
+        if api_key:
+            # Set API key directly using Codex CLI
+            console.print("   Using provided API key...")
+
+            # Set CODEX_CONFIG_HOME to our config directory and run auth with API key
+            env = os.environ.copy()
+            env['CODEX_CONFIG_HOME'] = str(config.codex_config_dir)
+
+            cmd = ['codex', 'auth', '--api-key', api_key]
+
+            if debug:
+                console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
+                console.print(f"[dim]CODEX_CONFIG_HOME: {config.codex_config_dir}[/dim]")
+
+            result = subprocess.run(
+                cmd,
+                env=env,
+                capture_output=True,
+                text=True
+            )
+
+            if result.returncode != 0:
+                error_msg = result.stderr or result.stdout or "Unknown error"
+                raise Exception(f"Codex authentication failed: {error_msg}")
+
+        else:
+            # Interactive authentication
+            console.print("   Starting interactive authentication...")
+            console.print("   Follow the prompts to authenticate with Codex")
+            console.print("")
+
+            # Set CODEX_CONFIG_HOME to our config directory
+            env = os.environ.copy()
+            env['CODEX_CONFIG_HOME'] = str(config.codex_config_dir)
+
+            cmd = ['codex', 'auth']
+
+            if debug:
+                console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
+                console.print(f"[dim]CODEX_CONFIG_HOME: {config.codex_config_dir}[/dim]")
+
+            # Run interactively
+            result = subprocess.run(
+                cmd,
+                env=env,
+                check=False
+            )
+
+            if result.returncode != 0:
+                raise Exception("Codex authentication was cancelled or failed")
+
+        console.print("")
+        console.print("✅ Codex authentication configured successfully!")
+        console.print(f"   Configuration saved to: {config.codex_config_dir}")
+        console.print("   This authentication will be shared across all devcontainers")
+        console.print("")
+        console.print("💡 You can now use Codex in any devcontainer:")
+        console.print("   devs codex <dev-name> 'Your prompt here'")
+
+    except FileNotFoundError:
+        console.print("❌ Codex CLI not found on host machine")
+        console.print("")
+        console.print("Please install Codex CLI first:")
+        console.print("   npm install -g @openai/codex")
+        console.print("")
+        console.print("Note: Codex needs to be installed on the host machine")
+        console.print("      for authentication. It's already available in containers.")
+        sys.exit(1)
+
+    except Exception as e:
+        console.print(f"❌ Failed to configure Codex authentication: {e}")
+        if debug:
+            import traceback
+            console.print(traceback.format_exc())
+        sys.exit(1)
+
+
 @cli.command()
 @click.argument('dev_name')
 @click.option('--reset-workspace', is_flag=True, help='Reset workspace contents before execution')

{devs_cli-0.1.4 → devs_cli-0.1.5}/devs/config.py

@@ -15,17 +15,24 @@ class Config(BaseConfig):
     WORKSPACES_DIR = Path.home() / ".devs" / "workspaces"
     BRIDGE_DIR = Path.home() / ".devs" / "bridge"
     CLAUDE_CONFIG_DIR = Path.home() / ".devs" / "claudeconfig"
-    
+    CODEX_CONFIG_DIR = Path.home() / ".devs" / "codexconfig"
+
     def __init__(self) -> None:
         """Initialize configuration with environment variable overrides."""
         super().__init__()
-        
+
         # CLI-specific configuration
         claude_config_env = os.getenv("DEVS_CLAUDE_CONFIG_DIR")
         if claude_config_env:
             self.claude_config_dir = Path(claude_config_env)
         else:
             self.claude_config_dir = self.CLAUDE_CONFIG_DIR
+
+        codex_config_env = os.getenv("DEVS_CODEX_CONFIG_DIR")
+        if codex_config_env:
+            self.codex_config_dir = Path(codex_config_env)
+        else:
+            self.codex_config_dir = self.CODEX_CONFIG_DIR
     
     def get_default_workspaces_dir(self) -> Path:
         """Get default workspaces directory for CLI package."""
@@ -43,6 +50,7 @@ class Config(BaseConfig):
         """Ensure required directories exist."""
         super().ensure_directories()
         self.claude_config_dir.mkdir(parents=True, exist_ok=True)
+        self.codex_config_dir.mkdir(parents=True, exist_ok=True)
 
 
 # Global config instance

{devs_cli-0.1.4 → devs_cli-0.1.5/devs_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devs-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: DevContainer Management Tool - Manage multiple named devcontainers for any project
 Author: Dan Lester
 License-Expression: MIT

{devs_cli-0.1.4 → devs_cli-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devs-cli"
-version = "0.1.4"
+version = "0.1.5"
 description = "DevContainer Management Tool - Manage multiple named devcontainers for any project"
 readme = "README.md"
 requires-python = ">=3.8"

{devs_cli-0.1.4 → devs_cli-0.1.5}/tests/test_cli.py

@@ -202,5 +202,87 @@ class TestCLI:
         runner = CliRunner()
         result = runner.invoke(cli, ['claude'])
 
+        assert result.exit_code != 0
+        assert "DEV_NAME and PROMPT are required unless using --auth" in result.output
+
+    def test_codex_command_help(self):
+        """Test codex command help."""
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex', '--help'])
+
+        assert result.exit_code == 0
+        assert "Execute OpenAI Codex CLI in devcontainer or set up authentication" in result.output
+        assert "--auth" in result.output
+        assert "--api-key" in result.output
+
+    @patch('devs.cli.subprocess.run')
+    @patch('devs.cli.config')
+    def test_codex_auth_with_api_key(self, mock_config, mock_subprocess):
+        """Test codex --auth command with API key."""
+        # Setup mocks
+        mock_config.codex_config_dir = '/tmp/test-codex-config'
+        mock_config.ensure_directories = Mock()
+        mock_subprocess.return_value.returncode = 0
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex', '--auth', '--api-key', 'test-key-123'])
+
+        assert result.exit_code == 0
+        assert "Setting up Codex authentication" in result.output
+        assert "Codex authentication configured successfully" in result.output
+
+        # Verify subprocess was called with correct arguments
+        mock_subprocess.assert_called_once()
+        call_args = mock_subprocess.call_args
+        assert 'codex' in call_args[0][0]
+        assert 'auth' in call_args[0][0]
+        assert '--api-key' in call_args[0][0]
+        assert 'test-key-123' in call_args[0][0]
+
+    @patch('devs.cli.subprocess.run')
+    @patch('devs.cli.config')
+    def test_codex_auth_interactive(self, mock_config, mock_subprocess):
+        """Test codex --auth command in interactive mode."""
+        # Setup mocks
+        mock_config.codex_config_dir = '/tmp/test-codex-config'
+        mock_config.ensure_directories = Mock()
+        mock_subprocess.return_value.returncode = 0
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex', '--auth'])
+
+        assert result.exit_code == 0
+        assert "Setting up Codex authentication" in result.output
+        assert "Starting interactive authentication" in result.output
+        assert "Codex authentication configured successfully" in result.output
+
+        # Verify subprocess was called for interactive auth
+        mock_subprocess.assert_called_once()
+        call_args = mock_subprocess.call_args
+        assert 'codex' in call_args[0][0]
+        assert 'auth' in call_args[0][0]
+        assert '--api-key' not in call_args[0][0]
+
+    @patch('devs.cli.subprocess.run')
+    @patch('devs.cli.config')
+    def test_codex_auth_command_not_found(self, mock_config, mock_subprocess):
+        """Test codex --auth when codex CLI is not installed."""
+        # Setup mocks
+        mock_config.codex_config_dir = '/tmp/test-codex-config'
+        mock_config.ensure_directories = Mock()
+        mock_subprocess.side_effect = FileNotFoundError()
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex', '--auth'])
+
+        assert result.exit_code == 1
+        assert "Codex CLI not found" in result.output
+        assert "npm install -g @openai/codex" in result.output
+
+    def test_codex_missing_args(self):
+        """Test codex command without required args (not using --auth)."""
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex'])
+
         assert result.exit_code != 0
         assert "DEV_NAME and PROMPT are required unless using --auth" in result.output