@oneciel-ai/ciel-runtime 0.2.10 → 0.2.11

package/ciel_runtime.py

@@ -491,7 +491,7 @@ from ciel_runtime_support.runtime_paths import (CHANNEL_COMPACT_REQUEST_PATH,  #
                                                 OLLAMA_MODEL_CATALOG_PATH, PID_PATH, PLAN_ARTIFACTS_DIR,
                                                 RATE_LIMIT_STATE_PATH, REQUEST_DUMP_PATH, RESPONSE_DUMP_PATH,
                                                 ROUTER_ACTIVITY_PATH, ROUTER_BASE, ROUTER_CLIENTS_DIR,
-                                                ROUTER_EXTERNAL_TOKEN_PATH, ROUTER_HOST, ROUTER_INSTANCE_DIR, ROUTER_PORT, ROUTER_WORKSPACE, SSE_LAST_PATH,
+                                                ROUTER_EXTERNAL_TOKEN_PATH, ROUTER_HOST, ROUTER_INSTANCE_DIR, ROUTER_INSTANCE_ID, ROUTER_PORT, ROUTER_WORKSPACE, SSE_LAST_PATH,
                                                 SSE_TRACE_PATH, TOOL_CALL_LOG_PATH, USAGE_EVENTS_PATH,
                                                 WEB_TOOLS_MCP_CONFIG, ZAI_MCP_CONFIG, agy_user_bin_dir,
                                                 ciel_runtime_user_bin_dir, default_router_port,
@@ -1691,7 +1691,7 @@ def handle_llm_config_post(handler: BaseHTTPRequestHandler, path: str, body: dic
 
 def web_ui_controller() -> WebUiController:
     return WebUiController(
-        constants=WebUiConstants(VERSION, ROUTER_ACTIVITY_PATH, CONTEXT_USAGE_PATH, DEFAULT_REQUEST_TIMEOUT_MS),
+        constants=WebUiConstants(VERSION, ROUTER_ACTIVITY_PATH, CONTEXT_USAGE_PATH, DEFAULT_REQUEST_TIMEOUT_MS, ROUTER_WORKSPACE, ROUTER_PORT, ROUTER_INSTANCE_ID),
         projection=WebUiProjectionPorts(current_alias, read_json_file, router_rate_limit_usage, positive_int, timeout_profile_idle_ms, context_limit_for_status),
         display=WebUiDisplayPorts(render_router_home_page, render_web_chat_page, provider_mode_label, api_key_status_line),
         http=WebUiHttpPorts(load_config, get_current_provider, write_text_response),
@@ -2836,7 +2836,7 @@ def _router_server_context() -> RouterServerContext:
                                                                                                        config=load_config())),
     )
     return RouterServerContext(
-        health=RouterHealthPresentationPorts(VERSION, SOURCE_FINGERPRINT, os.getpid, getpass.getuser, HOME, ROUTER_INSTANCE_DIR, ROUTER_WORKSPACE, ROUTER_PORT, current_alias),
+        health=RouterHealthPresentationPorts(VERSION, SOURCE_FINGERPRINT, os.getpid, getpass.getuser, HOME, ROUTER_INSTANCE_DIR, ROUTER_WORKSPACE, ROUTER_PORT, ROUTER_INSTANCE_ID, current_alias),
         http_services=http_services,
         server_runtime=server_runtime,
     )

package/ciel_runtime_support/config_repository.py

@@ -25,6 +25,7 @@ def build_default_config(provider_defaults: dict[str, Any]) -> dict[str, Any]:
             "host": "127.0.0.1",
             "port": 0,
             "tailscale_https": False,
+            "workspace": "",
         },
         "speech": {
             "colab": {

package/ciel_runtime_support/router_server_context.py

@@ -20,6 +20,7 @@ class RouterHealthPresentationPorts:
     config_dir: Path
     workspace: str
     router_port: int
+    instance_id: str
     current_alias: Callable[[dict[str, Any]], str]
 
 
@@ -46,6 +47,7 @@ class RouterServerContext:
             "config_dir": str(self.health.config_dir),
             "workspace": self.health.workspace,
             "router_port": self.health.router_port,
+            "instance_id": self.health.instance_id,
             "provider": provider,
             "model": self.health.current_alias(cfg),
             "web_chat": "/ca/web/chat",

package/ciel_runtime_support/runtime_constants.py

@@ -93,7 +93,7 @@ OFFICIAL_CHANNEL_PLUGINS = {
 }
 
 APP_NAME = "Ciel Runtime"
-VERSION = "0.2.10"
+VERSION = "0.2.11"
 CREDITS = "Credits: One Ciel LLC"
 PRELAUNCH_CANCEL = 10
 PRELAUNCH_LAUNCH_CODEX = 11

package/ciel_runtime_support/runtime_launch.py

@@ -19,7 +19,11 @@ from ciel_runtime_support.runtime_constants import (
     ROUTED_COMPAT_PROMPT,
 )
 from ciel_runtime_support.runtime_paths import CONFIG_DIR, LOG_PATH, ROUTER_INSTANCE_DIR
-from ciel_runtime_support.web_endpoints import web_backend_settings
+from ciel_runtime_support.web_endpoints import (
+    current_web_workspace,
+    web_backend_owned_by_workspace,
+    web_backend_settings,
+)
 
 
 CLAUDE_CODE_GENERATED_GREEDY_OPTIONS = frozenset(
@@ -32,7 +36,11 @@ def web_backend_start_requested(config: dict[str, Any]) -> bool:
         "1", "true", "yes", "on"
     }:
         return True
-    return web_backend_settings(config).enabled
+    settings = web_backend_settings(config)
+    return settings.enabled and web_backend_owned_by_workspace(
+        settings,
+        current_web_workspace(),
+    )
 
 
 @dataclass(frozen=True, slots=True)

package/ciel_runtime_support/runtime_paths.py

@@ -109,6 +109,7 @@ ROUTER_WORKSPACE = workspace_identity(
     os.environ.get("CIEL_RUNTIME_LAUNCH_CWD") or Path.cwd()
 )
 _WORKSPACE_DIGEST = hashlib.sha256(ROUTER_WORKSPACE.encode("utf-8", errors="replace")).hexdigest()[:12]
+ROUTER_INSTANCE_ID = f"{ROUTER_PORT}-{_WORKSPACE_DIGEST}"
 _STATE_DIR_OVERRIDE = str(os.environ.get("CIEL_RUNTIME_STATE_DIR") or "").strip()
 _TEST_STATE_ISOLATED = str(os.environ.get("CIEL_RUNTIME_TEST_ISOLATED") or "").strip().lower() in {
     "1",
@@ -121,7 +122,7 @@ ROUTER_INSTANCE_DIR = (
     if _STATE_DIR_OVERRIDE
     else CONFIG_DIR
     if _TEST_STATE_ISOLATED
-    else CONFIG_DIR / "router-instances" / f"{ROUTER_PORT}-{_WORKSPACE_DIGEST}"
+    else CONFIG_DIR / "router-instances" / ROUTER_INSTANCE_ID
 )
 LOG_PATH = ROUTER_INSTANCE_DIR / "router.log"
 LOG_LEVEL_PATH = CONFIG_DIR / "log-level"

package/ciel_runtime_support/web_endpoints.py

@@ -13,6 +13,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
+from .workspace_router_selection import workspace_identity
+
 
 _TRUE = {"1", "true", "yes", "on"}
 _WILDCARD_HOSTS = {"0.0.0.0", "::", "[::]"}
@@ -49,6 +51,7 @@ class WebBackendSettings:
     host: str = "127.0.0.1"
     port: int = 0
     tailscale_https: bool = False
+    workspace: str = ""
 
     @property
     def client_host(self) -> str:
@@ -74,7 +77,34 @@ def web_backend_settings(config: dict[str, Any] | None) -> WebBackendSettings:
         if enabled_value is not None
         else bool(tailscale_https or host != "127.0.0.1" or port)
     )
-    return WebBackendSettings(enabled, host, port, tailscale_https)
+    workspace = workspace_identity(values.get("workspace"))
+    return WebBackendSettings(enabled, host, port, tailscale_https, workspace)
+
+
+def current_web_workspace(
+    environ: MutableMapping[str, str] | None = None,
+) -> str:
+    environment = os.environ if environ is None else environ
+    return workspace_identity(environment.get("CIEL_RUNTIME_LAUNCH_CWD") or Path.cwd())
+
+
+def web_backend_owned_by_workspace(
+    settings: WebBackendSettings,
+    workspace: str | os.PathLike[str] | None = None,
+) -> bool:
+    if not settings.workspace:
+        return True
+    return settings.workspace == workspace_identity(workspace or current_web_workspace())
+
+
+def web_backend_owned_by_instance(
+    settings: WebBackendSettings,
+    router_port: int,
+    workspace: str | os.PathLike[str] | None = None,
+) -> bool:
+    if not web_backend_owned_by_workspace(settings, workspace):
+        return False
+    return not settings.port or settings.port == router_port
 
 
 def load_saved_web_backend(path: os.PathLike[str] | str) -> WebBackendSettings:
@@ -117,7 +147,11 @@ def web_backend_panel_rows(
 
 
 def update_web_backend_config(
-    config: dict[str, Any], key: str, value: Any, effective_port: int
+    config: dict[str, Any],
+    key: str,
+    value: Any,
+    effective_port: int,
+    workspace: str | os.PathLike[str] | None = None,
 ) -> list[str]:
     current = web_backend_settings(config)
     enabled = current.enabled
@@ -144,6 +178,7 @@ def update_web_backend_config(
         "host": host,
         "port": port or effective_port,
         "tailscale_https": tailscale_https,
+        "workspace": workspace_identity(workspace or current_web_workspace()),
     }
     external = host in _WILDCARD_HOSTS or not _is_loopback(host)
     config["router_debug_external_access"] = external
@@ -152,6 +187,7 @@ def update_web_backend_config(
     return [
         f"Web backend: {'on' if enabled else 'off'} · {host}:{port or effective_port}.",
         f"Tailscale HTTPS: {'on' if tailscale_https else 'off'}.",
+        f"Web instance: {config['web_backend']['workspace']}:{port or effective_port}.",
         f"Runtime is restarting so {scheme} endpoint settings apply now.",
     ]
 
@@ -341,6 +377,44 @@ def tailscale_https_url_for_target(
     return ""
 
 
+def tailscale_proxy_target_for_port(
+    public_port: int,
+    *,
+    executable: str | None = None,
+    timeout: float = 2.0,
+) -> str:
+    command = executable or shutil.which("tailscale")
+    if not command:
+        return ""
+    try:
+        completed = subprocess.run(
+            [command, "serve", "status", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        if completed.returncode != 0:
+            return ""
+        payload = json.loads(completed.stdout)
+    except (OSError, subprocess.SubprocessError, json.JSONDecodeError):
+        return ""
+    web = payload.get("Web") if isinstance(payload.get("Web"), dict) else {}
+    suffix = f":{public_port}"
+    for authority, config in web.items():
+        if public_port == 443:
+            matches = str(authority).rsplit(":", 1)[-1] in {"443", str(authority)}
+        else:
+            matches = str(authority).endswith(suffix)
+        if not matches or not isinstance(config, dict):
+            continue
+        handlers = config.get("Handlers")
+        root = handlers.get("/") if isinstance(handlers, dict) else None
+        if isinstance(root, dict):
+            return str(root.get("Proxy") or "").rstrip("/")
+    return ""
+
+
 def build_web_endpoint_report(
     client_host: str,
     bind_host: str,
@@ -375,13 +449,28 @@ def configure_tailscale_https(router_port: int, https_port: int | None = None) -
     if not executable:
         return ["Tailscale HTTPS was requested, but the tailscale CLI was not found."]
     public_port = https_port or router_port
+    target = f"http://127.0.0.1:{router_port}"
+    existing_target = tailscale_proxy_target_for_port(
+        public_port,
+        executable=executable,
+    )
+    if (
+        existing_target
+        and existing_target != target
+        and public_port != router_port
+    ):
+        return [
+            "Tailscale HTTPS setup refused: "
+            f"public port {public_port} already belongs to {existing_target}; "
+            f"this runtime is {target}. Use a unique public port."
+        ]
     command = [
         executable,
         "serve",
         f"--https={public_port}",
         "--bg",
         "--yes",
-        f"http://127.0.0.1:{router_port}",
+        target,
     ]
     try:
         completed = subprocess.run(
@@ -413,14 +502,24 @@ def configure_requested_web_endpoints(
     environment = os.environ if environ is None else environ
     lines: list[str] = []
     saved = web_backend_settings(config)
-    requested = (
-        str(environment.get("CIEL_RUNTIME_TAILSCALE_HTTPS") or "").lower() in _TRUE
-        or (saved.enabled and saved.tailscale_https)
+    explicit = str(environment.get("CIEL_RUNTIME_TAILSCALE_HTTPS") or "").lower() in _TRUE
+    owned = web_backend_owned_by_instance(
+        saved,
+        router_port,
+        current_web_workspace(environment),
     )
+    requested = explicit or (saved.enabled and saved.tailscale_https and owned)
     if requested:
         configured_port = str(environment.get("CIEL_RUNTIME_TAILSCALE_HTTPS_PORT") or "").strip()
         https_port = _valid_port(configured_port, "CIEL_RUNTIME_TAILSCALE_HTTPS_PORT") if configured_port else None
         lines.extend(configure_tailscale_https(router_port, https_port))
+    elif saved.enabled and saved.tailscale_https and not owned:
+        owner = saved.workspace or "legacy port"
+        lines.append(
+            "web_tailscale_skipped: settings belong to "
+            f"{owner}:{saved.port or 'auto'}, current instance is "
+            f"{current_web_workspace(environment)}:{router_port}"
+        )
     lines.extend(build_web_endpoint_report(client_host, bind_host, router_port).status_lines())
     return lines
 
@@ -437,11 +536,15 @@ __all__ = [
     "build_web_endpoint_report",
     "configure_requested_web_endpoints",
     "configure_tailscale_https",
+    "current_web_workspace",
     "discover_tailscale_node",
     "load_saved_web_backend",
     "tailscale_https_url_for_target",
+    "tailscale_proxy_target_for_port",
     "update_web_backend_config",
     "web_backend_panel_rows",
+    "web_backend_owned_by_instance",
+    "web_backend_owned_by_workspace",
     "web_backend_settings",
     "web_backend_summary",
 ]

package/ciel_runtime_support/web_ui.py

@@ -12,11 +12,16 @@ def render_web_chat_page(
     mode: str,
     api_status: str,
     timeout_ms: int,
+    workspace: str,
+    router_port: int,
+    instance_id: str,
 ) -> str:
     escaped_model = html_lib.escape(model)
     escaped_provider = html_lib.escape(provider)
     escaped_mode = html_lib.escape(mode)
     escaped_api_status = html_lib.escape(api_status)
+    escaped_workspace = html_lib.escape(workspace)
+    escaped_instance_id = html_lib.escape(instance_id)
     return f"""<!doctype html>
 <html lang="en">
 <head>
@@ -173,6 +178,8 @@ def render_web_chat_page(
         <div><div class="meta-label">API</div><div class="meta-value">{escaped_api_status}</div></div>
         <div><div class="meta-label">Timeout</div><div class="meta-value">{timeout_ms:,} ms</div></div>
         <div><div class="meta-label">Bridge</div><div class="meta-value">active session channel</div></div>
+        <div><div class="meta-label">Instance</div><div class="meta-value">{escaped_instance_id}</div></div>
+        <div><div class="meta-label">Workspace</div><div class="meta-value">{escaped_workspace}</div></div>
       </div>
       <div class="nav">
         <a href="/">Router Home</a>
@@ -269,6 +276,20 @@ def render_web_chat_page(
   </dialog>
   <script>
     const MODEL = {json.dumps(model)};
+    const EXPECTED_INSTANCE_ID = {json.dumps(instance_id)};
+    const EXPECTED_WORKSPACE = {json.dumps(workspace)};
+    const EXPECTED_ROUTER_PORT = {int(router_port)};
+    const ORIGIN_INSTANCE_KEY = 'ciel-runtime-web-chat-origin-instance:' + location.origin;
+    const bootstrapParams = new URLSearchParams(location.search);
+    const previousOriginInstance = localStorage.getItem(ORIGIN_INSTANCE_KEY) || '';
+    const rebindOriginInstance = bootstrapParams.get('rebind') === '1';
+    if (!previousOriginInstance || rebindOriginInstance) {{
+      localStorage.setItem(ORIGIN_INSTANCE_KEY, EXPECTED_INSTANCE_ID);
+    }}
+    const boundOriginInstance = rebindOriginInstance ? EXPECTED_INSTANCE_ID : previousOriginInstance;
+    let instanceIdentityBlocked = boundOriginInstance && boundOriginInstance !== EXPECTED_INSTANCE_ID
+      ? `This browser origin is bound to ${{previousOriginInstance}}, but the page came from ${{EXPECTED_INSTANCE_ID}}.`
+      : '';
     const transcript = document.getElementById('transcript');
     const composer = document.getElementById('composer');
     const prompt = document.getElementById('prompt');
@@ -533,6 +554,41 @@ def render_web_chat_page(
       }}
       return bubble;
     }}
+    function blockRuntimeIdentity(reason) {{
+      const detail = String(reason || 'Runtime identity changed.');
+      if (instanceIdentityBlocked === detail && sendButton.disabled) return;
+      instanceIdentityBlocked = detail;
+      if (eventSource) eventSource.close();
+      eventSource = null;
+      sendButton.disabled = true;
+      attachButton.disabled = true;
+      micButton.disabled = true;
+      stopActiveSpeech();
+      setState('instance mismatch', 'error');
+      addBubble('system', 'Web Chat stopped to prevent cross-instance delivery. ' + detail + ' Restore the original proxy target, or intentionally open this URL once with ?rebind=1.');
+    }}
+    async function verifyRuntimeIdentity(options = {{}}) {{
+      if (instanceIdentityBlocked) {{
+        if (options.announce !== false) blockRuntimeIdentity(instanceIdentityBlocked);
+        return false;
+      }}
+      try {{
+        const response = await fetch('/health', {{headers: {{'accept': 'application/json'}}, cache: 'no-store'}});
+        if (!response.ok) throw new Error(`HTTP ${{response.status}}`);
+        const health = await response.json();
+        const actualInstance = String(health.instance_id || '');
+        const actualWorkspace = String(health.workspace || '');
+        const actualPort = Number(health.router_port || 0);
+        if (actualInstance !== EXPECTED_INSTANCE_ID || actualWorkspace !== EXPECTED_WORKSPACE || actualPort !== EXPECTED_ROUTER_PORT) {{
+          blockRuntimeIdentity(`Expected ${{EXPECTED_INSTANCE_ID}} (${{EXPECTED_WORKSPACE}}:${{EXPECTED_ROUTER_PORT}}), received ${{actualInstance || 'unknown'}} (${{actualWorkspace || 'unknown'}}:${{actualPort || 'unknown'}}).`);
+          return false;
+        }}
+        return true;
+      }} catch (err) {{
+        if (options.announce !== false) setState('identity check failed', 'error');
+        return false;
+      }}
+    }}
     function structuredWebResponse(message) {{
       const value = message && message.meta && message.meta.web_response;
       if (!value || typeof value !== 'object') return null;
@@ -965,6 +1021,7 @@ def render_web_chat_page(
       }}
     }}
     async function startVoiceInput() {{
+      if (!await verifyRuntimeIdentity()) throw new Error('Runtime identity verification failed');
       if (!navigator.mediaDevices) throw new Error('This browser does not support microphone recording');
       const AudioContextClass = window.AudioContext || window.webkitAudioContext;
       if (!AudioContextClass) throw new Error('Live voice requires Web Audio support');
@@ -1119,7 +1176,8 @@ def render_web_chat_page(
         historyLoading = false;
       }}
     }}
-    function startChannelStream() {{
+    async function startChannelStream() {{
+      if (!await verifyRuntimeIdentity()) return;
       if (eventSource) eventSource.close();
       const url = `/ca/channel/stream?channel=${{encodeURIComponent(channel)}}&recipient=web&after=${{lastId}}&timeout=3600`;
       eventSource = new EventSource(url);
@@ -1137,6 +1195,7 @@ def render_web_chat_page(
       }};
     }}
     async function sendMessage(text, files = [], options = {{}}) {{
+      if (!await verifyRuntimeIdentity()) return;
       setState('queued');
       sendButton.disabled = true;
       attachButton.disabled = true;
@@ -1292,10 +1351,14 @@ def render_web_chat_page(
     transcript.addEventListener('scroll', () => {{
       if (transcript.scrollTop < 48) loadOlderHistory();
     }});
-    addBubble('system', `Connected to active session bridge for ${{MODEL}}. Messages are queued on channel ${{channel}} and replies stream back from /ca/channel/stream.`);
-    loadSpeechConfig().catch(() => {{ micButton.disabled = true; }});
-    loadInitialHistory().finally(startChannelStream);
-    prompt.focus();
+    addBubble('system', `Connecting to runtime ${{EXPECTED_INSTANCE_ID}} for ${{MODEL}} on ${{EXPECTED_WORKSPACE}}.`);
+    verifyRuntimeIdentity().then(ok => {{
+      if (!ok) return;
+      loadSpeechConfig().catch(() => {{ micButton.disabled = true; }});
+      loadInitialHistory().finally(startChannelStream);
+      prompt.focus();
+      setInterval(() => verifyRuntimeIdentity({{announce: false}}), 5000);
+    }});
   </script>
 </body>
 </html>"""

package/ciel_runtime_support/web_ui_controller.py

@@ -17,6 +17,9 @@ class WebUiConstants:
     activity_path: Path
     context_usage_path: Path
     default_timeout_ms: int
+    workspace: str = ""
+    router_port: int = 0
+    instance_id: str = ""
 
 
 @dataclass(frozen=True, slots=True)
@@ -136,6 +139,9 @@ class WebUiController:
                 provider_config,
             ),
             timeout_ms=timeout_ms,
+            workspace=self.constants.workspace,
+            router_port=self.constants.router_port,
+            instance_id=self.constants.instance_id,
         )
 
     def handle_get(self, handler: Any, path: str) -> bool:

package/docs/COLAB_SPEECH.md

@@ -32,6 +32,10 @@ The Colab Qwen endpoint remains a batch HTTP API, so the live caption is progres
 
 Web Chat requests carry an input mode and a structured response contract. The active agent first sends a short acknowledgement and then a final response containing `spoken`, `overview`, and optional `details` fields. The browser renders the fields separately and sends only `spoken` to TTS, avoiding long Markdown, URLs, code, and tables in synthesized speech. Legacy plain `message` replies remain supported.
 
+### Multiple local runtime instances
+
+Web backend ownership is scoped to the normalized workspace and router port. A saved Web/Tailscale configuration is not inherited by another workspace, and Ciel refuses to take an explicitly selected Tailscale HTTPS port that already proxies a different local router. `/health` advertises a stable `instance_id` derived from the workspace and port. Web Chat binds each browser origin to that ID, verifies it before sends, voice capture, and SSE reconnects, and stops delivery if a proxy begins returning another runtime. Use `?rebind=1` only when intentionally assigning that browser origin to a different instance.
+
 ## API surface
 
 - `GET|POST /ca/speech/config`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oneciel-ai/ciel-runtime",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "Universal AI coding-agent runtime and model-routing layer for Claude, Codex, AGY, and compatible runtimes.",
   "license": "MIT",
   "author": "One Ciel LLC",