silicon-cli 1.0.0__tar.gz → 1.0.4__tar.gz

silicon_cli-1.0.4/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: silicon-cli
+Version: 1.0.4
+Summary: Silicon CLI — create, run, and manage your silicon instances.
+Author: Saket
+Project-URL: Homepage, https://github.com/saket1225/silicon-cli
+Project-URL: Repository, https://github.com/saket1225/silicon-cli
+Keywords: silicon,cli,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: certifi>=2024.2.2
+Dynamic: license-file
+
+# silicon-cli
+
+This is the single source for the installable **`silicon`** command. The PyPI
+package is named `silicon-cli`, and the code lives here in this `silicon-cli`
+repo.
+
+The command manages silicon instances on a machine: create them from the
+[silicon-stemcell](https://github.com/unlikefraction/silicon-stemcell) base,
+start/stop them under an auto-restart watchdog, stream logs, and back them up to
+Glass. It reads the same `~/.silicon/registry.json`, so existing installs carry
+over unchanged.
+
+## Install
+
+```bash
+pip install silicon-cli
+```
+
+(Zero runtime dependencies — stdlib only.)
+
+## Commands
+
+```
+silicon                      Show status or list instances
+silicon new [dir]            Create a new Silicon (hydrate from stemcell)
+silicon new .                Hydrate the current folder into a runnable silicon
+silicon start <target>       Start silicon(s). target = name, index, 1,2,4, or all
+silicon stop [--full] <target>  Stop silicon(s) (--full also stops the glass agent)
+silicon restart <target>     Restart silicon(s)
+silicon agent <start|stop|status> [name]   Manage the per-silicon glass agent
+silicon status [name]        Show instance status
+silicon browser [name]       Open a headed browser for login
+silicon debug [name]         Tail a running instance's logs
+silicon attach [path]        Register an existing silicon directory
+silicon pull [api_token]     Pull a Glass silicon into a new local folder
+silicon push [name] [now|stop]   Daily 23:59 GMT backups to Glass (now = one-shot, stop = end loop)
+silicon backup [name] [now|stop] Alias for silicon push
+silicon update <target>      Update silicon(s) from the latest stemcell
+silicon list                 List all instances
+silicon script update        Update this CLI itself
+silicon help                 Show help
+```
+
+## Configuration (env vars)
+
+| Var | Default | Purpose |
+| --- | --- | --- |
+| `SILICON_HOME` | `~/.silicon` | registry + CLI state |
+| `GLASS_SERVER_URL` | `https://glass.teamofsilicons.com` | Glass sync server (pull/push) |
+| `SILICON_STEMCELL_REPO` | `unlikefraction/silicon-stemcell` | base for `new` |
+| `SILICON_GLASS_CLI_REPO` | `unlikefraction/glass` | glass backup CLI |
+| `SILICON_PYTHON` | `python3` | interpreter used to run a silicon's `main.py` |
+| `SILICON_INTERFACE_CLI_PACKAGE` | `@teamofsilicons/silicon-interface-cli` | npm package used to install the Silicon Interface CLI |
+| `SILICON_INTERFACE_CLI_TARBALL` | versioned npm tarball | fallback package URL if registry metadata is briefly unavailable |
+| `SILICON_INTERFACE_CLI_SOURCE` | *(empty)* | local package dir or `silicon-interface.mjs` path for dev installs |
+| `SILICON_INTERFACE_CLI_SKIP` | *(empty)* | set to `1` to skip interface CLI setup |
+| `SILICON_INTERFACE_DAEMON_SKIP` | *(empty)* | set to `1` to install the CLI without starting its listener daemon |
+
+## Silicon Interface CLI
+
+`silicon new`, `silicon install`, and `silicon pull` also set up the
+Silicon Interface CLI in the silicon folder when Node 22+ is available.
+When a Glass `.glass.json` is present, setup also starts the background listener
+daemon so the silicon receives live conversation frames without polling.
+
+`silicon pull` is token-native. Generate an API token from the silicon detail
+page in Glass, then run:
+
+```bash
+silicon pull
+# paste the token when prompted
+
+# or, less private because it lands in shell history:
+silicon pull scs_live_...
+```
+
+The command validates the token with Glass, creates a folder named after the
+silicon, hydrates the stemcell, writes `.glass.json`, `.env`, and `env.py`,
+registers the instance, and starts the Silicon Interface daemon.
+
+Provider API keys for voice, browser profiles, billing, and architecture
+generation are configured on the Glass backend. A Glass-pulled silicon only
+stores its Glass API token locally.
+
+The local wrappers are written to:
+
+```bash
+<silicon>/.silicon-interface/bin/si
+<silicon>/.silicon-interface/bin/silicon-interface
+<silicon>/.silicon-interface/inbox.jsonl
+<silicon>/.silicon-interface/state.json
+```
+
+For Glass-pulled silicons, those wrappers automatically use the folder's
+`.glass.json` (`server_url` + `api_key`) for conversation API auth.
+
+During local development, point `SILICON_INTERFACE_CLI_SOURCE` at the package:
+
+```bash
+SILICON_INTERFACE_CLI_SOURCE=../silicon-interface/packages/silicon-interface-cli silicon new ./ada
+```
+
+## Backups
+
+`silicon push <name> now` and `silicon backup <name> now` use the
+`.backupsilicon` manifest when the instance has one. The CLI archives those
+paths and uploads them to Glass via `/api/v1/silicon-backups/` with the
+instance's `.glass.json` API key. If no manifest exists, the command falls back
+to the legacy `glass push` snapshot flow.
+
+`silicon push <name>` starts the background loop. Scheduled manifest backups run
+daily at 23:59 GMT; `now` remains available for one-shot manual backups.
+
+## How it differs from the bash version
+
+- Pure Python package with a `silicon` console entry point (installed in an
+  isolated venv), instead of a single bash script.
+- The auto-restart watchdog runs as `silicon _watchdog` (a detached supervisor
+  process) rather than a backgrounded bash function — same crash-loop detection,
+  `.silicon.stop` sentinel, and `.silicon.pid`/`.silicon.log` behavior.
+- `silicon script update` reinstalls the package via pip from its recorded source.
+- Everything (server, stemcell repo) is env-overridable.

silicon_cli-1.0.4/README.md

@@ -0,0 +1,122 @@
+# silicon-cli
+
+This is the single source for the installable **`silicon`** command. The PyPI
+package is named `silicon-cli`, and the code lives here in this `silicon-cli`
+repo.
+
+The command manages silicon instances on a machine: create them from the
+[silicon-stemcell](https://github.com/unlikefraction/silicon-stemcell) base,
+start/stop them under an auto-restart watchdog, stream logs, and back them up to
+Glass. It reads the same `~/.silicon/registry.json`, so existing installs carry
+over unchanged.
+
+## Install
+
+```bash
+pip install silicon-cli
+```
+
+(Zero runtime dependencies — stdlib only.)
+
+## Commands
+
+```
+silicon                      Show status or list instances
+silicon new [dir]            Create a new Silicon (hydrate from stemcell)
+silicon new .                Hydrate the current folder into a runnable silicon
+silicon start <target>       Start silicon(s). target = name, index, 1,2,4, or all
+silicon stop [--full] <target>  Stop silicon(s) (--full also stops the glass agent)
+silicon restart <target>     Restart silicon(s)
+silicon agent <start|stop|status> [name]   Manage the per-silicon glass agent
+silicon status [name]        Show instance status
+silicon browser [name]       Open a headed browser for login
+silicon debug [name]         Tail a running instance's logs
+silicon attach [path]        Register an existing silicon directory
+silicon pull [api_token]     Pull a Glass silicon into a new local folder
+silicon push [name] [now|stop]   Daily 23:59 GMT backups to Glass (now = one-shot, stop = end loop)
+silicon backup [name] [now|stop] Alias for silicon push
+silicon update <target>      Update silicon(s) from the latest stemcell
+silicon list                 List all instances
+silicon script update        Update this CLI itself
+silicon help                 Show help
+```
+
+## Configuration (env vars)
+
+| Var | Default | Purpose |
+| --- | --- | --- |
+| `SILICON_HOME` | `~/.silicon` | registry + CLI state |
+| `GLASS_SERVER_URL` | `https://glass.teamofsilicons.com` | Glass sync server (pull/push) |
+| `SILICON_STEMCELL_REPO` | `unlikefraction/silicon-stemcell` | base for `new` |
+| `SILICON_GLASS_CLI_REPO` | `unlikefraction/glass` | glass backup CLI |
+| `SILICON_PYTHON` | `python3` | interpreter used to run a silicon's `main.py` |
+| `SILICON_INTERFACE_CLI_PACKAGE` | `@teamofsilicons/silicon-interface-cli` | npm package used to install the Silicon Interface CLI |
+| `SILICON_INTERFACE_CLI_TARBALL` | versioned npm tarball | fallback package URL if registry metadata is briefly unavailable |
+| `SILICON_INTERFACE_CLI_SOURCE` | *(empty)* | local package dir or `silicon-interface.mjs` path for dev installs |
+| `SILICON_INTERFACE_CLI_SKIP` | *(empty)* | set to `1` to skip interface CLI setup |
+| `SILICON_INTERFACE_DAEMON_SKIP` | *(empty)* | set to `1` to install the CLI without starting its listener daemon |
+
+## Silicon Interface CLI
+
+`silicon new`, `silicon install`, and `silicon pull` also set up the
+Silicon Interface CLI in the silicon folder when Node 22+ is available.
+When a Glass `.glass.json` is present, setup also starts the background listener
+daemon so the silicon receives live conversation frames without polling.
+
+`silicon pull` is token-native. Generate an API token from the silicon detail
+page in Glass, then run:
+
+```bash
+silicon pull
+# paste the token when prompted
+
+# or, less private because it lands in shell history:
+silicon pull scs_live_...
+```
+
+The command validates the token with Glass, creates a folder named after the
+silicon, hydrates the stemcell, writes `.glass.json`, `.env`, and `env.py`,
+registers the instance, and starts the Silicon Interface daemon.
+
+Provider API keys for voice, browser profiles, billing, and architecture
+generation are configured on the Glass backend. A Glass-pulled silicon only
+stores its Glass API token locally.
+
+The local wrappers are written to:
+
+```bash
+<silicon>/.silicon-interface/bin/si
+<silicon>/.silicon-interface/bin/silicon-interface
+<silicon>/.silicon-interface/inbox.jsonl
+<silicon>/.silicon-interface/state.json
+```
+
+For Glass-pulled silicons, those wrappers automatically use the folder's
+`.glass.json` (`server_url` + `api_key`) for conversation API auth.
+
+During local development, point `SILICON_INTERFACE_CLI_SOURCE` at the package:
+
+```bash
+SILICON_INTERFACE_CLI_SOURCE=../silicon-interface/packages/silicon-interface-cli silicon new ./ada
+```
+
+## Backups
+
+`silicon push <name> now` and `silicon backup <name> now` use the
+`.backupsilicon` manifest when the instance has one. The CLI archives those
+paths and uploads them to Glass via `/api/v1/silicon-backups/` with the
+instance's `.glass.json` API key. If no manifest exists, the command falls back
+to the legacy `glass push` snapshot flow.
+
+`silicon push <name>` starts the background loop. Scheduled manifest backups run
+daily at 23:59 GMT; `now` remains available for one-shot manual backups.
+
+## How it differs from the bash version
+
+- Pure Python package with a `silicon` console entry point (installed in an
+  isolated venv), instead of a single bash script.
+- The auto-restart watchdog runs as `silicon _watchdog` (a detached supervisor
+  process) rather than a backgrounded bash function — same crash-loop detection,
+  `.silicon.stop` sentinel, and `.silicon.pid`/`.silicon.log` behavior.
+- `silicon script update` reinstalls the package via pip from its recorded source.
+- Everything (server, stemcell repo) is env-overridable.

{silicon_cli-1.0.0 → silicon_cli-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "silicon-cli"
-version = "1.0.0"
+version = "1.0.4"
 description = "Silicon CLI — create, run, and manage your silicon instances."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -15,7 +15,7 @@ classifiers = [
   "License :: OSI Approved :: MIT License",
   "Operating System :: OS Independent",
 ]
-dependencies = []   # stdlib only — keeps the install bulletproof
+dependencies = ["certifi>=2024.2.2"]
 
 [project.urls]
 Homepage = "https://github.com/saket1225/silicon-cli"

{silicon_cli-1.0.0 → silicon_cli-1.0.4}/silicon_cli/__init__.py

@@ -1,2 +1,2 @@
 """Silicon CLI — manage silicon instances. Python port of the original bash manager."""
-__version__ = "1.0.0"
+__version__ = "1.0.1"

{silicon_cli-1.0.0 → silicon_cli-1.0.4}/silicon_cli/cli.py

@@ -9,7 +9,7 @@ from . import glassagent, process, registry, stemcell, sync, ui, update
 from .config import python_run_cmd
 
 COMMANDS = ["start", "stop", "restart", "status", "browser", "debug", "attach",
-            "pull", "push", "update", "list", "install", "new", "help", "script", "agent"]
+            "pull", "push", "backup", "update", "list", "install", "new", "help", "script", "agent"]
 
 
 # ----------------------------------------------------------------- commands
@@ -164,10 +164,11 @@ def cmd_help() -> None:
   silicon browser [name]      Open headed browser for login
   silicon debug [name]        Attach to running instance (live logs)
   silicon attach [path]       Register an existing silicon instance
-  silicon pull <username>     Pull a silicon from Glass into a new folder
-  silicon push [name]         Start hourly backup loop to Glass
+  silicon pull [api_token]    Pull a Glass silicon into a new local folder
+  silicon push [name]         Start daily 23:59 GMT backup loop to Glass
   silicon push [name] now     Push a one-time backup to Glass
-  silicon push [name] stop    Stop the hourly backup loop
+  silicon push [name] stop    Stop the daily backup loop
+  silicon backup [name] [now|stop] Alias for silicon push
   silicon update <target>     Update silicon(s) to latest. target = name, index, 1,2,4, or all
   silicon list                List all instances
   silicon script update       Update the silicon CLI itself
@@ -199,6 +200,10 @@ def main(argv: list[str] | None = None) -> None:
         process.watchdog_loop(name=a2 or "silicon", path=a1, pid_file=argv[3] if len(argv) > 3 else "")
         return
 
+    if cmd == "_backup_loop":  # internal: the scheduled manifest backup loop
+        sync.backup_loop(a1 or ".", a2)
+        return
+
     if cmd == "start":
         process.start(a1)
     elif cmd == "stop":
@@ -218,7 +223,7 @@ def main(argv: list[str] | None = None) -> None:
         cmd_attach(a1)
     elif cmd == "pull":
         sync.pull(a1)
-    elif cmd == "push":
+    elif cmd in ("push", "backup"):
         sync.push(a1, a2)
     elif cmd == "update":
         update.update_instance(a1)

{silicon_cli-1.0.0 → silicon_cli-1.0.4}/silicon_cli/config.py

@@ -11,9 +11,8 @@ REGISTRY_DIR = Path(os.environ.get("SILICON_HOME", HOME / ".silicon"))
 REGISTRY_FILE = REGISTRY_DIR / "registry.json"
 CLI_SOURCE_FILE = REGISTRY_DIR / "cli-source"  # where `silicon script update` reinstalls from
 
-# Glass sync server (pull/push). Kept as the original default for compatibility;
-# override with GLASS_SERVER_URL to point at your own.
-GLASS_SERVER_URL = os.environ.get("GLASS_SERVER_URL", "https://glass.unlikefraction.com").rstrip("/")
+# Glass sync server (pull/push). Override with GLASS_SERVER_URL to point elsewhere.
+GLASS_SERVER_URL = os.environ.get("GLASS_SERVER_URL", "https://glass.teamofsilicons.com").rstrip("/")
 
 # Stemcell — the base every new silicon is hydrated from.
 STEMCELL_REPO = os.environ.get("SILICON_STEMCELL_REPO", "unlikefraction/silicon-stemcell")
@@ -23,6 +22,24 @@ STEMCELL_ZIP_URL = f"https://github.com/{STEMCELL_REPO}/archive/refs/heads/main.
 # Glass CLI (used by pull/push for backups).
 GLASS_CLI_REPO = os.environ.get("SILICON_GLASS_CLI_REPO", "unlikefraction/glass")
 
+# Silicon Interface CLI. During local development, silicon-cli will auto-detect
+# a sibling silicon-interface checkout; in production this package spec is used.
+SILICON_INTERFACE_CLI_PACKAGE = os.environ.get(
+    "SILICON_INTERFACE_CLI_PACKAGE",
+    "@teamofsilicons/silicon-interface-cli",
+)
+SILICON_INTERFACE_CLI_TARBALL = os.environ.get(
+    "SILICON_INTERFACE_CLI_TARBALL",
+    "https://registry.npmjs.org/@teamofsilicons/silicon-interface-cli/-/silicon-interface-cli-0.1.2.tgz",
+)
+SILICON_INTERFACE_CLI_SOURCE = os.environ.get("SILICON_INTERFACE_CLI_SOURCE", "")
+SILICON_INTERFACE_CLI_SKIP = os.environ.get("SILICON_INTERFACE_CLI_SKIP", "").lower() in {
+    "1", "true", "yes", "on",
+}
+SILICON_INTERFACE_DAEMON_SKIP = os.environ.get("SILICON_INTERFACE_DAEMON_SKIP", "").lower() in {
+    "1", "true", "yes", "on",
+}
+
 
 def python_run_cmd() -> str:
     """The interpreter used to RUN a silicon's main.py (not this CLI's venv)."""

silicon_cli-1.0.4/silicon_cli/interface_cli.py

@@ -0,0 +1,182 @@
+"""Install the Silicon Interface CLI into a silicon folder."""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from . import ui
+from .config import (
+    SILICON_INTERFACE_DAEMON_SKIP,
+    SILICON_INTERFACE_CLI_PACKAGE,
+    SILICON_INTERFACE_CLI_SKIP,
+    SILICON_INTERFACE_CLI_SOURCE,
+    SILICON_INTERFACE_CLI_TARBALL,
+)
+
+
+def _node_major() -> int | None:
+    node = shutil.which("node")
+    if not node:
+        return None
+    try:
+        out = subprocess.run(
+            [node, "--version"],
+            capture_output=True,
+            text=True,
+            check=False,
+        ).stdout.strip()
+    except Exception:
+        return None
+    m = re.match(r"^v?(\d+)", out)
+    return int(m.group(1)) if m else None
+
+
+def _source_script() -> Path | None:
+    if SILICON_INTERFACE_CLI_SOURCE:
+        source = Path(SILICON_INTERFACE_CLI_SOURCE).expanduser().resolve()
+        if source.is_file():
+            return source
+        candidate = source / "bin" / "silicon-interface.mjs"
+        if candidate.exists():
+            return candidate
+        return None
+
+    # Local dev layout: ../silicon-interface/packages/silicon-interface-cli
+    repo_root = Path(__file__).resolve().parents[2]
+    candidate = (
+        repo_root
+        / "silicon-interface"
+        / "packages"
+        / "silicon-interface-cli"
+        / "bin"
+        / "silicon-interface.mjs"
+    )
+    return candidate if candidate.exists() else None
+
+
+def _run(cmd: list[str], target: Path, *, warn: bool = True) -> bool:
+    try:
+        proc = subprocess.run(
+            cmd,
+            cwd=str(target),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=False,
+        )
+    except Exception as exc:
+        if warn:
+            ui.warn(f"Silicon Interface CLI setup skipped: {exc}")
+        return False
+    if proc.returncode == 0:
+        return True
+    if not warn:
+        return False
+    detail = (proc.stderr or proc.stdout or "").strip().splitlines()
+    suffix = f": {detail[-1]}" if detail else ""
+    ui.warn(f"Silicon Interface CLI setup skipped{suffix}")
+    return False
+
+
+def _npm_install_command(target: Path, package_spec: str) -> list[str] | None:
+    npm = shutil.which("npm")
+    if not npm:
+        return None
+    return [
+        npm,
+        "exec",
+        "--yes",
+        "--package",
+        package_spec,
+        "--",
+        "silicon-interface",
+        "install",
+        str(target),
+    ]
+
+
+def _npm_install_commands(target: Path) -> list[list[str]]:
+    package_specs = [SILICON_INTERFACE_CLI_PACKAGE]
+    if (
+        SILICON_INTERFACE_CLI_TARBALL
+        and SILICON_INTERFACE_CLI_TARBALL not in package_specs
+    ):
+        package_specs.append(SILICON_INTERFACE_CLI_TARBALL)
+
+    commands: list[list[str]] = []
+    for package_spec in package_specs:
+        cmd = _npm_install_command(target, package_spec)
+        if cmd:
+            commands.append(cmd)
+    return commands
+
+
+def _start_daemon(target: Path) -> bool:
+    if SILICON_INTERFACE_DAEMON_SKIP:
+        return False
+    if not (target / ".glass.json").exists():
+        return False
+    si = target / ".silicon-interface" / "bin" / "si"
+    if not si.exists():
+        return False
+    ok = _run([str(si), "daemon", "start"], target, warn=False)
+    if ok:
+        ui.success("Silicon Interface daemon running.")
+    else:
+        ui.warn("Silicon Interface daemon was not started; run '.silicon-interface/bin/si daemon start'.")
+    return ok
+
+
+def setup(target: str | Path) -> bool:
+    """Install local si/silicon-interface wrappers into ``target``.
+
+    This is intentionally best-effort. A missing Node runtime or unpublished npm
+    package should not break `silicon new` or `silicon pull`; the user can rerun
+    the setup later after installing Node or setting SILICON_INTERFACE_CLI_SOURCE.
+    """
+    if SILICON_INTERFACE_CLI_SKIP:
+        return False
+
+    target_path = Path(target).resolve()
+    major = _node_major()
+    if major is None:
+        ui.warn("Silicon Interface CLI setup skipped: node not found.")
+        return False
+    if major < 22:
+        ui.warn(
+            "Silicon Interface CLI setup skipped: Node 22+ is required "
+            f"(found Node {major})."
+        )
+        return False
+
+    script = _source_script()
+    ui.info("Setting up Silicon Interface CLI...")
+    if script:
+        ok = _run([shutil.which("node") or "node", str(script), "install", str(target_path)], target_path)
+    else:
+        commands = _npm_install_commands(target_path)
+        if not commands:
+            ui.warn("Silicon Interface CLI setup skipped: npm not found.")
+            return False
+        ok = False
+        for index, cmd in enumerate(commands):
+            final_attempt = index == len(commands) - 1
+            ok = _run(cmd, target_path, warn=final_attempt)
+            if ok:
+                break
+            if not final_attempt:
+                ui.warn(
+                    "Silicon Interface CLI package lookup failed; "
+                    "retrying with published tarball."
+                )
+
+    if ok:
+        ui.success(
+            "Silicon Interface CLI ready: "
+            f"{target_path}/.silicon-interface/bin/si"
+        )
+        _start_daemon(target_path)
+    return ok

{silicon_cli-1.0.0 → silicon_cli-1.0.4}/silicon_cli/stemcell.py

@@ -2,8 +2,8 @@
 
 `silicon new <dir>` downloads the stemcell, copies in any files the target is
 missing (never clobbering env.py / silicon.json / .glass.json), seeds config +
-env keys, prompts for tokens + brain/worker providers, installs requirements,
-and registers the instance — same flow as the original bash CLI.
+env keys, prompts for brain/worker providers, installs requirements, and
+registers the instance.
 """
 from __future__ import annotations
 
@@ -16,7 +16,7 @@ import sys
 import tempfile
 from pathlib import Path
 
-from . import registry, ui
+from . import interface_cli, registry, ui
 from .config import STEMCELL_GIT_URL, STEMCELL_ZIP_URL, python_run_cmd
 
 SKIP_NAMES = {".git", "__pycache__", ".DS_Store"}
@@ -144,9 +144,9 @@ def hydrate(target: str) -> None:
         silicon.pop("version", None)
         sj.write_text(json.dumps(silicon, indent=4) + "\n")
 
-        # Seed env.py required keys
+        # Seed env.py required keys used by the current stemcell.
         env_path = dst / "env.py"
-        for key, default in {"TELEGRAM_BOT_TOKEN": "", "OPENAI_API_KEY": "", "GEMINI_API_KEY": "", "BROWSER_PROFILE": name}.items():
+        for key, default in {"GLASS_API_KEY": "", "BROWSER_PROFILE": name}.items():
             if not _env_value(env_path, key):
                 _env_upsert(env_path, key, default)
 
@@ -158,7 +158,7 @@ def hydrate(target: str) -> None:
 
         # Interactive setup
         if ui.interactive():
-            _interactive_setup(dst, env_path, sj, name)
+            _interactive_setup(sj)
 
         # Install dependencies
         req = dst / "requirements.txt"
@@ -169,36 +169,14 @@ def hydrate(target: str) -> None:
                 subprocess.run([python_run_cmd(), "-m", "pip", "install", "-r", str(req), "--quiet", "--user"])
 
         registry.register(name, abs_target)
+        interface_cli.setup(abs_target)
         ui.success(f"Hydrated '{name}' at {abs_target}")
         ui.info(f"Run 'silicon start {name}' when you're ready.")
     finally:
         shutil.rmtree(tmp_src, ignore_errors=True)
 
 
-def _interactive_setup(dst: Path, env_path: Path, sj: Path, name: str) -> None:
-    if not _env_value(env_path, "TELEGRAM_BOT_TOKEN"):
-        ui.info("You need a Telegram bot token to use Silicon.")
-        sys.stderr.write(f"{ui.DIM}  1. Open Telegram and search for @BotFather{ui.RESET}\n")
-        sys.stderr.write(f"{ui.DIM}  2. Send /newbot and follow the prompts{ui.RESET}\n")
-        sys.stderr.write(f"{ui.DIM}  3. Copy the token BotFather gives you{ui.RESET}\n")
-        token = ui.read_secret("Telegram bot token")
-        if not token:
-            ui.error("Telegram bot token is required.")
-            sys.exit(1)
-        _env_upsert(env_path, "TELEGRAM_BOT_TOKEN", token)
-
-    if not _env_value(env_path, "OPENAI_API_KEY"):
-        ui.info("OpenAI API key (for incoming voice transcription via Whisper). Enter to skip.")
-        v = ui.read_secret("OpenAI API key (optional)")
-        if v:
-            _env_upsert(env_path, "OPENAI_API_KEY", v)
-
-    if not _env_value(env_path, "GEMINI_API_KEY"):
-        ui.info("Gemini API key (for outgoing text-to-speech). Enter to skip.")
-        v = ui.read_secret("Gemini API key (optional)")
-        if v:
-            _env_upsert(env_path, "GEMINI_API_KEY", v)
-
+def _interactive_setup(sj: Path) -> None:
     # Brain / worker providers — only ask when both claude + codex are present
     brain = "claude"
     workers = {"browser": ["claude"], "terminal": ["claude"], "writer": ["claude"]}