silicon-cli 1.0.22__tar.gz → 1.0.24__tar.gz

{silicon_cli-1.0.22/silicon_cli.egg-info → silicon_cli-1.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: silicon-cli
-Version: 1.0.22
+Version: 1.0.24
 Summary: Silicon CLI — create, run, and manage your silicon instances.
 Author: Saket
 License-Expression: MIT
@@ -97,8 +97,8 @@ and durable update jobs.
 | `GLASS_SERVER_URL` | `https://glass.teamofsilicons.com` | Glass sync server (pull/push) |
 | `SILICON_STEMCELL_REPO` | `teamofsilicons/silicon-stemcell` | GitHub repository used by `new`, `pull`, and `update` |
 | `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_PACKAGE` | immutable Interface CLI release asset | package spec used to install the Silicon Interface CLI |
+| `SILICON_INTERFACE_CLI_TARBALL` | same immutable release asset | fallback package spec for an explicitly overridden primary source |
 | `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 |
@@ -301,6 +301,15 @@ The local wrappers are written to:
 
 For Glass-pulled silicons, those wrappers automatically use the folder's
 `.glass.json` (`server_url` + `api_key`) for conversation API auth.
+Docker startup atomically rewrites these two small per-instance launchers on
+every boot. They export the instance root and execute the absolute Interface
+CLI bundled in the selected runtime image; the package itself is never copied
+over durable inbox or cursor state. Selecting an older runtime image therefore
+selects that image's Interface CLI as well, including the first rollback to
+the immediately preceding pre-fix image because both images expose the same
+absolute runtime command. Images older than the Interface runtime contract,
+which do not contain `/usr/local/bin/silicon-interface`, require a supported
+intermediate release rather than direct rollback.
 
 During local development, point `SILICON_INTERFACE_CLI_SOURCE` at the package:
 

{silicon_cli-1.0.22 → silicon_cli-1.0.24}/README.md

@@ -79,8 +79,8 @@ and durable update jobs.
 | `GLASS_SERVER_URL` | `https://glass.teamofsilicons.com` | Glass sync server (pull/push) |
 | `SILICON_STEMCELL_REPO` | `teamofsilicons/silicon-stemcell` | GitHub repository used by `new`, `pull`, and `update` |
 | `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_PACKAGE` | immutable Interface CLI release asset | package spec used to install the Silicon Interface CLI |
+| `SILICON_INTERFACE_CLI_TARBALL` | same immutable release asset | fallback package spec for an explicitly overridden primary source |
 | `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 |
@@ -283,6 +283,15 @@ The local wrappers are written to:
 
 For Glass-pulled silicons, those wrappers automatically use the folder's
 `.glass.json` (`server_url` + `api_key`) for conversation API auth.
+Docker startup atomically rewrites these two small per-instance launchers on
+every boot. They export the instance root and execute the absolute Interface
+CLI bundled in the selected runtime image; the package itself is never copied
+over durable inbox or cursor state. Selecting an older runtime image therefore
+selects that image's Interface CLI as well, including the first rollback to
+the immediately preceding pre-fix image because both images expose the same
+absolute runtime command. Images older than the Interface runtime contract,
+which do not contain `/usr/local/bin/silicon-interface`, require a supported
+intermediate release rather than direct rollback.
 
 During local development, point `SILICON_INTERFACE_CLI_SOURCE` at the package:
 

{silicon_cli-1.0.22 → silicon_cli-1.0.24}/docker/runtime/Dockerfile

@@ -4,7 +4,8 @@ FROM node:22-bookworm-slim@sha256:6c74791e557ce11fc957704f6d4fe134a7bc8d6f5ca440
 ARG SILICON_CLI_SPEC=silicon-cli==1.0.22
 ARG SILICON_BROWSER_SPEC=silicon-browser==1.0.8
 ARG SILICON_EXTEND_SPEC=silicon-extend==0.1.1
-ARG SILICON_INTERFACE_CLI_SPEC=@teamofsilicons/silicon-interface-cli@2.0.1
+ARG SILICON_INTERFACE_CLI_URL=https://github.com/teamofsilicons/silicon-interface-web/releases/download/interface-cli-v2.0.2/teamofsilicons-silicon-interface-cli-2.0.2.tgz
+ARG SILICON_INTERFACE_CLI_SHA256=5f594958e8165dfaf87e19a71781a628012b5debe0482dcdc24f28b308e710b2
 ARG CLAUDE_CODE_SPEC=@anthropic-ai/claude-code@2.1.220
 ARG CODEX_SPEC=@openai/codex@0.145.0
 ARG PIP_SPEC=pip==26.1.2
@@ -47,13 +48,23 @@ RUN python3 -m venv /opt/silicon-runtime \
         "${SILICON_EXTEND_SPEC}" \
     && /opt/silicon-runtime/bin/pip check
 
-RUN npm install -g --no-audit --no-fund \
-    "${SILICON_INTERFACE_CLI_SPEC}" \
+RUN curl --fail --location --silent --show-error \
+        --output /tmp/silicon-interface-cli.tgz \
+        "${SILICON_INTERFACE_CLI_URL}" \
+    && echo "${SILICON_INTERFACE_CLI_SHA256}  /tmp/silicon-interface-cli.tgz" \
+        | sha256sum --check --strict \
+    && npm install -g --no-audit --no-fund \
+        /tmp/silicon-interface-cli.tgz \
+    && rm -f /tmp/silicon-interface-cli.tgz \
+    && npm install -g --no-audit --no-fund \
     "${CLAUDE_CODE_SPEC}" \
     "${CODEX_SPEC}"
 
+COPY docker/runtime/activate-interface-cli.py /usr/local/libexec/silicon-activate-interface-cli.py
 COPY docker/runtime/runtime-entrypoint.sh /usr/local/bin/silicon-runtime-entrypoint
-RUN chmod +x /usr/local/bin/silicon-runtime-entrypoint
+RUN chmod 0555 \
+        /usr/local/libexec/silicon-activate-interface-cli.py \
+        /usr/local/bin/silicon-runtime-entrypoint
 
 WORKDIR /silicon
 ENTRYPOINT ["tini", "--", "/usr/local/bin/silicon-runtime-entrypoint"]

silicon_cli-1.0.24/docker/runtime/activate-interface-cli.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""Atomically activate an image-owned Interface CLI for one Silicon.
+
+Docker runtime images already contain the exact, checksum-verified Interface
+package selected by the Stemcell release.  Persisting another package copy
+under ``.silicon-interface`` makes upgrades non-atomic and prevents an image
+rollback from selecting its own older CLI.  Instead, this helper atomically
+writes per-instance launchers that export the durable instance root and execute
+the selected image's absolute CLI path.
+
+The launcher path is stable across runtime generations.  Once an instance has
+booted one fixed image, even a rollback to the immediately preceding pre-fix
+image selects that image's bundled CLI without requiring the old entrypoint to
+understand the new activation scheme.
+"""
+
+from __future__ import annotations
+
+import argparse
+import fcntl
+import json
+import os
+import re
+import stat
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+VERSION_RE = re.compile(
+    r"(?<!\d)(\d+(?:\.\d+){1,3}(?:[-+][A-Za-z0-9_.-]+)?)(?!\d)"
+)
+COMMAND_TIMEOUT_SECONDS = 30
+
+
+class ActivationError(RuntimeError):
+    """The selected runtime CLI could not be activated safely."""
+
+
+def _fsync_directory(path: Path) -> None:
+    flags = os.O_RDONLY | getattr(os, "O_DIRECTORY", 0)
+    descriptor = os.open(path, flags)
+    try:
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def _ensure_real_directory(path: Path, *, mode: int = 0o700) -> None:
+    try:
+        metadata = path.lstat()
+    except FileNotFoundError:
+        path.mkdir(mode=mode)
+        _fsync_directory(path.parent)
+        return
+    if stat.S_ISLNK(metadata.st_mode) or not stat.S_ISDIR(metadata.st_mode):
+        raise ActivationError(f"unsafe Interface activation directory: {path}")
+
+
+def _atomic_write(path: Path, payload: bytes, *, mode: int) -> None:
+    descriptor, temporary = tempfile.mkstemp(
+        prefix=f".{path.name}.",
+        dir=path.parent,
+    )
+    temporary_path = Path(temporary)
+    try:
+        os.fchmod(descriptor, mode)
+        with os.fdopen(descriptor, "wb", closefd=True) as output:
+            descriptor = -1
+            output.write(payload)
+            output.flush()
+            os.fsync(output.fileno())
+        os.replace(temporary_path, path)
+        _fsync_directory(path.parent)
+    finally:
+        if descriptor >= 0:
+            os.close(descriptor)
+        temporary_path.unlink(missing_ok=True)
+
+
+def _version(command: Path, *, cwd: Path) -> str:
+    try:
+        result = subprocess.run(
+            [str(command), "--version"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=COMMAND_TIMEOUT_SECONDS,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        raise ActivationError(
+            f"could not execute Silicon Interface CLI: {exc}"
+        ) from exc
+    output = "\n".join(
+        value.strip()
+        for value in (result.stdout, result.stderr)
+        if value.strip()
+    )
+    match = VERSION_RE.search(output)
+    if result.returncode != 0 or match is None:
+        detail = output or f"exited with {result.returncode}"
+        raise ActivationError(f"invalid Silicon Interface CLI: {detail}")
+    return match.group(1)
+
+
+def _launcher(runtime_executable: Path) -> bytes:
+    executable = str(runtime_executable)
+    if "\n" in executable or "'" in executable:
+        raise ActivationError("runtime Interface CLI path is unsafe")
+    return f"""#!/bin/sh
+set -eu
+HERE=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+ROOT=$(CDPATH= cd -- "$HERE/../.." && pwd)
+export SILICON_INTERFACE_ROOT="$ROOT"
+exec '{executable}' "$@"
+""".encode("utf-8")
+
+
+def _activate_locked(
+    root: Path,
+    runtime_executable: Path,
+) -> dict[str, str]:
+    interface_root = root / ".silicon-interface"
+    binaries = interface_root / "bin"
+    _ensure_real_directory(binaries)
+
+    expected_version = _version(runtime_executable, cwd=root)
+    launcher = _launcher(runtime_executable)
+
+    # Replace the secondary spelling first. The canonical `si` path used by
+    # Stemcell changes only after every prerequisite is durable. Each rename is
+    # atomic, and both the old and new launcher remain independently runnable.
+    _atomic_write(
+        binaries / "silicon-interface",
+        launcher,
+        mode=0o755,
+    )
+    _atomic_write(binaries / "si", launcher, mode=0o755)
+
+    for name in ("silicon-interface", "si"):
+        actual = _version(binaries / name, cwd=root)
+        if actual != expected_version:
+            raise ActivationError(
+                f"activated {name} does not match the runtime image"
+            )
+    return {
+        "version": expected_version,
+        "runtime_executable": str(runtime_executable),
+    }
+
+
+def activate(
+    root: Path,
+    runtime_executable: Path,
+) -> dict[str, str]:
+    root = root.resolve(strict=True)
+    if not root.is_dir():
+        raise ActivationError(f"Silicon root is not a directory: {root}")
+    if not runtime_executable.is_absolute():
+        raise ActivationError("runtime Interface CLI path must be absolute")
+    resolved_executable = runtime_executable.resolve(strict=True)
+    if not resolved_executable.is_file() or not os.access(
+        resolved_executable, os.X_OK
+    ):
+        raise ActivationError(
+            "runtime Silicon Interface CLI is not executable: "
+            f"{runtime_executable}"
+        )
+
+    interface_root = root / ".silicon-interface"
+    _ensure_real_directory(interface_root)
+    lock_path = interface_root / ".activation.lock"
+    flags = os.O_RDWR | os.O_CREAT | getattr(os, "O_CLOEXEC", 0)
+    flags |= getattr(os, "O_NOFOLLOW", 0)
+    descriptor = os.open(lock_path, flags, 0o600)
+    try:
+        fcntl.flock(descriptor, fcntl.LOCK_EX)
+        return _activate_locked(root, runtime_executable)
+    finally:
+        fcntl.flock(descriptor, fcntl.LOCK_UN)
+        os.close(descriptor)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Atomically activate the runtime's Silicon Interface CLI"
+    )
+    parser.add_argument("--root", required=True, type=Path)
+    parser.add_argument("--executable", required=True, type=Path)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    arguments = _parser().parse_args(argv)
+    try:
+        result = activate(arguments.root, arguments.executable)
+    except (ActivationError, OSError) as exc:
+        print(f"Silicon Interface activation failed: {exc}", file=sys.stderr)
+        return 1
+    print(json.dumps(result, sort_keys=True, separators=(",", ":")))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{silicon_cli-1.0.22 → silicon_cli-1.0.24}/docker/runtime/runtime-entrypoint.sh

@@ -71,14 +71,12 @@ prepare_runtime() {
     log "missing mount: $SILICON_ROOT"
     exit 1
   fi
-  if [ ! -f "$SILICON_ROOT/main.py" ]; then
-    log "$SILICON_ROOT does not look like a Silicon instance; expected main.py"
-    exit 1
-  fi
 
   mkdir -p "$HOME" "$SILICON_HOME" "$SILICON_BROWSER_HOME"
   prepare_shared_auth
   cd "$SILICON_ROOT"
+  local runtime_python
+  runtime_python="$(command -v python3)"
 
   # Resolve the same atomically selected generation as silicon-cli.  Generation
   # pointers are instance-relative so the host path and /silicon mount can
@@ -188,6 +186,10 @@ PY
 )
   release_root="${runtime_paths[0]}"
   environment_python="${runtime_paths[1]:-}"
+  if [ ! -f "$release_root/main.py" ]; then
+    log "$release_root does not look like a Silicon instance; expected main.py"
+    exit 1
+  fi
 
   local dependency_file=""
   local -a pip_integrity_args=()
@@ -257,14 +259,25 @@ if (
     )
 PY
 
-  if command -v silicon-interface >/dev/null 2>&1; then
-    if [ ! -x "$SILICON_ROOT/.silicon-interface/bin/si" ]; then
-      log "installing Silicon Interface shim"
-      silicon-interface install "$SILICON_ROOT" >/dev/null
-    fi
-  fi
-
-  python - "$INSTANCE_NAME" "$SILICON_ROOT" <<'PY'
+  global_interface="/usr/local/bin/silicon-interface"
+  local_interface="$SILICON_ROOT/.silicon-interface/bin/si"
+  [ -x "$global_interface" ] \
+    || die "Silicon Interface CLI is missing from the runtime image"
+  global_interface_version="$("$global_interface" --version 2>/dev/null || true)"
+  [ -n "$global_interface_version" ] \
+    || die "Silicon Interface CLI in the runtime image is not executable"
+  log "atomically activating Silicon Interface CLI from the runtime image"
+  "$runtime_python" \
+    /usr/local/libexec/silicon-activate-interface-cli.py \
+    --root "$SILICON_ROOT" \
+    --executable "$global_interface" \
+    >/dev/null \
+    || die "Silicon Interface CLI activation failed"
+  local_interface_version="$("$local_interface" --version 2>/dev/null || true)"
+  [ "$local_interface_version" = "$global_interface_version" ] \
+    || die "Silicon Interface shim does not match the runtime image"
+
+  "$runtime_python" - "$INSTANCE_NAME" "$SILICON_ROOT" <<'PY'
 import sys
 from pathlib import Path
 
@@ -384,6 +397,44 @@ PY
 
 prepare_runtime
 
+# The Interface daemon PID belongs to the prior container namespace. Keep this
+# one-shot marker outside the protected Interface snapshot so an updater-owned
+# suspended boot can restore state first; process.start consumes it immediately
+# before starting Interface.
+python3 - "$SILICON_ROOT" <<'PY' \
+  || die "could not publish the Interface daemon fresh-boot marker"
+import os
+import stat
+import sys
+from pathlib import Path
+
+root = Path(sys.argv[1]).resolve()
+state = root / ".silicon"
+state.mkdir(mode=0o700, exist_ok=True)
+if state.is_symlink() or not state.is_dir():
+    raise SystemExit("Silicon runtime state directory is unsafe")
+marker = state / "interface-daemon-reset-required"
+flags = os.O_CREAT | os.O_WRONLY
+flags |= getattr(os, "O_CLOEXEC", 0) | getattr(os, "O_NOFOLLOW", 0)
+descriptor = os.open(marker, flags, 0o600)
+try:
+    metadata = os.fstat(descriptor)
+    if not stat.S_ISREG(metadata.st_mode) or metadata.st_nlink != 1:
+        raise SystemExit("Interface daemon fresh-boot marker is unsafe")
+    os.ftruncate(descriptor, 0)
+    os.fsync(descriptor)
+finally:
+    os.close(descriptor)
+directory = os.open(
+    state,
+    os.O_RDONLY | getattr(os, "O_DIRECTORY", 0),
+)
+try:
+    os.fsync(directory)
+finally:
+    os.close(directory)
+PY
+
 # PIDs are namespaced to each container boot. Stale files from a previous
 # container can point at an unrelated new process, so remove them before start.
 rm -f \
@@ -399,7 +450,8 @@ if [ -f "$SILICON_ROOT/.silicon/docker-start-suspended" ]; then
   rm -f "$SILICON_ROOT/.silicon/docker-start-suspended"
   log "service start suspended for transactional state restoration"
 else
-  silicon start "$INSTANCE_NAME" || log "initial start returned non-zero; container stays alive for inspection"
+  SILICON_INTERFACE_RESET_DAEMON_PID=1 silicon start "$INSTANCE_NAME" \
+    || log "initial start returned non-zero; container stays alive for inspection"
 fi
 
 while true; do

{silicon_cli-1.0.22 → silicon_cli-1.0.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "silicon-cli"
-version = "1.0.22"
+version = "1.0.24"
 description = "Silicon CLI — create, run, and manage your silicon instances."
 readme = "README.md"
 requires-python = ">=3.9"

{silicon_cli-1.0.22 → silicon_cli-1.0.24}/silicon_cli/config.py

@@ -34,14 +34,25 @@ if (
 STEMCELL_GIT_URL = f"https://github.com/{STEMCELL_REPO}.git"
 
 # Silicon Interface CLI. During local development, silicon-cli will auto-detect
-# a sibling silicon-interface checkout; in production this package spec is used.
+# a sibling silicon-interface checkout. Production uses the immutable GitHub
+# release asset because npm publishing is not part of the runtime release path.
+SILICON_INTERFACE_CLI_VERSION = "2.0.2"
+SILICON_INTERFACE_CLI_RELEASE_URL = (
+    "https://github.com/teamofsilicons/silicon-interface-web/releases/download/"
+    "interface-cli-v2.0.2/"
+    "teamofsilicons-silicon-interface-cli-2.0.2.tgz"
+)
+SILICON_INTERFACE_CLI_RELEASE_SHA256 = (
+    "5f594958e8165dfaf87e19a71781a628"
+    "012b5debe0482dcdc24f28b308e710b2"
+)
 SILICON_INTERFACE_CLI_PACKAGE = os.environ.get(
     "SILICON_INTERFACE_CLI_PACKAGE",
-    "@teamofsilicons/silicon-interface-cli",
+    SILICON_INTERFACE_CLI_RELEASE_URL,
 )
 SILICON_INTERFACE_CLI_TARBALL = os.environ.get(
     "SILICON_INTERFACE_CLI_TARBALL",
-    "https://registry.npmjs.org/@teamofsilicons/silicon-interface-cli/-/silicon-interface-cli-2.0.1.tgz",
+    SILICON_INTERFACE_CLI_RELEASE_URL,
 )
 SILICON_INTERFACE_CLI_SOURCE = os.environ.get("SILICON_INTERFACE_CLI_SOURCE", "")
 SILICON_INTERFACE_CLI_SKIP = os.environ.get("SILICON_INTERFACE_CLI_SKIP", "").lower() in {