@chatpanel/events 0.30.0 → 0.32.0

package/media-transcript.js

@@ -170,6 +170,54 @@ export function pickCaptionTrack(tracks, { language = '', languages = ['en'] } =
     .sort((a, b) => b.s - a.s)[0].t;
 }
 
+// --------------------------------------------------------------------------
+// The InnerTube player request — how a caption URL that WORKS is obtained
+// --------------------------------------------------------------------------
+//
+// The caption URLs printed into the watch page's HTML answer HTTP 200 with an EMPTY BODY —
+// measured on every video tried, with and without session cookies, Referer and Origin. The
+// ones returned by the InnerTube player endpoint for the ANDROID client do not.
+//
+// AND THE CLIENT VERSION IS THE WHOLE DIFFERENCE, which is worth stating because it is
+// invisible and it will go stale:
+//
+//   clientVersion 20.10.38  -> 1 track,  60,441 bytes of captions
+//   clientVersion 19.09.37  -> no captionTracks at all
+//   clientVersion 17.31.35  -> no captionTracks at all
+//
+// A stale version does not error. It returns a well-formed player response with the
+// `captions` block missing, which reads exactly like "this video has no subtitles" — so the
+// failure mode of letting this rot is a feature that quietly claims videos have no captions.
+// tests/media-transcript.test.js pins the shape; a live check is the client's job.
+
+/** The InnerTube client whose player response carries usable caption URLs. */
+export const INNERTUBE_ANDROID = Object.freeze({ clientName: 'ANDROID', clientVersion: '20.10.38' });
+
+/** The public InnerTube key is printed into every watch page; it is not a secret. */
+export function innertubeApiKeyFromHtml(html) {
+  const m = /"INNERTUBE_API_KEY":\s*"([^"]+)"/.exec(String(html || ''))
+    || /INNERTUBE_API_KEY\\":\\"([^\\"]+)/.exec(String(html || ''));
+  return m ? m[1] : '';
+}
+
+/**
+ * The request to make, as data — so the caller performs it wherever its network is.
+ *
+ * Returned rather than sent for the same reason nothing else here fetches: the extension, the
+ * bridge and a mobile client each have their own idea of what "fetch" means, and this file
+ * has to run in all three.
+ */
+export function innertubePlayerRequest(videoId, { apiKey = '', client = INNERTUBE_ANDROID } = {}) {
+  if (!videoId) return null;
+  const query = apiKey ? `?key=${encodeURIComponent(apiKey)}` : '';
+  return {
+    url: `https://www.youtube.com/youtubei/v1/player${query}`,
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ context: { client: { ...client } }, videoId }),
+  };
+}
+
 /**
  * Ask a caption URL for a specific serialisation.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chatpanel/events",
-  "version": "0.30.0",
-  "description": "The canonical ChatPanel event-log and capability contracts \u2014 typed durable facts, clock-free deterministic linearization, schema upcasting, and the invariants the replay harness asserts. Pure, dependency-free ESM shared by the ChatPanel extension, gateway and bridge.",
+  "version": "0.32.0",
+  "description": "The canonical ChatPanel event-log and capability contracts — typed durable facts, clock-free deterministic linearization, schema upcasting, and the invariants the replay harness asserts. Pure, dependency-free ESM shared by the ChatPanel extension, gateway and bridge.",
   "type": "module",
   "main": "index.js",
   "exports": {

package/voice-intents.js

@@ -233,13 +233,35 @@ export function findWakeCommands(text, wake = compileWake(), { maxSentences = MA
   const tokens = tokenize(raw);
   if (!tokens.length) return [];
   const hits = wakeHits(raw, tokens, wake);
-  return hits.map((hit, idx) => {
-    // Bounded by the NEXT address, then by sentence count. A second wake word is the end of
-    // the first command however the sentences fall.
-    const stop = idx + 1 < hits.length ? hits[idx + 1].start : raw.length;
+  const out = [];
+  // How far the last command emitted reaches. A wake phrase the speaker used as a WORD, inside
+  // a command already running, is part of that command and not a second one.
+  let covered = 0;
+  for (let idx = 0; idx < hits.length; idx++) {
+    const hit = hits[idx];
+    // THE PRODUCT'S OWN NAME IS A WORD PEOPLE SAY.
+    //
+    // "Okay chat panel, take the notes of whatever we spoke so far in chat panel notes" holds
+    // the wake phrase twice: once as an address, once as the name of where to put them. The
+    // second was treated as a fresh address, which did two things and both were wrong — it cut
+    // the command down to "…so far", losing where they wanted the notes, and it emitted
+    // "notes. So that is good." as a command of its own, which noteIntent matched. One spoken
+    // request became two notes and a truncated one.
+    //
+    // A mention that is not an address and falls inside the command already being carried is
+    // skipped. A mention that stands on its own still gets through — the intent match is the
+    // safety net for an address this heuristic misjudged, and dropping those outright would
+    // trade a stray action for a lost one.
+    if (!hit.addressed && hit.start < covered) continue;
+    // Bounded by the next ADDRESS, then by sentence count. Deliberately the next address and
+    // not the next mention: a second wake word is the end of the first command only when the
+    // speaker was turning to us again, and the sentence they are still saying is not that.
+    let stop = raw.length;
+    for (let j = idx + 1; j < hits.length; j++) if (hits[j].addressed) { stop = hits[j].start; break; }
     const span = raw.slice(hit.end, stop);
     const command = trimTrailingLeadIn(stripLeadIn(firstSentences(span, maxSentences)).trim());
-    return {
+    covered = Math.max(covered, hit.end + span.indexOf(command) + command.length);
+    out.push({
       command,
       wake: hit.phrase,
       heard: raw.slice(hit.start, hit.end),
@@ -248,8 +270,9 @@ export function findWakeCommands(text, wake = compileWake(), { maxSentences = MA
       // What was said after the command's own sentences, up to the next address. Not part of
       // the command — kept so a caller refining with a model has the surrounding words.
       rest: raw.slice(hit.end + span.indexOf(command) + command.length, stop).trim(),
-    };
-  });
+    });
+  }
+  return out;
 }
 
 /**
@@ -380,7 +403,12 @@ export const REFINEMENT_SCHEMA = defineSchema({
     name: { type: 'string', max: 48, describe: 'a label of at most 6 words' },
     kind: {
       type: 'enum',
-      values: ['question', 'monitor', 'note', 'skill', 'timer', 'none'],
+      // 'action' is here because it was MISSING, and the gap was silent. A browser command
+      // ("go to google.com and search for chat panel") is not something they want to KNOW, so
+      // it does not read as a question — and the only other bucket that fitted a rambling,
+      // narrated demo was "none", which is dropped without a word. Spoken four different ways
+      // in one meeting, it did nothing every time while the timer beside it worked.
+      values: ['question', 'action', 'monitor', 'note', 'skill', 'timer', 'none'],
       // An unknown kind becomes a QUESTION — the least surprising thing to do with something
       // someone asked for, and the only kind that is undone by ignoring the answer. Guessing
       // "monitor" instead would leave a card watching the meeting that nobody asked for.
@@ -405,6 +433,7 @@ export function refinementPrompt(utterance) {
     '',
     'Pick the SMALLEST kind that does what they asked:',
     '  question — answer it once, now. The DEFAULT for anything they want to know.',
+    '  action   — DO something in the browser or an app ("go to google.com and search for X").',
     '  monitor  — only if they asked to be told as the meeting CONTINUES ("let me know if",',
     '             "keep an eye on"). A one-off question is NOT a monitor.',
     '  note     — they asked for notes written down ("take notes on", "write that up").',
@@ -474,6 +503,36 @@ export function settleRefinement(v) {
   return { request, name, kind, skill: v.skill || '' };
 }
 
+/**
+ * Did the user's own spoken words name this host?
+ *
+ * The authority test for a hands-free browser command. A URL a MODEL picked is
+ * attacker-influenced by construction — it has been reading page text and meeting captions —
+ * so it gets a confirmation dialog. A URL whose host the USER said out loud has already been
+ * reviewed by the only person that dialog would have asked, and a modal in a side panel is
+ * exactly what nobody in a meeting is looking at: "go to google.com and search for chat
+ * panel" was spoken four ways in one call and did nothing every time.
+ *
+ * Deliberately strict. The full hostname always counts ("google.com"). The bare first label
+ * counts ONLY for a two-label host, so saying "docs" can never authorise `docs.evil.test` —
+ * anything deeper has to be said in full.
+ *
+ * Shared rather than written in the panel because it is a pure decision with no platform in
+ * it: the bridge relays the same page tools, and a second copy of an authority rule is a
+ * second answer to "may this happen".
+ */
+export function spokenNamesHost(url, spoken) {
+  const said = String(spoken || '').toLowerCase();
+  if (!said) return false;
+  let host;
+  try { host = new URL(url).hostname.toLowerCase().replace(/^www\./, ''); } catch { return false; }
+  if (!host) return false;
+  if (said.includes(host)) return true;
+  const labels = host.split('.');
+  if (labels.length !== 2) return false;
+  return new RegExp(`\\b${labels[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(said);
+}
+
 /**
  * The same answer, AS IT ARRIVES.
  *