@passioncode-ai/fabric-agent-adapter 0.81.0 → 0.82.0

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-lock.mjs

@@ -1,5 +1,15 @@
 // One copy of a service, locked before any side effect (LC-01, DEC-0057): the instance lock and the supervisor marker.
 // Part of the Node service kit (FAA-65, layer L3); the twin of fabric_lock.py. Node 20+ (22+ for the Linux lock), no dependency.
+//
+// A lock that moves under its holder (FAA-303). Linux and Windows hold a name keyed by the lock's path (an abstract
+// unix socket, a named pipe), so a folder swapped under a running copy cannot let a second copy in. macOS has no such
+// name: O_EXLOCK (and the Python twin's flock) lock an inode, so after a data import swaps the data folder a second
+// copy locks the new file and starts. There the holder watches its lock instead (InstanceLock#watch, started by
+// holdSingleInstance): every LOCK_WATCH_SECONDS it compares the inode it locked with the file at the path, and once
+// the path names another file it stops with 75 and one sentence naming the path, before writing anything more into a
+// folder that is no longer the one it read. Two copies then overlap for at most one interval. A path-keyed name on
+// macOS was weighed and left: it needs a file in a folder outside the data folder that the system never cleans and
+// every copy can write, which Node alone cannot promise.
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import net from 'node:net';
@@ -15,6 +25,12 @@ export const LOCK_BACKOFF_FIRST_SECONDS = 0.5;
 
 export const LOCK_BACKOFF_MAX_SECONDS = 30;
 
+/**
+ * How often a holder that has no path-keyed name (macOS) compares the inode it locked with the file at the lock's path
+ * (FAA-303): one stat and one fstat; two copies overlap for at most this long after a folder swap.
+ */
+export const LOCK_WATCH_SECONDS = 2;
+
 const O_EXLOCK = 0x20; // BSD/macOS: open(2) takes flock(LOCK_EX); absent from fs.constants
 
 export class AlreadyRunning extends ServiceError {
@@ -34,6 +50,7 @@ export class InstanceLock {
     this.path = path.join(dataDir, 'service.lock');
     this.fd = null;
     this.server = null;
+    this.timer = null;
   }
 
   async acquire() {
@@ -124,14 +141,65 @@ export class InstanceLock {
     return true;
   }
 
+  /**
+   * Re-check, every `intervalSeconds` on an unref'd timer, that the file this copy locked is still the file at the path
+   * (FAA-303); the first time the path names another file (a swapped folder's lock, or the one a second copy made),
+   * call `onLost(lock)` once and stop watching. The default stops the process with 75 and one sentence
+   * (stopLostHolder). A path that is gone or cannot be read now is read as nothing there yet and tried again next time:
+   * a second copy has to make a file there to start, and the watch then sees that file. `release` ends the watch. Only
+   * a lock held as a file is watched (macOS): elsewhere the descriptor is null and the path-keyed name keeps a second
+   * copy out, so this is a no-op, as for a lock not held.
+   */
+  watch({ onLost, intervalSeconds = LOCK_WATCH_SECONDS } = {}) {
+    if (this.fd === null || this.timer !== null) return this;
+    const fd = this.fd;
+    const react = onLost ?? stopLostHolder;
+    this.timer = setInterval(() => {
+      let here;
+      let held;
+      try {
+        here = fs.statSync(this.path);
+        held = fs.fstatSync(fd);
+      } catch {
+        return;
+      }
+      if (here.dev === held.dev && here.ino === held.ino) return;
+      clearInterval(this.timer);
+      this.timer = null;
+      react(this);
+    }, intervalSeconds * 1000);
+    this.timer.unref();
+    return this;
+  }
+
   release() {
+    if (this.timer !== null) clearInterval(this.timer);
     if (this.fd !== null) fs.closeSync(this.fd);
     if (this.server) this.server.close();
+    this.timer = null;
     this.fd = null;
     this.server = null;
   }
 }
 
+/** The one sentence a holder whose lock moved under it stops with (FAA-303). */
+export function lostLockMessage(lockPath) {
+  return `${lockPath} is no longer the file this copy locked (the data folder moved or was swapped?): stopping, so a copy started on the folder now at that path runs alone.`;
+}
+
+/**
+ * InstanceLock#watch's default: write lostLockMessage and end the process with 75 at once. Not a graceful stop: a
+ * shutdown would write this copy's state into the folder now at the path, which is not the one it read; the kit's
+ * journals make an abrupt stop recoverable (LC-03).
+ */
+export function stopLostHolder(lock) {
+  try {
+    fs.writeSync(2, `${lostLockMessage(lock.path)}\n`);
+  } finally {
+    process.exit(EXIT_ALREADY_RUNNING);
+  }
+}
+
 let abstractNamesSeen = null;
 
 /**
@@ -253,10 +321,12 @@ const sleepSeconds = (s) => new Promise((resolve) => setTimeout(resolve, s * 100
  * supervisor that restarts on exit (launchd's KeepAlive) an immediate exit is a respawn every ThrottleInterval,
  * forever; so a supervised copy first backs off in-process (0.5 s doubling to 30 s,
  * LOCK_WAIT_SUPERVISED_SECONDS in all), takes over if the holder leaves, and exits 75 only when
- * the wait runs out. `waitSeconds` overrides the choice (0 = never wait).
+ * the wait runs out. `waitSeconds` overrides the choice (0 = never wait). Where the lock is held as a file (macOS)
+ * the held lock is watched (InstanceLock#watch, FAA-303): a folder swapped under the running copy stops it with 75;
+ * `onLost` replaces that reaction.
  */
 export async function holdSingleInstance(dataDir, {
-  waitSeconds, sleep = sleepSeconds, clock = () => performance.now() / 1000, exit = (code) => process.exit(code), env, argv,
+  waitSeconds, sleep = sleepSeconds, clock = () => performance.now() / 1000, exit = (code) => process.exit(code), env, argv, onLost,
 } = {}) {
   // DEC-0057: markers that disagree exit 75 at once, before the lock, naming them.
   const marker = supervisorMarker({ ...(env === undefined ? {} : { env }), ...(argv === undefined ? {} : { argv }) });
@@ -270,7 +340,7 @@ export async function holdSingleInstance(dataDir, {
   let announced = false;
   for (;;) {
     try {
-      return await new InstanceLock(dataDir).acquire();
+      return (await new InstanceLock(dataDir).acquire()).watch({ onLost });
     } catch (error) {
       if (!(error instanceof AlreadyRunning)) throw error;
       const remaining = deadline - clock();

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-peer-owner.mjs

@@ -40,12 +40,14 @@
 // privilege. The parsers are pure functions over captured text (test/fixtures/peer-owner/).
 
 import { execFile } from 'node:child_process';
+import { realpathSync } from 'node:fs';
 import { open } from 'node:fs/promises';
 import http from 'node:http';
 import net from 'node:net';
 import os from 'node:os';
+import { fileURLToPath } from 'node:url';
 
-export const PEER_OWNER_VERSION = '1.2.0+kit.5'; // the Python twin's, Observatory's 1.2.0 with the kit's differences
+export const PEER_OWNER_VERSION = '1.2.0+kit.6'; // the Python twin's, Observatory's 1.2.0 with the kit's differences
 export const THIS_ACCOUNT = 'this-account';
 export const ANOTHER_ACCOUNT = 'another-account';
 export const SYSTEM = 'system';
@@ -62,6 +64,8 @@ export const LSOF = '/usr/sbin/lsof';
 // The reason a socket table hides other processes' sockets from this one (FAA-267): macOS 27.2 gives an ad-hoc-signed
 // runtime an empty netstat.
 export const TABLE_RESTRICTED = 'table-restricted';
+// A macOS table that lists sockets but not the reader's own connection (DEC-0155 RT-1, FAA-312).
+export const NO_ROW_RESTRICTED = `${TABLE_RESTRICTED}: no row for this connection`;
 export const SERVER_NOT_OWN = 'server-not-own';
 export const SERVER_UNVERIFIED = 'server-unverified';
 export const SERVER_NOT_THIS_WORKSPACE = 'server-not-this-workspace';
@@ -290,10 +294,10 @@ export function runProgram(file, args, timeout = TIMEOUT_MS) {
   });
 }
 
-export function method() {
-  if (process.platform === 'darwin') return 'netstat';
-  if (process.platform === 'linux') return 'proc';
-  if (process.platform === 'win32') return 'netstat-windows';
+export function method(platform = process.platform) {
+  if (platform === 'darwin') return 'netstat';
+  if (platform === 'linux') return 'proc';
+  if (platform === 'win32') return 'netstat-windows';
   return 'none';
 }
 
@@ -319,9 +323,18 @@ async function readProc(name) {
   return Buffer.concat(chunks);
 }
 
-export async function readTable({ run = runProgram } = {}) {
-  const how = method();
-  if (how === 'netstat') return { rows: parseNetstat(await run(NETSTAT, ['-anv', '-p', 'tcp'])), how };
+export async function readTable({ run = runProgram, platform = process.platform } = {}) {
+  const how = method(platform);
+  if (how === 'netstat') {
+    let text;
+    try {
+      text = await run(NETSTAT, ['-anv', '-p', 'tcp']);
+    } catch (err) {
+      // A netstat that fails, exits non-zero or times out is a restricted table (DEC-0155 RT-1, FAA-312).
+      throw new TableUnreadable(`${TABLE_RESTRICTED}: ${err instanceof TableUnreadable ? err.message : `netstat: ${err?.name ?? 'error'}`}`);
+    }
+    return { rows: parseNetstat(text), how };
+  }
   if (how === 'proc') {
     const rows = [];
     for (const [name, family] of [['/proc/net/tcp', 4], ['/proc/net/tcp6', 6]]) {
@@ -387,6 +400,21 @@ export async function resolve(row, how, { run = runProgram, ownUid: mine, ownSid
 
 // -- the questions ----------------------------------------------------------------------------------------------------
 
+// DEC-0155 RT-1 (FAA-312): a macOS table holding no row of another uid (sysctl, the Python twin's, which carries uids)
+// or of another process (netstat, which carries pids) is restricted, and a missing row proves nothing. Never on Linux
+// or Windows, which carry the owner on each row.
+export function restricted(rows, how, { ownUid: mine, ownPid } = {}) {
+  if (how === 'sysctl') {
+    const own = mine ?? ownUid();
+    return !rows.some((r) => r.uid !== null && r.uid !== undefined && r.uid !== own);
+  }
+  if (how === 'netstat') {
+    const own = ownPid ?? process.pid;
+    return !rows.some((r) => r.pid !== null && r.pid !== undefined && r.pid !== own);
+  }
+  return false;
+}
+
 // The live connected rows with exactly this local and remote address: one, or the caller cannot tell.
 // A row printed twice is one socket: Linux resumes a /proc read that sockets came and went under by position, and can
 // print the same row again (0.74.0 seam reading 6); rows equal in every field count once.
@@ -414,7 +442,8 @@ async function ownerOf(local, remote, opts = {}, server = false) {
     // A /proc read under churn can skip a row or print one twice; one more read before answering unknown.
     if (table.how !== 'proc' || found.length === 1) break;
   }
-  if (found.length === 0) return owner(UNKNOWN, { method: table.how, reason: 'no-row' });
+  // A macOS table without the reader's own connection is restricted (DEC-0155 RT-1, FAA-312).
+  if (found.length === 0) return owner(UNKNOWN, { method: table.how, reason: ['sysctl', 'netstat'].includes(table.how) ? NO_ROW_RESTRICTED : 'no-row' });
   if (found.length > 1) return owner(UNKNOWN, { method: table.how, reason: 'several-rows' });
   if (table.how === 'proc' && server && found[0].uid === null) {
     // Linux: a connection not yet accept()ed is printed with uid 0 and inode 0; it belongs to the listener on its local
@@ -491,23 +520,28 @@ export async function listener(port, opts = {}) {
   const at = now();
   const hit = injected ? undefined : listeners.get(port);
   if (hit && at - hit[0] < LISTENER_TTL_MS) return hit[1];
-  let found;
-  let how;
   let table;
   try {
     table = await (read ?? readTable)(opts);
-    how = table.how;
-    found = pickListener(table.rows, port);
   } catch (err) {
     const who = owner(UNKNOWN, { method: method(), reason: err instanceof TableUnreadable ? err.message : `table: ${err.name}` });
     if (!injected) listeners.set(port, [at, who]);
     return who;
   }
-  const who = await oneOwner(found, how, opts);
+  const who = restricted(table.rows, table.how, opts) ? await restrictedListener(table.rows, port, table.how, opts)
+    : await oneOwner(pickListener(table.rows, port), table.how, opts);
   if (!injected) listeners.set(port, [at, who]);
   return who;
 }
 
+// DEC-0155 RT-4 (FAA-312): under a restricted table only this account's own bind on exactly 127.0.0.1 is its own; its
+// wildcard or ::1 listener, root's, and a port with no row are an owner that cannot be told.
+async function restrictedListener(rows, port, how, opts) {
+  const who = await oneOwner(rows.filter((r) => r.listening && r.local[0] === '127.0.0.1' && r.local[1] === port), how, opts);
+  if (who.kind === THIS_ACCOUNT) return who;
+  return owner(UNKNOWN, { method: how, reason: `${TABLE_RESTRICTED}: no listener of this account on exactly 127.0.0.1:${port}` });
+}
+
 // [code, why] when a client must not send on a connection whose server end is `who`, else null.
 export function refusal(who, port, expectPid = null) {
   if (who.kind === ANOTHER_ACCOUNT || who.kind === SYSTEM) return [SERVER_NOT_OWN, `the server on port ${port} belongs to ${who.kind}`];
@@ -518,16 +552,20 @@ export function refusal(who, port, expectPid = null) {
   return null;
 }
 
-// macOS, when the socket table is restricted (FAA-267): whether process `pid`, this account's, listens on 127.0.0.1:<port>
-// or the IPv4 wildcard (IPv4 alone: a v6-only wildcard never vouches for a 127.0.0.1 connection). `lsof -p` asks the process itself, which the restriction does not hide. Only a caller that started
-// `pid` itself (a launchd job it installed) may vouch with it.
-export async function pidListens(pid, port, { run = runProgram, platform = process.platform, ownUid: mine } = {}) {
+// macOS, when the socket table is restricted (FAA-267, DEC-0155 RT-3): whether process `pid`, this account's, listens on
+// exactly 127.0.0.1:<port> (never the IPv4 wildcard, which lsof prints as it prints an IPv6-only one, nor ::1; FAA-312).
+// `lsof -p` asks the process itself, which the restriction does not hide. Only a caller that started `pid` itself (a
+// launchd job it installed) may vouch with it, and never a set-uid one (its real and effective uid differ, DEC-0155).
+export async function pidListens(pid, port, { run = runProgram, platform = process.platform, ownUid: mine, ownEuid } = {}) {
   if (platform !== 'darwin' || !Number.isInteger(pid) || pid <= 1) return false;
+  const real = mine ?? ownUid();
+  const effective = ownEuid ?? (typeof process.geteuid === 'function' ? process.geteuid() : real);
+  if (effective !== real) return false;
   try {
     const uid = parsePsUid(await run(PS, ['-o', 'uid=', '-p', String(pid)]));
-    if (uid === null || uid !== (mine ?? ownUid())) return false;
+    if (uid === null || uid !== real) return false;
     const out = await run(LSOF, ['-nP', '-a', '-p', String(pid), '-i4TCP', '-sTCP:LISTEN', '-Fn']);
-    return parseLsofListeners(out).some(([host, p]) => (host === '127.0.0.1' || host === '*') && p === port);
+    return parseLsofListeners(out).some(([host, p]) => host === '127.0.0.1' && p === port);
   } catch {
     return false;
   }
@@ -587,3 +625,32 @@ export class CheckedAgent extends http.Agent {
       expectPid: this.expectPid, vouchPid: this.vouchPid, ...this.ask }).then((socket) => callback(null, socket), (err) => callback(err));
   }
 }
+
+const USAGE = 'usage: fabric-peer-owner.mjs listener <port> [--json]\n';
+
+// `listener <port> [--json]`: the kind of who listens on 127.0.0.1:<port>, which the dashboard link gate takes as
+// listener_owner (FAA-315), or the whole owner as JSON; 2 on a usage error. `listener` and `write` are the tests'.
+export async function main(argv, { listener: ask = listener, write = (text) => process.stdout.write(text) } = {}) {
+  const asJson = argv.length === 3 && argv[2] === '--json';
+  const port = Number(argv[1]);
+  if (argv.length !== 2 + Number(asJson) || argv[0] !== 'listener' || !/^[0-9]+$/.test(argv[1] ?? '') || port < 1 || port > 65535) {
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  const who = await ask(port);
+  write(asJson ? `${JSON.stringify({ kind: who.kind, uid: who.uid, pid: who.pid, method: who.method, reason: who.reason })}\n` : `${who.kind}\n`);
+  return 0;
+}
+
+// Whether node was started on this file, by real paths (a symlinked install folder, as check_dashboard_layout.mjs).
+function startedDirectly() {
+  try {
+    return Boolean(process.argv[1]) && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+if (startedDirectly()) {
+  main(process.argv.slice(2)).then((code) => { process.exitCode = code; }, (err) => { process.stderr.write(`${err?.message ?? err}\n`); process.exitCode = 1; });
+}

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-secrets.mjs

@@ -38,6 +38,31 @@ export function credentialName(name) {
 
 /** A JWT or JWS anywhere in a value. */
 export const JWT_SHAPE = /eyJ[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]*/;
+const isUrlBase64 = (code) => (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a) || (code >= 0x30 && code <= 0x39)
+  || code === 0x2d || code === 0x5f;
+const runEnd = (text, from) => { let end = from; while (end < text.length && isUrlBase64(text.charCodeAt(end))) end += 1; return end; };
+/** The spans JWT_SHAPE matches in a text, leftmost and not overlapping, read in one pass (the contract's jwtSpans,
+ * FAA-313): the regular expression backtracks from every `eyJ` of a long run, quadratic in it, while every `eyJ` of one
+ * run shares that run's end, so only its first is tried, and a match ends where its third segment's run ends. `first`
+ * stops at the first match. */
+export function jwtSpans(text, first = false) {
+  const spans = [];
+  let from = 0;
+  for (let at = text.indexOf('eyJ', from); at >= 0; at = text.indexOf('eyJ', from)) {
+    const one = runEnd(text, at + 3);
+    from = one;
+    if (one - at - 3 < 2 || text[one] !== '.') continue;
+    const two = runEnd(text, one + 1);
+    if (two - one - 1 < 2 || text[two] !== '.') continue;
+    const three = runEnd(text, two + 1);
+    spans.push([at, three]);
+    if (first) break;
+    from = three;
+  }
+  return spans;
+}
+/** Whether JWT_SHAPE matches anywhere in a text, read in one pass (the contract's hasJwt, FAA-313). */
+export const hasJwt = (text) => jwtSpans(text, true).length > 0;
 /** A value that says it is a credential (`Bearer ` at its start, in any case), or a provider key's shape with its prefix
  * in its canonical case only, at the start of a value, after a character that is no ASCII letter or digit, or after an
  * escape; an `sk-` key holds a digit and an upper-case letter with 16 or more characters, or a digit with 32 or more,
@@ -48,7 +73,7 @@ const LONG_RUN = /[A-Za-z0-9+/=_-]{40,}/g;
 export const longSecret = (value) => (value.match(LONG_RUN) ?? []).some((run) => /[a-z]/.test(run) && /[A-Z]/.test(run) && /[0-9]/.test(run));
 
 /** Whether a value could be a credential: a JWT anywhere, a provider key or `Bearer …`, or a long secret-shaped run. */
-export const secretValue = (value) => JWT_SHAPE.test(value) || SECRET_VALUE.test(value) || longSecret(value);
+export const secretValue = (value) => hasJwt(value) || SECRET_VALUE.test(value) || longSecret(value);
 
 export const BEARER_INSIDE = /\bbearer\s+(?=[A-Za-z0-9._~+/-]*\d)[A-Za-z0-9._~+/-]{12,}=*/i;
 const PATH_LIKE = /^(?:[/~.]|[A-Za-z]:[\\/]|[a-z][a-z0-9+.-]*:\/\/)/i;
@@ -58,7 +83,7 @@ const pathLike = (piece) =>
 
 /** The same for a launch argument or a server's command and URL: a long run is looked for between path separators. */
 export const secretArgument = (value) =>
-  JWT_SHAPE.test(value) || SECRET_VALUE.test(value) || BEARER_INSIDE.test(value) ||
+  hasJwt(value) || SECRET_VALUE.test(value) || BEARER_INSIDE.test(value) ||
   value.split(/[\s=]/).some((piece) => (pathLike(piece) ? piece.split(/[\\/]/).some((part) => longSecret(part)) : longSecret(piece)));
 
 const decodeKeepingPlus = (raw) => { try { return decodeURIComponent(raw); } catch { return raw; } };
@@ -122,7 +147,8 @@ export function repositoryPassword(value) {
 
 // A repository's parameters, read as fabric_secrets.secret_url reads them, by hand: `new URL`
 // refuses a host it cannot parse and a special scheme written without `//` (`https:host/r?access_token=...`), where
-// the Python twin still reads them (0.62.0 readings 8 and 9, FAA-200 (17)).
+// the Python twin's repository_credential reads them too (0.62.0 readings 8 and 9, FAA-200 (17)); its secret_url, like
+// secretUrl, refuses such a URL since FAA-309.
 function repositoryParts(head, tail) {
   const text = tail.replace(/[\x00-\x20]+$/, '').replace(/[\t\n\r]/g, '');
   const hash = text.indexOf('#');

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-service.mjs

@@ -52,8 +52,11 @@ export {
   LOCK_WAIT_SUPERVISED_SECONDS,
   LOCK_BACKOFF_FIRST_SECONDS,
   LOCK_BACKOFF_MAX_SECONDS,
+  LOCK_WATCH_SECONDS,
   AlreadyRunning,
   InstanceLock,
+  lostLockMessage,
+  stopLostHolder,
   lockName,
   SUPERVISORS,
   SUPERVISOR_ARG,

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_connections.py

@@ -4,10 +4,7 @@
 `degraded[]`. Part of the service kit (FAA-62, layer L3). Standard library only."""
 from __future__ import annotations
 
-import bisect
-import ipaddress
 import re
-import unicodedata
 import urllib.parse
 from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence
 
@@ -18,7 +15,12 @@ if str(_Path(__file__).resolve().parent) not in _sys.path:  # the kit loads from
 
 from fabric_base import ServiceError  # noqa: E402
 from fabric_secrets import (  # noqa: E402
-    JWT_SHAPE, _BEARER_INSIDE as _BEARER, _long_secret, credential_name, raw_values, secret_argument, secret_value,
+    _BEARER_INSIDE as _BEARER, _long_secret, credential_name, has_jwt, raw_values, secret_argument, secret_value,
+)
+# The WHATWG host reading and its IDNA tables (FAA-98) live in fabric_secrets since FAA-309, where secret_url reads a
+# URL's host with them; the names stay here for code and tests that reached them.
+from fabric_secrets import (  # noqa: E402,F401
+    _FORBIDDEN_DOMAIN, _FORBIDDEN_HOST, _IDNA_DISALLOWED, _IDNA_IGNORED, _domain_ok, _idna_host, _ipv4_number, _ipv6_ok,
 )
 
 CONNECTIONS_EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/connections/0.1"
@@ -171,153 +173,6 @@ _credential_name, _secret_value, _secret_argument = credential_name, secret_valu
 
 
 _SPECIAL = ("http", "https", "ws", "wss", "ftp", "file")
-_FORBIDDEN_HOST = set("\x00\t\n\r #/:<>?@[\\]^|")
-_FORBIDDEN_DOMAIN = _FORBIDDEN_HOST | set(chr(c) for c in range(0x20)) | {"%", "\x7f"}
-
-
-# FAA-98: UTS46 narrowed, not ported. A non-ASCII host is refused only where every Node from 20 to 26 refuses it, so
-# the doubt stays on the closed side (its URL's credentials are read). The two tables are measured by
-# test/fixtures/idna/make_idna_tables.mjs (idna-tables.json, held equal by test_the_idna_tables_are_the_measured_ones):
-# code points refused in every context, and code points removed between letters. The contextual rules read Unicode 3.2
-# classes (`unicodedata.ucd_3_2_0`) and skip what that Unicode does not know, since Node's own UTS46 data lags its
-# Unicode: an Arabic letter of Unicode 14 is no right-to-left letter to it.
-_IDNA_DISALLOWED = (
-    (0x80, 0xa0), (0xa8, 0xa8), (0xaf, 0xaf), (0xb4, 0xb4), (0xb8, 0xb8), (0x2d8, 0x2dd), (0x37a, 0x37a),
-    (0x384, 0x385), (0x600, 0x605), (0x61c, 0x61c), (0x6dd, 0x6dd), (0x70f, 0x70f), (0x890, 0x891), (0x8e2, 0x8e2),
-    (0x1680, 0x1680), (0x1fbd, 0x1fbd), (0x1fbf, 0x1fc1), (0x1fcd, 0x1fcf), (0x1fdd, 0x1fdf), (0x1fed, 0x1fee),
-    (0x1ffd, 0x1ffe), (0x2000, 0x200a), (0x200e, 0x200f), (0x2017, 0x2017), (0x2024, 0x2026), (0x2028, 0x202f),
-    (0x203e, 0x203e), (0x2047, 0x2049), (0x205f, 0x205f), (0x2066, 0x2069), (0x2100, 0x2101), (0x2105, 0x2106),
-    (0x2488, 0x249b), (0x2a74, 0x2a74), (0x2ff0, 0x3000), (0x309b, 0x309c), (0x31ef, 0x31ef), (0x33c2, 0x33c2),
-    (0x33c7, 0x33c7), (0x33d8, 0x33d8), (0xe000, 0xf8ff), (0xfc5e, 0xfc63), (0xfdfa, 0xfdfb), (0xfe12, 0xfe13),
-    (0xfe16, 0xfe16), (0xfe19, 0xfe19), (0xfe30, 0xfe30), (0xfe47, 0xfe4c), (0xfe52, 0xfe52), (0xfe55, 0xfe56),
-    (0xfe5f, 0xfe5f), (0xfe64, 0xfe65), (0xfe68, 0xfe68), (0xfe6a, 0xfe6b), (0xfe70, 0xfe70), (0xfe72, 0xfe72),
-    (0xfe74, 0xfe74), (0xfe76, 0xfe76), (0xfe78, 0xfe78), (0xfe7a, 0xfe7a), (0xfe7c, 0xfe7c), (0xfe7e, 0xfe7e),
-    (0xff03, 0xff03), (0xff05, 0xff05), (0xff0f, 0xff0f), (0xff1a, 0xff1a), (0xff1c, 0xff1c), (0xff1e, 0xff20),
-    (0xff3b, 0xff3e), (0xff5c, 0xff5c), (0xffe3, 0xffe3), (0xfff9, 0xfffd), (0x110bd, 0x110bd), (0x110cd, 0x110cd),
-    (0x13430, 0x1343f), (0x1f100, 0x1f100), (0xe0001, 0xe0001), (0xe0020, 0xe007f), (0xf0000, 0xffffd),
-    (0x100000, 0x10fffd),
-)
-_IDNA_IGNORED = (
-    (0xad, 0xad), (0x34f, 0x34f), (0x180b, 0x180d), (0x180f, 0x180f), (0x200b, 0x200b), (0x2060, 0x2060),
-    (0x2064, 0x2064), (0xfe00, 0xfe0f), (0xfeff, 0xfeff), (0x1bca0, 0x1bca3), (0xe0100, 0xe01ef),
-)
-_IDNA_DOTS = re.compile("[.\u3002\uff0e\uff61]")
-_U32 = unicodedata.ucd_3_2_0
-_RTL_OK = {"R", "AL", "AN", "EN", "ES", "CS", "ET", "ON", "BN", "NSM"}
-_JOINERS = "\u200c\u200d"
-
-
-def _in_ranges(ranges: Sequence[tuple], cp: int) -> bool:
-    i = bisect.bisect_right(ranges, (cp, 0x10ffff)) - 1
-    return i >= 0 and ranges[i][0] <= cp <= ranges[i][1]
-
-
-def _known(c: str) -> bool:
-    return _U32.category(c) != "Cn" and unicodedata.category(c) != "Cn"
-
-
-def _joiner_refused(label: str, i: int) -> bool:
-    """CheckJoiners as Node 20 to 26 all read it: they find a joining context, or a virama, anywhere in the label
-    (`\u0628a\u200c\u0627` and `\u0628\u200c\u0627\u200d` parse), so only a joiner with nothing but ASCII beside it
-    in its label has none for certain."""
-    return all(c.isascii() for j, c in enumerate(label) if j != i)
-
-
-def _bidi_refused(label: str) -> bool:
-    """RFC 5893 as Node 20 to 26 all read it: only a label holding R, AL or AN is judged, and its first code point is
-    not (Node 26 alone refuses a label opening with a digit or a hyphen)."""
-    if not label or not all(_known(c) for c in label) or any(c in _JOINERS for c in label):
-        return False  # Node 20 to 26 pass a label holding a joiner over (`\u05d0a\u094d\u200d` parses)
-    k = [_U32.bidirectional(c) for c in label]
-    if not any(x in ("R", "AL", "AN") for x in k):
-        return False
-    body = list(k)
-    while body and body[-1] == "NSM":
-        body.pop()
-    if not body or body[-1] not in ("R", "AL", "EN", "AN"):
-        return True
-    return k[0] in ("R", "AL") and (any(x not in _RTL_OK for x in k) or ("EN" in k and "AN" in k))
-
-
-def _idna_host(host: str) -> Optional[str]:
-    """None where WHATWG's domain-to-ASCII refuses a non-ASCII host for certain; else the host as UTS46 maps it, read
-    as NFKC with case folding (exact enough for the ASCII rules that follow, which read digits and dots)."""
-    if any(_in_ranges(_IDNA_DISALLOWED, ord(c)) for c in host):
-        return None
-    kept = "".join(c for c in host if not _in_ranges(_IDNA_IGNORED, ord(c)))
-    if kept == "":
-        return None  # nothing left: an empty host
-    if not all(_known(c) for c in kept):
-        return host  # a code point this Python's Unicode does not know: the contextual rules are not read
-    mapped = unicodedata.normalize("NFC", unicodedata.normalize("NFKC", unicodedata.normalize("NFKC", kept).casefold()))
-    for label in _IDNA_DOTS.split(mapped):
-        first = label[:1]
-        if first and first not in "\u17b4\u17b5" and _U32.category(first)[0] == "M" and unicodedata.category(first)[0] == "M":
-            return None  # a label opening with a mark (U+17B4 and U+17B5 are ignored by the newer Nodes)
-        if any(c in _JOINERS and _joiner_refused(label, i) for i, c in enumerate(label)):
-            return None
-        if _bidi_refused(label):
-            return None
-    return _IDNA_DOTS.sub(".", mapped)
-
-
-def _ipv4_number(part: str) -> Optional[int]:
-    if part == "":
-        return None  # an empty part fails WHATWG's IPv4 parser (`1..2`); `0x` alone is 0
-    base = 10
-    if part[:2].lower() == "0x":
-        part, base = part[2:], 16
-    elif len(part) > 1 and part[0] == "0":
-        part, base = part[1:], 8
-    if part == "":
-        return 0
-    digits = {10: "0123456789", 16: "0123456789abcdefABCDEF", 8: "01234567"}[base]
-    return int(part, base) if all(c in digits for c in part) else None
-
-
-def _domain_ok(host: str) -> bool:
-    """The WHATWG host parser on a special scheme's host, enough to know when `new URL` refuses it."""
-    if host.startswith("["):
-        return host.endswith("]") and _ipv6_ok(host[1:-1])
-    if re.search(r"%(?![0-9A-Fa-f]{2})", host) is None:
-        try:
-            host = urllib.parse.unquote_to_bytes(host).decode("utf-8")
-        except UnicodeDecodeError:
-            return False
-    if any(c in _FORBIDDEN_DOMAIN for c in host):
-        return False
-    # A non-ASCII host goes through UTS46 in WHATWG; this module reads it narrowly (_idna_host, FAA-98). When unsure,
-    # the host is taken as valid, so its URL's credentials are read: the doubt then hides a list rather than publish one
-    # (round-2 reading). A host UTS46 maps to ASCII is read by the ASCII rules below (`１２７.０.０.１` is an address).
-    if any(ord(c) > 0x7f for c in host):
-        mapped = _idna_host(host)
-        if mapped is None:
-            return False
-        if not mapped.isascii() or any(c in _FORBIDDEN_DOMAIN for c in mapped):
-            return True
-        host = mapped
-    labels = host.split(".")
-    if labels and labels[-1] == "" and len(labels) > 1:
-        labels = labels[:-1]
-    last = labels[-1] if labels else ""
-    if not (last and (last.isdigit() and last.isascii() or re.fullmatch(r"0[xX][0-9A-Fa-f]*", last))):
-        return host != ""
-    numbers = [_ipv4_number(label) for label in labels]
-    if len(numbers) > 4 or any(n is None for n in numbers):
-        return False
-    return all(n <= 255 for n in numbers[:-1]) and numbers[-1] < 256 ** (5 - len(numbers))
-
-
-def _ipv6_ok(text: str) -> bool:
-    if "%" in text:
-        return False  # a zone id: `ipaddress` takes one, WHATWG does not
-    try:
-        ipaddress.IPv6Address(text)
-        return True
-    except ValueError:
-        return False
-
-
 _SURROGATE = re.compile("[\ud800-\udfff]")
 _QUERY_ENCODE = set(chr(c) for c in range(0x21)) | set('"#<>')
 _FRAGMENT_ENCODE = set(chr(c) for c in range(0x21)) | set('"<>`')
@@ -388,7 +243,7 @@ def _whatwg_parts(value: str) -> Optional[Dict[str, str]]:
             return None
     elif any(c in _FORBIDDEN_HOST for c in host):
         return None
-    elif host == "" and ("@" in authority or port):
+    elif host == "" and ("@" in authority or ":" in hostport):
         return None
     return {"password": password, "query": query, "fragment": fragment}
 
@@ -424,7 +279,7 @@ def _secret_url(value: str) -> bool:
 
 
 def _credential(value: str, runs: bool) -> bool:
-    return bool(JWT_SHAPE.search(value) or _KEY_SHAPE.search(value) or _BEARER.search(value)
+    return bool(has_jwt(value) or _KEY_SHAPE.search(value) or _BEARER.search(value)  # has_jwt: one pass (FAA-313)
                 or (runs and _long_run(value)) or any(_secret_url(url) for url in _urls_in(value)))
 
 

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_descriptor.py

@@ -55,7 +55,7 @@ from fabric_usage import (
 DASHBOARD_EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/dashboard/0.1"
 
 
-DASHBOARD_KIT = "fabric-dashboard-kit@1.1.6"
+DASHBOARD_KIT = "fabric-dashboard-kit@1.1.7"
 
 
 REFERENCE_THEMES = ("graphite", "fabric", "paper", "forest", "ocean", "ember", "contrast")

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_holds.py

@@ -55,6 +55,14 @@ LIFT_ACTION = "limit.lift"
 _MAX_STATUS_MESSAGE = 500
 _WAITING = re.compile(r"^waiting (daily-quota|caller-share|concurrency|money) since ([0-9][0-9TZ:.-]*?)(?:: ([\s\S]+))?\Z")
 _SIZES = ("jobs", "usd", "limit")
+#: One run of ECMAScript's whitespace, the class both twins squash with (FAA-316): Python's str.split() also takes
+#: U+001C to U+001F and U+0085 and not U+FEFF, so the twins wrote different statusMessages.
+_SPACES = re.compile("[%s]+" % fabric_secrets.JS_SPACE)
+
+
+def _squash(text: str) -> str:
+    """Runs of ECMAScript whitespace as one space, none at either end (the Node twin's `squash`)."""
+    return _SPACES.sub(" ", text).strip(" ")
 
 
 def _instant(value: Any, name: str) -> str:
@@ -75,10 +83,10 @@ def waiting_message(reason: str, since: str, until: Optional[str] = None, messag
     text = "waiting %s since %s" % (reason, since)
     head = len(QUOTA_EXHAUSTED) + (0 if until is None else len(" until ") + len(until)) + len(": ")
     if message is not None:
-        message = " ".join(str(message).split())
+        message = _squash(str(message))
         room = _MAX_STATUS_MESSAGE - head - len(text) - len(": ")
         if message and room > 0:
-            text += ": " + (message if len(message) <= room else message[:room - 3].rstrip() + "...")
+            text += ": " + (message if len(message) <= room else message[:room - 3].rstrip(" ") + "...")
     return pause_message(until, text)
 
 
@@ -124,11 +132,11 @@ def hold_sentence(caller: str, work: str, reason: str, until: Optional[str]) ->
 
 
 def _text(value: Any, name: str, high: int = 200) -> str:
-    if not isinstance(value, str) or not value.strip() or len(value) > high:
+    if not isinstance(value, str) or not _squash(value) or len(value) > high:
         raise ServiceError("%s is a text of 1 to %d characters." % (name, high))
     if fabric_secrets.secret_value(value):
         raise ServiceError("%s looks like a credential; a hold names callers and work, never a secret." % name)
-    return " ".join(value.split())
+    return _squash(value)
 
 
 class HoldBook:

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_http.py

@@ -73,8 +73,9 @@ class HttpError(Exception):
         self.retry_after_s = retry_after_s
         self.body = bytes(body[:2048])
         self.kind = kind  # http (an answer), connection, timeout, too-large, refused, foreign-user
-        #: For foreign-user, why (FAA-272): `table-restricted` (this process sees no other process's sockets, which
-        #: never clears), the owner's kind (`another-account`, `system`) or the check's reason (`no-row`).
+        #: For foreign-user, why (FAA-272): `table-restricted` (this process sees no other process's sockets, or on
+        #: macOS no row for this connection, DEC-0155 RT-1; it never clears), the owner's kind (`another-account`,
+        #: `system`) or the check's reason (`no-row`, from Linux and Windows only).
         self.reason = reason