Add aai dev/share/deploy and make starter templates deployable beyond Vercel

.importlinter

@@ -38,13 +38,16 @@ modules =
     aai_cli.commands.account
     aai_cli.commands.agent
     aai_cli.commands.audit
+    aai_cli.commands.deploy
+    aai_cli.commands.dev
     aai_cli.commands.doctor
     aai_cli.commands.init
     aai_cli.commands.keys
     aai_cli.commands.llm
     aai_cli.commands.login
     aai_cli.commands.sessions
     aai_cli.commands.setup
+    aai_cli.commands.share
     aai_cli.commands.stream
     aai_cli.commands.transcribe
     aai_cli.commands.transcripts

Formula/aai.rb

@@ -10,6 +10,7 @@ class Aai < Formula
 
   depends_on "pkgconf" => :build      # cffi / cryptography native builds
   depends_on "rust" => :build         # pydantic-core, jiter, cryptography
+  depends_on "cloudflared"           # public quick-tunnel for `aai share`
   depends_on "ffmpeg"                # decode non-WAV/URL audio (transcribe/stream)
   depends_on "openssl@3"             # cryptography linkage
   depends_on "portaudio"             # sounddevice (audio capture)

aai_cli/commands/deploy.py

@@ -0,0 +1,145 @@
+# aai_cli/commands/deploy.py
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+
+from aai_cli import help_panels, output
+from aai_cli.context import AppState, run_command
+from aai_cli.errors import CLIError
+from aai_cli.help_text import examples_epilog
+
+# Flattened single-command sub-typer (same pattern as `aai dev`).
+app = typer.Typer()
+
+
+@dataclass(frozen=True)
+class Target:
+    name: str  # human label, e.g. "Vercel"
+    bin: str  # executable resolved via shutil.which
+    flag: str  # CLI selector, e.g. "--vercel"
+    install: str  # full hint sentence shown when the CLI is missing
+    deploy_args: tuple[str, ...]  # subcommand(s) appended after `bin`
+    supports_prod: bool = False  # whether `--prod` adds a production flag
+    post_deploy_args: tuple[str, ...] | None = None  # command run after a successful deploy
+
+    def command(self, *, prod: bool) -> list[str]:
+        argv = [self.bin, *self.deploy_args]
+        if prod and self.supports_prod:
+            argv.append("--prod")
+        return argv
+
+
+VERCEL = Target(
+    name="Vercel",
+    bin="vercel",
+    flag="--vercel",
+    install="Install it with `npm i -g vercel`.",
+    deploy_args=("deploy",),
+    supports_prod=True,
+)
+RAILWAY = Target(
+    name="Railway",
+    bin="railway",
+    flag="--railway",
+    install="Install it with `npm i -g @railway/cli`.",
+    deploy_args=("up",),
+    post_deploy_args=("domain",),
+)
+FLY = Target(
+    name="Fly",
+    bin="fly",
+    flag="--fly",
+    install="Install it with `brew install flyctl`.",
+    # `fly launch` does it all: creates the app, generates fly.toml (detecting the
+    # shipped Dockerfile), and deploys — so no fly.toml needs to exist beforehand.
+    deploy_args=("launch",),
+)
+
+TARGETS = (VERCEL, RAILWAY, FLY)
+
+
+def _resolve_target(selected: list[Target]) -> Target:
+    if len(selected) > 1:
+        flags = " / ".join(t.flag for t in TARGETS)
+        raise CLIError(
+            f"Pass at most one deploy target ({flags}).",
+            error_type="usage_error",
+            exit_code=1,
+        )
+    return selected[0] if selected else VERCEL  # Vercel is the default
+
+
+def _require_cli(target: Target) -> None:
+    if shutil.which(target.bin) is None:
+        raise CLIError(
+            f"The {target.name} CLI is required to deploy. {target.install}",
+            error_type="missing_dependency",
+            exit_code=1,
+        )
+
+
+def _confirmed(target: Target, *, assume_yes: bool) -> bool:
+    """True when the deploy should proceed: --yes, or an interactive yes.
+
+    Refuses to guess in a non-interactive/agent session."""
+    if assume_yes:
+        return True
+    if output.is_agentic():
+        raise CLIError(
+            "Refusing to deploy without confirmation in a non-interactive session. "
+            "Pass --yes to deploy.",
+            error_type="usage_error",
+            exit_code=1,
+        )
+    return typer.confirm(f"Deploy this project to {target.name}?")
+
+
+def run_deploy(*, target: Target, prod: bool, assume_yes: bool) -> None:
+    """Confirm, then run the target's deploy command in the current directory."""
+    _require_cli(target)
+    if not _confirmed(target, assume_yes=assume_yes):
+        output.console.print("Aborted.")
+        return
+    result = subprocess.run(target.command(prod=prod), cwd=Path.cwd(), check=False)
+    if result.returncode:
+        raise typer.Exit(code=result.returncode)
+    if target.post_deploy_args is not None:
+        subprocess.run([target.bin, *target.post_deploy_args], cwd=Path.cwd(), check=False)
+
+
+@app.command(
+    rich_help_panel=help_panels.BUILD,
+    epilog=examples_epilog(
+        [
+            ("Deploy a preview to Vercel (asks first)", "aai deploy"),
+            ("Deploy to production on Vercel", "aai deploy --prod --yes"),
+            ("Deploy to Railway", "aai deploy --railway"),
+            ("Deploy to Fly.io", "aai deploy --fly"),
+        ]
+    ),
+)
+def deploy(
+    ctx: typer.Context,
+    prod: bool = typer.Option(False, "--prod", help="Deploy to production (Vercel only)."),
+    vercel: bool = typer.Option(False, "--vercel", help="Deploy to Vercel (the default)."),
+    railway: bool = typer.Option(False, "--railway", help="Deploy to Railway."),
+    fly: bool = typer.Option(False, "--fly", help="Deploy to Fly.io."),
+    assume_yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Deploy the current project to Vercel (default), Railway, or Fly.io.
+
+    Asks for confirmation first, then runs the target's CLI (`vercel deploy`,
+    `railway up`, or `fly launch`). Requires that target's CLI to be installed.
+    (Render deploys from a connected Git repo — see the project README.)
+    """
+
+    def body(_state: AppState, _json_mode: bool) -> None:
+        selected = [t for t, on in ((VERCEL, vercel), (RAILWAY, railway), (FLY, fly)) if on]
+        run_deploy(target=_resolve_target(selected), prod=prod, assume_yes=assume_yes)
+
+    run_command(ctx, body)

aai_cli/commands/dev.py

@@ -0,0 +1,80 @@
+# aai_cli/commands/dev.py
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import typer
+from rich.markup import escape
+
+from aai_cli import help_panels, output, steps
+from aai_cli.context import AppState, run_command
+from aai_cli.help_text import examples_epilog
+from aai_cli.init import devserver, procfile, runner
+
+# Flattened single-command sub-typer (same pattern as `aai init`): one
+# @app.command() registered via app.add_typer(dev.app) with no name.
+app = typer.Typer()
+
+
+def run_dev(*, port: int, no_install: bool, no_open: bool, json_mode: bool) -> None:
+    """Boot the project's Procfile `web:` process locally, with live reload."""
+    target = Path.cwd()
+    use_uv = runner.has_uv()
+
+    chosen_port = runner.find_free_port(port)
+    env = {**os.environ, "PORT": str(chosen_port)}
+    # Resolves the start command AND validates we're inside a scaffolded project.
+    web = procfile.web_argv(target, env=env)
+
+    report: list[steps.Step] = [
+        devserver.install_step(target, no_install=no_install, use_uv=use_uv)
+    ]
+    output.emit(report, lambda d: steps.render_steps(d, heading="Dev"), json_mode=json_mode)
+    if any(s["status"] == "failed" for s in report):
+        raise typer.Exit(code=1)
+
+    command = devserver.dev_command(target, web, use_uv=use_uv)
+    url = f"http://localhost:{chosen_port}"
+    if not json_mode:
+        output.console.print(
+            f"[aai.heading]Starting[/aai.heading] [aai.url]{escape(url)}[/aai.url]"
+            "  [aai.muted](Ctrl-C to stop)[/aai.muted]"
+        )
+    code = runner.run_server(
+        target, command=command, port=chosen_port, env=env, open_browser=not no_open
+    )
+    if code:
+        raise typer.Exit(code=code)
+
+
+@app.command(
+    rich_help_panel=help_panels.BUILD,
+    epilog=examples_epilog(
+        [
+            ("Launch the app in the current directory", "aai dev"),
+            ("Use a specific port", "aai dev --port 8000"),
+            ("Launch without opening a browser", "aai dev --no-open"),
+            ("Skip the dependency install step", "aai dev --no-install"),
+        ]
+    ),
+)
+def dev(
+    ctx: typer.Context,
+    port: int = typer.Option(3000, "--port", help="Local server port."),
+    no_open: bool = typer.Option(False, "--no-open", help="Launch, but don't open the browser."),
+    no_install: bool = typer.Option(
+        False, "--no-install", help="Skip dependency install; launch directly."
+    ),
+    json_out: bool = typer.Option(False, "--json", help="Output raw JSON."),
+) -> None:
+    """Launch the dev server for the app in the current directory.
+
+    Run this from inside a project created by `aai init`. It installs dependencies
+    if needed, then starts the FastAPI server with live reload and opens the browser.
+    """
+
+    def body(_state: AppState, json_mode: bool) -> None:
+        run_dev(port=port, no_install=no_install, no_open=no_open, json_mode=json_mode)
+
+    run_command(ctx, body, json=json_out)

aai_cli/commands/init.py

@@ -205,7 +205,7 @@ def run_init(
             {
                 "name": "launch",
                 "status": "skipped",
-                "detail": f"no API key; run `aai login`, then: cd {target} && uv run uvicorn api.index:app",
+                "detail": f"no API key; run `aai login`, then: cd {target} && aai dev",
             }
         )
 
@@ -218,9 +218,7 @@ def run_init(
     elif not json_mode:
         # Scaffolded but not launched (no key, or --no-install, or launch=False): leave the
         # user with the one command that starts their app, the way `vercel`/`supabase` sign off.
-        output.console.print(
-            output.hint(f"Run `cd {escape(str(target))} && uv run uvicorn api.index:app`.")
-        )
+        output.console.print(output.hint(f"Run `cd {escape(str(target))} && aai dev`."))
     return target
 
 

aai_cli/commands/onboard.py

@@ -4,7 +4,7 @@
 
 import typer
 
-from aai_cli import help_panels
+from aai_cli import help_panels, output
 from aai_cli.context import AppState, resolve_profile, run_command
 from aai_cli.help_text import examples_epilog
 from aai_cli.onboard import wizard
@@ -14,8 +14,11 @@
 app = typer.Typer()
 
 
-def build_prompter() -> Prompter:
-    """A real prompter only when both ends are a TTY; otherwise never block."""
+def build_prompter(*, non_interactive: bool = False) -> Prompter:
+    """A real prompter only when the caller hasn't opted out and both ends are a TTY;
+    otherwise never block for input."""
+    if non_interactive:
+        return NonInteractivePrompter()
     if sys.stdin.isatty() and sys.stdout.isatty():
         return InteractivePrompter()
     return NonInteractivePrompter()
@@ -32,13 +35,19 @@ def build_prompter() -> Prompter:
 def onboard(
     ctx: typer.Context,
     json_out: bool = typer.Option(False, "--json", help="Output raw JSON."),
+    non_interactive: bool = typer.Option(
+        False,
+        "--non-interactive",
+        help="Run without interactive prompts (default when agent detected).",
+    ),
 ) -> None:
     """Guided setup: sign in, run your first transcription, and start building."""
 
     def body(state: AppState, json_mode: bool) -> None:
         profile = resolve_profile(state)
         wiz_ctx = WizardContext(state=state, profile=profile, json_mode=json_mode)
-        code = wizard.run_onboarding(build_prompter(), wiz_ctx)
+        forced = non_interactive or output.is_agentic()
+        code = wizard.run_onboarding(build_prompter(non_interactive=forced), wiz_ctx)
         if code != 0:
             raise typer.Exit(code=code)