silicon-cli 1.0.0__py3-none-any.whl

silicon_cli/__init__.py

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

silicon_cli/cli.py

@@ -0,0 +1,250 @@
+"""silicon — manage your silicon instances. Dispatch mirrors the original bash CLI."""
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+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"]
+
+
+# ----------------------------------------------------------------- commands
+def cmd_list() -> None:
+    rows = registry.installs()
+    if not rows:
+        ui.info("No silicon installations found.")
+        ui.info("Run 'silicon install' to set up a new instance.")
+        return
+    print(f"\n{ui.BOLD}{ui.CYAN}Silicon Installations{ui.RESET}\n")
+    print(f"  {ui.DIM}{'#':<4}{'NAME':<22}{'STATUS':<10}PATH{ui.RESET}")
+    print(f"  {ui.DIM}{'---':<4}{'----':<22}{'------':<10}----{ui.RESET}")
+    for i in rows:
+        if process.is_running(i.pid_file):
+            pid = process.get_pid(i.pid_file)
+            status = f"{ui.GREEN}● running{ui.RESET}"
+            extra = f" {ui.DIM}(PID {pid}){ui.RESET}"
+        else:
+            status, extra = f"{ui.DIM}○ stopped{ui.RESET}", ""
+        print(f"  {i.index + 1:<4}{i.name:<22}{status}{extra}  {ui.DIM}{i.path}{ui.RESET}")
+    print()
+
+
+def _print_status(inst) -> None:
+    if process.is_running(inst.pid_file):
+        pid = process.get_pid(inst.pid_file)
+        print(f"\n{ui.BOLD}{inst.name}{ui.RESET} {ui.GREEN}● running{ui.RESET} (PID {pid})")
+    else:
+        print(f"\n{ui.BOLD}{inst.name}{ui.RESET} {ui.DIM}○ stopped{ui.RESET}")
+    print(f"{ui.DIM}  Path: {inst.path}{ui.RESET}\n")
+
+
+def cmd_status(target: str | None) -> None:
+    if target:
+        inst = registry.find(target)
+        if not inst:
+            cmd_list()
+            return
+        _print_status(inst)
+        return
+    inst = registry.find()
+    if inst:
+        _print_status(inst)
+    else:
+        cmd_list()
+
+
+def cmd_browser(target: str | None) -> None:
+    inst = registry.resolve_one(target)
+    ui.info(f"Opening browser for '{inst.name}'...")
+    subprocess.run([python_run_cmd(), "main.py", "browser"], cwd=inst.path)
+
+
+def cmd_debug(target: str | None) -> None:
+    inst = registry.resolve_one(target)
+    if not process.is_running(inst.pid_file):
+        ui.error(f"'{inst.name}' is not running. Start it first with: silicon start {inst.name}")
+        sys.exit(1)
+    log_file = Path(inst.path) / ".silicon.log"
+    if not log_file.exists():
+        ui.error(f"No log file found at {log_file}")
+        sys.exit(1)
+    pid = process.get_pid(inst.pid_file)
+    print(f"\n{ui.BOLD}{ui.CYAN}Debugging '{inst.name}'{ui.RESET} (PID {pid})")
+    print(f"{ui.DIM}  Log: {log_file}{ui.RESET}")
+    print(f"{ui.DIM}  Press Ctrl+C to detach{ui.RESET}\n")
+    try:
+        subprocess.run(["tail", "-f", str(log_file)])
+    except KeyboardInterrupt:
+        pass
+
+
+def cmd_attach(target_dir: str | None) -> None:
+    target = Path(target_dir or ".").resolve()
+    if not (target / "main.py").exists() or not (target / "config.py").exists():
+        ui.error("This doesn't look like a silicon directory.")
+        ui.info(f"Expected main.py and config.py in: {target}")
+        ui.info("  silicon attach /path/to/silicon")
+        sys.exit(1)
+    if not (target / "prompts").is_dir() or not (target / "core").is_dir():
+        ui.error("Missing prompts/ or core/ directory. Not a valid silicon.")
+        sys.exit(1)
+
+    for i in registry.installs():
+        if i.path == str(target):
+            ui.warn(f"This silicon is already registered as '{i.name}'")
+            return
+
+    ui.success(f"Found a silicon at: {target}")
+    name = ui.ask("Instance name", target.name)
+    if registry.name_taken(name):
+        ui.error(f"Name '{name}' is already taken. Pick a different one.")
+        sys.exit(1)
+
+    pid_file = target / ".silicon.pid"
+    running = process.is_running(str(pid_file))
+    registry.register(name, str(target), str(pid_file))
+    ui.success(f"Attached '{name}' at {target}")
+    if running:
+        print(f"\n  {ui.BOLD}{name}{ui.RESET} {ui.GREEN}● running{ui.RESET} (PID {process.get_pid(str(pid_file))})\n")
+    else:
+        print(f"\n  {ui.BOLD}{name}{ui.RESET} {ui.DIM}○ stopped{ui.RESET}")
+        print(f"  Start it with: {ui.BOLD}silicon start {name}{ui.RESET}\n")
+
+
+def cmd_agent(subcmd: str | None, target: str | None) -> None:
+    if not subcmd:
+        ui.error("Usage: silicon agent <start|stop|status> [name]")
+        sys.exit(1)
+    inst = registry.resolve_one(target)
+    if subcmd == "start":
+        glassagent.start(inst.path)
+    elif subcmd == "stop":
+        glassagent.stop(inst.path)
+    elif subcmd == "status":
+        if glassagent.status(inst.path):
+            pid = (Path(inst.path) / ".glass_agent.pid").read_text().strip()
+            print(f"{ui.GREEN}●{ui.RESET} Glass agent running (PID {pid})")
+        else:
+            print(f"{ui.DIM}○{ui.RESET} Glass agent stopped")
+    else:
+        ui.error(f"Unknown agent command: {subcmd}. Use start, stop, or status.")
+        sys.exit(1)
+
+
+def cmd_new(target: str | None) -> None:
+    if target:
+        stemcell.hydrate(target)
+        return
+    # No target: ask for a folder to create (Python-native installer).
+    name = ui.ask("New silicon folder name", "silicon")
+    if not name:
+        ui.error("A folder name is required.")
+        sys.exit(1)
+    stemcell.hydrate(str(Path.cwd() / name))
+
+
+def cmd_help() -> None:
+    print(f"""
+{ui.BOLD}{ui.CYAN}silicon{ui.RESET} – manage your silicon instances
+
+{ui.BOLD}Usage:{ui.RESET}
+  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 <target>       Stop silicon(s) (agent stays alive)
+  silicon stop --full <target> Stop silicon(s) and glass agent
+  silicon restart <target>    Restart silicon(s)
+  silicon agent <start|stop|status> [name]  Manage glass agent
+  silicon status [name]       Show instance status
+  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 push [name] now     Push a one-time backup to Glass
+  silicon push [name] stop    Stop the hourly backup loop
+  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
+  silicon install             Install a new instance
+  silicon help                Show this help
+""")
+
+
+def suggest_command(inp: str) -> None:
+    def score(cmd: str) -> int:
+        ld = abs(len(inp) - len(cmd))
+        if cmd.startswith(inp) or inp.startswith(cmd):
+            return ld
+        common = sum(1 for a, b in zip(inp, cmd) if a == b)
+        return max(len(cmd), len(inp)) - common + ld
+    best = min(COMMANDS + ["ls"], key=score)
+    if score(best) <= 3:
+        print(f"\n{ui.YELLOW}Did you mean?{ui.RESET}\n  silicon {best}\n")
+
+
+# ----------------------------------------------------------------- dispatch
+def main(argv: list[str] | None = None) -> None:
+    argv = argv if argv is not None else sys.argv[1:]
+    cmd = argv[0] if argv else ""
+    a1 = argv[1] if len(argv) > 1 else None
+    a2 = argv[2] if len(argv) > 2 else None
+
+    if cmd == "_watchdog":  # internal: the supervised auto-restart loop
+        process.watchdog_loop(name=a2 or "silicon", path=a1, pid_file=argv[3] if len(argv) > 3 else "")
+        return
+
+    if cmd == "start":
+        process.start(a1)
+    elif cmd == "stop":
+        if a1 == "--full":
+            process.stop(a2, full=True)
+        else:
+            process.stop(a1, full=(a2 == "--full"))
+    elif cmd == "restart":
+        process.restart(a1)
+    elif cmd == "status":
+        cmd_status(a1)
+    elif cmd == "browser":
+        cmd_browser(a1)
+    elif cmd == "debug":
+        cmd_debug(a1)
+    elif cmd == "attach":
+        cmd_attach(a1)
+    elif cmd == "pull":
+        sync.pull(a1)
+    elif cmd == "push":
+        sync.push(a1, a2)
+    elif cmd == "update":
+        update.update_instance(a1)
+    elif cmd in ("list", "ls"):
+        cmd_list()
+    elif cmd == "agent":
+        cmd_agent(a1, a2)
+    elif cmd == "script":
+        if a1 == "update":
+            update.update_cli()
+        else:
+            ui.error(f"Unknown script command: {a1}. Did you mean: silicon script update?")
+            sys.exit(1)
+    elif cmd == "new":
+        cmd_new(a1)
+    elif cmd == "install":
+        cmd_new(None)
+    elif cmd in ("help", "-h", "--help"):
+        cmd_help()
+    elif cmd == "":
+        cmd_status(None)
+    else:
+        ui.error(f"Unknown command: {cmd}")
+        suggest_command(cmd)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

silicon_cli/config.py

@@ -0,0 +1,29 @@
+"""Paths + endpoints. Everything is env-overridable so this CLI can point at
+either the original Glass or your own."""
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+HOME = Path.home()
+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("/")
+
+# Stemcell — the base every new silicon is hydrated from.
+STEMCELL_REPO = os.environ.get("SILICON_STEMCELL_REPO", "unlikefraction/silicon-stemcell")
+STEMCELL_GIT_URL = f"https://github.com/{STEMCELL_REPO}.git"
+STEMCELL_ZIP_URL = f"https://github.com/{STEMCELL_REPO}/archive/refs/heads/main.zip"
+
+# Glass CLI (used by pull/push for backups).
+GLASS_CLI_REPO = os.environ.get("SILICON_GLASS_CLI_REPO", "unlikefraction/glass")
+
+
+def python_run_cmd() -> str:
+    """The interpreter used to RUN a silicon's main.py (not this CLI's venv)."""
+    return os.environ.get("SILICON_PYTHON") or shutil.which("python3") or shutil.which("python") or "python3"

silicon_cli/glassagent.py

@@ -0,0 +1,66 @@
+"""The per-silicon Glass agent (glass_agent.py) — remote control / backups.
+
+Only relevant when the silicon dir has a .glass.json. Tracked via .glass_agent.pid.
+"""
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from . import ui
+from .config import python_run_cmd
+
+
+def _pid_file(path: str) -> Path:
+    return Path(path) / ".glass_agent.pid"
+
+
+def _read_pid(path: str) -> int | None:
+    try:
+        return int(_pid_file(path).read_text().strip())
+    except Exception:
+        return None
+
+
+def _alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+def status(path: str) -> bool:
+    pid = _read_pid(path)
+    return bool(pid and _alive(pid))
+
+
+def start(path: str) -> None:
+    if not (Path(path) / ".glass.json").exists():
+        return
+    if status(path):
+        return
+    log = open(Path(path) / ".glass_agent.log", "a")
+    proc = subprocess.Popen(
+        [python_run_cmd(), "-u", "glass_agent.py"], cwd=path,
+        stdout=log, stderr=subprocess.STDOUT, start_new_session=True,
+    )
+    _pid_file(path).write_text(str(proc.pid))
+    ui.info(f"Glass agent started (PID {proc.pid})")
+
+
+def stop(path: str) -> None:
+    pid = _read_pid(path)
+    if pid and _alive(pid):
+        try:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(1)
+            if _alive(pid):
+                os.kill(pid, signal.SIGKILL)
+        except (OSError, ProcessLookupError):
+            pass
+        ui.info("Glass agent stopped")
+    _pid_file(path).unlink(missing_ok=True)

silicon_cli/process.py

@@ -0,0 +1,258 @@
+"""Process supervision — start/stop instances with an auto-restart watchdog.
+
+Mirrors the bash watchdog: a detached supervisor process runs `python -u main.py`,
+restarts it on exit (with crash-loop detection), honors a .silicon.stop sentinel,
+writes .silicon.log + .silicon.pid (the pid is the *watchdog's*, so a stop signal
+reaches the supervisor which then kills its child and cleans up).
+"""
+from __future__ import annotations
+
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from . import glassagent, registry, ui
+from .config import python_run_cmd
+
+RESTART_DELAY = 5
+MAX_RAPID = 5
+RAPID_WINDOW = 60
+
+
+def get_pid(pid_file: str) -> str | None:
+    try:
+        pid = Path(pid_file).read_text().strip()
+        return pid or None
+    except Exception:
+        return None
+
+
+def _alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+def is_running(pid_file: str) -> bool:
+    pid = get_pid(pid_file)
+    if not pid:
+        return False
+    try:
+        return _alive(int(pid))
+    except ValueError:
+        return False
+
+
+def _floater_pids(path: str, skip: int | None = None) -> list[int]:
+    """PIDs of python processes running this dir's main.py (orphans)."""
+    main_py = str(Path(path) / "main.py")
+    try:
+        out = subprocess.run(["ps", "-eo", "pid=,command="], capture_output=True, text=True).stdout
+    except Exception:
+        return []
+    pids = []
+    for line in out.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        m = re.match(r"^(\d+)\s+(.*)$", line)
+        if not m:
+            continue
+        pid, cmd = int(m.group(1)), m.group(2)
+        if "python" in cmd and main_py in cmd:
+            if skip is not None and pid == skip:
+                continue
+            if pid == os.getpid():
+                continue
+            pids.append(pid)
+    return pids
+
+
+def kill_floaters(path: str, skip: int | None = None) -> None:
+    for pid in _floater_pids(path, skip):
+        ui.warn(f"Killing orphaned process (PID {pid}) from {path}")
+        try:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(1)
+            if _alive(pid):
+                os.kill(pid, signal.SIGKILL)
+        except (OSError, ProcessLookupError):
+            pass
+
+
+# --------------------------------------------------------------- watchdog
+def watchdog_loop(name: str, path: str, pid_file: str) -> None:
+    """Runs as the detached `silicon _watchdog` process."""
+    log_file = Path(path) / ".silicon.log"
+    main_py = str(Path(path) / "main.py")
+    stop_file = Path(path) / ".silicon.stop"
+    py = python_run_cmd()
+    child: subprocess.Popen | None = None
+
+    def _terminate(signum=None, frame=None):
+        if child and child.poll() is None:
+            try:
+                child.terminate()
+                for _ in range(6):
+                    if child.poll() is not None:
+                        break
+                    time.sleep(0.5)
+                if child.poll() is None:
+                    child.kill()
+            except Exception:
+                pass
+        try:
+            Path(pid_file).unlink()
+        except OSError:
+            pass
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, _terminate)
+    signal.signal(signal.SIGINT, _terminate)
+
+    restart_times: list[float] = []
+    while True:
+        kill_floaters(path, skip=os.getpid())
+        with open(log_file, "a") as lf:
+            child = subprocess.Popen([py, "-u", main_py], cwd=path, stdout=lf, stderr=subprocess.STDOUT)
+            exit_code = child.wait()
+        child = None
+
+        if stop_file.exists():
+            stop_file.unlink(missing_ok=True)
+            Path(pid_file).unlink(missing_ok=True)
+            break
+
+        now = time.time()
+        restart_times.append(now)
+        cutoff = now - RAPID_WINDOW
+        restart_times = [t for t in restart_times if t >= cutoff]
+        if len(restart_times) >= MAX_RAPID:
+            with open(log_file, "a") as lf:
+                lf.write(f"[silicon-watchdog] {time.ctime()}: '{name}' crashed {MAX_RAPID} times "
+                         f"in {RAPID_WINDOW}s. Giving up.\n")
+            Path(pid_file).unlink(missing_ok=True)
+            break
+
+        with open(log_file, "a") as lf:
+            lf.write(f"[silicon-watchdog] {time.ctime()}: '{name}' exited (code {exit_code}). "
+                     f"Restarting in {RESTART_DELAY}s...\n")
+        time.sleep(RESTART_DELAY)
+
+
+# --------------------------------------------------------------- start/stop
+def _spawn_watchdog(name: str, path: str, pid_file: str) -> int:
+    """Launch the detached watchdog; return its PID."""
+    proc = subprocess.Popen(
+        [sys.executable, "-m", "silicon_cli.cli", "_watchdog", path, name, pid_file],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        start_new_session=True,  # detach so it survives this CLI exiting
+    )
+    return proc.pid
+
+
+def start_one(target: str | None) -> None:
+    inst = registry.resolve_one(target)
+    if is_running(inst.pid_file):
+        ui.warn(f"'{inst.name}' is already running (PID {get_pid(inst.pid_file)})")
+        glassagent.start(inst.path)
+        return
+
+    kill_floaters(inst.path)
+    Path(inst.pid_file).unlink(missing_ok=True)
+    (Path(inst.path) / ".silicon.stop").unlink(missing_ok=True)
+
+    ui.info(f"Starting '{inst.name}' (with auto-restart)...")
+    pid = _spawn_watchdog(inst.name, inst.path, inst.pid_file)
+    Path(inst.pid_file).write_text(str(pid))
+
+    time.sleep(2)
+    if _alive(pid):
+        ui.success(f"'{inst.name}' started (PID {pid})")
+        ui.info(f"Auto-restart enabled. Logs: {inst.path}/.silicon.log")
+    else:
+        ui.error(f"'{inst.name}' failed to start. Check logs: {inst.path}/.silicon.log")
+        Path(inst.pid_file).unlink(missing_ok=True)
+
+    glassagent.start(inst.path)
+
+
+def stop_one(target: str | None, full: bool = False) -> None:
+    inst = registry.resolve_one(target)
+    if not is_running(inst.pid_file):
+        ui.warn(f"'{inst.name}' is not running")
+        kill_floaters(inst.path)
+        Path(inst.pid_file).unlink(missing_ok=True)
+        (Path(inst.path) / ".silicon.stop").unlink(missing_ok=True)
+        if full:
+            glassagent.stop(inst.path)
+        return
+
+    pid = int(get_pid(inst.pid_file))
+    (Path(inst.path) / ".silicon.stop").touch()  # tell the watchdog not to restart
+    ui.info(f"Stopping '{inst.name}' (PID {pid})...")
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except (OSError, ProcessLookupError):
+        pass
+    for _ in range(10):
+        if not _alive(pid):
+            break
+        time.sleep(0.5)
+    if _alive(pid):
+        ui.warn("Force stopping...")
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except (OSError, ProcessLookupError):
+            pass
+
+    kill_floaters(inst.path)
+    Path(inst.pid_file).unlink(missing_ok=True)
+    (Path(inst.path) / ".silicon.stop").unlink(missing_ok=True)
+    ui.success(f"'{inst.name}' stopped")
+
+    if full:
+        glassagent.stop(inst.path)
+    else:
+        ui.info("Glass agent still running (use --full to stop it too).")
+
+
+def _multi(target: str, verb: str, fn) -> bool:
+    """Dispatch a multi-target selector. Returns True if it handled it."""
+    if not (target and registry.is_multi_target(target)):
+        return False
+    names = registry.resolve_targets(target)
+    if not names:
+        ui.error("No matching installations")
+        sys.exit(1)
+    if target == "all":
+        joined = ", ".join(names)
+        if not ui.confirm(f"Are you sure you want to {verb} the following silicons: {joined}?"):
+            return True
+    for n in names:
+        fn(n)
+    return True
+
+
+def start(target: str | None) -> None:
+    if _multi(target or "", "start", start_one):
+        return
+    start_one(target)
+
+
+def stop(target: str | None, full: bool = False) -> None:
+    if _multi(target or "", "stop", lambda n: stop_one(n, full)):
+        return
+    stop_one(target, full)
+
+
+def restart(target: str | None) -> None:
+    stop(target)
+    time.sleep(1)
+    start(target)