@volter/supercode-teams 0.2.70 → 0.2.72

package/README.md

@@ -82,6 +82,7 @@ supercode teams machine start                        # local door only
 supercode open --new bash --detach                   # a pane; prints its contextKey
 supercode open <ctx>                                 # attach; ctrl-] detaches
 supercode teams input <ctx> "make test"
+supercode teams input <ctx> --key Escape             # keys by tmux name: C-c, "Down Enter", …
 supercode teams title set <ctx> "rate-limit rescue"  # also names the owned tmux window
 supercode teams suspend <ctx>                        # remote input refused; observe keeps streaming
 supercode teams resume <ctx> --input "carry on"      # the input that hands the pane back

package/bin/teams.mjs

@@ -10,7 +10,7 @@
 //   machine status                                               the running daemon, if any
 //   describe                                     the host-key-signed statement
 //   panes ls | capture <pane> | close <pane>
-//   input <pane> <text> [--no-enter]
+//   input <pane> <text> [--no-enter] | input <pane> --key NAMES   text, or keys by tmux name (Escape, C-c, Down …)
 //   suspend <pane> [--interrupt] | resume <pane> [--input text]   refuse/allow remote input on a pane
 //   files ls|get|put|stat|search <path> [--out f] [--in f] [--query q]
 //   ports ls | resolve <pane>          port <pane>/<n> [--listen host:port]
@@ -45,7 +45,7 @@ import { NODE_PROTOCOL } from '@volter/teams/channel';
 
 const MACHINE_VERBS = new Set(['machine', 'describe', 'panes', 'input', 'suspend', 'resume', 'files', 'ports', 'port', 'browser', 'stream', 'jobs', 'workspace', 'title', 'attention', 'watch', 'rpc', 'log', 'mail']);
 // Every flag a machine verb reads; any other is refused rather than silently ignored.
-const KNOWN_FLAGS = new Set(['home', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'listen', 'list', 'from', 'to', 'path', 'to-path']);
+const KNOWN_FLAGS = new Set(['home', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path']);
 
 const argv = process.argv.slice(2);
 const flags = {};
@@ -90,6 +90,18 @@ const out = (value) => process.stdout.write((typeof value === 'string' ? value :
 const die = (message, code = 2) => { process.stderr.write(`supercode teams: ${message}\n`); process.exit(code); };
 if (!workspaceVerb) for (const flag of Object.keys(flags)) if (!KNOWN_FLAGS.has(flag)) die(`unknown flag: --${flag}`);
 
+/** Named keys (tmux's names) as the bytes a terminal sends for them: `panes.input` delivers
+ *  text without a trailing newline as a keystream, which every terminal host turns back into keys. */
+const KEY_BYTES = { Escape: '\u001b', Enter: '\r', Tab: '\t', BTab: '\u001b[Z', BSpace: '\u007f', Space: ' ', Up: '\u001b[A', Down: '\u001b[B', Right: '\u001b[C', Left: '\u001b[D', Home: '\u001b[H', End: '\u001b[F', PPage: '\u001b[5~', NPage: '\u001b[6~', DC: '\u001b[3~' };
+function keyBytes(names) {
+  return names.split(/[\s,]+/u).filter(Boolean).map((name) => {
+    const control = /^C-([a-z])$/iu.exec(name);
+    if (control) return String.fromCharCode(control[1].toLowerCase().charCodeAt(0) - 96);
+    if (!Object.hasOwn(KEY_BYTES, name)) die(`unknown key ${name}: one of ${Object.keys(KEY_BYTES).join(', ')}, C-a … C-z`);
+    return KEY_BYTES[name];
+  }).join('');
+}
+
 async function machineChannel() {
   return openMachine({ machine: flags.machine ? String(flags.machine) : null, context: flags.context ? String(flags.context) : null, home });
 }
@@ -198,6 +210,10 @@ async function main() {
       // `input <pane> <text>`: one delivery through the host's own sendInput; gated like control.
       // `--when-composer-empty`: a user's own turn, typed only into an empty composer
       // (answers `delivered: false` with the reason when it holds a draft).
+      if (flags.key !== undefined) {
+        if (flags.key === true || rest.length) die('input <pane> --key NAMES: keys by tmux name, space- or comma-separated (Escape, Enter, Tab, BTab, BSpace, Space, Up, Down, Left, Right, Home, End, PPage, NPage, DC, C-a … C-z)');
+        return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: keyBytes(String(flags.key)), submit: false })));
+      }
       if (flags['when-composer-empty']) return withNode(async (rpc) => out(await rpc.call('panes.turn', { pane: sub, text: rest.join(' ') })));
       return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: rest.join(' '), submit: !flags['no-enter'] })));
     case 'port': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.70",
+  "version": "0.2.72",
   "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/terminal-look.mjs

@@ -11,6 +11,11 @@ import { join } from 'node:path';
 import { TERMINAL_BASIC } from './terminal-basic.mjs';
 
 const TERMINAL_FONTS = '/System/Applications/Utilities/Terminal.app/Contents/Resources/Fonts';
+// Where CoreText finds a glyph Terminal.app's face lacks, in its order (CTFontCopyDefaultCascadeListForLanguages for
+// SFMonoTerminal-Regular, then the faces it picked for ⎿ and ⏺ on macOS 26): WezTerm's own fallbacks come after.
+// CoreText's cascade holds a subset of Apple Symbols (.AppleSymbolsFB) that lacks ⎿, which it draws from Hiragino
+// Sans; WezTerm reads the whole face, so Apple Symbols comes after the faces CoreText reached first.
+const MAC_CASCADE = ['Menlo', 'Monaco', 'Courier New', 'Helvetica', 'Lucida Grande', 'PingFang SC', 'Hiragino Sans', 'STIX Two Math', 'Apple Symbols', 'Apple Color Emoji'];
 const ANSI = ['Black', 'Red', 'Green', 'Yellow', 'Blue', 'Magenta', 'Cyan', 'White'];
 
 // Runs in osascript's JavaScript for Automation with the Objective-C bridge: no Apple Event is sent, so no automation
@@ -40,7 +45,7 @@ function run() {
   const font = archived('Font');
   return JSON.stringify({
     name, colors,
-    font: font && !font.isNil() ? { family: ObjC.unwrap(font.familyName), size: font.pointSize } : null,
+    font: font && !font.isNil() ? { family: ObjC.unwrap(font.familyName), size: font.pointSize, lineHeight: $.NSLayoutManager.alloc.init.defaultLineHeightForFont(font), ascender: font.ascender, descender: font.descender } : null,
     widthSpacing: value('FontWidthSpacing'), heightSpacing: value('FontHeightSpacing'),
     cursorType: value('CursorType'), cursorBlink: value('CursorBlink'), optionIsMeta: value('useOptionAsMetaKey'),
     bell: value('Bell'), visualBell: value('VisualBell'), brightBold: value('UseBrightBold'),
@@ -63,6 +68,7 @@ const lua = (value) => (typeof value === 'string' ? JSON.stringify(value) : Stri
 
 /** 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] : [] } = {}) {
+  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.
   const scheme = (basic) => {
@@ -79,7 +85,10 @@ export function weztermConfig(profile, { fontDirs = existsSync(TERMINAL_FONTS) ?
     };
   };
   const table = (colors) => `{\n${Object.entries(colors).map(([key, value]) => `    ${key} = ${Array.isArray(value) ? `{ ${value.map(lua).join(', ')} }` : lua(value)},`).join('\n')}\n  }`;
-  const families = [...new Set([profile?.font?.family, 'SF Mono Terminal', 'SF Mono', 'Menlo'].filter(Boolean))];
+  const families = mac ? [...new Set([profile?.font?.family ?? 'SF Mono Terminal', ...MAC_CASCADE])] : [];
+  // A row is AppKit's line height for the face (Terminal.app's), where WezTerm's is the face's ascent plus descent.
+  const font = profile?.font;
+  const rowScale = font?.lineHeight && font.ascender - font.descender > 0 ? font.lineHeight / (font.ascender - font.descender) : 1;
   const opacity = stored.BackgroundColor?.[3] ?? 1;
   const cursorShape = ['Block', 'Underline', 'Bar'][profile?.cursorType ?? 0] ?? 'Block';
   const composed = !profile?.optionIsMeta;
@@ -91,10 +100,14 @@ export function weztermConfig(profile, { fontDirs = existsSync(TERMINAL_FONTS) ?
     "local appearance = wezterm.gui and wezterm.gui.get_appearance() or 'Dark'",
     "config.colors = appearance:find('Dark') and schemes.dark or schemes.light",
     `config.font_dirs = { ${fontDirs.map(lua).join(', ')} }`,
-    `config.font = wezterm.font_with_fallback({ ${families.map(lua).join(', ')} })`,
+    ...(families.length ? [`config.font = wezterm.font_with_fallback({ ${families.map(lua).join(', ')} })`] : []),
+    // CoreText draws glyphs unhinted; FreeType's default hinting snaps their outlines to the pixel grid.
+    "config.freetype_load_flags = 'NO_HINTING'",
+    // Box and block characters are the face's own glyphs, as CoreText draws them, not WezTerm's drawn lines.
+    'config.custom_block_glyphs = false',
     `config.font_size = ${profile?.font?.size ?? TERMINAL_BASIC.fontSize}`,
     `config.cell_width = ${profile?.widthSpacing ?? 1}`,
-    `config.line_height = ${profile?.heightSpacing ?? 1}`,
+    `config.line_height = ${Number(((profile?.heightSpacing ?? 1) * rowScale).toFixed(4))}`,
     `config.default_cursor_style = ${lua(`${profile?.cursorBlink ? 'Blinking' : 'Steady'}${cursorShape}`)}`,
     `config.send_composed_key_when_left_alt_is_pressed = ${composed}`,
     `config.send_composed_key_when_right_alt_is_pressed = ${composed}`,