#!/usr/bin/env python3
"""Claude Code Bridge — client agent.

Runs on your own machine and does the actual work there: it reads and writes
your files, runs your shell commands, and serves the chat UI on localhost. The
only thing it sends elsewhere is the model call, which goes to your bridge —
the machine holding the Claude subscription — where usage caps and the model
allowlist are enforced.

Python 3.8+, standard library only. Works on Linux, macOS and Windows.

    python3 agent.py --bridge http://192.168.1.20:8787 --token <token>

Then open http://localhost:8600 in a browser.
"""

import argparse
import base64
import http.client
import fnmatch
import json
import mimetypes
import os
import platform
import queue
import re
import shutil
import socket
import subprocess
import sys
import threading
import time
import traceback
import urllib.error
import urllib.parse
import urllib.request
import uuid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

VERSION = "1.1.0"
IS_WINDOWS = os.name == "nt"

AGENT_PATH = os.path.abspath(__file__)
SERVER = None
RESTART = threading.Event()

# Populated when the bridge serves this file as a single-file download.
EMBEDDED_UI = {"api.js":"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","app.css":"/* Claude Code Bridge — client console
   Instrument-panel direction: petrol enamel, paper ink, pilot-lamp amber. */

:root {
  --panel-deep: #0c171b;
  --panel: #122127;
  --panel-raised: #182f37;
  --rule: #26454e;
  --rule-soft: #1c383f;

  --ink: #e9e5d9;
  --ink-dim: #8ea3a9;
  --ink-faint: #5f767d;

  --live: #4fbfa0;
  --amber: #e8a33d;
  --rust: #d4614a;
  --violetish: #8d9fd8;

  --mono: "JetBrains Mono", "IBM Plex Mono", "DejaVu Sans Mono", ui-monospace, Menlo, Consolas, monospace;
  --sans: "Inter", "Segoe UI", system-ui, -apple-system, "Helvetica Neue", Arial, sans-serif;

  --legend: 600 10px/1.2 var(--mono);
  --legend-track: 0.14em;

  --rail: 272px;
  --radius: 3px;
  --shadow: 0 1px 0 rgba(255, 255, 255, 0.04) inset, 0 8px 24px rgba(0, 0, 0, 0.35);
}

* { box-sizing: border-box; }

/* Class-level display rules would otherwise beat the hidden attribute. */
[hidden] { display: none !important; }

html, body {
  height: 100%;
  margin: 0;
}

body {
  background: var(--panel-deep);
  color: var(--ink);
  font: 15px/1.55 var(--sans);
  -webkit-text-size-adjust: 100%;
  overflow: hidden;
}

button, input, textarea, select { font: inherit; color: inherit; }

button {
  background: none;
  border: none;
  cursor: pointer;
}

:focus-visible {
  outline: 2px solid var(--live);
  outline-offset: 2px;
}

::-webkit-scrollbar { width: 10px; height: 10px; }
::-webkit-scrollbar-thumb { background: var(--rule-soft); border-radius: 10px; }
::-webkit-scrollbar-track { background: transparent; }

.legend {
  font: var(--legend);
  letter-spacing: var(--legend-track);
  text-transform: uppercase;
  color: var(--ink-faint);
}

/* ---------------- shell ---------------- */

.shell {
  display: grid;
  grid-template-rows: auto 1fr;
  /* Without this the single implicit column is auto-sized to max-content, and
     one long file path widens the entire app past the viewport. */
  grid-template-columns: minmax(0, 1fr);
  height: 100vh;
  height: 100dvh;
}

.topbar {
  display: flex;
  align-items: center;
  gap: 16px;
  padding: 0 14px;
  height: 52px;
  background: var(--panel);
  border-bottom: 1px solid var(--rule);
  box-shadow: 0 1px 0 rgba(255, 255, 255, 0.03) inset;
}

.brand {
  display: flex;
  align-items: baseline;
  gap: 8px;
  flex-shrink: 0;
}

.brand__mark {
  font: 700 13px/1 var(--mono);
  letter-spacing: 0.18em;
  color: var(--ink);
}

.brand__sub {
  font: var(--legend);
  letter-spacing: var(--legend-track);
  text-transform: uppercase;
  color: var(--ink-faint);
}

.topbar__where {
  flex: 1;
  min-width: 0;
  display: flex;
  align-items: center;
  gap: 8px;
  font: 12px/1 var(--mono);
  color: var(--ink-dim);
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

.topbar__actions { display: flex; gap: 6px; align-items: center; }

.iconbtn {
  width: 34px;
  height: 34px;
  display: grid;
  place-items: center;
  border: 1px solid var(--rule-soft);
  border-radius: var(--radius);
  color: var(--ink-dim);
  background: var(--panel-raised);
}

.iconbtn:hover { color: var(--ink); border-color: var(--rule); }
.iconbtn[aria-pressed="true"] { color: var(--live); border-color: var(--live); }

/* ---------------- meters (the signature element) ---------------- */

.meterstrip {
  display: flex;
  gap: 18px;
  align-items: center;
  flex-shrink: 0;
  overflow-x: auto;
  scrollbar-width: none;
}

.meterstrip::-webkit-scrollbar { display: none; }

.meter { min-width: 132px; }

.meter__head {
  display: flex;
  justify-content: space-between;
  align-items: baseline;
  gap: 8px;
  margin-bottom: 4px;
}

.meter__label {
  font: var(--legend);
  letter-spacing: var(--legend-track);
  text-transform: uppercase;
  color: var(--ink-faint);
  white-space: nowrap;
}

.meter__value {
  font: 600 12px/1 var(--mono);
  font-variant-numeric: tabular-nums;
  color: var(--ink-dim);
}

.meter__track {
  position: relative;
  height: 8px;
  border-radius: 1px;
  background:
    repeating-linear-gradient(90deg, rgba(0, 0, 0, 0.55) 0 1px, transparent 1px 5px),
    var(--rule-soft);
  overflow: hidden;
}

.meter__fill {
  position: absolute;
  inset: 0 auto 0 0;
  background: var(--live);
  transition: width 420ms cubic-bezier(0.2, 0.7, 0.2, 1), background-color 300ms;
}

.meter__notch {
  position: absolute;
  top: -2px;
  bottom: -2px;
  width: 2px;
  transform: translateX(-1px);
  background: var(--ink-faint);
}

.meter__notch--block { background: var(--rust); }
.meter__notch--warn { background: var(--amber); opacity: 0.75; }

.meter[data-level="warn"] .meter__fill { background: var(--amber); }
.meter[data-level="block"] .meter__fill { background: var(--rust); }
.meter[data-level="warn"] .meter__value { color: var(--amber); }
.meter[data-level="block"] .meter__value { color: var(--rust); }
.meter[data-level="off"] .meter__fill { background: var(--ink-faint); }

.meter__foot {
  margin-top: 4px;
  font: 10px/1 var(--mono);
  color: var(--ink-faint);
  font-variant-numeric: tabular-nums;
}

/* ---------------- body layout ---------------- */

.body {
  display: grid;
  /* minmax(0, 1fr) lets the column shrink below its content; a plain 1fr
     track is floored at max-content, which long file paths then blow past. */
  grid-template-columns: var(--rail) minmax(0, 1fr);
  grid-template-areas: "rail main";
  min-height: 0;
  height: 100%;
}

.body[data-files="open"] {
  grid-template-columns: var(--rail) minmax(0, 1fr) 320px;
  grid-template-areas: "rail main files";
}

/* Named areas keep the layout stable when a region is hidden: a hidden
   element stops being a grid item, and positional placement would shift
   everything after it into the wrong track. */
.rail { grid-area: rail; }
.main { grid-area: main; }
.files { grid-area: files; }

.rail {
  background: var(--panel);
  border-right: 1px solid var(--rule);
  display: flex;
  flex-direction: column;
  min-height: 0;
}

.rail__head {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: 12px 14px 8px;
}

.rail__list {
  overflow-y: auto;
  padding: 0 8px 12px;
  flex: 1;
  min-height: 0;
}

.sessionitem {
  display: block;
  width: 100%;
  text-align: left;
  padding: 9px 10px;
  border-radius: var(--radius);
  border: 1px solid transparent;
  margin-bottom: 2px;
}

.sessionitem:hover { background: var(--panel-raised); }

.sessionitem[aria-current="true"] {
  background: var(--panel-raised);
  border-color: var(--rule);
}

.sessionitem__title {
  display: block;
  font-size: 13.5px;
  color: var(--ink);
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

.sessionitem__meta {
  display: flex;
  gap: 8px;
  align-items: center;
  margin-top: 3px;
  font: 10px/1.3 var(--mono);
  letter-spacing: 0.06em;
  color: var(--ink-faint);
}

.lamp {
  width: 6px;
  height: 6px;
  border-radius: 50%;
  background: var(--ink-faint);
  flex-shrink: 0;
}

.lamp--running { background: var(--live); animation: pulse 1.6s ease-in-out infinite; }
.lamp--idle { background: var(--live); opacity: 0.4; }

@keyframes pulse {
  0%, 100% { opacity: 1; box-shadow: 0 0 0 0 rgba(79, 191, 160, 0.5); }
  50% { opacity: 0.55; box-shadow: 0 0 0 4px rgba(79, 191, 160, 0); }
}

.btn {
  display: inline-flex;
  align-items: center;
  gap: 6px;
  padding: 7px 12px;
  border: 1px solid var(--rule);
  border-radius: var(--radius);
  background: var(--panel-raised);
  color: var(--ink-dim);
  font: var(--legend);
  letter-spacing: var(--legend-track);
  text-transform: uppercase;
}

.btn:hover { color: var(--ink); border-color: var(--live); }
.btn:disabled { opacity: 0.4; cursor: not-allowed; }
.btn--primary { background: var(--live); color: #06201a; border-color: var(--live); font-weight: 700; }
.btn--primary:hover { color: #06201a; filter: brightness(1.08); }
.btn--danger:hover { border-color: var(--rust); color: var(--rust); }

/* ---------------- conversation ---------------- */

.main {
  display: grid;
  grid-template-rows: auto minmax(0, 1fr) auto;
  grid-template-areas: "banner" "thread" "composer";
  min-height: 0;
  min-width: 0;
  background: var(--panel-deep);
}

.banner { grid-area: banner; }
.thread { grid-area: thread; }
.composer { grid-area: composer; }

.banner {
  display: flex;
  gap: 10px;
  align-items: flex-start;
  padding: 10px 16px;
  border-bottom: 1px solid var(--rule-soft);
  font-size: 13px;
  background: var(--panel);
}

.banner--warn { color: var(--amber); border-left: 3px solid var(--amber); }
.banner--block { color: var(--rust); border-left: 3px solid var(--rust); }

.inlinemsg {
  padding: 9px 13px;
  margin-bottom: 14px;
  border-radius: var(--radius);
  background: var(--panel);
  border-left: 3px solid var(--amber);
  color: var(--amber);
  font-size: 13px;
}

.inlinemsg--error { border-left-color: var(--rust); color: var(--rust); }

.thread {
  position: relative;
  min-width: 0;
  overflow-x: hidden;
  overflow-y: auto;
  padding: 22px 16px 28px;
  min-height: 0;
  scroll-behavior: smooth;
}

.thread__inner { max-width: 860px; min-width: 0; margin: 0 auto; }

@media (prefers-reduced-motion: reduce) {
  .thread { scroll-behavior: auto; }
  .lamp--running { animation: none; }
  .meter__fill { transition: none; }
}

.turn { margin-bottom: 20px; }

.msg--user {
  background: var(--panel);
  border: 1px solid var(--rule-soft);
  border-left: 3px solid var(--violetish);
  border-radius: var(--radius);
  padding: 11px 14px;
  margin-bottom: 18px;
  white-space: pre-wrap;
  overflow-wrap: anywhere;
}

.msg--assistant { margin-bottom: 14px; overflow-wrap: anywhere; }

.msg--assistant p { margin: 0 0 0.85em; }
.msg--assistant p:last-child { margin-bottom: 0; }
.msg--assistant h1, .msg--assistant h2, .msg--assistant h3 {
  font-size: 15px;
  margin: 1.2em 0 0.5em;
  letter-spacing: 0.01em;
}
.msg--assistant ul, .msg--assistant ol { margin: 0 0 0.85em; padding-left: 1.3em; }
.msg--assistant li { margin-bottom: 0.25em; }
.msg--assistant a { color: var(--live); }

code {
  font: 12.5px/1.5 var(--mono);
  background: var(--panel);
  border: 1px solid var(--rule-soft);
  border-radius: 2px;
  padding: 0.1em 0.35em;
}

pre {
  margin: 0 0 0.9em;
  padding: 11px 13px;
  background: var(--panel);
  border: 1px solid var(--rule-soft);
  border-radius: var(--radius);
  overflow-x: auto;
}

pre code { background: none; border: none; padding: 0; }

.thinking {
  border-left: 2px solid var(--rule);
  padding: 2px 0 2px 12px;
  margin-bottom: 12px;
  color: var(--ink-faint);
  font-size: 13.5px;
  font-style: italic;
  white-space: pre-wrap;
}

.attach-row { display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 8px; }
.attach-row img { max-height: 120px; border-radius: var(--radius); border: 1px solid var(--rule); }

/* ---------------- tool cards ---------------- */

.tool {
  max-width: 100%;
  border: 1px solid var(--rule-soft);
  border-radius: var(--radius);
  background: var(--panel);
  margin-bottom: 10px;
  overflow: hidden;
}

.tool__head {
  display: flex;
  align-items: center;
  gap: 10px;
  width: 100%;
  padding: 8px 11px;
  text-align: left;
}

.tool__name {
  font: 600 11px/1 var(--mono);
  letter-spacing: 0.1em;
  text-transform: uppercase;
  color: var(--live);
  flex-shrink: 0;
}

.tool__summary {
  font: 12px/1.4 var(--mono);
  color: var(--ink-dim);
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
  flex: 1;
  min-width: 0;
}

.tool__status { flex-shrink: 0; }
.tool__status--error { color: var(--rust); }

.tool__body {
  border-top: 1px solid var(--rule-soft);
  padding: 10px 11px;
  font: 12px/1.5 var(--mono);
  white-space: pre-wrap;
  /* pre-wrap alone will not break an unbroken 120-character path. */
  overflow-wrap: anywhere;
  overflow-x: auto;
  color: var(--ink-dim);
  max-height: 420px;
  overflow-y: auto;
}

.tool__body[hidden] { display: none; }

.tool[data-state="error"] .tool__name { color: var(--rust); }

.diff { font: 12px/1.55 var(--mono); }
.diff__line { display: block; padding: 0 6px; white-space: pre-wrap; overflow-wrap: anywhere; }
.diff__line--add { background: rgba(79, 191, 160, 0.12); color: #a7e5d0; }
.diff__line--del { background: rgba(212, 97, 74, 0.12); color: #efab9c; }
.diff__line--ctx { color: var(--ink-faint); }

/* ---------------- composer ---------------- */

.composer {
  border-top: 1px solid var(--rule);
  background: var(--panel);
  padding: 10px 16px 12px;
}

.composer__inner { max-width: 860px; min-width: 0; margin: 0 auto; }

.composer__box {
  display: flex;
  align-items: flex-end;
  gap: 8px;
  border: 1px solid var(--rule);
  border-radius: var(--radius);
  background: var(--panel-raised);
  padding: 8px;
}

.composer__box:focus-within { border-color: var(--live); }
.composer__box.is-dragging { border-color: var(--live); border-style: dashed; }

.composer textarea {
  flex: 1;
  min-height: 24px;
  max-height: 180px;
  resize: none;
  border: none;
  background: none;
  outline: none;
  padding: 4px 2px;
  line-height: 1.5;
}

.composer__controls {
  display: flex;
  align-items: center;
  gap: 10px;
  margin-top: 8px;
  flex-wrap: wrap;
}

.select {
  background: var(--panel-raised);
  border: 1px solid var(--rule-soft);
  border-radius: var(--radius);
  padding: 5px 8px;
  font: 11px/1 var(--mono);
  letter-spacing: 0.06em;
  color: var(--ink-dim);
}

.select:disabled { opacity: 0.45; }

.composer__hint {
  flex: 1;
  text-align: right;
  font: 10px/1 var(--mono);
  letter-spacing: 0.08em;
  color: var(--ink-faint);
  text-transform: uppercase;
}

/* ---------------- files panel ---------------- */

.files {
  background: var(--panel);
  border-left: 1px solid var(--rule);
  display: flex;
  flex-direction: column;
  min-height: 0;
}

.files[hidden] { display: none; }

.files__head {
  padding: 12px 14px 8px;
  border-bottom: 1px solid var(--rule-soft);
}

.files__path {
  font: 11px/1.4 var(--mono);
  color: var(--ink-dim);
  margin-top: 4px;
  overflow-wrap: anywhere;
}

.files__list { overflow-y: auto; flex: 1; padding: 6px; min-height: 0; }

.fileitem {
  display: flex;
  width: 100%;
  gap: 8px;
  align-items: center;
  padding: 5px 8px;
  border-radius: var(--radius);
  font: 12.5px/1.4 var(--mono);
  color: var(--ink-dim);
  text-align: left;
}

.fileitem:hover { background: var(--panel-raised); color: var(--ink); }
.fileitem__size { margin-left: auto; font-size: 10px; color: var(--ink-faint); }
.fileitem--dir { color: var(--violetish); }

/* ---------------- dialogs ---------------- */

.overlay {
  position: fixed;
  inset: 0;
  background: rgba(6, 14, 17, 0.8);
  display: grid;
  place-items: center;
  padding: 20px;
  z-index: 40;
}

.overlay[hidden] { display: none; }

.card {
  width: min(560px, 100%);
  max-height: 86vh;
  overflow: auto;
  background: var(--panel);
  border: 1px solid var(--rule);
  border-radius: var(--radius);
  box-shadow: var(--shadow);
  padding: 20px;
}

.card--wide { width: min(900px, 100%); }

.card h2 {
  margin: 0 0 4px;
  font: 700 15px/1.3 var(--sans);
  letter-spacing: 0.01em;
}

.card__sub { margin: 0 0 18px; color: var(--ink-dim); font-size: 13px; }

.field { margin-bottom: 14px; }
.field label { display: block; margin-bottom: 5px; }

.field input, .field select, .field textarea {
  width: 100%;
  padding: 9px 10px;
  background: var(--panel-deep);
  border: 1px solid var(--rule);
  border-radius: var(--radius);
  outline: none;
}

.field input:focus, .field select:focus { border-color: var(--live); }

.card__actions { display: flex; gap: 8px; justify-content: flex-end; margin-top: 18px; }

.error {
  color: var(--rust);
  font-size: 13px;
  margin-top: 10px;
  min-height: 1em;
}

.filepeek {
  font: 12px/1.6 var(--mono);
  white-space: pre;
  overflow: auto;
  max-height: 60vh;
  background: var(--panel-deep);
  border: 1px solid var(--rule-soft);
  border-radius: var(--radius);
  padding: 12px;
}

.empty {
  position: absolute;
  inset: 0;
  display: grid;
  place-items: center;
  text-align: center;
  padding: 30px;
  color: var(--ink-faint);
}

.empty__inner { max-width: 340px; }
.empty h3 { font: 700 15px/1.4 var(--sans); color: var(--ink-dim); margin: 0 0 6px; }
.empty p { margin: 0 0 16px; font-size: 13.5px; }

/* ---------------- responsive ---------------- */

.rail__scrim { display: none; }

@media (max-width: 900px) {
  .body,
  .body[data-files="open"] {
    grid-template-columns: minmax(0, 1fr);
    grid-template-areas: "main";
  }

  .rail {
    position: fixed;
    top: 52px;
    bottom: 0;
    left: 0;
    width: 84vw;
    max-width: var(--rail);
    z-index: 30;
    transform: translateX(-102%);
    transition: transform 220ms cubic-bezier(0.2, 0.7, 0.2, 1);
  }

  .body[data-rail="open"] .rail { transform: none; }

  .body[data-rail="open"] .rail__scrim {
    display: block;
    position: fixed;
    inset: 52px 0 0;
    background: rgba(6, 14, 17, 0.6);
    z-index: 20;
  }

  .files {
    position: fixed;
    top: 52px;
    bottom: 0;
    right: 0;
    width: 88vw;
    z-index: 30;
  }

  .meterstrip { display: none; }
  .thread { padding: 16px 12px 22px; }
  .composer { padding: 8px 12px 10px; }
}

@media (prefers-reduced-motion: reduce) {
  .rail { transition: none; }
}

.only-narrow { display: none; }

@media (max-width: 900px) {
  .only-narrow { display: grid; }
}

.updatebtn {
  font: inherit; font-size: 12px; padding: 4px 10px; border-radius: 999px; cursor: pointer;
  color: var(--live); background: transparent; border: 1px solid var(--live); white-space: nowrap;
}
.updatebtn:disabled { opacity: .6; cursor: progress; }
","app.js":"import { api, openStream } from './api.js';
import { escapeHtml, formatBytes, meterHtml, renderDiff, renderMarkdown, toolLabel, toolSummary } from './render.js';

const $ = (id) => document.getElementById(id);

const el = {
  shell: $('shell'),
  bodyGrid: $('bodyGrid'),
  where: $('where'),
  meterstrip: $('meterstrip'),
  sessionList: $('sessionList'),
  thread: $('thread'),
  threadInner: $('threadInner'),
  emptyState: $('emptyState'),
  notice: $('notice'),
  input: $('input'),
  send: $('send'),
  stop: $('stop'),
  hint: $('hint'),
  modelSelect: $('modelSelect'),
  attachRow: $('attachRow'),
  attachBtn: $('attachBtn'),
  fileInput: $('fileInput'),
  composerBox: $('composerBox'),
  filesPanel: $('filesPanel'),
  filesList: $('filesList'),
  filesPath: $('filesPath'),
  filesToggle: $('filesToggle'),
  refreshUsage: $('refreshUsage'),
  railToggle: $('railToggle'),
  railScrim: $('railScrim'),
  setupOverlay: $('setupOverlay'),
  setupForm: $('setupForm'),
  bridgeInput: $('bridgeInput'),
  tokenInput: $('tokenInput'),
  setupError: $('setupError'),
  setupSkip: $('setupSkip'),
  rootInput: $('rootInput'),
  addRoot: $('addRoot'),
  newOverlay: $('newOverlay'),
  newForm: $('newForm'),
  projectSelect: $('projectSelect'),
  newModel: $('newModel'),
  newError: $('newError'),
  newCancel: $('newCancel'),
  peekOverlay: $('peekOverlay'),
  peekName: $('peekName'),
  peekMeta: $('peekMeta'),
  peekBody: $('peekBody'),
  peekClose: $('peekClose'),
};

const state = {
  boot: null,
  sessions: [],
  current: null,
  stream: null,
  running: false,
  attachments: [],
  toolCards: new Map(),
  live: null,
  filesCwd: '.',
};

/* ---------------- self-update ---------------- */

const updateBtn = document.getElementById('updateBtn');

async function checkForUpdate() {
  try {
    const info = await api.checkUpdate();
    if (!info.available) { updateBtn.hidden = true; return; }
    updateBtn.textContent = `Update to ${info.latest}`;
    updateBtn.title = `This agent is ${info.current}; the bridge has ${info.latest}.`;
    updateBtn.hidden = false;
  } catch { /* bridge unreachable: try again later */ }
}

updateBtn.addEventListener('click', async () => {
  if (!confirm('Update the agent from the bridge and restart it?')) return;
  updateBtn.disabled = true;
  updateBtn.textContent = 'Updating…';
  try {
    const result = await api.applyUpdate();
    if (!result.restarting) {
      updateBtn.textContent = result.updated ? 'Updated — restart the agent' : 'Up to date';
      return;
    }
    // Wait for the new process to come up, then load its UI.
    for (let i = 0; i < 60; i += 1) {
      await new Promise((r) => setTimeout(r, 1000));
      try {
        const boot = await api.bootstrap();
        if (boot.agent?.version === result.version) { location.reload(); return; }
      } catch { /* still restarting */ }
    }
    updateBtn.textContent = 'Restart the agent manually';
  } catch (err) {
    updateBtn.disabled = false;
    updateBtn.textContent = 'Update failed — retry';
    updateBtn.title = err.message;
  }
});

setInterval(checkForUpdate, 30 * 60 * 1000);

/* ---------------- boot ---------------- */

async function boot() {
  state.boot = await api.bootstrap();
  el.shell.hidden = false;
  checkForUpdate();
  // The agent runs locally, so nothing here is gated on a password. What it
  // does need is somewhere to send model calls.
  if (!state.boot.settings.connected) {
    el.bridgeInput.value = state.boot.settings.bridge ?? '';
    el.setupError.textContent = state.boot.settings.error ?? '';
    el.setupOverlay.hidden = false;
    el.tokenInput.focus();
  } else {
    el.setupOverlay.hidden = true;
  }
  state.sessions = state.boot.sessions;
  paintMeters(state.boot.usage);
  paintSessions();
  paintModelOptions();
  const last = localStorage.getItem('ccb:lastSession');
  if (last && state.sessions.some((s) => s.id === last)) await openSession(last);
  else paintEmpty();
}

el.setupForm.addEventListener('submit', async (event) => {
  event.preventDefault();
  el.setupError.textContent = 'Checking…';
  try {
    const result = await api.saveSettings({
      bridge: el.bridgeInput.value.trim(),
      token: el.tokenInput.value.trim(),
    });
    if (!result.ok) {
      el.setupError.textContent = result.error ?? 'The bridge refused that token.';
      return;
    }
    el.setupOverlay.hidden = true;
    await boot();
  } catch (err) {
    el.setupError.textContent = err.message;
  }
});

el.setupSkip.addEventListener('click', () => { el.setupOverlay.hidden = true; });

/* ---------------- meters ---------------- */

function paintMeters(usage) {
  if (!usage) return;
  if (!usage.ok && !usage.limits.length) {
    el.meterstrip.innerHTML = `<div class="meter"><div class="meter__head"><span class="meter__label">Usage</span></div>
      <div class="meter__foot">${escapeHtml(usage.error ?? 'unavailable')}</div></div>`;
    return;
  }
  el.meterstrip.innerHTML = usage.limits.map(meterHtml).join('');
  if (usage.paused) showNotice('block', 'The administrator paused this bridge. New turns are refused.');
}

async function refreshUsage() {
  try {
    const data = await api.usage();
    paintMeters(data.usage);
    state.boot.models = data.models;
    paintModelOptions();
  } catch { /* transient; the next poll retries */ }
}

el.refreshUsage.addEventListener('click', refreshUsage);
setInterval(refreshUsage, 120_000);

/* ---------------- sessions ---------------- */

function paintSessions() {
  if (!state.sessions.length) {
    el.sessionList.innerHTML = '<p class="legend" style="padding:8px 10px">No sessions yet</p>';
    return;
  }
  el.sessionList.innerHTML = state.sessions.map((session) => {
    const lampClass = session.running ? 'lamp--running' : session.alive ? 'lamp--idle' : '';
    const modelLabel = (state.boot.models.find((m) => m.id === session.model)?.label) ?? session.model;
    return `
      <button class="sessionitem" data-id="${session.id}" aria-current="${session.id === state.current?.id}">
        <span class="sessionitem__title">${escapeHtml(session.title || 'Untitled session')}</span>
        <span class="sessionitem__meta">
          <i class="lamp ${lampClass}"></i>
          <span>${escapeHtml(session.projectName ?? '')}</span>
          <span>·</span>
          <span>${escapeHtml(modelLabel)}</span>
        </span>
      </button>`;
  }).join('');
}

el.sessionList.addEventListener('click', (event) => {
  const button = event.target.closest('.sessionitem');
  if (button) {
    void openSession(button.dataset.id);
    closeRail();
  }
});

function paintEmpty() {
  el.emptyState.hidden = state.sessions.length > 0 && Boolean(state.current);
  if (!state.current) {
    el.emptyState.hidden = false;
    el.threadInner.innerHTML = '';
    el.where.textContent = 'No session open';
  }
}

async function openSession(id) {
  if (state.stream) {
    state.stream.close();
    state.stream = null;
  }
  state.toolCards.clear();
  state.live = null;
  el.threadInner.innerHTML = '';
  hideNotice();

  const session = state.sessions.find((s) => s.id === id);
  if (!session) return;
  state.current = session;
  localStorage.setItem('ccb:lastSession', id);
  el.emptyState.hidden = true;
  el.where.textContent = `${session.projectName} — ${session.projectPath}`;
  paintSessions();
  paintModelOptions();
  setComposerEnabled(true);

  const history = await api.history(id);
  for (const event of history.events) applyEvent(event, { replay: true });
  scrollToEnd(true);

  // Resume after what the history already covered, so nothing renders twice.
  state.stream = openStream(id, history.lastSeq, (event) => applyEvent(event, {}), (status) => {
    el.hint.textContent = status === 'reconnecting'
      ? 'Reconnecting…'
      : 'Enter sends · Shift+Enter newline';
  });
  void loadFiles('.');
}

/* ---------------- new session ---------------- */

function openNewDialog() {
  el.newError.textContent = '';
  el.projectSelect.innerHTML = state.boot.projects.length
    ? state.boot.projects.map((p) => `<option value="${escapeHtml(p.path)}">${escapeHtml(p.name)} — ${escapeHtml(p.path)}</option>`).join('')
    : '<option value="">Add a folder below to start</option>';
  el.newModel.innerHTML = state.boot.models
    .map((m) => `<option value="${m.id}" ${m.allowed ? '' : 'disabled'}>${escapeHtml(m.label)}${m.allowed ? '' : ' — over cap'}</option>`)
    .join('');
  el.newModel.value = state.boot.config.models.default ?? '';
  el.newOverlay.hidden = false;
}

el.addRoot.addEventListener('click', async () => {
  const path = el.rootInput.value.trim();
  if (!path) return;
  el.newError.textContent = '';
  try {
    const { roots } = await api.addRoot(path);
    state.boot.projects = roots;
    el.rootInput.value = '';
    openNewDialog();
  } catch (err) {
    el.newError.textContent = err.message;
  }
});

$('newSession').addEventListener('click', openNewDialog);
$('newSessionEmpty').addEventListener('click', openNewDialog);
el.newCancel.addEventListener('click', () => { el.newOverlay.hidden = true; });

el.newForm.addEventListener('submit', async (event) => {
  event.preventDefault();
  el.newError.textContent = '';
  try {
    const { session } = await api.createSession({
      projectPath: el.projectSelect.value,
      model: el.newModel.value,
    });
    state.sessions.unshift({ ...session, alive: false, running: false });
    el.newOverlay.hidden = true;
    paintSessions();
    await openSession(session.id);
    el.input.focus();
  } catch (err) {
    el.newError.textContent = err.message;
  }
});

/* ---------------- event application ---------------- */

function applyEvent(event, { replay = false } = {}) {
  const { type, data } = event;
  if (type === 'status') {
    setRunning(data.status === 'running');
    const session = state.sessions.find((s) => s.id === data.id);
    if (session) {
      Object.assign(session, { running: data.status === 'running', alive: data.alive, model: data.model });
      paintSessions();
    }
    return;
  }
  if (type === 'user_message') { appendUserMessage(data.content); return; }
  if (type === 'error') { appendSystemLine('error', data.message); return; }
  if (type === 'notice') { appendSystemLine('notice', data.message); return; }
  // A retried model call starts over, so drop the half-streamed text.
  if (type === 'retry') { clearLive(); appendSystemLine('notice', data.message); return; }
  if (type === 'blocked') { showNotice('block', data.reasons.join(' ')); setRunning(false); return; }
  if (type === 'warning') { showNotice('warn', warningText(data)); return; }
  if (type === 'stream_event') { applyStreamDelta(data); return; }
  if (type !== 'claude') return;

  const msg = data;
  if (msg.type === 'assistant') { appendAssistantMessage(msg.message); return; }
  if (msg.type === 'user') { applyUserTurn(msg.message, replay); return; }
  if (msg.type === 'result' && msg.is_error) {
    appendSystemLine('error', msg.result ?? 'The turn ended with an error.');
  }
}

function warningText(verdict) {
  const worst = verdict.warnings.find((w) => w.percent != null);
  if (!worst) return verdict.warnings[0]?.label ?? 'Approaching a usage limit.';
  return `${worst.label} is at ${worst.percent}% — turns stop at ${worst.block}%.`;
}

/** Live turns echo the user message themselves; replays carry it in the transcript. */
function applyUserTurn(message, replay) {
  const blocks = Array.isArray(message?.content) ? message.content : [];
  const results = blocks.filter((b) => b.type === 'tool_result');
  for (const result of results) applyToolResult(result);
  const visible = blocks.filter((b) => b.type === 'text' || b.type === 'image');
  if (replay && visible.length) appendUserMessage(visible);
}

/* ---------------- rendering into the thread ---------------- */

function nearBottom() {
  return el.thread.scrollHeight - el.thread.scrollTop - el.thread.clientHeight < 140;
}

function scrollToEnd(force = false) {
  if (force || nearBottom()) el.thread.scrollTop = el.thread.scrollHeight;
}

function append(node) {
  const stick = nearBottom();
  el.threadInner.appendChild(node);
  if (stick) scrollToEnd(true);
  return node;
}

function appendUserMessage(content) {
  const blocks = Array.isArray(content) ? content : [{ type: 'text', text: String(content) }];
  const images = blocks.filter((b) => b.type === 'image');
  const text = blocks.filter((b) => b.type === 'text').map((b) => b.text).join('\n');
  const node = document.createElement('div');
  node.className = 'msg--user';
  let html = '';
  if (images.length) {
    // Replayed transcripts are files on disk, so their media type and payload
    // are escaped like any other untrusted attribute value.
    html += `<div class="attach-row">${images
      .map((img) => `<img alt="Attached image" src="data:${escapeHtml(img.source?.media_type)};base64,${escapeHtml(img.source?.data)}">`)
      .join('')}</div>`;
  }
  html += escapeHtml(text);
  node.innerHTML = html;
  append(node);
}

function appendSystemLine(kind, message) {
  const node = document.createElement('div');
  node.className = kind === 'error' ? 'inlinemsg inlinemsg--error' : 'inlinemsg';
  node.textContent = message;
  append(node);
}

function clearLive() {
  if (state.live?.node?.isConnected) state.live.node.remove();
  state.live = null;
}

function applyStreamDelta(payload) {
  const inner = payload?.event;
  if (!inner) return;
  if (inner.type === 'content_block_delta') {
    const delta = inner.delta ?? {};
    const text = delta.text ?? delta.thinking;
    if (!text) return;
    const isThinking = delta.type === 'thinking_delta';
    if (!state.live || state.live.thinking !== isThinking) {
      clearLive();
      const node = document.createElement('div');
      node.className = isThinking ? 'thinking' : 'msg--assistant';
      state.live = { node: append(node), buffer: '', thinking: isThinking };
    }
    state.live.buffer += text;
    state.live.node.innerHTML = state.live.thinking
      ? escapeHtml(state.live.buffer)
      : renderMarkdown(state.live.buffer);
    scrollToEnd();
  }
}

function appendAssistantMessage(message) {
  clearLive();
  const blocks = Array.isArray(message?.content) ? message.content : [];
  for (const block of blocks) {
    if (block.type === 'text' && block.text.trim()) {
      const node = document.createElement('div');
      node.className = 'msg--assistant';
      node.innerHTML = renderMarkdown(block.text);
      append(node);
    } else if (block.type === 'thinking' && block.thinking) {
      const node = document.createElement('div');
      node.className = 'thinking';
      node.textContent = block.thinking;
      append(node);
    } else if (block.type === 'tool_use') {
      append(buildToolCard(block));
    }
  }
}

function buildToolCard(block) {
  const card = document.createElement('div');
  card.className = 'tool';
  card.dataset.state = 'pending';
  card.innerHTML = `
    <button class="tool__head" type="button" aria-expanded="false">
      <span class="tool__name">${escapeHtml(toolLabel(block.name))}</span>
      <span class="tool__summary">${escapeHtml(toolSummary(block.name, block.input))}</span>
      <span class="tool__status legend">running</span>
    </button>
    <div class="tool__body" hidden></div>`;

  const body = card.querySelector('.tool__body');
  body.innerHTML = detailHtml(block.name, block.input);

  const head = card.querySelector('.tool__head');
  head.addEventListener('click', () => {
    const open = body.hidden;
    body.hidden = !open;
    head.setAttribute('aria-expanded', String(open));
  });

  state.toolCards.set(block.id, card);
  return card;
}

/** Tool-specific detail: diffs for edits, the command for Bash, JSON otherwise. */
function detailHtml(name, input = {}) {
  if (name === 'edit_file') {
    return renderDiff(input.old_string ?? '', input.new_string ?? '');
  }
  if (name === 'write_file') {
    return `<div class="diff">${escapeHtml(input.content ?? '')}</div>`;
  }
  if (name === 'run_shell') {
    return escapeHtml(input.command ?? '');
  }
  return escapeHtml(JSON.stringify(input, null, 2));
}

function applyToolResult(result) {
  const card = state.toolCards.get(result.tool_use_id);
  if (!card) return;
  const isError = Boolean(result.is_error);
  card.dataset.state = isError ? 'error' : 'done';
  const status = card.querySelector('.tool__status');
  status.textContent = isError ? 'failed' : 'done';
  status.classList.toggle('tool__status--error', isError);

  const text = Array.isArray(result.content)
    ? result.content.map((c) => (c.type === 'text' ? c.text : `[${c.type}]`)).join('\n')
    : String(result.content ?? '');

  const body = card.querySelector('.tool__body');
  const existing = body.innerHTML;
  body.innerHTML = `${existing}<hr style="border:none;border-top:1px solid var(--rule-soft);margin:10px 0">${escapeHtml(
    text.length > 8000 ? `${text.slice(0, 8000)}\n… ${text.length - 8000} more characters` : text,
  )}`;
  if (isError) body.hidden = false;
}

/* ---------------- notices ---------------- */

function showNotice(kind, message) {
  el.notice.hidden = false;
  el.notice.className = `banner banner--${kind}`;
  el.notice.textContent = message;
}

function hideNotice() {
  el.notice.hidden = true;
}

/* ---------------- composer ---------------- */

function setComposerEnabled(enabled) {
  el.input.disabled = !enabled;
  el.send.disabled = !enabled;
  el.modelSelect.disabled = !enabled;
}

function setRunning(running) {
  state.running = running;
  el.stop.hidden = !running;
  el.send.disabled = running || !state.current;
  el.input.disabled = !state.current;
  el.modelSelect.disabled = running || !state.current;
}

function paintModelOptions() {
  if (!state.boot) return;
  const current = state.current;
  el.modelSelect.innerHTML = state.boot.models
    .map((m) => `<option value="${m.id}" ${m.allowed ? '' : 'disabled'}>${escapeHtml(m.label)}${m.allowed ? '' : ' — over cap'}</option>`)
    .join('');
  if (current) el.modelSelect.value = current.model;
}

el.modelSelect.addEventListener('change', async () => {
  if (!state.current) return;
  try {
    const { session } = await api.setModel(state.current.id, { model: el.modelSelect.value });
    Object.assign(state.current, session);
    paintSessions();
  } catch (err) {
    showNotice('block', err.message);
    el.modelSelect.value = state.current.model;
  }
});

el.input.addEventListener('input', () => {
  el.input.style.height = 'auto';
  el.input.style.height = `${Math.min(180, el.input.scrollHeight)}px`;
});

el.input.addEventListener('keydown', (event) => {
  if (event.key === 'Enter' && !event.shiftKey) {
    event.preventDefault();
    void submit();
  }
});

el.send.addEventListener('click', () => void submit());

el.stop.addEventListener('click', async () => {
  if (!state.current) return;
  await api.interrupt(state.current.id);
});

async function submit() {
  if (!state.current || state.running) return;
  const text = el.input.value.trim();
  if (!text && !state.attachments.length) return;
  hideNotice();

  const payload = {
    text,
    images: state.attachments.map(({ mediaType, dataBase64 }) => ({ mediaType, dataBase64 })),
  };
  el.input.value = '';
  el.input.style.height = 'auto';
  const sent = state.attachments;
  state.attachments = [];
  paintAttachments();
  setRunning(true);

  try {
    const res = await api.sendMessage(state.current.id, payload);
    if (res.policy?.level === 'warn') showNotice('warn', warningText(res.policy));
  } catch (err) {
    setRunning(false);
    state.attachments = sent;
    paintAttachments();
    el.input.value = text;
    showNotice('block', err.message);
  }
}

/* ---------------- attachments ---------------- */

function paintAttachments() {
  el.attachRow.innerHTML = state.attachments
    .map((a, i) => `<img src="data:${escapeHtml(a.mediaType)};base64,${escapeHtml(a.dataBase64)}" alt="${escapeHtml(a.name)}" data-index="${i}" title="Click to remove">`)
    .join('');
}

el.attachRow.addEventListener('click', (event) => {
  const index = event.target.dataset?.index;
  if (index == null) return;
  state.attachments.splice(Number(index), 1);
  paintAttachments();
});

el.attachBtn.addEventListener('click', () => el.fileInput.click());
el.fileInput.addEventListener('change', () => {
  void addFiles([...el.fileInput.files]);
  el.fileInput.value = '';
});

async function addFiles(files) {
  const max = state.boot.config.limits.maxUploadBytes;
  for (const file of files) {
    if (!file.type.startsWith('image/')) continue;
    if (file.size > max) {
      showNotice('warn', `${file.name} is larger than the ${formatBytes(max)} attachment limit.`);
      continue;
    }
    const dataBase64 = await new Promise((resolve) => {
      const reader = new FileReader();
      reader.onload = () => resolve(String(reader.result).split(',')[1]);
      reader.readAsDataURL(file);
    });
    state.attachments.push({ name: file.name, mediaType: file.type, dataBase64 });
  }
  paintAttachments();
}

el.input.addEventListener('paste', (event) => {
  const files = [...(event.clipboardData?.files ?? [])];
  if (files.length) {
    event.preventDefault();
    void addFiles(files);
  }
});

['dragover', 'dragenter'].forEach((name) => el.composerBox.addEventListener(name, (event) => {
  event.preventDefault();
  el.composerBox.classList.add('is-dragging');
}));

['dragleave', 'drop'].forEach((name) => el.composerBox.addEventListener(name, (event) => {
  event.preventDefault();
  el.composerBox.classList.remove('is-dragging');
  if (name === 'drop') void addFiles([...(event.dataTransfer?.files ?? [])]);
}));

/* ---------------- files panel ---------------- */

el.filesToggle.addEventListener('click', () => {
  const open = el.filesPanel.hidden;
  el.filesPanel.hidden = !open;
  el.bodyGrid.dataset.files = open ? 'open' : 'closed';
  el.filesToggle.setAttribute('aria-pressed', String(open));
  if (open) void loadFiles(state.filesCwd);
});

async function loadFiles(path) {
  if (!state.current) return;
  try {
    const data = await api.listDir(state.current.projectPath, path);
    state.filesCwd = data.cwd;
    el.filesPath.textContent = data.cwd === '.' ? state.current.projectPath : data.cwd;
    const up = data.cwd === '.'
      ? ''
      : '<button class="fileitem fileitem--dir" data-type="up">.. up one level</button>';
    el.filesList.innerHTML = up + data.entries.map((entry) => `
      <button class="fileitem ${entry.type === 'dir' ? 'fileitem--dir' : ''}"
              data-type="${entry.type}" data-path="${escapeHtml(entry.path)}">
        <span>${entry.type === 'dir' ? '▸' : '·'}</span>
        <span>${escapeHtml(entry.name)}</span>
        <span class="fileitem__size">${formatBytes(entry.size)}</span>
      </button>`).join('');
  } catch (err) {
    el.filesList.innerHTML = `<p class="legend" style="padding:8px">${escapeHtml(err.message)}</p>`;
  }
}

el.filesList.addEventListener('click', async (event) => {
  const button = event.target.closest('.fileitem');
  if (!button) return;
  if (button.dataset.type === 'up') {
    const parent = state.filesCwd.includes('/') ? state.filesCwd.replace(/\/[^/]+$/, '') : '.';
    return loadFiles(parent);
  }
  if (button.dataset.type === 'dir') return loadFiles(button.dataset.path);

  const file = await api.readFile(state.current.projectPath, button.dataset.path);
  el.peekName.textContent = button.dataset.path;
  el.peekMeta.textContent = file.binary
    ? 'Binary file — not shown'
    : `${formatBytes(file.size)}${file.truncated ? ' · truncated' : ''}`;
  el.peekBody.textContent = file.binary ? '' : file.content;
  el.peekOverlay.hidden = false;
  return undefined;
});

el.peekClose.addEventListener('click', () => { el.peekOverlay.hidden = true; });
el.peekOverlay.addEventListener('click', (event) => {
  if (event.target === el.peekOverlay) el.peekOverlay.hidden = true;
});

/* ---------------- rail (mobile) ---------------- */

function closeRail() {
  el.bodyGrid.dataset.rail = 'closed';
}

el.railToggle.addEventListener('click', () => {
  el.bodyGrid.dataset.rail = el.bodyGrid.dataset.rail === 'open' ? 'closed' : 'open';
});

el.railScrim.addEventListener('click', closeRail);

document.addEventListener('keydown', (event) => {
  if (event.key === 'Escape') {
    el.peekOverlay.hidden = true;
    el.newOverlay.hidden = true;
    closeRail();
  }
});

boot().catch((err) => {
  document.body.innerHTML = `<div class="empty"><div class="empty__inner"><h3>Bridge unavailable</h3><p>${escapeHtml(err.message)}</p></div></div>`;
});
","index.html":"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","render.js":"/* Presentation helpers: safe markdown, tool summaries, diffs, meters. */

export function escapeHtml(value) {
  return String(value ?? '')
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;');
}

function inlineMarkdown(text) {
  // Input is already HTML-escaped, so these only ever produce our own tags.
  return text
    .replace(/`([^`]+)`/g, '<code>$1</code>')
    .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
    .replace(/(^|[\s(])\*([^*\n]+)\*/g, '$1<em>$2</em>')
    .replace(/\[([^\]]+)\]\((https?:[^)\s]+)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
}

function renderBlock(block) {
  const lines = block.split('\n');
  let html = '';
  let list = null;

  const closeList = () => {
    if (list) {
      html += `</${list}>`;
      list = null;
    }
  };

  for (const raw of lines) {
    const line = raw.trimEnd();
    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
    const bullet = /^\s*[-*]\s+(.*)$/.exec(line);
    const numbered = /^\s*\d+\.\s+(.*)$/.exec(line);

    if (heading) {
      closeList();
      const level = Math.min(3, heading[1].length);
      html += `<h${level}>${inlineMarkdown(heading[2])}</h${level}>`;
    } else if (bullet) {
      if (list !== 'ul') { closeList(); list = 'ul'; html += '<ul>'; }
      html += `<li>${inlineMarkdown(bullet[1])}</li>`;
    } else if (numbered) {
      if (list !== 'ol') { closeList(); list = 'ol'; html += '<ol>'; }
      html += `<li>${inlineMarkdown(numbered[1])}</li>`;
    } else if (!line.trim()) {
      closeList();
    } else {
      closeList();
      html += `<p>${inlineMarkdown(line)}</p>`;
    }
  }
  closeList();
  return html;
}

/** Minimal markdown: fences, headings, lists, bold/italic/code/links. */
export function renderMarkdown(text) {
  const escaped = escapeHtml(text);
  const parts = escaped.split(/```/);
  let html = '';
  parts.forEach((part, index) => {
    if (index % 2 === 1) {
      const newline = part.indexOf('\n');
      const body = newline === -1 ? part : part.slice(newline + 1);
      html += `<pre><code>${body.replace(/\n$/, '')}</code></pre>`;
    } else {
      html += renderBlock(part);
    }
  });
  return html;
}

/* ---------------- tool cards ---------------- */

const TRUNCATE = 160;

function shorten(value, max = TRUNCATE) {
  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
  return text.length > max ? `${text.slice(0, max)}…` : text;
}

/** A one-line description of what a tool call is about to do. */
export function toolSummary(name, input = {}) {
  switch (name) {
    case 'run_shell': return shorten(input.command);
    case 'read_file':
    case 'write_file':
    case 'edit_file':
    case 'list_dir': return shorten(input.path ?? '.');
    case 'glob': return shorten(input.pattern);
    case 'grep': return shorten(`${input.pattern ?? ''} ${input.glob ?? ''}`.trim());
    default: return shorten(input.description ?? input.path ?? JSON.stringify(input));
  }
}

/** Human-readable label for a tool, used as the card's title. */
const TOOL_LABELS = {
  read_file: 'read',
  write_file: 'write',
  edit_file: 'edit',
  list_dir: 'list',
  glob: 'glob',
  grep: 'grep',
  run_shell: 'shell',
};

export function toolLabel(name) {
  return TOOL_LABELS[name] ?? name;
}

/* ---------------- diffs ---------------- */

/** Longest-common-subsequence line diff, good enough for edit previews. */
export function lineDiff(before, after) {
  const a = String(before ?? '').split('\n');
  const b = String(after ?? '').split('\n');
  const table = Array.from({ length: a.length + 1 }, () => new Uint32Array(b.length + 1));

  for (let i = a.length - 1; i >= 0; i -= 1) {
    for (let j = b.length - 1; j >= 0; j -= 1) {
      table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
    }
  }

  const rows = [];
  let i = 0;
  let j = 0;
  while (i < a.length && j < b.length) {
    if (a[i] === b[j]) { rows.push({ kind: 'ctx', text: a[i] }); i += 1; j += 1; }
    else if (table[i + 1][j] >= table[i][j + 1]) { rows.push({ kind: 'del', text: a[i] }); i += 1; }
    else { rows.push({ kind: 'add', text: b[j] }); j += 1; }
  }
  while (i < a.length) { rows.push({ kind: 'del', text: a[i] }); i += 1; }
  while (j < b.length) { rows.push({ kind: 'add', text: b[j] }); j += 1; }
  return rows;
}

const MARK = { add: '+', del: '−', ctx: ' ' };

export function renderDiff(before, after) {
  const rows = lineDiff(before, after);
  const body = rows
    .map((row) => `<span class="diff__line diff__line--${row.kind}">${MARK[row.kind]} ${escapeHtml(row.text)}</span>`)
    .join('');
  return `<div class="diff">${body}</div>`;
}

/* ---------------- formatting ---------------- */

export function formatBytes(bytes) {
  if (bytes == null) return '';
  if (bytes < 1024) return `${bytes} B`;
  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
}

export function formatReset(iso) {
  if (!iso) return '';
  const ms = Date.parse(iso) - Date.now();
  if (Number.isNaN(ms)) return '';
  if (ms <= 0) return 'resetting';
  const minutes = Math.round(ms / 60000);
  if (minutes < 60) return `resets in ${minutes}m`;
  const hours = Math.floor(minutes / 60);
  if (hours < 24) return `resets in ${hours}h ${minutes % 60}m`;
  return `resets in ${Math.floor(hours / 24)}d ${hours % 24}h`;
}

export function formatUsd(value) {
  if (!value) return '$0.00';
  return value < 0.01 ? `$${value.toFixed(4)}` : `$${value.toFixed(2)}`;
}

/* ---------------- meters ---------------- */

/**
 * The signature control: a segmented gauge whose track carries physical
 * notches at the warn and block thresholds.
 */
export function meterHtml(limit) {
  const percent = Math.max(0, Math.min(100, limit.percent ?? 0));
  const cap = limit.cap ?? null;
  const notches = cap && cap.enabled !== false
    ? `<i class="meter__notch meter__notch--warn" style="left:${cap.warn}%"></i>
       <i class="meter__notch meter__notch--block" style="left:${cap.block}%"></i>`
    : '';
  return `
    <div class="meter" data-level="${limit.level ?? 'ok'}" title="${escapeHtml(limit.label)} — ${percent}%">
      <div class="meter__head">
        <span class="meter__label">${escapeHtml(limit.label)}</span>
        <span class="meter__value">${percent}%</span>
      </div>
      <div class="meter__track">
        <div class="meter__fill" style="width:${percent}%"></div>
        ${notches}
      </div>
      <div class="meter__foot">${escapeHtml(formatReset(limit.resetsAt))}</div>
    </div>`;
}
"}
DEFAULT_BRIDGE = "https://claude-bridge.sardine-hue.ts.net"

MAX_TOOL_RESULT = 30000
MAX_READ_BYTES = 400_000
DEFAULT_MAX_TOKENS = 8192
SHELL_TIMEOUT = 120

# The bridge may restart (an update, a reboot); Funnel answers 502 meanwhile.
# Model calls wait it out instead of failing the turn.
RETRY_STATUSES = (0, 502, 503, 504, 529)
RETRY_DELAYS = (2, 3, 5, 8, 10, 10, 10, 10, 10)

# --------------------------------------------------------------------------
# configuration and state
# --------------------------------------------------------------------------


def config_dir():
    if IS_WINDOWS:
        base = os.environ.get("APPDATA") or os.path.expanduser("~")
    else:
        base = os.environ.get("XDG_CONFIG_HOME") or os.path.join(os.path.expanduser("~"), ".config")
    path = os.path.join(base, "ccb-agent")
    os.makedirs(path, exist_ok=True)
    return path


class Store:
    """Config and sessions, persisted as JSON next to each other."""

    def __init__(self):
        self.dir = config_dir()
        self.config_path = os.path.join(self.dir, "config.json")
        self.sessions_path = os.path.join(self.dir, "sessions.json")
        self.lock = threading.Lock()
        self.config = self._load(self.config_path, {"bridge": "", "token": "", "roots": [], "maxTokens": DEFAULT_MAX_TOKENS})
        self.sessions = self._load(self.sessions_path, {})

    @staticmethod
    def _load(path, fallback):
        try:
            with open(path, "r", encoding="utf-8") as handle:
                return json.load(handle)
        except Exception:
            return fallback

    def _save(self, path, value):
        tmp = "%s.%d.tmp" % (path, os.getpid())
        # The config holds the bridge token: keep it readable by this user only.
        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
        with os.fdopen(fd, "w", encoding="utf-8") as handle:
            json.dump(value, handle, indent=2)
        os.replace(tmp, path)

    def save_config(self):
        with self.lock:
            self._save(self.config_path, self.config)

    def save_sessions(self):
        with self.lock:
            self._save(self.sessions_path, self.sessions)


STORE = Store()


# --------------------------------------------------------------------------
# workspace-scoped filesystem access
# --------------------------------------------------------------------------


class ToolError(Exception):
    pass


def resolve_in_root(root, relative):
    """Resolve `relative` under `root`, refusing anything that escapes it."""
    root_real = os.path.realpath(root)
    target = os.path.realpath(os.path.join(root_real, relative or "."))
    if target != root_real and not target.startswith(root_real + os.sep):
        raise ToolError("Path is outside the workspace: %s" % relative)
    return target


SKIP_DIRS = {".git", "node_modules", ".venv", "__pycache__", "dist", "build", ".next", ".cache"}
BINARY_EXT = {
    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tar",
    ".so", ".dll", ".exe", ".bin", ".wasm", ".mp3", ".mp4", ".woff", ".woff2", ".ttf",
}


def read_text(path, limit=MAX_READ_BYTES):
    if os.path.splitext(path)[1].lower() in BINARY_EXT:
        raise ToolError("That is a binary file.")
    size = os.path.getsize(path)
    with open(path, "r", encoding="utf-8", errors="replace") as handle:
        data = handle.read(limit)
    if size > limit:
        data += "\n… truncated, %d bytes total" % size
    return data


# --------------------------------------------------------------------------
# tools exposed to the model
# --------------------------------------------------------------------------

TOOL_SPECS = [
    {
        "name": "read_file",
        "description": "Read a UTF-8 text file from the workspace. Returns the file content.",
        "input_schema": {
            "type": "object",
            "properties": {"path": {"type": "string", "description": "Path relative to the workspace root."}},
            "required": ["path"],
        },
    },
    {
        "name": "write_file",
        "description": "Create a file or replace its entire contents. Creates parent directories as needed.",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {"type": "string"},
                "content": {"type": "string"},
            },
            "required": ["path", "content"],
        },
    },
    {
        "name": "edit_file",
        "description": (
            "Replace an exact string in a file. old_string must appear exactly once unless "
            "replace_all is true. Prefer this over write_file for changes to existing files."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {"type": "string"},
                "old_string": {"type": "string"},
                "new_string": {"type": "string"},
                "replace_all": {"type": "boolean"},
            },
            "required": ["path", "old_string", "new_string"],
        },
    },
    {
        "name": "list_dir",
        "description": "List the entries of a directory in the workspace.",
        "input_schema": {
            "type": "object",
            "properties": {"path": {"type": "string", "description": "Defaults to the workspace root."}},
        },
    },
    {
        "name": "glob",
        "description": "Find files matching a glob pattern, e.g. '**/*.py'. Returns paths relative to the workspace.",
        "input_schema": {
            "type": "object",
            "properties": {"pattern": {"type": "string"}},
            "required": ["pattern"],
        },
    },
    {
        "name": "grep",
        "description": "Search file contents for a regular expression. Returns matching lines with their paths.",
        "input_schema": {
            "type": "object",
            "properties": {
                "pattern": {"type": "string"},
                "glob": {"type": "string", "description": "Optional file filter, e.g. '*.js'."},
            },
            "required": ["pattern"],
        },
    },
    {
        "name": "run_shell",
        "description": (
            "Run a shell command in the workspace and return its combined output. "
            "Uses cmd.exe on Windows and /bin/sh elsewhere."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "command": {"type": "string"},
                "timeout": {"type": "integer", "description": "Seconds; defaults to 120."},
            },
            "required": ["command"],
        },
    },
]


def walk_workspace(root):
    for dirpath, dirnames, filenames in os.walk(root):
        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS and not d.startswith(".")]
        for name in filenames:
            yield os.path.join(dirpath, name)


def run_tool(root, name, args):
    """Execute one tool call. Returns text; raises ToolError for tool failures."""
    if name == "read_file":
        return read_text(resolve_in_root(root, args.get("path", "")))

    if name == "write_file":
        target = resolve_in_root(root, args.get("path", ""))
        os.makedirs(os.path.dirname(target), exist_ok=True)
        with open(target, "w", encoding="utf-8") as handle:
            handle.write(args.get("content", ""))
        return "Wrote %d bytes to %s" % (len(args.get("content", "")), args.get("path"))

    if name == "edit_file":
        target = resolve_in_root(root, args.get("path", ""))
        old, new = args.get("old_string", ""), args.get("new_string", "")
        if not old:
            raise ToolError("old_string must not be empty; use write_file to create a file.")
        with open(target, "r", encoding="utf-8") as handle:
            content = handle.read()
        count = content.count(old)
        if count == 0:
            raise ToolError("old_string was not found in %s" % args.get("path"))
        if count > 1 and not args.get("replace_all"):
            raise ToolError(
                "old_string appears %d times in %s; pass replace_all or include more context."
                % (count, args.get("path"))
            )
        content = content.replace(old, new) if args.get("replace_all") else content.replace(old, new, 1)
        with open(target, "w", encoding="utf-8") as handle:
            handle.write(content)
        return "Edited %s (%d replacement%s)" % (args.get("path"), count if args.get("replace_all") else 1,
                                                 "s" if args.get("replace_all") and count > 1 else "")

    if name == "list_dir":
        target = resolve_in_root(root, args.get("path", "."))
        rows = []
        for entry in sorted(os.listdir(target)):
            if entry.startswith("."):
                continue
            full = os.path.join(target, entry)
            rows.append("%s%s" % (entry, "/" if os.path.isdir(full) else ""))
        return "\n".join(rows) or "(empty directory)"

    if name == "glob":
        pattern = args.get("pattern", "")
        root_real = os.path.realpath(root)
        hits = []
        for path in walk_workspace(root_real):
            rel = os.path.relpath(path, root_real).replace(os.sep, "/")
            if fnmatch.fnmatch(rel, pattern) or fnmatch.fnmatch(os.path.basename(rel), pattern):
                hits.append(rel)
            if len(hits) >= 500:
                break
        return "\n".join(sorted(hits)) or "(no matches)"

    if name == "grep":
        try:
            regex = re.compile(args.get("pattern", ""))
        except re.error as err:
            raise ToolError("Invalid regular expression: %s" % err)
        file_glob = args.get("glob")
        root_real = os.path.realpath(root)
        out = []
        for path in walk_workspace(root_real):
            rel = os.path.relpath(path, root_real).replace(os.sep, "/")
            if file_glob and not (fnmatch.fnmatch(rel, file_glob) or fnmatch.fnmatch(os.path.basename(rel), file_glob)):
                continue
            if os.path.splitext(path)[1].lower() in BINARY_EXT:
                continue
            try:
                with open(path, "r", encoding="utf-8", errors="ignore") as handle:
                    for number, line in enumerate(handle, 1):
                        if regex.search(line):
                            out.append("%s:%d: %s" % (rel, number, line.rstrip()[:300]))
                            if len(out) >= 300:
                                return "\n".join(out)
            except OSError:
                continue
        return "\n".join(out) or "(no matches)"

    if name == "run_shell":
        command = args.get("command", "")
        timeout = int(args.get("timeout") or SHELL_TIMEOUT)
        try:
            completed = subprocess.run(
                command,
                shell=True,
                cwd=os.path.realpath(root),
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                timeout=timeout,
            )
        except subprocess.TimeoutExpired:
            raise ToolError("Command timed out after %ds." % timeout)
        output = completed.stdout.decode("utf-8", errors="replace")
        suffix = "" if completed.returncode == 0 else "\n(exit code %d)" % completed.returncode
        return (output or "(no output)") + suffix

    raise ToolError("Unknown tool: %s" % name)


# --------------------------------------------------------------------------
# bridge client
# --------------------------------------------------------------------------


class RetryableError(Exception):
    pass


class BridgeError(Exception):
    def __init__(self, message, status=0):
        super().__init__(message)
        self.status = status


def bridge_request(path, payload=None, method="GET", stream=False, timeout=600, session_id=None):
    cfg = STORE.config
    base = (cfg.get("bridge") or "").rstrip("/")
    if not base:
        raise BridgeError("No bridge configured.")
    data = json.dumps(payload).encode("utf-8") if payload is not None else None
    request = urllib.request.Request(base + path, data=data, method=method)
    request.add_header("authorization", "Bearer %s" % cfg.get("token", ""))
    request.add_header("x-ccb-client", "agent/%s %s" % (VERSION, socket.gethostname()[:40]))
    if session_id:
        request.add_header("x-ccb-session", session_id)
    if data is not None:
        request.add_header("content-type", "application/json")
    try:
        response = urllib.request.urlopen(request, timeout=timeout)
    except urllib.error.HTTPError as err:
        body = err.read().decode("utf-8", errors="replace")
        try:
            message = json.loads(body).get("error") or body
        except Exception:
            message = body
        raise BridgeError(message, err.code)
    except urllib.error.URLError as err:
        raise BridgeError("Cannot reach the bridge: %s" % err.reason)
    if stream:
        return response
    return json.loads(response.read().decode("utf-8"))


def stream_messages(payload, session_id=None):
    """Yield parsed SSE events from the bridge's /v1/messages endpoint."""
    response = bridge_request("/v1/messages", payload, method="POST", stream=True, session_id=session_id)
    try:
        for raw in response:
            line = raw.decode("utf-8", errors="replace").strip()
            if not line.startswith("data:"):
                continue
            chunk = line[5:].strip()
            if not chunk or chunk == "[DONE]":
                continue
            try:
                yield json.loads(chunk)
            except ValueError:
                continue
    finally:
        response.close()


# --------------------------------------------------------------------------
# agent session
# --------------------------------------------------------------------------

SYSTEM_PROMPT = """You are a coding agent working directly on the user's machine.

Use the provided tools to inspect and change real files in the workspace, and to
run commands. Prefer edit_file over write_file when changing an existing file.
Read a file before editing it. Keep replies short: describe what you changed,
not what you are about to do. The workspace root is {root} on {system}."""


class Session:
    """One conversation, with its own history, workspace and subscribers."""

    def __init__(self, meta):
        self.meta = meta
        self.history = meta.get("history", [])
        self.subscribers = []
        self.sub_lock = threading.Lock()
        self.events = []
        self.seq = 0
        self.running = False
        self.cancel = threading.Event()

    # -- events ---------------------------------------------------------

    def emit(self, kind, data, ephemeral=False):
        self.seq += 1
        event = {"seq": self.seq, "type": kind, "data": data, "at": time.time()}
        if not ephemeral:
            self.events.append(event)
            del self.events[:-1200]
        payload = "id: %d\nevent: message\ndata: %s\n\n" % (event["seq"], json.dumps(event))
        with self.sub_lock:
            for q in list(self.subscribers):
                q.put(payload)

    def status(self):
        return {
            "id": self.meta["id"],
            "status": "running" if self.running else "idle",
            "model": self.meta.get("model"),
            "alive": True,
            "turnCount": self.meta.get("turnCount", 0),
        }

    def subscribe(self, last_seq):
        q = queue.Queue()
        with self.sub_lock:
            self.subscribers.append(q)
        for event in self.events:
            if event["seq"] > last_seq:
                q.put("id: %d\nevent: message\ndata: %s\n\n" % (event["seq"], json.dumps(event)))
        q.put("id: %d\nevent: message\ndata: %s\n\n"
              % (self.seq, json.dumps({"seq": self.seq, "type": "status", "data": self.status()})))
        return q

    def unsubscribe(self, q):
        with self.sub_lock:
            if q in self.subscribers:
                self.subscribers.remove(q)

    # -- turns ----------------------------------------------------------

    def start_turn(self, content):
        if self.running:
            raise ToolError("This session is already working on a turn.")
        self.running = True
        self.cancel.clear()
        self.history.append({"role": "user", "content": content})
        self.emit("user_message", {"content": content})
        self.emit("status", self.status())
        if not self.meta.get("title"):
            for block in content:
                if block.get("type") == "text":
                    self.meta["title"] = block["text"].strip().replace("\n", " ")[:60]
                    break
        threading.Thread(target=self._run, daemon=True).start()

    def interrupt(self):
        if not self.running:
            return False
        self.cancel.set()
        self.emit("notice", {"message": "Stopping…"})
        return True

    def _run(self):
        started = time.time()
        steps = 0
        try:
            while True:
                steps += 1
                if self.cancel.is_set():
                    self.emit("notice", {"message": "Stopped."})
                    break
                blocks, stop_reason = self._call_model()
                if blocks is None:
                    break
                self.history.append({"role": "assistant", "content": blocks})
                self.emit("claude", {"type": "assistant", "message": {"role": "assistant", "content": blocks}})

                tool_uses = [b for b in blocks if b.get("type") == "tool_use"]
                if stop_reason != "tool_use" or not tool_uses:
                    break
                results = [self._run_tool(block) for block in tool_uses]
                self.history.append({"role": "user", "content": results})
                self.emit("claude", {"type": "user", "message": {"role": "user", "content": results}})
                if steps > 60:
                    self.emit("error", {"message": "Stopped after 60 steps to avoid looping."})
                    break
        except BridgeError as err:
            self.emit("blocked" if err.status in (401, 403, 429) else "error",
                      {"message": str(err), "reasons": [str(err)]})
        except Exception:
            self.emit("error", {"message": traceback.format_exc(limit=2)})
        finally:
            self.running = False
            self.meta["turnCount"] = self.meta.get("turnCount", 0) + 1
            self.meta["history"] = self.history
            STORE.sessions[self.meta["id"]] = self.meta
            STORE.save_sessions()
            self.emit("claude", {"type": "result", "duration_ms": int((time.time() - started) * 1000)})
            self.emit("status", self.status())

    def _call_model(self):
        """A model call that survives a bridge restart: retry while it is unreachable."""
        for delay in RETRY_DELAYS + (None,):
            try:
                return self._call_model_once()
            except RetryableError as err:
                if delay is None or self.cancel.is_set():
                    raise BridgeError("The bridge is unreachable: %s" % err)
                self.emit("retry", {"message": "Bridge unavailable (%s) — retrying in %ds…" % (err, delay)})
                if self.cancel.wait(delay):
                    return None, None

    def _call_model_once(self):
        """One streaming model call. Returns (content blocks, stop_reason)."""
        payload = {
            "model": self.meta["model"],
            "max_tokens": STORE.config.get("maxTokens", DEFAULT_MAX_TOKENS),
            "stream": True,
            "system": SYSTEM_PROMPT.format(root=self.meta["root"], system=platform.platform()),
            "tools": TOOL_SPECS,
            "messages": self.history,
        }
        blocks = {}
        stop_reason = None
        finished = False
        try:
            for event in stream_messages(payload, self.meta["id"]):
                if self._apply_event(blocks, event):
                    stop_reason = event.get("delta", {}).get("stop_reason", stop_reason)
                finished = finished or event.get("type") == "message_stop"
                if self.cancel.is_set():
                    return self._finish_blocks(blocks), stop_reason
        except BridgeError as err:
            if err.status in RETRY_STATUSES:
                raise RetryableError(str(err) or "status %d" % err.status)
            raise
        except (OSError, http.client.HTTPException) as err:
            # The stream broke mid-reply (bridge restarted): redo the whole call.
            raise RetryableError("connection lost: %s" % err)
        if not finished:
            # Ended without message_stop: the bridge went away mid-reply.
            raise RetryableError("reply was cut off")
        return self._finish_blocks(blocks), stop_reason

    def _apply_event(self, blocks, event):
        """Fold one SSE event into blocks. True when it is a message_delta."""
        kind = event.get("type")
        if kind == "content_block_start":
            blocks[event["index"]] = dict(event["content_block"])
            if blocks[event["index"]].get("type") == "tool_use":
                blocks[event["index"]]["_json"] = ""
        elif kind == "content_block_delta":
            delta = event.get("delta", {})
            block = blocks.setdefault(event["index"], {"type": "text", "text": ""})
            kind_of_delta = delta.get("type")
            if kind_of_delta == "text_delta":
                block["text"] = block.get("text", "") + delta["text"]
                self.emit("stream_event", {"event": event}, ephemeral=True)
            elif kind_of_delta == "input_json_delta":
                block["_json"] = block.get("_json", "") + delta.get("partial_json", "")
            elif kind_of_delta == "thinking_delta":
                # Thinking blocks must be echoed back intact, signature and
                # all, or the next request is rejected as malformed.
                block["thinking"] = block.get("thinking", "") + delta.get("thinking", "")
                self.emit("stream_event", {"event": event}, ephemeral=True)
            elif kind_of_delta == "signature_delta":
                block["signature"] = block.get("signature", "") + delta.get("signature", "")
        elif kind == "message_delta":
            return True
        elif kind == "error":
            error = event.get("error", {})
            if error.get("type") in ("overloaded_error", "api_error"):
                raise RetryableError(error.get("message", "upstream error"))
            raise BridgeError(error.get("message", "stream error"))
        return False

    @staticmethod
    def _finish_blocks(blocks):
        ordered = []
        for index in sorted(blocks):
            block = blocks[index]
            if block.get("type") == "tool_use":
                raw = block.pop("_json", "") or "{}"
                try:
                    block["input"] = json.loads(raw)
                except ValueError:
                    block["input"] = {}
            if block.get("type") == "text" and not block.get("text", "").strip():
                continue
            if block.get("type") == "thinking" and not block.get("thinking", "").strip():
                continue
            ordered.append(block)
        return ordered or None

    def _run_tool(self, block):
        name, args = block.get("name"), block.get("input") or {}
        try:
            output = run_tool(self.meta["root"], name, args)
            is_error = False
        except ToolError as err:
            output, is_error = str(err), True
        except Exception as err:
            output, is_error = "%s: %s" % (type(err).__name__, err), True
        if len(output) > MAX_TOOL_RESULT:
            output = output[:MAX_TOOL_RESULT] + "\n… truncated"
        return {
            "type": "tool_result",
            "tool_use_id": block.get("id"),
            "content": [{"type": "text", "text": output}],
            "is_error": is_error,
        }


SESSIONS = {}
SESSIONS_LOCK = threading.Lock()


def get_session(session_id):
    with SESSIONS_LOCK:
        if session_id in SESSIONS:
            return SESSIONS[session_id]
        meta = STORE.sessions.get(session_id)
        if not meta:
            return None
        session = Session(meta)
        SESSIONS[session_id] = session
        return session


# --------------------------------------------------------------------------
# HTTP surface for the local UI
# --------------------------------------------------------------------------


def ui_asset(name):
    if EMBEDDED_UI:
        blob = EMBEDDED_UI.get(name)
        return base64.b64decode(blob) if blob else None
    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "ui", name)
    try:
        with open(path, "rb") as handle:
            return handle.read()
    except OSError:
        return None


class Handler(BaseHTTPRequestHandler):
    server_version = "ccb-agent/" + VERSION
    protocol_version = "HTTP/1.1"

    def log_message(self, fmt, *args):
        if os.environ.get("CCB_AGENT_DEBUG"):
            sys.stderr.write("%s - %s\n" % (self.address_string(), fmt % args))

    # -- helpers --------------------------------------------------------

    def _send(self, status, body=b"", content_type="application/json", extra=None):
        self.send_response(status)
        self.send_header("content-type", content_type)
        self.send_header("content-length", str(len(body)))
        self.send_header("cache-control", "no-store")
        for key, value in (extra or {}).items():
            self.send_header(key, value)
        self.end_headers()
        if self.command != "HEAD":
            self.wfile.write(body)

    def _json(self, status, value):
        self._send(status, json.dumps(value).encode("utf-8"))

    def _body(self):
        length = int(self.headers.get("content-length") or 0)
        if not length:
            return {}
        try:
            return json.loads(self.rfile.read(length).decode("utf-8"))
        except ValueError:
            raise ToolError("Invalid JSON body.")

    def _guard(self):
        """Only this machine may drive the agent; it runs commands as you."""
        host = (self.headers.get("host") or "").split(":")[0].strip("[]")
        if host not in ("localhost", "127.0.0.1", "::1"):
            self._send(421, b"Open the agent at http://localhost", "text/plain")
            return False
        origin = self.headers.get("origin")
        if origin:
            allowed = {"http://localhost:%d" % PORT, "http://127.0.0.1:%d" % PORT}
            if origin not in allowed:
                self._json(403, {"error": "Cross-origin requests are refused."})
                return False
        return True

    # -- routing --------------------------------------------------------

    def do_GET(self):
        if not self._guard():
            return
        path = self.path.split("?")[0]
        query = {}
        if "?" in self.path:
            for part in self.path.split("?", 1)[1].split("&"):
                if "=" in part:
                    key, value = part.split("=", 1)
                    query[key] = urllib.parse.unquote_plus(value)
        try:
            if path == "/api/bootstrap":
                return self._json(200, self.bootstrap())
            if path == "/api/usage":
                return self._json(200, self.usage())
            if path == "/api/sessions":
                return self._json(200, {"sessions": list_sessions()})
            if path.startswith("/api/sessions/") and path.endswith("/history"):
                session = get_session(path.split("/")[3])
                if not session:
                    return self._json(404, {"error": "Session not found."})
                return self._json(200, {"source": "live", "events": session.events,
                                        "lastSeq": session.seq})
            if path.startswith("/api/sessions/") and path.endswith("/events"):
                return self.sse(path.split("/")[3], query.get("lastEventId"))
            if path == "/api/update":
                return self._json(200, check_update())
            if path == "/api/files":
                return self._json(200, browse(query.get("project"), query.get("path", ".")))
            if path == "/api/file":
                return self._json(200, peek(query.get("project"), query.get("path")))
            return self.static(path)
        except ToolError as err:
            return self._json(400, {"error": str(err)})
        except BridgeError as err:
            return self._json(err.status or 502, {"error": str(err)})
        except Exception as err:
            return self._json(500, {"error": "%s: %s" % (type(err).__name__, err)})

    def do_POST(self):
        if not self._guard():
            return
        path = self.path.split("?")[0]
        try:
            if path == "/api/update":
                # Replacing our own code: demand a JSON content type so a
                # cross-site form can never reach this, even without Origin.
                if not (self.headers.get("content-type") or "").startswith("application/json"):
                    return self._json(415, {"error": "JSON required."})
                return self._json(200, apply_update())
            body = self._body()
            if path == "/api/config":
                return self._json(200, save_settings(body))
            if path == "/api/roots":
                return self._json(200, add_root(body.get("path", "")))
            if path == "/api/sessions":
                return self._json(201, {"session": create_session(body)})
            if path.startswith("/api/sessions/") and path.endswith("/message"):
                return self._json(202, send_message(path.split("/")[3], body))
            if path.startswith("/api/sessions/") and path.endswith("/interrupt"):
                session = get_session(path.split("/")[3])
                return self._json(200, {"ok": bool(session and session.interrupt())})
            if path.startswith("/api/sessions/") and path.endswith("/model"):
                return self._json(200, {"session": set_model(path.split("/")[3], body)})
            return self._json(404, {"error": "Not found"})
        except ToolError as err:
            return self._json(400, {"error": str(err)})
        except BridgeError as err:
            return self._json(err.status or 502, {"error": str(err)})
        except Exception as err:
            return self._json(500, {"error": "%s: %s" % (type(err).__name__, err)})

    def do_DELETE(self):
        if not self._guard():
            return
        path = self.path.split("?")[0]
        if path.startswith("/api/sessions/"):
            session_id = path.split("/")[3]
            with SESSIONS_LOCK:
                SESSIONS.pop(session_id, None)
            STORE.sessions.pop(session_id, None)
            STORE.save_sessions()
            return self._json(200, {"ok": True})
        if path == "/api/roots":
            target = urllib.parse.unquote_plus(self.path.split("path=", 1)[1]) if "path=" in self.path else ""
            STORE.config["roots"] = [r for r in STORE.config["roots"] if r.get("path") != target]
            STORE.save_config()
            return self._json(200, {"roots": STORE.config["roots"]})
        return self._json(404, {"error": "Not found"})

    # -- endpoints ------------------------------------------------------

    def bootstrap(self):
        policy = safe_policy()
        return {
            "config": {
                "models": {"allowed": policy.get("models", []), "default": default_model(policy)},
                "projects": STORE.config.get("roots", []),
                "limits": {"maxUploadBytes": 10 * 1024 * 1024},
                "paused": policy.get("paused", False),
            },
            "models": policy.get("models", []),
            "projects": STORE.config.get("roots", []),
            "sessions": list_sessions(),
            "usage": policy.get("usage", {"ok": False, "error": policy.get("error"), "limits": []}),
            "settings": {"bridge": STORE.config.get("bridge", ""), "connected": policy.get("ok", False),
                         "error": policy.get("error")},
            "agent": {"version": VERSION, "platform": platform.platform(), "cwd": os.getcwd()},
        }

    def usage(self):
        policy = safe_policy()
        return {"usage": policy.get("usage", {"ok": False, "error": policy.get("error"), "limits": []}),
                "models": policy.get("models", [])}

    def sse(self, session_id, last_event_id):
        session = get_session(session_id)
        if not session:
            return self._json(404, {"error": "Session not found."})
        try:
            last_seq = int(last_event_id or self.headers.get("last-event-id") or 0)
        except ValueError:
            last_seq = 0
        self.send_response(200)
        self.send_header("content-type", "text/event-stream; charset=utf-8")
        self.send_header("cache-control", "no-cache, no-transform")
        self.send_header("connection", "keep-alive")
        self.end_headers()
        q = session.subscribe(last_seq)
        try:
            self.wfile.write(b"retry: 2000\n\n")
            self.wfile.flush()
            while True:
                try:
                    payload = q.get(timeout=20)
                except queue.Empty:
                    payload = ": ping\n\n"
                self.wfile.write(payload.encode("utf-8"))
                self.wfile.flush()
        except (BrokenPipeError, ConnectionResetError, OSError):
            pass
        finally:
            session.unsubscribe(q)

    def static(self, path):
        name = "index.html" if path in ("/", "") else path.lstrip("/")
        blob = ui_asset(name)
        if blob is None and not name.startswith("api/"):
            blob = ui_asset("index.html")
            name = "index.html"
        if blob is None:
            return self._send(404, b"Not found", "text/plain")
        kind = mimetypes.guess_type(name)[0] or "application/octet-stream"
        if name.endswith(".js"):
            kind = "text/javascript; charset=utf-8"
        return self._send(200, blob, kind)


# --------------------------------------------------------------------------
# endpoint helpers
# --------------------------------------------------------------------------


# --------------------------------------------------------------------------
# self-update from the bridge
# --------------------------------------------------------------------------


def _version_tuple(text):
    try:
        return tuple(int(part) for part in text.split("."))
    except (AttributeError, ValueError):
        return (0,)


def fetch_latest_agent():
    response = bridge_request("/agent.py", stream=True, timeout=60)
    try:
        text = response.read().decode("utf-8")
    finally:
        response.close()
    match = re.search(r'^VERSION = "([^"]+)"', text, re.M)
    if not match:
        raise BridgeError("The bridge served something that is not the agent.")
    return text, match.group(1)


def check_update():
    try:
        _, latest = fetch_latest_agent()
    except BridgeError as err:
        return {"current": VERSION, "latest": None, "available": False, "error": str(err)}
    return {"current": VERSION, "latest": latest,
            "available": _version_tuple(latest) > _version_tuple(VERSION),
            "autoRestart": not IS_WINDOWS}


def apply_update():
    """Replace this file with the bridge's current agent, then restart into it."""
    if any(session.running for session in list(SESSIONS.values())):
        raise ToolError("Wait for the running turn to finish, then update.")
    text, latest = fetch_latest_agent()
    if _version_tuple(latest) <= _version_tuple(VERSION):
        return {"updated": False, "version": VERSION}
    compile(text, AGENT_PATH, "exec")  # refuse anything that is not valid Python
    shutil.copy2(AGENT_PATH, AGENT_PATH + ".bak")
    tmp = AGENT_PATH + ".new"
    with open(tmp, "w", encoding="utf-8", newline="") as handle:
        handle.write(text)
    os.replace(tmp, AGENT_PATH)
    if IS_WINDOWS:
        # execv on Windows detaches from the console; ask for a manual restart.
        return {"updated": True, "version": latest, "restarting": False}
    threading.Thread(target=_restart, daemon=True).start()
    return {"updated": True, "version": latest, "restarting": True}


def _restart():
    time.sleep(0.5)  # let the HTTP response go out first
    RESTART.set()
    SERVER.shutdown()  # main() then re-execs itself once serve_forever returns


def announce():
    """Tell the bridge this agent exists, so it shows up in the admin console."""
    try:
        bridge_request("/api/hello", {}, method="POST", timeout=15)
        return True
    except BridgeError:
        return False


def safe_policy():
    """Ask the bridge what is allowed; never let an outage break the UI."""
    try:
        data = bridge_request("/api/policy", timeout=20)
        data["ok"] = True
        return data
    except BridgeError as err:
        return {"ok": False, "error": str(err), "models": [], "usage": {"ok": False, "error": str(err), "limits": []}}


def default_model(policy):
    models = policy.get("models", [])
    preferred = policy.get("default")
    ids = [m["id"] for m in models]
    return preferred if preferred in ids else (ids[0] if ids else None)


def list_sessions():
    rows = []
    for meta in STORE.sessions.values():
        live = SESSIONS.get(meta["id"])
        rows.append({
            "id": meta["id"],
            "title": meta.get("title"),
            "projectPath": meta.get("root"),
            "projectName": meta.get("rootName") or os.path.basename(meta.get("root", "")),
            "model": meta.get("model"),
            "turnCount": meta.get("turnCount", 0),
            "createdAt": meta.get("createdAt"),
            "lastActivity": meta.get("lastActivity"),
            "alive": bool(live),
            "running": bool(live and live.running),
        })
    rows.sort(key=lambda r: r.get("lastActivity") or "", reverse=True)
    return rows


def save_settings(body):
    if "bridge" in body:
        STORE.config["bridge"] = (body["bridge"] or "").strip().rstrip("/")
    if body.get("token"):
        STORE.config["token"] = body["token"].strip()
    STORE.save_config()
    announce()
    policy = safe_policy()
    return {"ok": policy.get("ok", False), "error": policy.get("error"), "models": policy.get("models", [])}


def add_root(path):
    expanded = os.path.realpath(os.path.expanduser(path.strip()))
    if not os.path.isdir(expanded):
        raise ToolError("Not a directory: %s" % expanded)
    roots = STORE.config.setdefault("roots", [])
    if not any(r.get("path") == expanded for r in roots):
        roots.append({"name": os.path.basename(expanded) or expanded, "path": expanded})
        STORE.save_config()
    return {"roots": roots}


def known_root(path):
    for root in STORE.config.get("roots", []):
        if root.get("path") == path:
            return root
    raise ToolError("That folder is not on the agent's list.")


def create_session(body):
    root = known_root(body.get("projectPath"))
    policy = safe_policy()
    model = body.get("model") or default_model(policy)
    if not model:
        raise ToolError("The bridge has not allowed any models.")
    meta = {
        "id": str(uuid.uuid4()),
        "title": None,
        "root": root["path"],
        "rootName": root["name"],
        "model": model,
        "createdAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
        "lastActivity": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
        "turnCount": 0,
        "history": [],
    }
    STORE.sessions[meta["id"]] = meta
    STORE.save_sessions()
    with SESSIONS_LOCK:
        SESSIONS[meta["id"]] = Session(meta)
    return {k: v for k, v in meta.items() if k != "history"}


def set_model(session_id, body):
    session = get_session(session_id)
    if not session:
        raise ToolError("Session not found.")
    if session.running:
        raise ToolError("Cannot change the model while a turn is running.")
    model = body.get("model")
    if model:
        allowed = [m["id"] for m in safe_policy().get("models", [])]
        if allowed and model not in allowed:
            raise ToolError('Model "%s" is not allowed by the bridge.' % model)
        session.meta["model"] = model
        STORE.save_sessions()
    return {k: v for k, v in session.meta.items() if k != "history"}


def send_message(session_id, body):
    session = get_session(session_id)
    if not session:
        raise ToolError("Session not found.")
    content = []
    for image in body.get("images") or []:
        if not image.get("dataBase64") or not image.get("mediaType"):
            raise ToolError("Malformed image attachment.")
        content.append({"type": "image", "source": {"type": "base64",
                                                    "media_type": image["mediaType"],
                                                    "data": image["dataBase64"]}})
    text = (body.get("text") or "").strip()
    if text:
        content.append({"type": "text", "text": text})
    if not content:
        raise ToolError("Message is empty.")
    session.meta["lastActivity"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    session.start_turn(content)
    return {"ok": True}


def browse(project, relative):
    root = known_root(project)["path"]
    target = resolve_in_root(root, relative or ".")
    entries = []
    for name in sorted(os.listdir(target)):
        if name.startswith(".") and name != ".claude":
            continue
        full = os.path.join(target, name)
        is_dir = os.path.isdir(full)
        if is_dir and name in SKIP_DIRS:
            continue
        entries.append({
            "name": name,
            "type": "dir" if is_dir else "file",
            "size": None if is_dir else os.path.getsize(full),
            "path": os.path.relpath(full, root).replace(os.sep, "/"),
        })
    entries.sort(key=lambda e: (e["type"] != "dir", e["name"].lower()))
    return {"cwd": os.path.relpath(target, root).replace(os.sep, "/"), "entries": entries}


def peek(project, relative):
    if not relative:
        raise ToolError("path is required.")
    root = known_root(project)["path"]
    target = resolve_in_root(root, relative)
    size = os.path.getsize(target)
    if os.path.splitext(target)[1].lower() in BINARY_EXT:
        return {"path": relative, "size": size, "binary": True, "content": None}
    return {"path": relative, "size": size, "binary": False,
            "truncated": size > MAX_READ_BYTES, "content": read_text(target)}


# --------------------------------------------------------------------------
# entry point
# --------------------------------------------------------------------------

PORT = 8600


def main():
    global PORT, SERVER
    parser = argparse.ArgumentParser(description="Claude Code Bridge client agent")
    parser.add_argument("--bridge", default=STORE.config.get("bridge") or DEFAULT_BRIDGE,
                        help="Bridge base URL, e.g. http://192.168.1.20:8787")
    parser.add_argument("--token", default=STORE.config.get("token", ""), help="Bridge access token")
    parser.add_argument("--port", type=int, default=int(os.environ.get("CCB_AGENT_PORT", PORT)))
    parser.add_argument("--workspace", default=None, help="Folder to work in (defaults to the current directory)")
    parser.add_argument("--version", action="store_true")
    args = parser.parse_args()

    if args.version:
        print("ccb-agent %s" % VERSION)
        return

    PORT = args.port
    if args.bridge:
        STORE.config["bridge"] = args.bridge.rstrip("/")
    if args.token:
        STORE.config["token"] = args.token
    workspace = os.path.realpath(os.path.expanduser(args.workspace or os.getcwd()))
    roots = STORE.config.setdefault("roots", [])
    if os.path.isdir(workspace) and not any(r.get("path") == workspace for r in roots):
        roots.append({"name": os.path.basename(workspace) or workspace, "path": workspace})
    STORE.save_config()

    if STORE.config.get("bridge") and STORE.config.get("token"):
        threading.Thread(target=announce, daemon=True).start()

    server = SERVER = ThreadingHTTPServer(("127.0.0.1", PORT), Handler)
    server.daemon_threads = True

    print("Claude Code Bridge agent %s" % VERSION)
    print("  bridge    %s" % (STORE.config.get("bridge") or "(not set — configure it in the UI)"))
    print("  workspace %s" % workspace)
    print("  open      http://localhost:%d" % PORT)
    if not shutil.which("git"):
        print("  note: git was not found on PATH; the agent can still edit files")
    sys.stdout.flush()
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\nstopped")
        return
    if RESTART.is_set():
        # Re-exec in the main thread: from a worker thread, the main thread
        # would return here and end the process before the exec happened.
        server.server_close()
        print("updated; restarting\n", flush=True)
        sys.stdout.flush()
        os.execv(sys.executable, [sys.executable, AGENT_PATH] + sys.argv[1:])


if __name__ == "__main__":
    main()