chamba 0.6.1 → 0.8.0

package/templates/webterm/typed-line.js

@@ -0,0 +1,148 @@
+// =========================================================================================================================================
+// typed-line.js - What a message is reduced to before a terminal ever sees it.
+//
+// A tool in the pane tells the agent beside it that something arrived, by typing one line into that agent's
+// terminal. The line is framed - `[specs] <event>: "<detail>" - read <path>` - and the frame is a visual
+// convention, so what this file protects is how the line reads. An agent must be able to tell the server's
+// own words from a message's, and no message may pose as a second voice.
+//
+// The text rides a bracketed paste, where a newline is not a second submit but a second visible line inside
+// the same prompt. So a text carrying one would show the agent a line below the framed one, in no frame at
+// all. Reduction to a single line is what closes that, and it starts from the shipped single-line cleaner:
+// controls dropped, whitespace runs collapsed, ends trimmed.
+//
+// That cleaner needs two corrections here, and both live in this wrapper, so the pane's titles and its nudge
+// keep the behaviour they have.
+//
+//   - Its length argument defaults to a page title's length, which would cut a message to a fragment. The
+//     limit is checked before the reduction instead, and an over-limit message is refused with a reason.
+//   - Its character rule keeps every code point at or above U+00A0, which leaves every invisible one alive.
+//     The rule this path needs is "renders as nothing", and no single Unicode property means that, so it is
+//     built from what survives rather than from what does not - in two layers, and it needs both.
+// =========================================================================================================================================
+
+import { cleanLine } from "./artifacts.js";
+
+// The first layer: the categories a visible character is in. Letters, the marks that combine with them,
+// numbers, and the common punctuation and symbol categories, plus the one space the collapse produces.
+// Nothing outside them survives, whatever it is and whenever it was assigned - which ends the format
+// characters, the bidi controls, and the tag block at U+E0000, since all three are format characters and
+// none of those is a category here. The tag block is worth naming: it is a complete invisible copy of
+// printable ASCII, and it is the carrier a hidden second instruction actually travels in.
+const VISIBLE = /[\p{L}\p{M}\p{N}\p{P}\p{S} ]/u;
+
+// The second layer: what the first keeps by accident. The allowed categories hold blank-rendering members of
+// their own - U+3164 HANGUL FILLER is a letter, the variation selectors are combining marks, U+2800 BRAILLE
+// PATTERN BLANK is a symbol - so a category allowlist alone passes all three at full width. Every code point
+// carrying Default_Ignorable_Code_Point goes whatever its category, which covers the fillers and the
+// selectors. U+2800 is then named, because it carries no such property and nothing else separates it from
+// the braille it belongs to. That one code point is the only closed part of the rule.
+const BLANK = /[\p{Default_Ignorable_Code_Point}\u2800]/u;
+
+// No surviving code point can be confusable with the frame's quote, so every one that reads as a double
+// quote is mapped to a single one - the way the pane's nudge already does for the ASCII quote alone. The
+// rule is what a code point looks like rather than what it is called, so the property is no help: the
+// quotation-mark property leaves out the double primes, the gershayim, the modifier letters that render as
+// a pair of ticks, and the double acute, and each of those closes the frame on screen just as well.
+const DOUBLE_QUOTES =
+    /["\u00ab\u00bb\u02ba\u02dd\u02ee\u02f6\u05f4\u201c\u201d\u201e\u201f\u2033\u2036\u275d\u275e\u2e42\u3003\u301d\u301e\u301f\uff02]|[\u{1f676}-\u{1f678}]/gu;
+
+// All three CLIs read "@path" in a submitted line as a file to pull into the context, so no detail may carry
+// one. The frame names a file in the one place it is allowed to - the path, which the server built and which
+// is dropped unless the reduction leaves it whole - and a detail is not that place. So the at sign goes the
+// way the quote lookalikes go, for every agent.
+const FILE_MENTION = /@/g;
+
+// The rules that are one CLI's own syntax, and nobody else's. The frame promises that a framed line instructs
+// nobody, and the command line promises that its argument is a name and not a second instruction. Both
+// promises rest on a character meaning something only where this server put it, and each CLI breaks that in
+// its own way - so each cell below is one CLI's syntax, mapped to a code point that reads the same and means
+// nothing to it. Every other agent is untouched.
+//
+//   claude    nothing of its own. The two rules above cover it.
+//   codex     "$name" is a skill mention wherever it sits in the line.
+//   opencode  a prompt expands a backticked shell command by running it. The expansion happens after the
+//             argument is placed in the command file, so a name typed by a button is scanned for one.
+//             Neutralizing the backtick is what ends it: the command form cannot be written without one.
+//             The dollar goes too: the argument is placed with String.replaceAll, where "$&" and the two
+//             quote forms beside it are replacement patterns that rebuild text out of the template.
+//
+// The replacements read the same and mean nothing to the CLI they are for. Two of the three are the
+// compatibility forms, so a consumer that normalized the line to NFKC would fold them back - nothing in this
+// chain normalizes, and this is the property to re-check if anything downstream ever does.
+//
+// Every agent has a row, empty where it needs nothing, and an agent with no row gets every rule in the table.
+// A caller that omits the agent, or a fourth CLI added to the session side and not to this one, then loses a
+// character rather than a guarantee.
+const NO_RULES = [];
+const CODEX_RULES = [[/\$/g, "\uff04"]]; // Fullwidth dollar sign
+const OPENCODE_RULES = [[/`/g, "\u02cb"], ...CODEX_RULES]; // Modifier letter grave accent, then the dollar
+const AGENT_RULES = {
+    claude: NO_RULES,
+    codex: CODEX_RULES,
+    opencode: OPENCODE_RULES,
+};
+const EVERY_RULE = [...OPENCODE_RULES];
+
+/**
+ * One line of somebody else's text, safe to put inside the frame.
+ *
+ * A code point outside the visible categories becomes a space, which the cleaner then collapses: it was a
+ * control, a separator or a format character, and a space is what it was standing in for. One that renders
+ * as nothing inside an allowed category is removed rather than spaced, because it was padding rather than a
+ * gap - which is what keeps a padded tail inside the quotes instead of pushed off the row.
+ *
+ * `agent` is the agent this text is being reduced for. It is what decides the per-agent rules above; the two
+ * rules before them hold for every agent, and an agent the table does not name gets all of them. The detail
+ * is not always the user's own words either: a directory name read off the workspace comes through here too.
+ */
+export function reduceLine(raw, max, agent) {
+    if (typeof raw !== "string") return "";
+    let kept = "";
+    for (const ch of raw) {
+        if (BLANK.test(ch)) continue;
+        kept += VISIBLE.test(ch) ? ch : " ";
+    }
+    let text = kept.replace(DOUBLE_QUOTES, "'").replace(FILE_MENTION, "\uff20"); // Fullwidth commercial at
+    // Read as the table's own entries: the agent is validated at session creation, and this keeps a name
+    // off Object.prototype from reaching the loop as something that is not a list of rules.
+    const rules = Object.hasOwn(AGENT_RULES, agent) ? AGENT_RULES[agent] : EVERY_RULE;
+    for (const [pattern, readsAs] of rules) text = text.replace(pattern, readsAs);
+    return cleanLine(text, max);
+}
+
+/**
+ * The line itself.
+ *
+ * `tag` and `event` are the caller's own words and never a message's, so a tool's text sits inside
+ * delimiters it cannot close and cannot pose as the user or as another source. `detail` is the only part
+ * that arrives here already reduced.
+ *
+ * `path` is a path this server built, but it is not made of this server's words: every segment of it is a
+ * name off the filesystem, and a name may hold any byte but the separator. So it goes through the same
+ * reduction, for the same agent, and it is named only when the reduction changed nothing. A path that changed
+ * is not a path any more - naming the reduced spelling would send the agent to a file that does not exist -
+ * and a path holding anything the reduction removes is the one case where naming no file is the honest line.
+ * A directory whose name holds one of the per-agent characters above is one of those, in that agent's session
+ * and in no other.
+ */
+export function framedLine({ tag, event, detail, path, agent }) {
+    const said = detail ? `: "${detail}"` : "";
+    const named = path && reduceLine(path, path.length, agent) === path ? path : "";
+    return `[${tag}] ${event}${said}${named ? ` - read ${named}` : ""}`;
+}
+
+/**
+ * The line for a button that starts a skill: the command itself, as the user would type it.
+ *
+ * A skill the user alone may start does not start from a framed sentence, because the sentence reaches an
+ * agent that is not allowed to act on it. The button click is the user's own act, so the line it types is
+ * the command, and the frame would only get in the way of it.
+ *
+ * `command` is this server's own word, like every event word above. `argument` is the one part that came
+ * from somewhere else, and it arrives reduced: every code point that renders as a double quote is a single
+ * one by then, so it stays one quoted word and can neither close the quote nor open a second line.
+ */
+export function commandLine(command, argument) {
+    return argument ? `${command} "${argument}"` : command;
+}

package/templates/context/context-usage.md

@@ -1 +0,0 @@
-- You can check your own context-window and rate-limit usage at any time: run `context-usage`.

package/templates/context-usage.sh

@@ -1,266 +0,0 @@
-#!/bin/sh
-# =============================================================================
-# context-usage -- prints the freshest Claude Code context/quota snapshot.
-# Baked into the container image at /usr/local/share/chamba/context-usage.sh
-# and symlinked to /usr/local/bin/context-usage.
-#
-# Snapshots are written by claude-statusline.sh to ~/.claude/context-usage/
-# on every prompt render, one file per session - that script prints nothing, so
-# the snapshot is the whole of what it does. Each snapshot records the pid
-# (and start time) of the Claude CLI process that spawned the status line; this
-# helper runs as a descendant of that SAME process, so matching them identifies
-# the asking session's own snapshot deterministically. When pid resolution fails, the
-# newest file by mtime is used instead (it is almost always the asking
-# session's own: its status line re-rendered the moment the current prompt
-# was submitted), and warnings cover the two ways that heuristic can mislead
-# (stale snapshot, another session writing at the same time).
-# =============================================================================
-
-snap_dir="${HOME:-/home/devuser}/.claude/context-usage"
-
-# All snapshots, newest first. Filenames are sanitized to [A-Za-z0-9-].json at
-# write time, so ls output is line-safe and word-splitting the list below is
-# safe too. An unmatched glob yields no stdout lines (error suppressed).
-files=$(ls -t -- "$snap_dir"/*.json 2>/dev/null)
-
-if [ -z "$files" ]; then
-  echo "No context snapshots found in $snap_dir." >&2
-  echo "Snapshots appear once Claude Code has rendered its first prompt in this session." >&2
-  exit 1
-fi
-
-# Resolve the pid of this session's Claude CLI process; mirrors find_claude_pid in
-# claude-statusline.sh (see the comments there). Prints nothing when resolution fails.
-find_claude_pid() {
-  fcp_pid=$$
-  while [ "$fcp_pid" -gt 1 ] 2>/dev/null; do
-    fcp_comm=""
-    read -r fcp_comm 2>/dev/null < "/proc/$fcp_pid/comm" || return
-    case "$fcp_comm" in
-      claude) printf '%s' "$fcp_pid"; return ;;
-      node*) grep -aq "claude-code" "/proc/$fcp_pid/cmdline" 2>/dev/null && { printf '%s' "$fcp_pid"; return; } ;;
-    esac
-    read -r fcp_stat 2>/dev/null < "/proc/$fcp_pid/stat" || return
-    fcp_rest="${fcp_stat##*) }"
-    set -- $fcp_rest
-    fcp_pid=$2
-  done
-}
-
-# Start time of a process (jiffies since host boot, /proc/<pid>/stat field 22); mirrors
-# proc_start_time in claude-statusline.sh. Prints nothing when unavailable.
-proc_start_time() {
-  read -r pst_stat 2>/dev/null < "/proc/$1/stat" || return
-  pst_rest="${pst_stat##*) }"
-  set -- $pst_rest
-  printf '%s' "${20}"
-}
-
-# CHAMBA_CLAUDE_PID and CHAMBA_CLAUDE_PID_START are test/debug overrides.
-my_claude_pid="${CHAMBA_CLAUDE_PID:-$(find_claude_pid)}"
-case "$my_claude_pid" in *[!0-9]*) my_claude_pid="" ;; esac
-my_pid_start=""
-[ -n "$my_claude_pid" ] && my_pid_start="${CHAMBA_CLAUDE_PID_START:-$(proc_start_time "$my_claude_pid")}"
-case "$my_pid_start" in *[!0-9]*) my_pid_start="" ;; esac
-
-# Deterministic selection first: the snapshot recorded by this session's own Claude
-# process. The list is newest-first, so the first match also wins when one process
-# wrote several session files over time (e.g. after /clear). Pids get recycled across
-# container restarts while snapshots persist in the bind-mounted home, so when both
-# sides carry a start time it must agree too; a missing start time on either side
-# falls back to the pid alone. The while-read loop (heredoc, not a pipe, so $matched
-# survives) keeps paths intact even if the directory prefix contains spaces.
-newest=""
-second=""
-matched=""
-if [ -n "$my_claude_pid" ]; then
-  while IFS= read -r f; do
-    pid_fields=$(jq -r '(.claude_pid // ""), (.claude_pid_start // "")' "$f" 2>/dev/null)
-    {
-      IFS= read -r fpid
-      IFS= read -r fstart
-    } <<INNER
-$pid_fields
-INNER
-    [ "$fpid" = "$my_claude_pid" ] || continue
-    if [ -n "$fstart" ] && [ -n "$my_pid_start" ] && [ "$fstart" != "$my_pid_start" ]; then
-      continue
-    fi
-    matched="$f"
-    break
-  done <<EOF
-$files
-EOF
-fi
-
-if [ -n "$matched" ]; then
-  newest="$matched"
-else
-  # Heuristic fallback: newest by mtime, plus the runner-up for the ambiguity warning.
-  {
-    IFS= read -r newest
-    IFS= read -r second
-  } <<EOF
-$files
-EOF
-fi
-
-# Single jq pass over the snapshot, one field per line. Every path has a fallback so a
-# missing field becomes an empty string (or 0) instead of failing the script.
-parsed=$(jq -r '
-    .session_id // "",
-    .updated_at // "",
-    .context_tokens // 0,
-    .context_used_pct // 0,
-    .context_window_size // 0,
-    .model // "",
-    .effort // "",
-    .quota_left_pct // "",
-    .quota_resets_at // "",
-    .quota_week_left_pct // "",
-    .quota_week_resets_at // ""
-' "$newest" 2>/dev/null)
-
-if [ -z "$parsed" ]; then
-  echo "Snapshot $newest is unreadable." >&2
-  exit 1
-fi
-
-{
-  IFS= read -r session_id
-  IFS= read -r updated_at
-  IFS= read -r tokens
-  IFS= read -r used_pct
-  IFS= read -r window_size
-  IFS= read -r model
-  IFS= read -r effort
-  IFS= read -r quota_left
-  IFS= read -r quota_resets_at
-  IFS= read -r quota_week_left
-  IFS= read -r quota_week_resets_at
-} <<EOF
-$parsed
-EOF
-
-now=$(date +%s)
-
-# Format a seconds delta as "Xd Yh", "Xh Ym", "Xm", or "Xs". The day unit is here for the seven-day
-# rate-limit window, which is days away for most of its life; the hours are truncated rather than
-# rounded so a delta of 4 days and 23h50m never reads "4d 24h".
-fmt_delta() {
-  d=$1
-  if [ "$d" -ge 86400 ]; then
-    echo "$(( d / 86400 ))d $(( (d % 86400) / 3600 ))h"
-  elif [ "$d" -ge 3600 ]; then
-    echo "$(( d / 3600 ))h $(( (d % 3600) / 60 ))m"
-  elif [ "$d" -ge 60 ]; then
-    echo "$(( d / 60 ))m"
-  else
-    echo "${d}s"
-  fi
-}
-
-# Age of the snapshot from its own updated_at field (portable, and equal to file mtime).
-# age stays empty when updated_at is missing or non-numeric.
-age=""
-age_label="unknown"
-case "$updated_at" in
-  '' | *[!0-9]*) ;;
-  *)
-    age=$(( now - updated_at ))
-    [ "$age" -lt 0 ] && age=0
-    age_label="$(fmt_delta "$age") ago"
-    ;;
-esac
-
-# Token counts read the way the strip in the web interface says them: 45.0k below
-# 100k, 245k above, 1M above a million.
-fmt_tokens() {
-  case "$1" in
-    '' | *[!0-9]*) printf '?' ;;
-    *) awk -v t="$1" 'BEGIN {
-         if (t == 0) printf "0k";
-         else if (t >= 1000000) { m = t/1000000; if (m == int(m)) printf "%dM", m; else printf "%.1fM", m; }
-         else if (t >= 100000) printf "%dk", int(t/1000 + 0.5);
-         else printf "%.1fk", t/1000;
-       }' ;;
-  esac
-}
-
-tokens_label=$(fmt_tokens "$tokens")
-
-# The window the tokens sit in, when the snapshot knows how big it is. Unknown (an
-# older snapshot, or a release that stopped reporting it) leaves the whole clause out,
-# rather than naming a window with no size.
-window_label=""
-case "$window_size" in
-  '' | 0 | *[!0-9]*) ;;
-  *) window_label=" of $(fmt_tokens "$window_size") window" ;;
-esac
-
-# The "this session" marker means the snapshot was matched by pid and is guaranteed to
-# describe the asking session; without it the newest-file heuristic picked the snapshot.
-if [ -n "$matched" ]; then
-  printf 'session: %s (this session, updated %s)\n' "${session_id:-unknown}" "$age_label"
-else
-  printf 'session: %s (updated %s)\n' "${session_id:-unknown}" "$age_label"
-fi
-printf 'context: %s tokens (%s%%%s)\n' "$tokens_label" "${used_pct:-?}" "$window_label"
-
-# One rate-limit window as a line, printed only when the snapshot carried that window. Claude Code
-# reports two - the five-hour one, which "quota" has always meant here, and the seven-day one - and an
-# account may have both, one, or neither. The label is padded to the width the other lines use.
-quota_line() {
-  ql_label=$1
-  ql_left=$2
-  ql_resets=$3
-  [ -n "$ql_left" ] || return 0
-  ql_reset_label=""
-  case "$ql_resets" in
-    '' | *[!0-9]*) ;;
-    *)
-      ql_delta=$(( ql_resets - now ))
-      if [ "$ql_delta" -gt 0 ]; then
-        ql_reset_label=", resets in $(fmt_delta "$ql_delta")"
-      else
-        ql_reset_label=", resets now"
-      fi
-      ;;
-  esac
-  printf '%-8s %s%% remaining%s\n' "$ql_label" "$ql_left" "$ql_reset_label"
-}
-
-quota_line 'quota:' "$quota_left" "$quota_resets_at"
-quota_line 'weekly:' "$quota_week_left" "$quota_week_resets_at"
-
-if [ -n "$model" ]; then
-  effort_label=""
-  [ -n "$effort" ] && effort_label=" (effort $effort)"
-  printf 'model:   %s%s\n' "$model" "$effort_label"
-fi
-
-# Warnings apply only to the heuristic path: a pid-matched snapshot is this session's own
-# by construction, however old it is (it reflects the last render, i.e. the turn start).
-
-# Freshness warning: a snapshot older than 5 minutes likely belongs to an idle session.
-if [ -z "$matched" ] && [ -n "$age" ] && [ "$age" -gt 300 ]; then
-  printf 'warning: snapshot is %s old - it may not reflect the current session\n' "$(fmt_delta "$age")"
-fi
-
-# Ambiguity warning: another session wrote its snapshot around the same moment, so mtime
-# ordering may not identify the asking session. Compare updated_at of the two newest files.
-# Guarded on age being set, which implies updated_at is numeric. The explicit matched check
-# keeps this off the pid path even if a future edit populates $second unconditionally.
-if [ -z "$matched" ] && [ -n "$second" ] && [ -n "$age" ]; then
-  second_updated=$(jq -r '.updated_at // ""' "$second" 2>/dev/null)
-  case "$second_updated" in
-    '' | *[!0-9]*) ;;
-    *)
-      gap=$(( updated_at - second_updated ))
-      [ "$gap" -lt 0 ] && gap=$(( -gap ))
-      if [ "$gap" -lt 60 ]; then
-        printf 'warning: another session updated its snapshot within the last minute - this may not be your session (%s)\n' "$second"
-      fi
-      ;;
-  esac
-fi