@volter/teams 0.2.19 → 0.2.21

package/board-owner.mjs

@@ -0,0 +1,80 @@
+// A home's board owner (`supercode workflow serve`, one per install: D152) answers every card verb on that home's boards
+// over one local socket. The CLI and the machine daemon's board door hold nothing: each sends the verb here and renders
+// the answer. The socket is the home's own (`<home>/board.sock`, beside the owner's lock `<home>/board.lock`), by the
+// home's real path, so every process naming the home reaches the one owner whatever its environment.
+//
+//   request:  one JSON line  { v: 1, argv | tool, board, caller, session, facts, cwd, stdin }
+//               argv     the verb and its arguments, without --root or --board
+//               tool     a dispatched worker's board tool instead of a verb: { name, args, env } (its HERMES_KANBAN_*
+//                        task, run and board, and HERMES_PROFILE); answered with the tool's JSON as stdout
+//               board    the board's slug
+//               caller   the calling session's address when its side named it (`sc:<machine>:<harness>:<id>`), or null
+//               session  { id, harness } when the caller is a session on the owner's machine that the CLI named
+//               facts    what the caller's environment says of it (SUPERCODE_AGENT_ID, SUPERCODE_AUTOMATION,
+//                        SUPERCODE_CONTEXT, HERMES_PROFILE, USER, SUPERCODE_CALLER, and a launched worker's
+//                        SUPERCODE_RUN_LAUNCH: the owner's secret for its run, which only run-session reads)
+//               cwd      the caller's working directory, against which a path it names is read
+//               stdin    the caller's standard input, when it names `-` as a file (else null)
+//   answer:   one JSON line  { code, stdout, stderr }
+import { realpathSync } from 'node:fs';
+import { connect } from 'node:net';
+import { join, resolve } from 'node:path';
+
+/** A Unix socket's path is at most 104 bytes on macOS (108 on Linux), terminator included. */
+const SOCKET_PATH_MAX = 103;
+
+/** The home's real path. */
+export function boardHome(root) {
+  try { return realpathSync(resolve(root)); } catch { return resolve(root); }
+}
+
+/** The owner's socket for the home at `root`: the home's own, by its real path. */
+export function boardOwnerSocket(root) {
+  const path = join(boardHome(root), 'board.sock');
+  if (Buffer.byteLength(path) > SOCKET_PATH_MAX) throw new Error(`the home's board socket ${path} is longer than a Unix socket path may be (${SOCKET_PATH_MAX} bytes); keep the home at a shorter path`);
+  return path;
+}
+
+/**
+ * The verbs that are a board's own operation, run on its machine as acts of their own and never sent to its owner or
+ * through the board door: the owner itself and its one-shot round, init, adoption, the board list, housekeeping and
+ * repair, migration, the dispatching switch, and the verbs that hold the call open (watch, tail, attach, events).
+ */
+export const BOARD_OPERATION_VERBS = new Set(['serve', 'daemon', 'dispatch', 'dispatching', 'init', 'boards', 'gc', 'repair', 'migrate', 'watch', 'tail', 'events']);
+
+/** The facts of a caller's environment the owner reads, and nothing else of it. */
+export const CALLER_FACTS = ['SUPERCODE_AGENT_ID', 'SUPERCODE_AUTOMATION', 'SUPERCODE_CONTEXT', 'HERMES_PROFILE', 'USER', 'SUPERCODE_CALLER', 'SUPERCODE_RUN_LAUNCH'];
+export const callerFacts = (env = process.env) => Object.fromEntries(CALLER_FACTS.filter((key) => env[key]).map((key) => [key, env[key]]));
+
+/**
+ * Send one verb to the owner of the home at `root`: answers `{ code, stdout, stderr }`. A home whose owner is not
+ * running answers that, with what starts it; nothing else runs the verb.
+ */
+export function askBoardOwner(root, request) {
+  let path;
+  try { path = boardOwnerSocket(root); } catch (error) { return Promise.resolve({ code: 1, stdout: '', stderr: `${error.message}\n` }); }
+  return new Promise((done) => {
+    let answer = '';
+    let settled = false;
+    const finish = (value) => { if (!settled) { settled = true; done(value); } };
+    const socket = connect(path);
+    socket.setEncoding('utf8');
+    // The request is one line, and the connection stays open both ways until the answer's line has come: an answer that
+    // takes its time (a Teams lookup, a reread home) is never lost to a closed side.
+    socket.on('connect', () => socket.write(`${JSON.stringify({ v: 1, ...request })}\n`));
+    socket.on('data', (chunk) => {
+      answer += chunk;
+      const end = answer.indexOf('\n');
+      if (end < 0) return;
+      socket.end();
+      try { finish(JSON.parse(answer.slice(0, end))); } catch { finish({ code: 1, stdout: '', stderr: `the board owner of ${root} answered nothing readable\n` }); }
+    });
+    socket.on('close', () => finish({ code: 1, stdout: '', stderr: `the board owner of ${root} closed the call before answering\n` }));
+    socket.on('error', (error) => {
+      const down = ['ENOENT', 'ECONNREFUSED'].includes(error.code);
+      finish({ code: 1, stdout: '', stderr: down
+        ? `the boards of ${root} have no running owner: \`supercode workflow serve --root ${root}\` is it (an install's keeper runs it)\n`
+        : `the board owner of ${root} could not be reached: ${error.message}\n` });
+    });
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/teams",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "type": "module",
   "description": "Volter Teams, the neutral team plane: machine identity and daemon core, the local door and server link, admission from machine grants, product doors, and the Teams server's neutral routes (company RFC 0008).",
   "license": "MIT",
@@ -54,7 +54,8 @@
       "default": "./redact.mjs"
     },
     "./checkout": "./checkout.mjs",
-    "./board-name": "./board-name.mjs"
+    "./board-name": "./board-name.mjs",
+    "./board-owner": "./board-owner.mjs"
   },
   "files": [
     "LICENSE-MIT",

package/redact.mjs

@@ -3,7 +3,8 @@
 //   - the values this machine keeps in its custody files (KEY=value lines), which no detector knows; the files are named
 //     in `<supercode home>/custody.json` ({ "files": [...] }) and in SUPERCODE_CUSTODY_FILES (path-separated);
 //   - gitleaks' default rule set, vendored unchanged as redact/gitleaks-rules.json (its source and sha256 inside): each
-//     rule's keywords gate it, its secret group is what is replaced, and its entropy floor is kept.
+//     rule's keywords gate it, its secret group is what is replaced, and its entropy floor is kept;
+//   - the tokens a Teams server mints itself (TEAM_TOKENS), which no gitleaks rule knows.
 // Local files are never touched; only what is sent is redacted.
 import { readFileSync, existsSync, statSync } from 'node:fs';
 import { createHash } from 'node:crypto';
@@ -103,6 +104,13 @@ function longestMatch(source) {
 const RULES = vendored.rules.map((rule) => { const regex = jsPattern(rule.regex); return { id: rule.id, regex, longest: regex ? longestMatch(regex.source) : Infinity, group: rule.secretGroup ?? null, keywords: (rule.keywords ?? []).map((k) => k.toLowerCase()), entropy: rule.entropy ?? null }; }).filter((rule) => rule.regex);
 export const RULESET = { source: vendored.source, sha256: vendored.sha256, rules: RULES.length };
 
+// The tokens a Teams server mints (sdk/volter-teams/server, sdk/teams/server): a credential `sct_<id>.<32 bytes>`
+// (`sct_cred_<hex>.…`, the one three Codex session copies uploaded on 2026-09-30/10-01 carried, purged under D126), an
+// invitation or install code `sci_[<id>.]<32 bytes>`, an app secret `sca_<32 bytes>`, an attachment token
+// `sat_<id>.<32 bytes>`, each base64url, and a webhook signing secret `whsec_<32 bytes, base64>`. Each is replaced
+// whole, by a marker naming its kind.
+const TEAM_TOKENS = /\b(sct|sci|sca|sat)_(?:[A-Za-z]+_[0-9a-f]{32}\.)?[A-Za-z0-9_-]{43}(?![A-Za-z0-9_-])|\b(whsec)_[A-Za-z0-9+/]{43}=/g;
+
 // Where each of many literals occurs, in one pass over the text (gitleaks finds its keywords the same way, with one
 // automaton): a lookahead finds every position some literal starts at, and only those are compared literal by literal.
 // Hundreds of separate includes() read a 5 MB tool result hundreds of times.
@@ -182,6 +190,7 @@ export function redactText(text, env = process.env) {
   // Custody values are random, so one alternation of them gives the regex engine nothing to skip on: each is looked
   // for on its own, which reads a 5 MB text in a few dozen milliseconds.
   for (const { value, name } of custodyValues(env)) if (out.includes(value)) out = out.split(value).join(`[redacted:${name}]`);
+  if (/(?:sct|sci|sca|sat|whsec)_/.test(out)) out = out.replace(TEAM_TOKENS, (_, kind, hook) => `[redacted:teams-${kind ?? hook}-token]`);
   // Every rule has keywords, so a text holding none of them is done (the one test is cheap; finding where each keyword
   // occurs is not, and most texts are short and hold none).
   let lower = out.toLowerCase();