augint-shell 0.71.2__tar.gz → 0.72.0__tar.gz

{augint_shell-0.71.2 → augint_shell-0.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: augint-shell
-Version: 0.71.2
+Version: 0.72.0
 Summary: Launch AI coding tools and local LLMs in Docker containers
 Author: svange
 Requires-Dist: docker>=7.0.0
@@ -132,7 +132,7 @@ The dev container cannot open a browser on the Windows host, which blocks OAuth
 What you get:
 
 - Claude drives Chrome tabs on your Windows desktop, visible in real time.
-- Uses a **separate Chrome profile** (`ai-debug-profile`) -- your normal browsing is untouched.
+- Uses a **separate Chrome profile per project** -- your normal browsing is untouched, and each repo keeps its own logged-in state.
 - No Chrome extension. No third-party service. All traffic stays on `localhost` between the container and the host.
 
 ### How it works
@@ -142,9 +142,10 @@ ai-shell claude --local-chrome
 ```
 
 `ai-shell` automatically:
-1. Checks if Chrome is already running with a debug port (port 9222).
-2. If not, **launches Chrome** on a free port with its own profile at `%LOCALAPPDATA%\Google\Chrome\ai-debug-profile`.
-3. Starts a TCP proxy inside the container and injects `chrome-devtools-mcp` as an MCP server for Claude.
+1. Computes a stable debug port and Chrome profile for the current project.
+2. Reuses that project's Chrome if it is already running.
+3. If not, **launches Chrome** for the project on its assigned port with its own profile under `%LOCALAPPDATA%\Google\Chrome\ai-shell\...`.
+4. Starts a TCP proxy inside the container and injects `chrome-devtools-mcp` as an MCP server for Claude.
 
 No manual setup required. Chrome stays open after Claude exits so your login sessions persist. Sign in to whatever accounts you need in that Chrome window (first time only; cookies persist in the profile).
 
@@ -161,16 +162,17 @@ Or set the environment variable: `AI_SHELL_LOCAL_CHROME=1`.
 
 ### Manual Chrome launch (fallback)
 
-If `ai-shell` can't find `chrome.exe` automatically, launch Chrome yourself:
+If `ai-shell` can't find `chrome.exe` automatically, launch Chrome yourself using the project-specific port and profile path that `ai-shell` prints in the error message. The shape of the command is:
 
 ```
-chrome.exe --remote-debugging-port=9222 --remote-debugging-address=127.0.0.1 --remote-allow-origins=* --user-data-dir="%LOCALAPPDATA%\Google\Chrome\ai-debug-profile"
+chrome.exe --remote-debugging-port=<project-port> --remote-debugging-address=127.0.0.1 --remote-allow-origins=* --user-data-dir="%LOCALAPPDATA%\Google\Chrome\ai-shell\<project-slug>"
 ```
 
 ### Troubleshooting
 
 - **"Chrome could not be found or launched"** -- Chrome is not installed at a standard location. Use the manual launch command above, or set the path in your system PATH.
-- **Tabs appear empty / not logged in** -- Sign in to the accounts you need inside the auto-launched Chrome (the one with the `ai-debug-profile` window title). Cookies persist across sessions.
+- **Tabs appear empty / not logged in** -- Sign in to the accounts you need inside the auto-launched Chrome for that project. Cookies persist in that project's profile across sessions.
+- **A different repo opened the wrong Chrome window** -- Each project now gets its own Chrome profile and debug port. Re-run from the correct repo so `ai-shell` attaches to that repo's browser instance.
 - **Firefox / Safari** -- not supported. `chrome-devtools-mcp` requires a Chromium-based browser. Edge works with the same flags but has not been tested here.
 
 ## Standardization architecture

{augint_shell-0.71.2 → augint_shell-0.72.0}/README.md

@@ -119,7 +119,7 @@ The dev container cannot open a browser on the Windows host, which blocks OAuth
 What you get:
 
 - Claude drives Chrome tabs on your Windows desktop, visible in real time.
-- Uses a **separate Chrome profile** (`ai-debug-profile`) -- your normal browsing is untouched.
+- Uses a **separate Chrome profile per project** -- your normal browsing is untouched, and each repo keeps its own logged-in state.
 - No Chrome extension. No third-party service. All traffic stays on `localhost` between the container and the host.
 
 ### How it works
@@ -129,9 +129,10 @@ ai-shell claude --local-chrome
 ```
 
 `ai-shell` automatically:
-1. Checks if Chrome is already running with a debug port (port 9222).
-2. If not, **launches Chrome** on a free port with its own profile at `%LOCALAPPDATA%\Google\Chrome\ai-debug-profile`.
-3. Starts a TCP proxy inside the container and injects `chrome-devtools-mcp` as an MCP server for Claude.
+1. Computes a stable debug port and Chrome profile for the current project.
+2. Reuses that project's Chrome if it is already running.
+3. If not, **launches Chrome** for the project on its assigned port with its own profile under `%LOCALAPPDATA%\Google\Chrome\ai-shell\...`.
+4. Starts a TCP proxy inside the container and injects `chrome-devtools-mcp` as an MCP server for Claude.
 
 No manual setup required. Chrome stays open after Claude exits so your login sessions persist. Sign in to whatever accounts you need in that Chrome window (first time only; cookies persist in the profile).
 
@@ -148,16 +149,17 @@ Or set the environment variable: `AI_SHELL_LOCAL_CHROME=1`.
 
 ### Manual Chrome launch (fallback)
 
-If `ai-shell` can't find `chrome.exe` automatically, launch Chrome yourself:
+If `ai-shell` can't find `chrome.exe` automatically, launch Chrome yourself using the project-specific port and profile path that `ai-shell` prints in the error message. The shape of the command is:
 
 ```
-chrome.exe --remote-debugging-port=9222 --remote-debugging-address=127.0.0.1 --remote-allow-origins=* --user-data-dir="%LOCALAPPDATA%\Google\Chrome\ai-debug-profile"
+chrome.exe --remote-debugging-port=<project-port> --remote-debugging-address=127.0.0.1 --remote-allow-origins=* --user-data-dir="%LOCALAPPDATA%\Google\Chrome\ai-shell\<project-slug>"
 ```
 
 ### Troubleshooting
 
 - **"Chrome could not be found or launched"** -- Chrome is not installed at a standard location. Use the manual launch command above, or set the path in your system PATH.
-- **Tabs appear empty / not logged in** -- Sign in to the accounts you need inside the auto-launched Chrome (the one with the `ai-debug-profile` window title). Cookies persist across sessions.
+- **Tabs appear empty / not logged in** -- Sign in to the accounts you need inside the auto-launched Chrome for that project. Cookies persist in that project's profile across sessions.
+- **A different repo opened the wrong Chrome window** -- Each project now gets its own Chrome profile and debug port. Re-run from the correct repo so `ai-shell` attaches to that repo's browser instance.
 - **Firefox / Safari** -- not supported. `chrome-devtools-mcp` requires a Chromium-based browser. Edge works with the same flags but has not been tested here.
 
 ## Standardization architecture

{augint_shell-0.71.2 → augint_shell-0.72.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "augint-shell"
-version = "0.71.2"
+version = "0.72.0"
 description = "Launch AI coding tools and local LLMs in Docker containers"
 authors = [{name = "svange"}]
 readme = "README.md"

{augint_shell-0.71.2 → augint_shell-0.72.0}/src/ai_shell/__init__.py

@@ -1,6 +1,6 @@
 """augint-shell (ai-shell) - Launch AI coding tools and local LLMs in Docker containers."""
 
-__version__ = "0.71.2"
+__version__ = "0.72.0"
 
 __all__ = [
     "__version__",

{augint_shell-0.71.2 → augint_shell-0.72.0}/src/ai_shell/cli/commands/tools.py

@@ -34,6 +34,14 @@ def _generate_worktree_name() -> str:
     return uuid.uuid4().hex[:8]
 
 
+def _print_tmux_quick_start() -> None:
+    """Print a short tmux quick-start before attaching."""
+    console.print("[dim]tmux: mouse click=focus drag=resize wheel=scroll[/dim]")
+    console.print(
+        "[dim]      Ctrl-b o=pane c=tab Space=layout p/n=tab z=zoom d=detach &=kill-tab[/dim]"
+    )
+
+
 def _setup_worktree(container_name: str, container_project_dir: str, name: str) -> str:
     """Create a git worktree inside the container and return its absolute container path.
 
@@ -255,6 +263,130 @@ def _get_manager(
     return manager, container_name, exec_env, config
 
 
+def _bedrock_label(exec_env: dict[str, str]) -> str:
+    """Return the user-facing Bedrock suffix for launch messages."""
+    profile_label = exec_env.get("AWS_PROFILE", "default")
+    region_label = exec_env.get("AWS_REGION", "us-east-1")
+    return f" via Bedrock (profile={profile_label}, region={region_label})"
+
+
+def _configure_local_chrome(
+    container_name: str,
+    *,
+    project_name: str,
+    project_dir: Path | str | None,
+) -> tuple[list[str], str]:
+    """Attach chrome-devtools-mcp to a host Chrome instance."""
+    from ai_shell.local_chrome import (
+        LocalChromeUnavailable,
+        ensure_host_chrome,
+        start_chrome_proxy,
+        write_mcp_config,
+    )
+
+    console.print("[dim]Connecting to host Chrome...[/dim]")
+    try:
+        chrome_port = ensure_host_chrome(
+            container_name,
+            project_name=project_name,
+            project_dir=project_dir,
+        )
+    except LocalChromeUnavailable as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    console.print(f"[dim]Chrome debug port {chrome_port} reachable.[/dim]")
+
+    # Start TCP proxy: localhost:<port> -> host.docker.internal:<port>
+    # Chrome rejects non-localhost Host headers, so the MCP server
+    # must connect via localhost.
+    start_chrome_proxy(container_name, chrome_port)
+
+    host_mcp_path = write_mcp_config(chrome_port)
+    container_mcp_path = "/etc/ai-shell/chrome-mcp.json"
+    _inject_mcp_config(container_name, str(host_mcp_path), container_mcp_path)
+    console.print("[dim]Chrome DevTools MCP attached.[/dim]")
+    return ["--mcp-config", container_mcp_path], container_mcp_path
+
+
+def _launch_loaded_config_claude(
+    config: AiShellConfig,
+    *,
+    safe: bool,
+    use_aws: bool,
+    cli_profile: str | None,
+    extra_args: tuple[str, ...],
+    local_chrome: bool = False,
+    team_mode: bool = False,
+    worktree_name: str | None = None,
+) -> None:
+    """Launch Claude for an already loaded project config."""
+    use_bedrock = use_aws or config.claude_provider == "aws"
+    manager = ContainerManager(config)
+    container_name = manager.ensure_dev_container()
+    exec_env = build_dev_environment(
+        config.extra_env,
+        config.project_dir,
+        project_name=config.project_name,
+        bedrock=use_bedrock,
+        aws_profile=config.ai_profile,
+        aws_region=config.aws_region,
+        bedrock_profile=cli_profile or config.bedrock_profile,
+    )
+
+    if team_mode:
+        exec_env = dict(exec_env)
+        exec_env["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"] = "1"
+
+    bedrock_label = ""
+    if use_bedrock:
+        bedrock_label = _bedrock_label(exec_env)
+        console.print(
+            "Checking Bedrock access "
+            f"(profile={exec_env.get('AWS_PROFILE', 'default')}, "
+            f"region={exec_env.get('AWS_REGION', 'us-east-1')})..."
+        )
+        _check_bedrock_access(container_name, exec_env)
+
+    workdir: str | None = None
+    resolved_worktree_name = worktree_name
+    if resolved_worktree_name is not None:
+        if resolved_worktree_name == "":
+            resolved_worktree_name = _generate_worktree_name()
+        container_project_dir = f"/root/projects/{config.project_name}"
+        workdir = _setup_worktree(container_name, container_project_dir, resolved_worktree_name)
+        console.print(f"[dim]Worktree: {workdir} (branch: worktree-{resolved_worktree_name})[/dim]")
+
+    mcp_args: list[str] = []
+    if local_chrome:
+        mcp_args, _ = _configure_local_chrome(
+            container_name,
+            project_name=config.project_name,
+            project_dir=config.project_dir,
+        )
+
+    if safe:
+        cmd = ["claude", *mcp_args, *extra_args]
+        console.print(
+            f"[bold]Launching Claude Code (safe mode){bedrock_label} in {container_name}...[/bold]"
+        )
+        manager.exec_interactive(container_name, cmd, extra_env=exec_env, workdir=workdir)
+        return
+
+    cmd_continue = ["claude", "--dangerously-skip-permissions", "-c", *mcp_args, *extra_args]
+    console.print(f"[bold]Launching Claude Code{bedrock_label} in {container_name}...[/bold]")
+    exit_code, elapsed = manager.run_interactive(
+        container_name, cmd_continue, extra_env=exec_env, workdir=workdir
+    )
+
+    if exit_code != 0 and elapsed < FAST_FAILURE_THRESHOLD:
+        console.print("[yellow]No prior conversation found, starting fresh...[/yellow]")
+        cmd_fresh = ["claude", "--dangerously-skip-permissions", *mcp_args, *extra_args]
+        manager.exec_interactive(container_name, cmd_fresh, extra_env=exec_env, workdir=workdir)
+        return
+
+    sys.exit(exit_code)
+
+
 def _load_workspace_repos(workspace_yaml: Path) -> tuple[str, list[dict[str, Any]]]:
     """Parse workspace.yaml and return (workspace_name, repos_list).
 
@@ -273,20 +405,21 @@ def _load_workspace_repos(workspace_yaml: Path) -> tuple[str, list[dict[str, Any
     return workspace_name, repos
 
 
-def _launch_interactive_multi(
+def _launch_interactive(
     ctx: click.Context,
     *,
     safe: bool,
     use_aws: bool,
     cli_profile: str | None,
     extra_args: tuple[str, ...],
+    worktree_name: str | None = None,
 ) -> None:
-    """Interactive multi-pane launcher.
+    """Interactive Claude launcher.
 
-    Walks the user through a guided wizard to configure each tmux pane,
-    then builds and launches the customised tmux session.
+    Walks the user through a guided wizard to configure panes, then launches
+    either a normal single session or a customised tmux session.
     """
-    from ai_shell.interactive import build_interactive_panes, run_interactive_wizard
+    from ai_shell.interactive import PaneType, build_interactive_panes, run_interactive_wizard
     from ai_shell.tmux import (
         TMUX_SESSION_PREFIX,
         build_attach_command,
@@ -294,13 +427,83 @@ def _launch_interactive_multi(
         build_tmux_commands,
     )
 
-    # Load config early -- needed for session check and container setup.
+    # Load config early -- needed for prompt defaults and any single-pane launch.
     project = ctx.obj.get("project") if ctx.obj else None
     config = load_config(project_override=project, project_dir=Path.cwd())
+
+    # Gather workspace repos if available.
+    workspace_yaml = Path.cwd() / "workspace.yaml"
+    workspace_repos = None
+    if workspace_yaml.exists():
+        _, workspace_repos = _load_workspace_repos(workspace_yaml)
+
+    # Run the wizard.
+    interactive_config = run_interactive_wizard(
+        project_name=config.project_name,
+        workspace_repos=workspace_repos,
+        default_windows=2,
+        default_shared_chrome=config.local_chrome is True,
+    )
+    if interactive_config is None:
+        console.print("[dim]Cancelled.[/dim]")
+        return
+
+    if interactive_config.pane_count == 1:
+        choice = interactive_config.pane_choices[0]
+
+        if choice.pane_type == PaneType.BASH:
+            manager = ContainerManager(config)
+            container_name = manager.ensure_dev_container()
+            exec_env = build_dev_environment(
+                config.extra_env,
+                config.project_dir,
+                project_name=config.project_name,
+                aws_profile=config.ai_profile,
+                aws_region=config.aws_region,
+                bedrock_profile=cli_profile or config.bedrock_profile,
+            )
+            console.print(f"[bold]Launching Bash in {container_name}...[/bold]")
+            manager.exec_interactive(
+                container_name,
+                ["/bin/bash"],
+                extra_env=exec_env,
+                workdir=f"/root/projects/{config.project_name}",
+            )
+            return
+
+        selected_dir = config.project_dir
+        target_label = config.project_name
+        if choice.pane_type == PaneType.WORKSPACE_REPO:
+            selected_dir = Path.cwd() / choice.repo_path
+            if not selected_dir.exists():
+                raise click.ClickException(
+                    f"Repo directory not found: {selected_dir}\n"
+                    "  Run /ai-workspace-sync to clone workspace repos first."
+                )
+            target_label = choice.repo_name
+
+        console.print(
+            f"[dim]Single Claude pane selected -- launching standard session in "
+            f"{target_label}[/dim]"
+        )
+        selected_config = load_config(project_override=project, project_dir=selected_dir)
+        _launch_loaded_config_claude(
+            selected_config,
+            safe=safe,
+            use_aws=use_aws,
+            cli_profile=cli_profile,
+            extra_args=extra_args,
+            local_chrome=interactive_config.shared_chrome,
+            team_mode=interactive_config.team_mode,
+            worktree_name=worktree_name,
+        )
+        return
+
     session_name = f"{TMUX_SESSION_PREFIX}-{config.project_name}"
     container_name = dev_container_name(config.project_name, config.project_dir)
 
-    # Check for existing tmux session.
+    # Check for existing tmux session after the user has actually chosen a
+    # multi-pane launch.
     check_cmd = build_check_session_command(container_name, session_name)
     has_session = subprocess.run(check_cmd, capture_output=True).returncode == 0
 
@@ -314,28 +517,13 @@ def _launch_interactive_multi(
         if choice == "reconnect":
             attach_cmd = build_attach_command(container_name, session_name)
             logger.debug("tmux reattach: %s", " ".join(attach_cmd))
+            _print_tmux_quick_start()
             sys.stdout.flush()
             sys.stderr.flush()
             attach = subprocess.run(attach_cmd)
             sys.exit(attach.returncode)
-        elif choice == "cancel":
+        if choice == "cancel":
             return
-        # choice == "fresh": fall through to wizard
-
-    # Gather workspace repos if available.
-    workspace_yaml = Path.cwd() / "workspace.yaml"
-    workspace_repos = None
-    if workspace_yaml.exists():
-        _, workspace_repos = _load_workspace_repos(workspace_yaml)
-
-    # Run the wizard.
-    interactive_config = run_interactive_wizard(
-        project_name=config.project_name,
-        workspace_repos=workspace_repos,
-    )
-    if interactive_config is None:
-        console.print("[dim]Cancelled.[/dim]")
-        return
 
     # Ensure container is running.
     use_bedrock = use_aws or config.claude_provider == "aws"
@@ -357,25 +545,12 @@ def _launch_interactive_multi(
     # Handle shared Chrome if requested.
     mcp_config_path: str | None = None
     if interactive_config.shared_chrome:
-        from ai_shell.local_chrome import (
-            LocalChromeUnavailable,
-            ensure_host_chrome,
-            start_chrome_proxy,
-            write_mcp_config,
+        _, mcp_config_path = _configure_local_chrome(
+            container_name,
+            project_name=config.project_name,
+            project_dir=config.project_dir,
         )
 
-        console.print("[dim]Connecting to host Chrome...[/dim]")
-        try:
-            chrome_port = ensure_host_chrome(container_name)
-        except LocalChromeUnavailable as exc:
-            raise click.ClickException(str(exc)) from exc
-
-        start_chrome_proxy(container_name, chrome_port)
-        host_mcp_path = write_mcp_config(chrome_port)
-        mcp_config_path = "/etc/ai-shell/chrome-mcp.json"
-        _inject_mcp_config(container_name, str(host_mcp_path), mcp_config_path)
-        console.print("[dim]Chrome DevTools MCP attached.[/dim]")
-
     # Build pane specs.
     container_project_root = f"/root/projects/{config.project_name}"
     panes = build_interactive_panes(
@@ -401,6 +576,7 @@ def _launch_interactive_multi(
 
     final_cmd = cmds[-1]
     logger.debug("tmux attach: %s", " ".join(final_cmd))
+    _print_tmux_quick_start()
     sys.stdout.flush()
     sys.stderr.flush()
     attach = subprocess.run(final_cmd)
@@ -571,6 +747,7 @@ def _launch_single_repo_multi(
 
     final_cmd = cmds[-1]
     logger.debug("tmux attach: %s", " ".join(final_cmd))
+    _print_tmux_quick_start()
     sys.stdout.flush()
     sys.stderr.flush()
     attach = subprocess.run(final_cmd)
@@ -628,6 +805,7 @@ def _launch_multi(
         if choice == "reconnect":
             attach_cmd = build_attach_command(container_name, session_name)
             logger.debug("tmux reattach: %s", " ".join(attach_cmd))
+            _print_tmux_quick_start()
             sys.stdout.flush()
             sys.stderr.flush()
             attach = subprocess.run(attach_cmd)
@@ -686,41 +864,16 @@ def _launch_multi(
                 "  Run /ai-workspace-sync to clone workspace repos first."
             )
         console.print(f"[dim]Single selection -- launching Claude in {sel.label}[/dim]")
-        # Re-derive config from the selected repo's directory
         project = ctx.obj.get("project") if ctx.obj else None
         config = load_config(project_override=project, project_dir=sel_path)
-        use_bedrock = use_aws or config.claude_provider == "aws"
-        manager = ContainerManager(config)
-        container_name = manager.ensure_dev_container()
-        exec_env = build_dev_environment(
-            config.extra_env,
-            config.project_dir,
-            project_name=config.project_name,
-            bedrock=use_bedrock,
-            aws_profile=config.ai_profile,
-            aws_region=config.aws_region,
-            bedrock_profile=cli_profile or config.bedrock_profile,
+        _launch_loaded_config_claude(
+            config,
+            safe=safe,
+            use_aws=use_aws,
+            cli_profile=cli_profile,
+            extra_args=extra_args,
+            worktree_name=worktree_name,
         )
-
-        if use_bedrock:
-            _check_bedrock_access(container_name, exec_env)
-
-        workdir = f"/root/projects/{config.project_name}"
-        if safe:
-            cmd = ["claude", *extra_args]
-            manager.exec_interactive(container_name, cmd, extra_env=exec_env, workdir=workdir)
-        else:
-            cmd_c = ["claude", "--dangerously-skip-permissions", "-c", *extra_args]
-            exit_code, elapsed = manager.run_interactive(
-                container_name, cmd_c, extra_env=exec_env, workdir=workdir
-            )
-            if exit_code != 0 and elapsed < FAST_FAILURE_THRESHOLD:
-                cmd_fresh = ["claude", "--dangerously-skip-permissions", *extra_args]
-                manager.exec_interactive(
-                    container_name, cmd_fresh, extra_env=exec_env, workdir=workdir
-                )
-            else:
-                sys.exit(exit_code)
         return
 
     # Multi selection (2-4 repos): validate dirs, build tmux session
@@ -801,6 +954,7 @@ def _launch_multi(
     # Final command: interactive attach (replaces process)
     final_cmd = cmds[-1]
     logger.debug("tmux attach: %s", " ".join(final_cmd))
+    _print_tmux_quick_start()
     sys.stdout.flush()
     sys.stderr.flush()
     attach = subprocess.run(final_cmd)
@@ -852,9 +1006,9 @@ def _launch_multi(
     is_flag=True,
     default=False,
     help=(
-        "Attach Chrome DevTools MCP to host Chrome running with "
-        "--remote-debugging-port=9222. Gives Claude browser control "
-        "over your real Windows Chrome tabs."
+        "Attach Chrome DevTools MCP to a project-scoped host Chrome session. "
+        "ai-shell launches or reuses a separate Windows Chrome profile for "
+        "this repo and gives Claude browser control over those tabs."
     ),
 )
 @click.option(
@@ -865,8 +1019,8 @@ def _launch_multi(
     default=False,
     help=(
         "Interactive multi-pane setup: walk through a guided menu to "
-        "configure window types, teams mode, and shared Chrome before "
-        "launching tmux.  Requires --multi."
+        "configure windows, teams mode, and shared Chrome before launch. "
+        "A single Claude pane falls back to a normal session."
     ),
 )
 @click.argument("extra_args", nargs=-1, type=click.UNPROCESSED)
@@ -887,8 +1041,6 @@ def claude(
     # Incompatibility checks
     if do_team and do_multi:
         raise click.ClickException("--team and --multi are incompatible (both manage tmux).")
-    if do_interactive and not do_multi:
-        raise click.ClickException("--interactive requires --multi.")
     if do_interactive and do_team:
         raise click.ClickException(
             "--interactive and --team are incompatible (interactive handles teams mode itself)."
@@ -899,16 +1051,18 @@ def claude(
             "(interactive handles Chrome setup itself)."
         )
 
+    if do_interactive:
+        _launch_interactive(
+            ctx,
+            safe=safe,
+            use_aws=use_aws,
+            cli_profile=cli_profile,
+            extra_args=extra_args,
+            worktree_name=worktree_name,
+        )
+        return
+
     if do_multi:
-        if do_interactive:
-            _launch_interactive_multi(
-                ctx,
-                safe=safe,
-                use_aws=use_aws,
-                cli_profile=cli_profile,
-                extra_args=extra_args,
-            )
-            return
         _launch_multi(
             ctx,
             safe=safe,
@@ -929,88 +1083,19 @@ def claude(
         )
         return
 
-    # Auto-init if .claude/ is missing
-    # Load config first to check provider setting
+    # Load config for the current project and launch a normal Claude session.
     project = ctx.obj.get("project") if ctx.obj else None
     config = load_config(project_override=project, project_dir=Path.cwd())
-    use_bedrock = use_aws or config.claude_provider == "aws"
-
-    manager, name, exec_env, config = _get_manager(
-        ctx,
-        bedrock=use_bedrock,
-        bedrock_profile=cli_profile or "",
-    )
-
-    if use_bedrock:
-        profile_label = exec_env.get("AWS_PROFILE", "default")
-        region_label = exec_env.get("AWS_REGION", "us-east-1")
-        bedrock_label = f" via Bedrock (profile={profile_label}, region={region_label})"
-        console.print(
-            f"Checking Bedrock access (profile={profile_label}, region={region_label})..."
-        )
-        _check_bedrock_access(name, exec_env)
-    else:
-        bedrock_label = ""
-
-    # Resolve worktree working directory (if --worktree/-w was given)
-    worktree_dir: str | None = None
-    if worktree_name is not None:
-        if worktree_name == "":
-            worktree_name = _generate_worktree_name()
-        container_project_dir = f"/root/projects/{config.project_name}"
-        worktree_dir = _setup_worktree(name, container_project_dir, worktree_name)
-        console.print(f"[dim]Worktree: {worktree_dir} (branch: worktree-{worktree_name})[/dim]")
-
-    # Local Chrome bridge: probe debug port, write MCP config, inject into args
     local_chrome = local_chrome or config.local_chrome is True
-    mcp_args: list[str] = []
-    if local_chrome:
-        from ai_shell.local_chrome import (
-            LocalChromeUnavailable,
-            ensure_host_chrome,
-            start_chrome_proxy,
-            write_mcp_config,
-        )
-
-        console.print("[dim]Connecting to host Chrome...[/dim]")
-        try:
-            chrome_port = ensure_host_chrome(name)
-        except LocalChromeUnavailable as exc:
-            raise click.ClickException(str(exc)) from exc
-
-        console.print(f"[dim]Chrome debug port {chrome_port} reachable.[/dim]")
-
-        # Start TCP proxy: localhost:<port> -> host.docker.internal:<port>
-        # Chrome rejects non-localhost Host headers, so the MCP server
-        # must connect via localhost.
-        start_chrome_proxy(name, chrome_port)
-
-        mcp_path = write_mcp_config(chrome_port)
-        container_mcp_path = "/etc/ai-shell/chrome-mcp.json"
-        # Inject the MCP config file into the running container
-        _inject_mcp_config(name, str(mcp_path), container_mcp_path)
-        mcp_args = ["--mcp-config", container_mcp_path]
-        console.print("[dim]Chrome DevTools MCP attached.[/dim]")
-
-    if safe:
-        cmd = ["claude", *mcp_args, *extra_args]
-        console.print(f"[bold]Launching Claude Code (safe mode){bedrock_label} in {name}...[/bold]")
-        manager.exec_interactive(name, cmd, extra_env=exec_env, workdir=worktree_dir)
-    else:
-        # Try with -c first (continue previous conversation)
-        cmd_continue = ["claude", "--dangerously-skip-permissions", "-c", *mcp_args, *extra_args]
-        console.print(f"[bold]Launching Claude Code{bedrock_label} in {name}...[/bold]")
-        exit_code, elapsed = manager.run_interactive(
-            name, cmd_continue, extra_env=exec_env, workdir=worktree_dir
-        )
-
-        if exit_code != 0 and elapsed < FAST_FAILURE_THRESHOLD:
-            # -c failed quickly (likely no prior conversation), retry without it
-            console.print("[yellow]No prior conversation found, starting fresh...[/yellow]")
-            cmd_fresh = ["claude", "--dangerously-skip-permissions", *mcp_args, *extra_args]
-            manager.exec_interactive(name, cmd_fresh, extra_env=exec_env, workdir=worktree_dir)
-        else:
-            sys.exit(exit_code)
+    _launch_loaded_config_claude(
+        config,
+        safe=safe,
+        use_aws=use_aws,
+        cli_profile=cli_profile,
+        extra_args=extra_args,
+        local_chrome=local_chrome,
+        worktree_name=worktree_name,
+    )
 
 
 @click.command(context_settings=CONTEXT_SETTINGS)

{augint_shell-0.71.2 → augint_shell-0.72.0}/src/ai_shell/config.py

@@ -65,7 +65,7 @@ class AiShellConfig:
     bedrock_profile: str = ""  # AWS profile for Bedrock LLM API calls
 
     # Claude options
-    local_chrome: bool = False  # Attach Chrome DevTools MCP to host Chrome debug port
+    local_chrome: bool = False  # Attach Chrome DevTools MCP to project-scoped host Chrome
 
     # Per-tool provider
     claude_provider: str = ""  # "anthropic" (default) or "aws"

{augint_shell-0.71.2 → augint_shell-0.72.0}/src/ai_shell/interactive.py

@@ -1,8 +1,8 @@
-"""Interactive multi-pane wizard for ``ai-shell claude --multi -i``.
+"""Interactive launcher wizard for ``ai-shell claude -i``.
 
-Walks the user through a guided menu to configure each tmux pane,
-then converts the collected choices into :class:`~ai_shell.tmux.PaneSpec`
-objects ready for :func:`~ai_shell.tmux.build_tmux_commands`.
+Walks the user through a guided menu to configure each pane, then converts the
+collected choices into :class:`~ai_shell.tmux.PaneSpec` objects when a tmux
+session is needed.
 """
 
 from __future__ import annotations
@@ -48,6 +48,19 @@ class InteractiveConfig:
     team_mode: bool = False
     shared_chrome: bool = False
 
+    @property
+    def pane_count(self) -> int:
+        """Return the number of panes requested by the user."""
+        return len(self.pane_choices)
+
+    @property
+    def has_claude_panes(self) -> bool:
+        """Return ``True`` when at least one pane launches Claude."""
+        return any(
+            choice.pane_type in (PaneType.THIS_PROJECT, PaneType.WORKSPACE_REPO)
+            for choice in self.pane_choices
+        )
+
 
 # ── Option builder ───────────────────────────────────────────────────
 
@@ -69,7 +82,7 @@ def _build_pane_options(
     """Build the numbered option list for per-window type selection."""
     options: list[_PaneOption] = [
         _PaneOption(
-            label=f"This project ({project_name}) - Claude in worktree",
+            label=f"This project ({project_name}) - Claude session",
             pane_type=PaneType.THIS_PROJECT,
         ),
         _PaneOption(
@@ -102,8 +115,12 @@ def run_interactive_wizard(
     project_name: str,
     workspace_repos: list[dict[str, Any]] | None = None,
     console: Console | None = None,
+    min_windows: int = 1,
+    max_windows: int = 4,
+    default_windows: int | None = None,
+    default_shared_chrome: bool = False,
 ) -> InteractiveConfig | None:
-    """Walk the user through the interactive multi-pane setup.
+    """Walk the user through the interactive launcher flow.
 
     Returns :class:`InteractiveConfig` with all choices, or ``None`` if the
     user cancels (Ctrl-C / EOFError).
@@ -112,13 +129,15 @@ def run_interactive_wizard(
         console = Console(stderr=True)
 
     options = _build_pane_options(project_name, workspace_repos)
+    if default_windows is None:
+        default_windows = min_windows
 
     try:
         # Step 1: number of windows
         num_windows: int = click.prompt(
             "How many windows?",
-            type=click.IntRange(2, 4),
-            default=2,
+            type=click.IntRange(min_windows, max_windows),
+            default=default_windows,
         )
 
         # Step 2: per-window type
@@ -144,15 +163,23 @@ def run_interactive_wizard(
             )
 
         # Step 3: pre-launch options
-        console.print()
-        team_mode = click.confirm(
-            "Enable teams mode on the primary Claude pane?",
-            default=False,
-        )
-        shared_chrome = click.confirm(
-            "Enable shared Chrome browser for all Claude panes?",
-            default=False,
+        team_mode = False
+        shared_chrome = False
+        has_claude_panes = any(
+            choice.pane_type in (PaneType.THIS_PROJECT, PaneType.WORKSPACE_REPO)
+            for choice in choices
         )
+        if has_claude_panes:
+            console.print()
+            if num_windows == 1:
+                team_prompt = "Enable teams mode for this Claude pane?"
+                chrome_prompt = "Enable Chrome browser for this Claude pane?"
+            else:
+                team_prompt = "Enable teams mode on the primary Claude pane?"
+                chrome_prompt = "Enable shared Chrome browser for all Claude panes?"
+
+            team_mode = click.confirm(team_prompt, default=False)
+            shared_chrome = click.confirm(chrome_prompt, default=default_shared_chrome)
 
     except (EOFError, KeyboardInterrupt, click.Abort):
         return None

{augint_shell-0.71.2 → augint_shell-0.72.0}/src/ai_shell/local_chrome.py

@@ -18,21 +18,29 @@ import json
 import logging
 import os
 import platform
-import socket
 import subprocess
 import time
+from collections.abc import Callable
+from hashlib import sha1
+from http.client import HTTPConnection, HTTPException
 from pathlib import Path
 
+from ai_shell.defaults import unique_project_name
+
 logger = logging.getLogger(__name__)
 
 CHROME_DEBUG_HOST = "host.docker.internal"
-DEFAULT_CHROME_DEBUG_PORT = 9222
+CHROME_HOST_PROBE_TIMEOUT_SECONDS = 20.0
+CHROME_CONTAINER_PROBE_TIMEOUT_SECONDS = 10.0
+CHROME_PROBE_INTERVAL_SECONDS = 0.5
+CHROME_DEBUG_PORT_RANGE_START = 40000
+CHROME_DEBUG_PORT_RANGE_SIZE = 20000
 
 MCP_CONFIG_FILENAME = "chrome-mcp.json"
 
-# User-data-dir for the ai-shell debug Chrome profile (keeps it separate from
-# the user's normal browsing).
-_CHROME_PROFILE_DIR_NAME = "ai-debug-profile"
+# User-data-dir for ai-shell project-specific Chrome profiles (keeps them
+# separate from the user's normal browsing and from other repos).
+_CHROME_PROFILE_ROOT_DIR_NAME = "ai-shell"
 
 # Well-known Chrome install paths on Windows
 _CHROME_CANDIDATES = [
@@ -50,20 +58,6 @@ _NODE_PROXY_TEMPLATE = (
     "}}).listen({port},'127.0.0.1')"
 )
 
-SETUP_INSTRUCTIONS = """\
-Chrome could not be found or launched automatically, and the debug port \
-is not reachable.
-
-To fix, launch Chrome manually with these flags:
-
-  chrome.exe --remote-debugging-port=9222 \\
-    --remote-debugging-address=127.0.0.1 \\
-    --remote-allow-origins=* \\
-    --user-data-dir="%LOCALAPPDATA%\\Google\\Chrome\\ai-debug-profile"
-
-Then re-run this command.
-See README.md "Attaching to your Windows Chrome" for details."""
-
 
 class LocalChromeUnavailable(Exception):
     """Raised when the host Chrome debug port is not reachable."""
@@ -89,23 +83,57 @@ def find_chrome() -> str | None:
     return None
 
 
-def _chrome_profile_dir() -> str:
-    """Return the user-data-dir path for the ai-shell debug Chrome profile."""
+def _project_slug(project_name: str, project_dir: str | Path | None = None) -> str:
+    """Return a stable slug for project-scoped Chrome state."""
+    if project_dir is not None:
+        try:
+            return unique_project_name(Path(project_dir), project_name)
+        except (TypeError, ValueError):
+            logger.debug("Falling back to project-name-only slug for %s", project_name)
+    slug = "".join(ch if ch.isalnum() or ch == "-" else "-" for ch in project_name.lower())
+    slug = "-".join(part for part in slug.split("-") if part)
+    return slug or "project"
+
+
+def _chrome_profile_dir(project_name: str, project_dir: str | Path | None = None) -> str:
+    """Return the user-data-dir path for a project's ai-shell debug Chrome."""
+    slug = _project_slug(project_name, project_dir)
     local_app = os.environ.get("LOCALAPPDATA", "")
     if local_app:
-        return str(Path(local_app) / "Google" / "Chrome" / _CHROME_PROFILE_DIR_NAME)
-    return str(Path.home() / ".config" / "google-chrome" / _CHROME_PROFILE_DIR_NAME)
+        return str(Path(local_app) / "Google" / "Chrome" / _CHROME_PROFILE_ROOT_DIR_NAME / slug)
+    return str(Path.home() / ".config" / "google-chrome" / _CHROME_PROFILE_ROOT_DIR_NAME / slug)
 
 
-def _find_free_port() -> int:
-    """Find a free TCP port on the host by briefly binding to port 0."""
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(("127.0.0.1", 0))
-        port: int = s.getsockname()[1]
-        return port
+def _project_debug_port(project_name: str, project_dir: str | Path | None = None) -> int:
+    """Return a stable per-project Chrome remote debugging port."""
+    slug = _project_slug(project_name, project_dir)
+    digest = sha1(slug.encode("utf-8"), usedforsecurity=False).hexdigest()
+    return CHROME_DEBUG_PORT_RANGE_START + (int(digest[:8], 16) % CHROME_DEBUG_PORT_RANGE_SIZE)
+
+
+def _build_setup_instructions(project_name: str, profile_dir: str, port: int) -> str:
+    """Return manual setup instructions for the project's Chrome profile."""
+    return f"""\
+Chrome could not be found or launched automatically, and the debug port \
+is not reachable.
+
+To fix, launch Chrome manually with these flags:
+
+  chrome.exe --remote-debugging-port={port} \\
+    --remote-debugging-address=127.0.0.1 \\
+    --remote-allow-origins=* \\
+    --user-data-dir="{profile_dir}"
+
+Then re-run this command for project '{project_name}'.
+See README.md "Attaching to your Windows Chrome" for details."""
 
 
-def launch_chrome(port: int) -> bool:
+def launch_chrome(
+    port: int,
+    *,
+    project_name: str,
+    project_dir: str | Path | None = None,
+) -> bool:
     """Launch Chrome on the host with the debug port enabled.
 
     Returns ``True`` if Chrome was launched, ``False`` if Chrome could
@@ -115,7 +143,7 @@ def launch_chrome(port: int) -> bool:
     if chrome_path is None:
         return False
 
-    profile_dir = _chrome_profile_dir()
+    profile_dir = _chrome_profile_dir(project_name, project_dir)
     args = [
         chrome_path,
         f"--remote-debugging-port={port}",
@@ -167,38 +195,86 @@ def probe_chrome_port(container_name: str, port: int) -> bool:
     return True
 
 
-def ensure_host_chrome(container_name: str) -> int:
+def probe_host_chrome_port(port: int) -> bool:
+    """Check whether a Chrome debug port is reachable on the host."""
+    connection = HTTPConnection("127.0.0.1", port, timeout=2)
+    try:
+        connection.request("GET", "/json/version")
+        response = connection.getresponse()
+        return response.status == 200 and bool(response.read().strip())
+    except (OSError, HTTPException):
+        return False
+    finally:
+        connection.close()
+
+
+def _wait_until_ready(
+    probe_fn: Callable[..., bool],
+    *args: object,
+    timeout_seconds: float,
+    interval_seconds: float = CHROME_PROBE_INTERVAL_SECONDS,
+) -> bool:
+    """Poll until a probe succeeds or the timeout expires."""
+    deadline = time.monotonic() + timeout_seconds
+    while True:
+        if probe_fn(*args):
+            return True
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return False
+        time.sleep(min(interval_seconds, remaining))
+
+
+def ensure_host_chrome(
+    container_name: str,
+    *,
+    project_name: str,
+    project_dir: str | Path | None = None,
+) -> int:
     """Ensure Chrome is running with a debug port reachable from the container.
 
-    1. Probe the default port (9222) -- if Chrome is already running, return it.
-    2. Find a free port, launch Chrome on it, wait briefly for startup.
-    3. Raise :class:`LocalChromeUnavailable` if Chrome can't be found or started.
+    Each project gets its own debug profile directory and a stable debug port,
+    so different repos can keep separate logged-in Chrome instances alive.
 
     Returns the port number Chrome is listening on.
     """
-    # Try the default port first -- user may have Chrome open already
-    if probe_chrome_port(container_name, DEFAULT_CHROME_DEBUG_PORT):
-        return DEFAULT_CHROME_DEBUG_PORT
-
-    # Launch Chrome on a fresh port
-    port = _find_free_port()
-    logger.info(
-        "Chrome not found on port %d, launching on port %d", DEFAULT_CHROME_DEBUG_PORT, port
-    )
+    port = _project_debug_port(project_name, project_dir)
+    profile_dir = _chrome_profile_dir(project_name, project_dir)
+
+    if probe_chrome_port(container_name, port):
+        return port
 
-    if not launch_chrome(port):
-        raise LocalChromeUnavailable(SETUP_INSTRUCTIONS)
+    logger.info("Chrome for project %s not found on port %d, launching it", project_name, port)
+
+    if not launch_chrome(port, project_name=project_name, project_dir=project_dir):
+        raise LocalChromeUnavailable(_build_setup_instructions(project_name, profile_dir, port))
+
+    if not _wait_until_ready(
+        probe_host_chrome_port,
+        port,
+        timeout_seconds=CHROME_HOST_PROBE_TIMEOUT_SECONDS,
+    ):
+        raise LocalChromeUnavailable(
+            f"Chrome was launched for project '{project_name}' on port {port}, but the "
+            f"debug port did not open on localhost within "
+            f"{int(CHROME_HOST_PROBE_TIMEOUT_SECONDS)} seconds.\n\n"
+            "If another ai-shell Chrome window for this project is already open, "
+            "close it and retry."
+        )
 
-    # Brief wait for Chrome to start (typically <2s)
-    for attempt in range(5):
-        time.sleep(1)
-        if probe_chrome_port(container_name, port):
-            logger.info("Chrome ready on port %d after %ds", port, attempt + 1)
-            return port
+    if _wait_until_ready(
+        probe_chrome_port,
+        container_name,
+        port,
+        timeout_seconds=CHROME_CONTAINER_PROBE_TIMEOUT_SECONDS,
+    ):
+        logger.info("Chrome ready on port %d for project %s", port, project_name)
+        return port
 
     raise LocalChromeUnavailable(
-        f"Chrome was launched on port {port} but the debug port did not become "
-        "reachable within 5 seconds.\n\n"
+        f"Chrome is listening on localhost:{port} for project '{project_name}', but the "
+        "debug port did not become reachable from the dev container within "
+        f"{int(CHROME_CONTAINER_PROBE_TIMEOUT_SECONDS)} seconds.\n\n"
         "Check that Docker Desktop can reach the host via host.docker.internal."
     )
 

{augint_shell-0.71.2 → augint_shell-0.72.0}/src/ai_shell/tmux.py

@@ -250,7 +250,7 @@ def build_tmux_commands(
         # Status bar
         ("status-style", "bg=colour235 fg=colour248"),
         ("status-left", "#[fg=colour172,bold] #S #[fg=colour248]| "),
-        ("status-right", "#[fg=colour95] C-b z=zoom  C-b d=detach "),
+        ("status-right", "#[fg=colour95] C-b: ◫o +c ▦␣ ◀p ▶n ⛶z ⏏d ⌦& "),
         ("status-left-length", "40"),
         ("status-right-length", "40"),
     ]