@agentsdock/server 1.0.11-beta.1 → 1.0.11-beta.2

package/server/local_session_ownership.py

@@ -157,6 +157,7 @@ def exclusive_lock(path: Path):
 PROVIDER_ID_FIELDS = {
     "claude": "claude_session_id", "codex": "codex_thread_id",
     "cursor": "cursor_session_id", "opencode": "opencode_session_id",
+    "gemini": "gemini_session_id",
 }
 MAX_IMPORT_INDEX_BYTES = 64 * 1024 * 1024
 MAX_IMPORT_INDEX_TOTAL_BYTES = 128 * 1024 * 1024

package/server/provider_commands.py

@@ -987,6 +987,71 @@ def claude_provider_command_inventory(
     )
 
 
+def gemini_provider_skill_inventory(raw: str, *, cwd: str, selector_secret: str,
+                                    binding_context: str) -> ProviderCommandInventory:
+    """Project the pinned CLI's own resolved inventory, not a guessed scanner.
+
+    CLI 0.64 has no JSON skills command. Parse its exact bounded list format and
+    fail closed on ambiguous output. Paths/content stay server-side; invocation
+    asks Gemini's native activate_skill tool and never grants a tool permission.
+    """
+    records = []
+    text = raw.replace("\r\n", "\n")
+    if text.strip() == "No skills discovered.":
+        return _inventory(selector_secret, binding_context, "gemini", cwd, [], truncated=False)
+    header = "Discovered Agent Skills:\n\n"
+    if not text.startswith(header) or len(text.encode()) > 1024 * 1024:
+        raise ProviderCommandDiscoveryError("Gemini skill inventory format is unsupported")
+    blocks = text[len(header):].rstrip("\n").split("\n\n")
+    if len(blocks) > MAX_PROVIDER_COMMANDS:
+        raise ProviderCommandDiscoveryError("Gemini skill inventory exceeded its limit")
+    seen = set()
+    total = 0
+    for block in blocks:
+        match = re.fullmatch(r"([^\n]+) \[(Enabled|Disabled)\]( \[Built-in\])?\n  Description: ([\s\S]*?)\n  Location:    ([^\n]+)", block)
+        if not match:
+            raise ProviderCommandDiscoveryError("Gemini skill inventory format is unsupported")
+        name, enabled, builtin, description, location = match.groups()
+        if enabled == "Disabled":
+            continue
+        # Native names can be more permissive than our slash-token grammar.
+        # Such skills remain usable by the agent but are not offered as tokens.
+        if canonical_provider_command_name(name) is None:
+            continue
+        if name.casefold() in seen:
+            raise ProviderCommandDiscoveryError("Gemini skill names are ambiguous")
+        seen.add(name.casefold())
+        path = Path(location)
+        if not path.is_absolute() or path.name != "SKILL.md" or len(location) > MAX_PROVIDER_COMMAND_PATH_CHARS:
+            raise ProviderCommandDiscoveryError("Gemini returned an invalid skill location")
+        # Resolve native installed links, then open only a regular, bounded file.
+        # Discovery/revalidation is read-only; never use this path as a command.
+        path = path.resolve(strict=True)
+        descriptor = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+        try:
+            info = os.fstat(descriptor)
+            if not stat.S_ISREG(info.st_mode) or info.st_size > 1024 * 1024:
+                raise ProviderCommandDiscoveryError("Gemini skill file is unsupported")
+            data = os.read(descriptor, 1024 * 1024 + 1)
+            after = os.fstat(descriptor)
+            if len(data) > 1024 * 1024 or (info.st_size, info.st_mtime_ns) != (after.st_size, after.st_mtime_ns):
+                raise ProviderCommandDiscoveryError("Gemini skill changed during discovery")
+        finally:
+            os.close(descriptor)
+        total += len(data)
+        if total > 16 * 1024 * 1024:
+            raise ProviderCommandDiscoveryError("Gemini skills exceeded the aggregate limit")
+        digest = hashlib.sha256(data).hexdigest()
+        command_id = _opaque_command_id(selector_secret, binding_context, "gemini", cwd,
+            name, json.dumps([str(path), digest]))
+        records.append(ProviderCommandRecord(public={
+            "id": command_id, "name": name, "label": name,
+            "description": sanitize_provider_command_text(description, MAX_PROVIDER_COMMAND_DESCRIPTION_CHARS),
+            "scope": "built-in" if builtin else "native", "source": "gemini", "kind": "skill", "invocation": f"/{name}",
+        }, native={"name": name, "path": str(path), "content_sha256": digest}))
+    return _inventory(selector_secret, binding_context, "gemini", cwd, records, truncated=False)
+
+
 def empty_provider_command_inventory(
     backend: str,
     *,

package/server/provider_connections.py

@@ -28,7 +28,7 @@ MAX_BODY_BYTES = 16 * 1024
 # Reasoning can consume output tokens before the short visible check answer.
 # Keep this explicit probe bounded and single-shot, including for such models.
 MODEL_CHECK_MAX_OUTPUT_TOKENS = 256
-PROTOCOLS = {"claude": {"anthropic"}, "opencode": {"anthropic", "chat_completions", "responses"}, "cursor": {"cursor"}}
+PROTOCOLS = {"claude": {"anthropic"}, "opencode": {"anthropic", "chat_completions", "responses"}, "cursor": {"cursor"}, "gemini": {"gemini"}}
 RESULTS = {"verified", "authentication_failed", "rate_limited", "unsupported", "connection_failed", "invalid_response", "model_required", "cli_update_required"}
 
 
@@ -52,9 +52,11 @@ def selection(backend: str, value: object) -> dict:
         from cursor_api_key import ENDPOINT
         if value["base_url"] != ENDPOINT or value["protocol"] != "cursor" or value["auth_header"] != "bearer":
             raise HTTPException(400, "Cursor API keys use Cursor's official service only.")
-    if not isinstance(value["protocol"], str) or not isinstance(value["auth_header"], str) or value["protocol"] not in PROTOCOLS[backend] or value["auth_header"] not in {"bearer", "x-api-key"}:
+    if not isinstance(value["protocol"], str) or not isinstance(value["auth_header"], str) or value["protocol"] not in PROTOCOLS[backend] or value["auth_header"] not in {"bearer", "x-api-key", "x-goog-api-key"}:
         raise HTTPException(400, "Unsupported API protocol or authentication header.")
-    if value["protocol"] != "anthropic" and value["auth_header"] != "bearer":
+    if (value["protocol"] == "gemini") != (value["auth_header"] == "x-goog-api-key"):
+        raise HTTPException(400, "Gemini API requires x-goog-api-key authentication.")
+    if value["protocol"] not in {"anthropic", "gemini"} and value["auth_header"] != "bearer":
         raise HTTPException(400, "This API protocol requires bearer authentication.")
     selected = validate_selection({"base_url": value["base_url"], "api_key": value["api_key"],
                                    "model": None if value["model"] == "" else value["model"]})
@@ -207,11 +209,15 @@ class ConnectionStore:
         try:
             value = self.for_session(session) if session else self.read(backend)
             configured = value.get("configured") is True and value.get("last_result") == "verified"
+            model = value.get("model")
+            if configured and backend == "gemini":
+                from gemini_api import default_model
+                model = default_model(value)
             if summary:
                 # Large endpoint inventories belong to detail/settings reads,
                 # not repeated once for every row of a session-list response.
                 return {"configured": configured, "available": configured and installed,
-                        "model": value.get("model"), "base_url": value.get("base_url")}
+                        "model": model, "base_url": value.get("base_url")}
             models = []
             if configured:
                 cache_key = (backend, value["revision"])
@@ -225,12 +231,14 @@ class ConnectionStore:
                         self.catalog_cache.pop(next(iter(self.catalog_cache)))
                 if backend == "cursor" and not models:
                     models = [{"value": "auto", "label": "Auto"}]
-                model = value.get("model")
+                if backend == "gemini":
+                    from gemini_api import model_options
+                    models = model_options(value, models)
                 if model and not any(item["value"] == model for item in models):
                     models = [{"value": model, "label": model}, *models]
             return {"configured": configured, "available": configured and installed,
-                    "models": models, "efforts": [], "default_model": value.get("model"),
-                    "model": value.get("model"), "default_effort": None, "base_url": value.get("base_url")}
+                    "models": models, "efforts": [], "default_model": model,
+                    "model": model, "default_effort": None, "base_url": value.get("base_url")}
         except HTTPException:
             return {"configured": False, "available": False, "models": [], "efforts": [], "model": None, "base_url": None}
 
@@ -317,6 +325,9 @@ def require_model(value: dict) -> str:
 
 
 def discover_models(value: dict) -> list[dict]:
+    if value["protocol"] == "gemini":
+        from gemini_api import catalog
+        return catalog(value)["models"]
     return endpoint_model_catalog(value, protocol=value["protocol"])["models"]
 
 
@@ -355,6 +366,9 @@ def native_credentials_present(backend: str, diagnostic: dict) -> bool:
 
 async def probe_credentials(selected: dict) -> str:
     """Read-only key check. Public model lists alone never verify a credential."""
+    if selected.get("protocol") == "gemini":
+        from gemini_api import probe as gemini_probe
+        return await gemini_probe({**selected, "model": None})
     base = selected["base_url"]
     protocol = selected.get("protocol", "responses")
     headers = {"Accept": "application/json", "anthropic-version": "2023-06-01"}
@@ -397,6 +411,9 @@ async def probe_credentials(selected: dict) -> str:
 
 async def probe(selected: dict) -> str:
     """One small, explicit model request; no tools/history, redirects or retries."""
+    if selected.get("protocol") == "gemini":
+        from gemini_api import probe as gemini_probe
+        return await gemini_probe(selected)
     if not selected.get("model"):
         return await probe_credentials(selected)
     protocol = selected["protocol"]
@@ -546,7 +563,7 @@ def create_router(*, authorize, store: ConnectionStore, check=probe, account=nat
         return JSONResponse(value, headers={"Cache-Control": "no-store"})
 
     async def model_selection(backend, session_id=None):
-        if backend not in {"codex", "claude", "opencode", "cursor"}:
+        if backend not in {"codex", "claude", "opencode", "cursor", "gemini"}:
             raise HTTPException(400, "Unsupported custom endpoint.")
         session = session_lookup(session_id) if session_id and session_lookup else None
         if session_id and (not session or session.get("backend") != backend):
@@ -567,6 +584,10 @@ def create_router(*, authorize, store: ConnectionStore, check=probe, account=nat
         if backend == "cursor":
             if cursor_catalog is None: raise HTTPException(501, "Cursor API keys are unavailable.")
             result = await cursor_catalog(selected)
+        elif backend == "gemini":
+            from gemini_api import catalog, model_options
+            result = await asyncio.to_thread(catalog, selected)
+            result["models"] = model_options(selected, result["models"])
         else:
             result = await asyncio.to_thread(endpoint_model_catalog, selected, protocol=selected.get("protocol", "responses"))
         # Fence a settings read that raced replacement/forget. Session bindings
@@ -581,8 +602,12 @@ def create_router(*, authorize, store: ConnectionStore, check=probe, account=nat
             with store.lock:
                 store.catalog_cache[(backend, selected["revision"])] = (time.monotonic(), result["models"])
                 if len(store.catalog_cache) > 32: store.catalog_cache.pop(next(iter(store.catalog_cache)))
+        model = selected.get("model")
+        if backend == "gemini":
+            from gemini_api import default_model
+            model = default_model(selected)
         return reply({"backend": backend, "revision": selected.get("credential_id") if backend == "codex" else selected["revision"],
-                      "models": result["models"], "default_model": selected.get("model"), "discovery_status": result["discovery_status"]})
+                      "models": result["models"], "default_model": model, "discovery_status": result["discovery_status"]})
 
     @router.put("/api/admin/provider-models/{backend}")
     async def default_model(backend: str, request: Request):
@@ -611,7 +636,11 @@ def create_router(*, authorize, store: ConnectionStore, check=probe, account=nat
                     saved = store.write(backend, current["revision"], {**value, "model": model, "expected_revision": current["revision"]}, current["last_result"], checked_at=current["checked_at"])
                     cached = store.catalog_cache.get((backend, current["revision"]))
                     if cached: store.catalog_cache[(backend, saved["revision"])] = cached
-                    return {"backend": backend, "revision": saved["revision"], "default_model": saved["model"]}
+                    effective_model = saved["model"]
+                    if backend == "gemini":
+                        from gemini_api import default_model as gemini_default_model
+                        effective_model = gemini_default_model(saved)
+                    return {"backend": backend, "revision": saved["revision"], "default_model": effective_model}
             return reply(await asyncio.to_thread(save_model))
 
     @router.get("/api/admin/provider-accounts/{backend}")

package/server/server_instances.py

@@ -666,11 +666,8 @@ def show(instance: Instance, *, network: dict[str, str] | None = None):
     print()
 
 
-def show_status(instance: Instance, *, network: dict[str, str]) -> None:
-    """Read-only per-instance summary; never print configuration or tokens."""
-    item = describe(instance)
-    print(terminal_color(f"Server ({item['name']}):", "34"))
-    print(f"  Status:   {item['status']}")
+def show_connection_addresses(instance: Instance, item: dict, network: dict[str, str]) -> None:
+    """Use the same binding-aware address order for status and token display."""
     addresses = []
     if item["port"]:
         choices = connection_choices(read_config(instance).get("AGENTSDOCK_AGENT_BIND", "0.0.0.0"),
@@ -683,11 +680,150 @@ def show_status(instance: Instance, *, network: dict[str, str]) -> None:
     print("  Address:  " + (addresses[0] if addresses else "Not configured"))
     for address in addresses[1:]:
         print("            " + address)
+
+
+def show_status(instance: Instance, *, network: dict[str, str]) -> None:
+    """Read-only per-instance summary; never print configuration or tokens."""
+    item = describe(instance)
+    print(terminal_color(f"Server ({item['name']}):", "34"))
+    print(f"  Status:   {item['status']}")
+    show_connection_addresses(instance, item, network)
     print(f"  Version:  {item['version'] or 'unknown'}")
     print(f"  Port:     {item['port'] or 'Not configured'}")
     print()
 
 
+LOG_READ_BYTES = 1024 * 1024
+
+
+def log_line_count(value: str) -> int:
+    if not re.fullmatch(r"[0-9]{1,5}", value) or int(value) > 10000:
+        raise argparse.ArgumentTypeError("Log lines must be between 0 and 10000.")
+    return int(value)
+
+
+def log_sources(instance: Instance, platform: str) -> tuple[list[Path], list[str]]:
+    """Resolve fixed local log sources; never execute configuration or adopt paths."""
+    manifest = instance.runtime / "execution-layout.json"
+    check_path(manifest, instance.home)
+    if manifest.exists():
+        from execution_install import installed_layout
+
+        layout = installed_layout(instance.runtime)
+        if (instance.name != "default" or layout.install_root != instance.runtime
+                or layout.config_root != instance.config or layout.state_root != instance.state
+                or layout.home != instance.home
+                or layout.platform != ("Darwin" if platform == "darwin" else "Linux")):
+            raise ValueError("Execution log layout does not match the selected instance.")
+        return ([instance.state / "execution/logs" / f"{role}.{stream}.log"
+                 for role in ("gateway", "worker") for stream in ("stdout", "stderr")],
+                ["agents-server-gateway.service", "agents-server.service"])
+    validate_binding(instance, platform)
+    return ([instance.logs / "server.log", instance.logs / "server-error.log"],
+            [service_name(instance.name) + ".service"])
+
+
+def read_log_slice(instance: Instance, path: Path, lines: int,
+                   cursor: tuple[int, int, int] | None = None) -> tuple[bytes, tuple[int, int, int] | None, bool]:
+    """Bounded tail on first read, then bounded appended bytes; reopen on rotation.
+
+    Revalidate every open, including followed replacements. No shell tail process,
+    FIFO, symlink or file outside the selected fixed log roots is followed.
+    """
+    check_path(path, instance.home)
+    try:
+        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+    except FileNotFoundError:
+        # Remember that viewing has begun so a file created during --follow is
+        # read from its start, including with --lines 0.
+        return b"", cursor or (0, 0, 0), False
+    with os.fdopen(fd, "rb") as handle:
+        info = os.fstat(handle.fileno())
+        if (not stat.S_ISREG(info.st_mode) or info.st_uid != os.getuid()
+                or info.st_mode & 0o022 or info.st_nlink != 1):
+            raise ValueError(f"Unsafe service log: {path.name}")
+        identity = (info.st_dev, info.st_ino)
+        truncated = False
+        if cursor is None:
+            start = max(0, info.st_size - LOG_READ_BYTES) if lines else info.st_size
+            truncated = bool(start and lines)
+        elif cursor[:2] == identity and info.st_size >= cursor[2]:
+            start = cursor[2]
+        else:
+            start = 0  # The file was replaced or truncated, not a new history scan.
+        handle.seek(start)
+        data = handle.read(min(LOG_READ_BYTES, max(0, info.st_size - start)))
+        next_cursor = (*identity, start + len(data))
+        if cursor is None:
+            if truncated:
+                _partial, separator, rest = data.partition(b"\n")
+                data = rest if separator else b""
+            data = b"\n".join(data.split(b"\n")[-lines - (1 if data.endswith(b"\n") else 0):]) if lines else b""
+        return data, next_cursor, truncated
+
+
+def print_log_data(data: bytes) -> None:
+    # Logs are untrusted text; do not execute terminal escape/control sequences.
+    text = data.decode("utf-8", errors="replace")
+    text = "".join(f"\\x{ord(char):02x}" if (ord(char) < 32 and char not in "\n\t")
+                   or 127 <= ord(char) < 160 else char for char in text)
+    print(text, end="" if text.endswith("\n") else "\n", flush=True)
+
+
+def show_logs(instance: Instance, *, lines: int = 100, follow: bool = False,
+              platform: str = sys.platform) -> int:
+    if platform != "darwin" and not platform.startswith("linux"):
+        raise ValueError("Service logs are supported on macOS and Linux only.")
+    paths, units = log_sources(instance, platform)
+    port = read_config(instance).get("AGENTSDOCK_AGENT_PORT", "")
+    print(terminal_color(f"Logs ({instance.name}):", "34"), flush=True)
+    if port.isdigit() and 1 <= int(port) <= 65535:
+        print(f"  Port: {int(port)}", flush=True)
+    print("  Logs may contain private data. Review before sharing.", flush=True)
+    if follow:
+        print("  Following new entries; Ctrl+C stops viewing, not the server.", flush=True)
+    if platform.startswith("linux"):
+        print(f"  Last {lines} journal entries across: {', '.join(units)}\n", flush=True)
+        command = ["journalctl", "--user", "--no-pager", "--output=short-iso", "--lines", str(lines)]
+        for unit in units:
+            command += ["--unit", unit]
+        if follow:
+            command.append("--follow")
+        try:
+            result = subprocess.run(command, env={**os.environ, "SYSTEMD_COLORS": "0",
+                                    "SYSTEMD_PAGERSECURE": "1"}, check=False,
+                                    timeout=None if follow else 15)
+            return result.returncode if result.returncode >= 0 else 130
+        except subprocess.TimeoutExpired:
+            raise ValueError("Reading the service journal timed out. Try again with fewer lines.") from None
+        except KeyboardInterrupt:
+            print("\nStopped viewing logs.", flush=True)
+            return 0
+    print(f"  Last {lines} lines per file (up to 1 MiB per file).\n", flush=True)
+    cursors: dict[Path, tuple[int, int, int] | None] = {path: None for path in paths}
+    first = True
+    try:
+        while True:
+            for path in paths:
+                data, cursor, truncated = read_log_slice(instance, path, lines, cursors[path])
+                cursors[path] = cursor
+                if first or data or truncated:
+                    print(f"==> {path.name} <==", flush=True)
+                    if truncated:
+                        print("[Older bytes omitted: initial read is limited to 1 MiB.]", flush=True)
+                    if data:
+                        print_log_data(data)
+                    elif first:
+                        print("(no log entries to show)", flush=True)
+            if not follow:
+                return 0
+            first = False
+            time.sleep(0.25)
+    except KeyboardInterrupt:
+        print("\nStopped viewing logs.", flush=True)
+        return 0
+
+
 def read_token_menu_key(fd: int) -> str:
     key = os.read(fd, 1)
     if key in (b"", b"\x03", b"\x04"):
@@ -754,9 +890,10 @@ def arrow_token_choice(rows: list[str], fd: int, settings: list) -> int | None:
         sys.stdout.flush()
 
 
-def choose_token_instance(registry: Registry) -> Instance | None:
+def choose_token_instance(registry: Registry, items: list[Instance] | None = None) -> Instance | None:
     """Select by stable instance name; never default or expose unselected tokens."""
-    items = registry.instances()
+    if items is None:
+        items = registry.instances()
     if not items:
         print("No installations found. Run agentsdock setup to create your first server.")
         return None
@@ -807,6 +944,34 @@ def choose_token_instance(registry: Registry) -> Instance | None:
         print(f"Please enter a number from 1 to {len(items)} or a listed server name (Enter cancels).")
 
 
+def show_instance_token(instance: Instance, *, network: dict[str, str] | None = None) -> int:
+    # Redirected explicit token commands retain their raw, single-token output.
+    if sys.stdin.isatty() and sys.stdout.isatty():
+        print(terminal_color(f"\nServer ({instance.name}):", "34"))
+        show_connection_addresses(instance, describe(instance), network if network is not None else tailscale_status())
+        sys.stdout.flush()  # Keep the URL before the child helper's token/prompt.
+    try:
+        run(["/bin/bash", str(ROOT / "install.sh"), "--instance", instance.name, "--show-token"],
+            env=clean_environment(instance), cwd=ROOT)
+        return 0
+    except subprocess.CalledProcessError as exc:
+        return exc.returncode if exc.returncode > 0 else 1
+
+
+def offer_status_token(registry: Registry, items: list[Instance], network: dict[str, str]) -> int:
+    if not items or not (sys.stdin.isatty() and sys.stdout.isatty()):
+        return 0
+    try:
+        answer = input("View a server's URL and access token? [y/N] ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return 0
+    if answer not in {"y", "yes"}:
+        return 0
+    selected = choose_token_instance(registry, items)
+    return show_instance_token(selected, network=network) if selected is not None else 0
+
+
 def terminal_color(text: str, code: str) -> str:
     color = sys.stdout.isatty() and os.environ.get("TERM") != "dumb" and "NO_COLOR" not in os.environ
     return f"\033[{code}m{text}\033[0m" if color else text
@@ -952,13 +1117,19 @@ def parser() -> argparse.ArgumentParser:
     result = argparse.ArgumentParser(description="Independent AgentsServer instances for the current OS user. Defaults to list.")
     commands = result.add_subparsers(dest="command")
     commands.add_parser("list")
-    commands.add_parser("token", help="Choose an existing server and display only its access token")
+    token = commands.add_parser("token", help="Choose an existing server and display its URL and access token")
+    token.add_argument("name", nargs="?", type=instance_name)
     info = commands.add_parser("info")
     info.add_argument("name", type=instance_name)
     pairing = commands.add_parser("_pair-info", help=argparse.SUPPRESS)
     pairing.add_argument("name", type=instance_name)
     status = commands.add_parser("status", help="Show readable details for all instances or one name")
     status.add_argument("name", nargs="?", type=instance_name)
+    logs = commands.add_parser("logs", help="Read recent local service logs; use --follow for live output")
+    logs.add_argument("name", nargs="?", type=instance_name)
+    logs.add_argument("--instance", dest="named", type=instance_name)
+    logs.add_argument("-n", "--lines", type=log_line_count, default=100)
+    logs.add_argument("-f", "--follow", action="store_true")
     new = commands.add_parser("new")
     new.add_argument("--name", type=instance_name)
     new.add_argument("--port", type=int)
@@ -1001,16 +1172,24 @@ def main(argv: list[str] | None = None) -> int:
                 raise ValueError("Unknown instance. Use agentsdock list.")
             print(json.dumps(pairing_info(selected)))
             return 0
+        if args.command == "logs":
+            if args.name and args.named:
+                raise ValueError("Select the log instance once: NAME or --instance NAME.")
+            name = args.name or args.named or "default"
+            selected = next((item for item in registry.instances() if item.name == name), None)
+            if selected is None:
+                raise ValueError(f"Unknown instance {name!r}. Use agentsdock list to find its name.")
+            return show_logs(selected, lines=args.lines, follow=args.follow)
         if args.command == "token":
-            selected = choose_token_instance(registry)
+            if args.name:
+                # The installer retains read-only legacy token discovery even
+                # when an old default install is absent from the new registry.
+                selected = Instance(args.name, registry.home)
+            else:
+                selected = choose_token_instance(registry)
             if selected is None:
                 return 0
-            try:
-                run(["/bin/bash", str(ROOT / "install.sh"), "--instance", selected.name, "--show-token"],
-                    env=clean_environment(selected), cwd=ROOT)
-                return 0
-            except subprocess.CalledProcessError as exc:
-                return exc.returncode if exc.returncode > 0 else 1
+            return show_instance_token(selected)
         if args.command in {None, "list", "info", "status"}:
             items = registry.instances()
             if args.command in {"info", "status"} and args.name:
@@ -1025,6 +1204,7 @@ def main(argv: list[str] | None = None) -> int:
                     show_status(item, network=network)
                 if not items:
                     print("No installations found. Run agentsdock setup to create your first server.")
+                return offer_status_token(registry, items, network)
             else:
                 network = tailscale_status() if items else None
                 print("NAME                 STATUS     PORT")

package/server/title_generation.py

@@ -13,6 +13,9 @@ import sys
 import tempfile
 import time
 import unicodedata
+from urllib.parse import quote
+
+import httpx
 
 from codex_app_server import CodexAppServerClient
 from codex_side_question import isolated_config
@@ -35,6 +38,12 @@ class TitleGenerationError(Exception):
     """Keep errors content-free: prompts, credentials and output are private."""
 
 
+def gemini_title_seed(text: str) -> str:
+    # Pasted logs often put the actual question at the end. Keep the same
+    # bounded budget as other providers without storing the full log twice.
+    return text if len(text) <= 1600 else text[:780] + '\n[excerpt omitted]\n' + text[-800:]
+
+
 def title_prompt(user_text: str, reply: str) -> str:
     return INSTRUCTIONS + "\n\n" + json.dumps(
         {"user_message": user_text[:1600], "assistant_reply": reply[:800]},
@@ -329,8 +338,58 @@ async def generate_cursor_title(prompt: str, *, executable: str, model: str | No
         return clean_title(result)
 
 
+async def generate_gemini_title(prompt: str, *, model: str | None, provider_selection: dict) -> str | None:
+    """One tool-free API request on the exact chat binding; no native session.
+
+    No CLI, hooks, MCP, filesystem tools, account fallback or model discovery.
+    The caller resolves CLI Auto from this conversation's native model metadata.
+    """
+    from gemini_api import MODEL, api_base
+
+    if (not isinstance(model, str) or model == 'auto' or not MODEL.fullmatch(model)
+            or provider_selection.get('protocol') != 'gemini'
+            or provider_selection.get('auth_header') != 'x-goog-api-key'
+            or not provider_selection.get('api_key')):
+        raise TitleGenerationError('Gemini title connection/model unavailable')
+    try:
+        async with httpx.AsyncClient(timeout=TIMEOUT_SECONDS, follow_redirects=False, trust_env=False) as client:
+            async with client.stream('POST', api_base(provider_selection) + '/models/' + quote(model, safe='') + ':generateContent',
+                    headers={'x-goog-api-key': provider_selection['api_key']},
+                    json={'contents': [{'role': 'user', 'parts': [{'text': prompt}]}],
+                          'generationConfig': {'maxOutputTokens': 1024, 'candidateCount': 1}}) as response:
+                if response.status_code != 200:
+                    raise TitleGenerationError('Gemini title request failed')
+                raw = bytearray()
+                async for chunk in response.aiter_bytes(chunk_size=8192):
+                    raw.extend(chunk)
+                    if len(raw) > 64 * 1024:
+                        raise TitleGenerationError('Excessive Gemini title output')
+                value = json.loads(raw)
+        candidates = value.get('candidates')
+        if not isinstance(candidates, list) or len(candidates) != 1 or candidates[0].get('finishReason') != 'STOP':
+            raise TitleGenerationError('Gemini title request did not complete')
+        parts = candidates[0].get('content', {}).get('parts')
+        if not isinstance(parts, list) or not parts or len(parts) > 32:
+            raise TitleGenerationError('Invalid Gemini title output')
+        text = []
+        for part in parts:
+            if (not isinstance(part, dict) or not isinstance(part.get('text'), str)
+                    or set(part) - {'text', 'thought', 'thoughtSignature'}
+                    or ('thought' in part and not isinstance(part['thought'], bool))):
+                raise TitleGenerationError('Unexpected Gemini title content')
+            if part.get('thought') is not True:
+                text.append(part['text'])
+        title = clean_title(''.join(text))
+        if title and provider_selection['api_key'] in title:
+            return None
+        return title
+    except (httpx.HTTPError, ValueError, TypeError, AttributeError, KeyError):
+        raise TitleGenerationError('Gemini title request failed') from None
+
+
 async def generate_title(backend: str, user_text: str, reply: str, **options) -> str | None:
-    generator = {'codex': generate_codex_title, 'cursor': generate_cursor_title}.get(backend)
+    generator = {'codex': generate_codex_title, 'cursor': generate_cursor_title,
+                 'gemini': generate_gemini_title}.get(backend)
     if generator is None:
         return None
     return await asyncio.wait_for(generator(title_prompt(user_text, reply), **options), TIMEOUT_SECONDS)

package/server/transcript_reader.py

@@ -109,12 +109,15 @@ class RawRecord:
 
 
 class _RecordParser:
-    def __init__(self, stream, end, deadline, cancelled, project, maximum, budget_seconds):
+    def __init__(self, stream, end, deadline, cancelled, project, maximum, budget_seconds, retained_fields=None, max_nodes=-1, max_depth=None):
         self.stream, self.end = stream, end
         self.deadline, self.cancelled, self.project = deadline, cancelled, project
         self.buffer, self.index, self.final, self.complete = b'', 0, False, False
         self.retained, self.nodes, self.maximum = 0, 0, maximum
         self.budget_seconds = budget_seconds
+        self.retained_fields = retained_fields
+        self.max_nodes = MAX_NODES if max_nodes == -1 else max_nodes
+        self.max_depth = MAX_DEPTH if max_depth is None else max_depth
 
     def fill(self):
         if self.index < len(self.buffer):
@@ -207,15 +210,17 @@ class _RecordParser:
 
     def value(self, path=(), retain=True, depth=0):
         self.nodes += 1
-        if depth > MAX_DEPTH:
+        if depth > self.max_depth:
             raise TranscriptBudgetExceeded(
                 'Single transcript record exceeds the JSON nesting limit: '
-                f'observed depth {depth:,}; limit {MAX_DEPTH:,}.')
-        if self.nodes > MAX_NODES:
+                f'observed depth {depth:,}; limit {self.max_depth:,}.')
+        if self.max_nodes is not None and self.nodes > self.max_nodes:
             raise TranscriptBudgetExceeded(
                 'Single transcript record exceeds the JSON value-count limit: '
-                f'observed at least {self.nodes:,} values; limit {MAX_NODES:,}.')
+                f'observed at least {self.nodes:,} values; limit {self.max_nodes:,}.')
         self.space()
+        if path and self.retained_fields is not None and path[0] not in self.retained_fields:
+            retain = False
         if self.project and opaque_path(path):
             retain = False
         if retain:
@@ -235,7 +240,11 @@ class _RecordParser:
             while True:
                 if obj:
                     self.space()
-                    key = self.string(True, key=True)
+                    # Explicit metadata projection does not need keys inside
+                    # discarded subtrees. Do not charge transient key bytes as
+                    # retained metadata (native import behavior is unchanged).
+                    keep_key = retain or self.retained_fields is None or self.project
+                    key = self.string(keep_key, key=True)
                     self.space()
                     if self.take() != 58:
                         raise InvalidRecord('JSON colon expected')
@@ -271,12 +280,15 @@ class _RecordParser:
 
 def jsonl_records(stream: BinaryIO, *, end: int, project=True, strict=False,
                   require_newline=True, max_records=250_000, deadline=None,
-                  cancelled=None, max_retained_bytes=MAX_RETAINED_BYTES):
+                  cancelled=None, max_retained_bytes=MAX_RETAINED_BYTES, retained_fields=None,
+                  max_nodes=-1, max_depth=None):
     """Yield (projected object or None, ending offset, RawRecord).
 
     Malformed provider lines may be represented by None, as before. Resource
     exhaustion always raises, so callers never commit a partial-success cursor.
     A fixed end excludes concurrent appends; callers own file identity checks.
+    Native-import work budgets remain the default. Durable metadata-only scans
+    can supply separate structural limits without imposing import caps on logs.
     """
     # Externally supplied deadlines can belong to a larger operation. Do not
     # invent a duration for them; the caller can provide its own timeout detail.
@@ -291,7 +303,7 @@ def jsonl_records(stream: BinaryIO, *, end: int, project=True, strict=False,
                 'Transcript scan exceeds the record-count limit: '
                 f'observed at least {count:,} records; limit {max_records:,}. '
                 'This counts JSONL records, not chat messages.').at_record(count, start)
-        parser = _RecordParser(stream, end, deadline, cancelled, project, max_retained_bytes, budget_seconds)
+        parser = _RecordParser(stream, end, deadline, cancelled, project, max_retained_bytes, budget_seconds, retained_fields, max_nodes, max_depth)
         blank = False
         malformed = False
         try: