app: Add-program flow with server-side filesystem picker

Register an existing repo as a program from the /programs page — the web
equivalent of `castle program add`. An inline form with an editable,
autocompleting path bar browses the *server's* filesystem (a browser's own
file dialog only sees the client machine) and also accepts a git URL.

- core: extract the adopt logic (target parsing, stack/command detection,
  ProgramSpec build) into castle_core.adopt so the CLI and API share it; the
  CLI's add.py now delegates to it.
- castle-api: GET /fs/browse (directory listing, per-entry stat errors skipped
  so one unreadable child can't 403 the dir) and POST /programs/adopt.
- app: AddProgramForm + Add-program button on the Programs page; useBrowse /
  useAdoptProgram hooks.

Also tidy ProgramCard: deployments render below the description, and the
deployment name label is hidden when it matches the program title.

cli/src/castle_cli/commands/add.py

@@ -3,125 +3,43 @@
 `castle program create` makes new code from a stack. `castle program add` adopts code that
 already exists — a local path, or a git URL to clone. It detects sensible dev
 verb commands so a non-castle project becomes usable without writing them by hand.
+
+The adopt logic itself lives in ``castle_core.adopt`` so the CLI and the API
+(`POST /programs/adopt`, the dashboard's "Add program") behave identically.
 """
 
 from __future__ import annotations
 
 import argparse
-import tomllib
-from pathlib import Path
+
+from castle_core.adopt import AdoptError, build_adopted_program
 
 from castle_cli.config import load_config, save_config
-from castle_cli.manifest import BuildSpec, CommandsSpec, ProgramSpec
-
-
-def _is_git_url(s: str) -> bool:
-    return s.startswith(("http://", "https://", "git@", "ssh://")) or s.endswith(".git")
-
-
-def _detect(src: Path) -> tuple[str | None, dict[str, list[list[str]]]]:
-    """Detect (stack, commands) for a source dir.
-
-    Returns a stack name when the project fits a known one (so it inherits those
-    defaults), otherwise an explicit commands map. `add` adopts source only; the
-    deployment (and thus kind) is declared separately, so no kind is inferred here.
-    """
-    commands: dict[str, list[list[str]]] = {}
-
-    pyproject = src / "pyproject.toml"
-    if pyproject.exists():
-        try:
-            data = tomllib.loads(pyproject.read_text())
-        except (OSError, tomllib.TOMLDecodeError):
-            data = {}
-        deps = " ".join(data.get("project", {}).get("dependencies", []))
-        stack = "python-fastapi" if ("fastapi" in deps or "uvicorn" in deps) else "python-cli"
-        return stack, commands
-
-    if (src / "Cargo.toml").exists():
-        commands = {
-            "build": [["cargo", "build", "--release"]],
-            "test": [["cargo", "test"]],
-            "lint": [["cargo", "clippy"]],
-            "run": [["cargo", "run"]],
-        }
-        return None, commands
-
-    if (src / "package.json").exists():
-        commands = {
-            "build": [["pnpm", "build"]],
-            "test": [["pnpm", "test"]],
-            "lint": [["pnpm", "lint"]],
-        }
-        return None, commands
-
-    if (src / "Makefile").exists() or (src / "makefile").exists():
-        commands = {"build": [["make"]], "test": [["make", "test"]]}
-        return None, commands
-
-    return None, commands
 
 
 def run_add(args: argparse.Namespace) -> int:
     """Adopt an existing repo as a program."""
     config = load_config()
-    target = args.target
 
-    repo_url: str | None = None
-    source: str | None = None
-
-    if _is_git_url(target):
-        repo_url = target
-        name = args.name or Path(target.rstrip("/")).name.removesuffix(".git")
-        # Default local clone location; cloned later via `castle clone`.
-        source = str(config.repos_dir / name)
-        src_path = Path(source)
-    else:
-        src_path = Path(target).expanduser().resolve()
-        if not src_path.exists():
-            print(f"Error: path does not exist: {src_path}")
-            return 1
-        source = str(src_path)
-        name = args.name or src_path.name
-
-    if name in config.programs or config.deployments_named(name):
-        print(f"Error: '{name}' already exists in castle.yaml")
+    try:
+        adopted = build_adopted_program(
+            config, args.target, name=args.name, description=args.description
+        )
+    except AdoptError as e:
+        print(f"Error: {e}")
         return 1
 
-    # Detect verbs from the working copy if we have one on disk. `kind` is derived
-    # from a deployment, not stored on the program — so `castle add` adopts the
-    # source only; declare a deployment separately (castle service/job create).
-    stack: str | None = None
-    detected_commands: dict[str, list[list[str]]] = {}
-    if src_path.exists():
-        stack, detected_commands = _detect(src_path)
-
-    prog = ProgramSpec(
-        id=name,
-        description=args.description or f"Adopted from {target}",
-        source=source,
-        stack=stack,
-        repo=repo_url,
-    )
-    # `build` is declared via BuildSpec; every other verb via CommandsSpec.
-    if detected_commands:
-        build_cmds = detected_commands.pop("build", None)
-        if build_cmds:
-            prog.build = BuildSpec(commands=build_cmds)
-        if detected_commands:
-            prog.commands = CommandsSpec.model_validate(detected_commands)
-
-    config.programs[name] = prog
+    config.programs[adopted.name] = adopted.spec
     save_config(config)
 
-    print(f"Adopted '{name}' as a program.")
-    print(f"  source: {source}")
-    if repo_url:
-        print(f"  repo:   {repo_url}  (run 'castle clone {name}' to fetch it)")
-    if stack:
-        print(f"  stack:  {stack}  (verbs inherited from stack defaults)")
-    elif detected_commands:
-        print(f"  commands detected: {', '.join(sorted(detected_commands))}")
+    print(f"Adopted '{adopted.name}' as a program.")
+    print(f"  source: {adopted.source}")
+    if adopted.repo:
+        print(f"  repo:   {adopted.repo}  (run 'castle clone {adopted.name}' to fetch it)")
+    if adopted.stack:
+        print(f"  stack:  {adopted.stack}  (verbs inherited from stack defaults)")
+    elif adopted.commands:
+        print(f"  commands detected: {', '.join(adopted.commands)}")
     else:
         print("  no stack/commands detected — declare verbs in castle.yaml as needed")
     return 0