@volter/supercode-teams 0.2.81 → 0.2.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.81",
+  "version": "0.2.83",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",

package/popup-terminals.mjs

@@ -4,10 +4,10 @@
 // daemon's ConPTY host on Windows, holds it); the pane ending ends the client, and the terminal closes the window as
 // its command exits. Adapters are tried in rank order; SUPERCODE_POPUP_TERMINAL names one (or `none`).
 import { spawn, spawnSync } from 'node:child_process';
-import { chmodSync, existsSync, readdirSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { randomBytes } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { weztermConfigFile } from './terminal-look.mjs';
 
 const onPath = (name) => {
@@ -31,11 +31,12 @@ function selfDeletingScript(argv, extension) {
 // running process is on screen in about 0.3 s, where a process started per window took 0.7 to 2 s (measured on macOS
 // 26 with WezTerm 20240203). The process is known by its class; it listens on ~/.local/share/wezterm/gui-sock-<pid>.
 // A window goes into it with `wezterm cli spawn --new-window`, and when there is none, or the spawn fails, the window
-// starts it. The fallback runs in the launched shell, so the daemon never waits on WezTerm.
+// starts it. The fallback runs in the launched shell, so the daemon never waits on WezTerm. The class carries the
+// config's content: WezTerm does not reload it (terminal-look.mjs), so a process holding an older look is never reused.
 const WEZTERM_CLASS = 'dev.volter.supercode';
 
-/** The socket of a running supercode WezTerm process, or null. */
-function weztermSocket() {
+/** The socket of a running supercode WezTerm process of class `cls`, or null. */
+function weztermSocket(cls) {
   const dir = join(homedir(), '.local', 'share', 'wezterm');
   let names;
   try { names = readdirSync(dir); } catch { return null; }
@@ -44,15 +45,17 @@ function weztermSocket() {
     if (!pid) continue;
     try { process.kill(pid, 0); } catch { continue; }
     const command = spawnSync('ps', ['-p', String(pid), '-o', 'command='], { encoding: 'utf8', timeout: 2_000 }).stdout ?? '';
-    if (command.includes(`--class ${WEZTERM_CLASS}`)) return join(dir, name);
+    if (command.includes(`--class ${cls} `)) return join(dir, name);
   }
   return null;
 }
 
 /** WezTerm's launch: a window in supercode's running WezTerm, else a new one with supercode's look (terminal-look.mjs). */
 function weztermLaunch(program, argv) {
-  const start = [program, '--config-file', weztermConfigFile(), 'start', '--always-new-process', '--class', WEZTERM_CLASS, '--', ...argv];
-  const socket = process.platform === 'win32' ? null : weztermSocket();
+  const config = weztermConfigFile();
+  const cls = `${WEZTERM_CLASS}.${createHash('sha256').update(readFileSync(config)).digest('hex').slice(0, 12)}`;
+  const start = [program, '--config-file', config, 'start', '--always-new-process', '--class', cls, '--', ...argv];
+  const socket = process.platform === 'win32' ? null : weztermSocket(cls);
   if (!socket) return [start[0], start.slice(1)];
   const quote = (arg) => `'${String(arg).replaceAll("'", `'"'"'`)}'`;
   const spawnWindow = [program, 'cli', '--no-auto-start', 'spawn', '--new-window', '--', ...argv].map(quote).join(' ');

package/terminal-look.mjs

@@ -53,6 +53,38 @@ function run() {
   });
 }`;
 
+// AppKit's conversion of sRGB colours into each screen's colour space, keyed by the screen's scale. WezTerm writes its
+// colours to the screen unconverted, where Terminal.app's are colour-managed: on the owner's external monitor Clear
+// Dark's ground #212734 reached the glass as #212734 from WezTerm and as #1e242d from Terminal.app (#1d232d is AppKit's
+// conversion), so every colour looked lighter and bluer. Two screens at one scale share the main screen's conversion.
+const CONVERT_COLOURS = `
+ObjC.import('AppKit');
+function run(argv) {
+  const hexes = JSON.parse(argv[0]);
+  const two = (v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, '0');
+  const screens = $.NSScreen.screens, out = [];
+  for (let i = 0; i < screens.count; i++) {
+    const screen = screens.objectAtIndex(i), space = screen.colorSpace, map = {};
+    for (const hex of hexes) {
+      const [r, g, b] = [1, 3, 5].map((k) => parseInt(hex.slice(k, k + 2), 16) / 255);
+      const c = $.NSColor.colorWithSRGBRedGreenBlueAlpha(r, g, b, 1).colorUsingColorSpace(space);
+      map[hex] = '#' + two(c.redComponent) + two(c.greenComponent) + two(c.blueComponent);
+    }
+    out.push({ scale: screen.backingScaleFactor, map });
+  }
+  return JSON.stringify(out);
+}`;
+
+/** Each screen's conversion of `hexes` ([{ scale, map: { hex: hex } }], the main screen first); [] off macOS. */
+export function screenColours(hexes, platform = process.platform) {
+  if (platform !== 'darwin' || !hexes.length) return [];
+  try {
+    return JSON.parse(execFileSync('osascript', ['-l', 'JavaScript', '-e', CONVERT_COLOURS, JSON.stringify(hexes)], { encoding: 'utf8', timeout: 5_000, stdio: ['ignore', 'pipe', 'ignore'] }));
+  } catch {
+    return [];
+  }
+}
+
 /** This machine's Terminal.app default profile, as read by AppKit; null off macOS or when it cannot be read. */
 export function terminalAppProfile(platform = process.platform) {
   if (platform !== 'darwin') return null;
@@ -67,7 +99,7 @@ const hex = ([r, g, b]) => `#${[r, g, b].map((part) => Math.round(Math.min(1, Ma
 const lua = (value) => (typeof value === 'string' ? JSON.stringify(value) : String(value));
 
 /** WezTerm's config (Lua) for a window that looks like Terminal.app with `profile` (from terminalAppProfile, or null). */
-export function weztermConfig(profile, { fontDirs = existsSync(TERMINAL_FONTS) ? [TERMINAL_FONTS] : [] } = {}) {
+export function weztermConfig(profile, { fontDirs = existsSync(TERMINAL_FONTS) ? [TERMINAL_FONTS] : [], screens = [] } = {}) {
   const mac = fontDirs.length > 0;
   const stored = profile?.colors ?? {};
   // One colour table per appearance: the profile's colour where it stores one, else Basic's for that appearance.
@@ -93,8 +125,8 @@ export function weztermConfig(profile, { fontDirs = existsSync(TERMINAL_FONTS) ?
   // Terminal.app's cell is whole points: the advance rounded down (7 pt for SF Mono Terminal 12's 7.418) and the line
   // (ascent + descent + leading) rounded up (15 pt for 14.32), measured as 14 x 30 px on a Retina display. WezTerm rounds
   // its cell up to whole pixels before and after these factors, so the width factor is floor/ceil of the advance (14 px
-  // at 2x) and the height factor lands on the doubled line at 2x (30 px). Evidence stops at 2x: at 1x the same factors
-  // predict 7 x 16 px where Terminal.app draws 7 x 15.
+  // at 2x) and the height factor lands on the doubled line at 2x (30 px). Measured on both of the owner's displays: 14 x
+  // 30 px at 2x and 7 x 15 px at 1x, the same as Terminal.app's.
   const font = profile?.font;
   const advance = (font?.advance ?? 0) * (profile?.widthSpacing ?? 1);
   const cellWidth = advance > 0 ? Math.floor(advance) / Math.ceil(advance) : 1;
@@ -107,13 +139,32 @@ export function weztermConfig(profile, { fontDirs = existsSync(TERMINAL_FONTS) ?
   const opacity = alpha >= 0.9 ? 1 : alpha;
   const cursorShape = ['Block', 'Underline', 'Bar'][profile?.cursorType ?? 0] ?? 'Block';
   const composed = !profile?.optionIsMeta;
+  const light = scheme(TERMINAL_BASIC.light), dark = scheme(TERMINAL_BASIC.dark);
+  const convert = (colors, map) => Object.fromEntries(Object.entries(colors).map(([key, value]) => [key, Array.isArray(value) ? value.map((v) => map[v] ?? v) : map[value] ?? value]));
+  const entry = (key, map) => `  ${key} = { light = ${table(convert(light, map))}, dark = ${table(convert(dark, map))} },`;
+  const byScale = new Map();
+  for (const screen of screens) if (!byScale.has(screen.scale)) byScale.set(screen.scale, screen.map);
+  const palettes = [entry('main', screens[0]?.map ?? {}), ...[...byScale].map(([scale, map]) => entry(`[${scale}]`, map))].join('\n');
   const lines = [
     '-- Generated by supercode (sdk/teams/terminal-look.mjs): this window looks like Terminal.app' + (profile?.name ? ` with this machine's "${profile.name}" profile.` : "'s Basic profile."),
     "local wezterm = require 'wezterm'",
     'local config = wezterm.config_builder()',
-    `local schemes = {\n  light = ${table(scheme(TERMINAL_BASIC.light))},\n  dark = ${table(scheme(TERMINAL_BASIC.dark))},\n}`,
+    `local palettes = {\n${palettes}\n}`,
     "local appearance = wezterm.gui and wezterm.gui.get_appearance() or 'Dark'",
-    "config.colors = appearance:find('Dark') and schemes.dark or schemes.light",
+    "local function colours(scale) local p = palettes[scale] or palettes.main; return appearance:find('Dark') and p.dark or p.light end",
+    'config.colors = colours()',
+    // A window takes the palette converted for the screen it is on (by its scale), when it opens and when it moves.
+    'local shown = {}',
+    'local function fit(window)',
+    '  local scale = math.floor(window:get_dimensions().dpi / 72 + 0.5)',
+    '  if shown[window:window_id()] == scale then return end',
+    '  shown[window:window_id()] = scale',
+    '  local overrides = window:get_config_overrides() or {}',
+    '  overrides.colors = colours(scale)',
+    '  window:set_config_overrides(overrides)',
+    'end',
+    "wezterm.on('window-config-reloaded', fit)",
+    "wezterm.on('window-resized', fit)",
     `config.font_dirs = { ${fontDirs.map(lua).join(', ')} }`,
     ...(families.length ? [`config.font = wezterm.font_with_fallback({ ${families.join(', ')} })`] : []),
     // CoreText draws glyphs unhinted; FreeType's default hinting snaps their outlines to the pixel grid.
@@ -164,7 +215,10 @@ export function weztermConfig(profile, { fontDirs = existsSync(TERMINAL_FONTS) ?
 /** Writes the config for this machine, when it differs from the one on disk, and returns its path. */
 export function weztermConfigFile(platform = process.platform) {
   const path = join(tmpdir(), `supercode-wezterm-${process.getuid?.() ?? 'user'}.lua`);
-  const config = weztermConfig(terminalAppProfile(platform));
+  const profile = terminalAppProfile(platform);
+  const plain = weztermConfig(profile);
+  const hexes = [...new Set(plain.match(/#[0-9a-f]{6}/g) ?? [])];
+  const config = weztermConfig(profile, { screens: screenColours(hexes, platform) });
   let current = null;
   try { current = readFileSync(path, 'utf8'); } catch { /* not written yet */ }
   if (current === config) return path;