@pipod/cli 0.1.22 → 0.1.23

package/dist/{stdin-fragment-guard-SPIJC7GT.js → stdin-fragment-guard-DHHVSIXM.js}

@@ -14,6 +14,7 @@ var LONE_ESCAPE = "\x1B";
 var PASTE_START = "\x1B[200~";
 var CSI_START = "\x1B[";
 var NEGOTIATION_PREFIX = /^\x1b\[\?[\d;]*$/;
+var SGR_MOUSE_REPORT = /^\x1b\[<\d+;\d+;\d+[Mm]/;
 var PATCHED = /* @__PURE__ */ Symbol.for("pi-pod.stdin-fragment-guard");
 var dropped = 0;
 var held = /* @__PURE__ */ new WeakMap();
@@ -46,7 +47,7 @@ function guardStdinFragments() {
     held.delete(this);
     const text = typeof data === "string" ? data : Buffer.from(data).toString("utf8");
     const rejoined = fragment + text;
-    if (isKey(rejoined)) {
+    if (isKey(rejoined) || SGR_MOUSE_REPORT.test(rejoined)) {
       process.call(this, rejoined);
       return;
     }
@@ -58,4 +59,4 @@ function guardStdinFragments() {
 export {
   guardStdinFragments
 };
-//# sourceMappingURL=stdin-fragment-guard-SPIJC7GT.js.map
+//# sourceMappingURL=stdin-fragment-guard-DHHVSIXM.js.map

package/dist/stdin-fragment-guard-DHHVSIXM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client/runtime/stdin-fragment-guard.ts"],"sourcesContent":["/**\n * src/client/runtime/stdin-fragment-guard.ts — an incomplete escape fragment is never typed.\n *\n * pi-tui's StdinBuffer splits stdin into whole key sequences; whatever it cannot complete after\n * a short wait is flushed as keyboard input (50 ms for a partial sequence, 10 ms for a lone\n * ESC). That timeout exists so a real Escape key press is not held forever, but it also turns a\n * *fragment* into text: a key release arriving in two pieces types its tail — \"3\", \"u\" — at the\n * cursor, and behind a multiplexer a split is routine (measured: tmux forwards a split\n * verbatim). The same window swallows keystrokes that land while an unterminated terminal reply\n * is buffered.\n *\n * At the moment of the flush the distinction is exact: the buffer is either a lone ESC (a key)\n * or an unterminated escape sequence (never a key). Dropping the latter would leave its tail to\n * be typed instead, so the fragment is held for exactly one more read: if the bytes that follow\n * complete a key or fullscreen mouse report, the input is delivered as if it had never split.\n * Otherwise the fragment is discarded and those bytes are read on their own. Bounded by\n * construction — a held\n * fragment never survives the next chunk, so a stray fragment cannot swallow typing. Upstream\n * pi-tui still flushes these fragments (1.4.0 only rescues recognizable terminal *replies*), so\n * a version bump cannot fix it for us.\n *\n * This patches a pinned dependency's class, not our own code: it is deliberately narrow (only\n * the timeout flush and the read that may complete it), feature-detected, applied once, and\n * coupled to pi-tui 1.0.2's StdinBuffer contract. Re-check it on a pi-tui bump (the pin is\n * enforced by `npm run lint`).\n */\nimport {\n  decodeKittyPrintable,\n  isKeyRelease,\n  isKeyRepeat,\n  parseKey,\n  StdinBuffer,\n} from \"@earendil-works/pi-tui\";\nimport { debug } from \"../../log.js\";\n\nconst LONE_ESCAPE = \"\\x1b\";\n/** Pasted runs arrive complete; never drop a chunk that carries one. */\nconst PASTE_START = \"\\x1b[200~\";\n/**\n * pi-tui's terminal reassembles these *above* the buffer: a split kitty-flags or DA1 reply is\n * held there for its own window and joined to the next bytes. Leaving them untouched keeps that\n * working — the fragment guard only owns what nothing else would interpret.\n */\nconst CSI_START = \"\\x1b[\";\nconst NEGOTIATION_PREFIX = /^\\x1b\\[\\?[\\d;]*$/;\n/** A complete SGR mouse report; following reports/keystrokes belong to the same read. */\nconst SGR_MOUSE_REPORT = /^\\x1b\\[<\\d+;\\d+;\\d+[Mm]/;\n/** Set on the patched method so a second import (or a re-wire) cannot double-wrap it. */\nconst PATCHED = Symbol.for(\"pi-pod.stdin-fragment-guard\");\n/** Count of fragments dropped this process — reported only through debug logging. */\nlet dropped = 0;\n\n/** The fragment a timed-out flush released, waiting for the read that may complete it. */\nconst held = new WeakMap<StdinBuffer, string>();\n\ntype Flush = (this: StdinBuffer) => string[];\ntype Process = (this: StdinBuffer, data: string | Uint8Array) => void;\n\n/** True when `data` is one complete key, whatever the terminal encoded it as. */\nfunction isKey(data: string): boolean {\n  return (\n    parseKey(data) !== undefined ||\n    decodeKittyPrintable(data) !== undefined ||\n    isKeyRelease(data) ||\n    isKeyRepeat(data)\n  );\n}\n\n/**\n * Install the guard once per process. Safe to call from every session start: the prototype is\n * shared by the TUI pi builds and by this launcher, so one patch covers both.\n */\nexport function guardStdinFragments(): void {\n  const prototype = StdinBuffer.prototype as unknown as Record<PropertyKey, unknown> & {\n    flush: Flush;\n  };\n  if (prototype[PATCHED] === true) return;\n\n  const flush = prototype.flush;\n  const process = prototype.process;\n  if (typeof flush !== \"function\" || typeof process !== \"function\") return;\n  prototype[PATCHED] = true;\n  prototype.flush = function guardedFlush(this: StdinBuffer): string[] {\n    return flush.call(this).filter((sequence) => {\n      if (!sequence.startsWith(LONE_ESCAPE) || sequence === LONE_ESCAPE) return true;\n      if (sequence.includes(PASTE_START)) return true;\n      if (sequence === CSI_START || NEGOTIATION_PREFIX.test(sequence)) return true;\n      // A complete sequence would have been emitted already; anything here that does not parse\n      // is the unterminated remainder the timeout released.\n      if (parseKey(sequence) !== undefined) return true;\n      held.set(this, sequence);\n      return false;\n    });\n  };\n\n  prototype.process = function guardedProcess(this: StdinBuffer, data: string | Uint8Array): void {\n    const fragment = held.get(this);\n    if (fragment === undefined) {\n      process.call(this, data);\n      return;\n    }\n    held.delete(this);\n    const text = typeof data === \"string\" ? data : Buffer.from(data).toString(\"utf8\");\n    const rejoined = fragment + text;\n    // Fullscreen owns mouse input too. Dropping a timed-out report's head would type its\n    // coordinates into the editor. Let StdinBuffer split any coalesced input after the report.\n    if (isKey(rejoined) || SGR_MOUSE_REPORT.test(rejoined)) {\n      process.call(this, rejoined);\n      return;\n    }\n    // The tail never came: drop the fragment, keep the user's bytes intact.\n    dropped += 1;\n    debug(`stdin fragment guard: dropped ${JSON.stringify(fragment)} (${dropped} this session)`);\n    process.call(this, data);\n  };\n}\n"],"mappings":";;;;;AA0BA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP,IAAM,cAAc;AAEpB,IAAM,cAAc;AAMpB,IAAM,YAAY;AAClB,IAAM,qBAAqB;AAE3B,IAAM,mBAAmB;AAEzB,IAAM,UAAU,uBAAO,IAAI,6BAA6B;AAExD,IAAI,UAAU;AAGd,IAAM,OAAO,oBAAI,QAA6B;AAM9C,SAAS,MAAM,MAAuB;AACpC,SACE,SAAS,IAAI,MAAM,UACnB,qBAAqB,IAAI,MAAM,UAC/B,aAAa,IAAI,KACjB,YAAY,IAAI;AAEpB;AAMO,SAAS,sBAA4B;AAC1C,QAAM,YAAY,YAAY;AAG9B,MAAI,UAAU,OAAO,MAAM,KAAM;AAEjC,QAAM,QAAQ,UAAU;AACxB,QAAM,UAAU,UAAU;AAC1B,MAAI,OAAO,UAAU,cAAc,OAAO,YAAY,WAAY;AAClE,YAAU,OAAO,IAAI;AACrB,YAAU,QAAQ,SAAS,eAA0C;AACnE,WAAO,MAAM,KAAK,IAAI,EAAE,OAAO,CAAC,aAAa;AAC3C,UAAI,CAAC,SAAS,WAAW,WAAW,KAAK,aAAa,YAAa,QAAO;AAC1E,UAAI,SAAS,SAAS,WAAW,EAAG,QAAO;AAC3C,UAAI,aAAa,aAAa,mBAAmB,KAAK,QAAQ,EAAG,QAAO;AAGxE,UAAI,SAAS,QAAQ,MAAM,OAAW,QAAO;AAC7C,WAAK,IAAI,MAAM,QAAQ;AACvB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAEA,YAAU,UAAU,SAAS,eAAkC,MAAiC;AAC9F,UAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,QAAI,aAAa,QAAW;AAC1B,cAAQ,KAAK,MAAM,IAAI;AACvB;AAAA,IACF;AACA,SAAK,OAAO,IAAI;AAChB,UAAM,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO,KAAK,IAAI,EAAE,SAAS,MAAM;AAChF,UAAM,WAAW,WAAW;AAG5B,QAAI,MAAM,QAAQ,KAAK,iBAAiB,KAAK,QAAQ,GAAG;AACtD,cAAQ,KAAK,MAAM,QAAQ;AAC3B;AAAA,IACF;AAEA,eAAW;AACX,UAAM,iCAAiC,KAAK,UAAU,QAAQ,CAAC,KAAK,OAAO,gBAAgB;AAC3F,YAAQ,KAAK,MAAM,IAAI;AAAA,EACzB;AACF;","names":[]}

package/docs/fullscreen.md

@@ -0,0 +1,57 @@
+# Fullscreen Pi in pipod
+
+Pipod uses its bundled Pi renderer locally; fullscreen does not need a different pod image
+or a remote terminal. Launch or attach with an explicit layout:
+
+```sh
+pipod -- --tui-mode fullscreen
+pipod attach <pod> -- --tui-mode fullscreen
+pipod attach <pod> -- --tui-mode regular
+```
+
+The override applies only to this client. Without it, Pi uses the derived pod/host display
+settings. Fullscreen keeps the editor and footer fixed while the transcript scrolls in the
+alternate screen; regular mode uses the terminal's scrollback. `/settings` can switch layouts
+without disconnecting. Display changes made there are session-local, not saved account or
+template configuration.
+
+## Mouse preferences
+
+The pod's display projection includes `tuiMode`, `fullscreenExitOutput`,
+`fullscreenScrollbar`, `fullscreenCopyOnSelect` (boolean), and
+`fullscreenWheelScrollLines` (`"auto"` or an integer from 1 through 100). Invalid pod values
+are ignored; command-valued settings never cross this boundary. Host-only preferences remain
+local. Both the server's manifest producer and the CLI validator need the new fields for pod
+copy/scroll preferences to reach an attached client. An already-running shim keeps its old
+projection until restarted; a server source update alone does not change it.
+
+## Input compatibility
+
+Fullscreen captures mouse reports. A wheel/click/drag/release report split across reads,
+past pi-tui's sequence timeout, must still reach the renderer as one report—not type its
+coordinates into the editor. The [stdin fragment guard](keyboard-input.md) rejoins a complete
+SGR mouse report and preserves any following input in the same read. A malformed fragment
+still cannot swallow the next ordinary keystroke. This retains the existing bound: recovery
+covers the next read, not arbitrarily delayed multi-fragment streams.
+
+## Manual acceptance
+
+Use a real pod in an agent-owned tmux session. Build and invoke the checkout by absolute path;
+do not accidentally verify a globally installed CLI instead. Keep and archive only the pod
+you create. No model call is needed: `!` shell commands can generate transcript content.
+
+Check the alternate-screen/mouse flags, not only visible text. Exercise:
+
+- Startup and reattach with both explicit layouts and the default.
+- Narrow/wide terminal resizes; editor/footer stay visible and input remains usable.
+- Transcript keyboard and wheel scrolling, including split SGR reports ending in `M` and `m`.
+- A completed report followed by printable input in the same read; only the printable input
+  enters the editor. Malformed fragments must not discard ordinary typing.
+- `/settings` layout switching and the detach chord afterward.
+- Detach/quit returns to the main screen with mouse reporting off, and leaves the pod running.
+- Real generated shim → validated manifest → Pi's file-backed SettingsManager: both copy
+  booleans, `"auto"`, numeric wheel bounds, invalid values, and unchanged host-only settings.
+
+When sending a partial mouse report through tmux, use `send-keys -H` for its hex bytes. A
+trailing semicolon in a `send-keys -l` argument is a tmux command separator and can be removed,
+turning a valid intended report into malformed diagnostic input.

package/docs/keyboard-input.md

@@ -58,9 +58,12 @@ reply is buffered.
 
 At the flush the distinction is exact: the buffer is a lone ESC (a key) or an unterminated
 escape sequence (never a key). The guard holds the fragment for exactly the next read and
-rejoins it only if the two together parse as one key — a split release then behaves as if it
-had never split. Otherwise the fragment is discarded and the user's bytes are read on their
-own, so a stray fragment cannot swallow the next keystroke.
+rejoins it only if the two together parse as one key or start with a complete SGR mouse report
+(`ESC [ < button ; column ; row M/m`). Fullscreen mode captures wheel, click, drag and release
+reports: treating them as non-keys dropped the report's head and typed its coordinates into
+the editor. Any input coalesced after the completed report goes through `StdinBuffer` normally.
+Otherwise the fragment is discarded and the user's bytes are read on their own, so a stray
+fragment cannot swallow the next keystroke.
 
 Fragments shaped like pi-tui's own keyboard-protocol replies are left untouched: the terminal
 reassembles those above the buffer already, and the guard must not starve that path. A split

package/man/pipod-config.5

@@ -1,4 +1,4 @@
-.TH "PIPOD\-CONFIG" "5" "November 2026" "0.1.22"
+.TH "PIPOD\-CONFIG" "5" "November 2026" "0.1.23"
 .SH "NAME"
 \fBpipod-config\fR \- pi pod configuration files
 .SH SYNOPSIS

package/man/pipod.1

@@ -1,4 +1,4 @@
-.TH "PIPOD" "1" "November 2026" "0.1.22"
+.TH "PIPOD" "1" "November 2026" "0.1.23"
 .SH "NAME"
 \fBpipod\fR \- run pi coding\-agent sessions in server\-managed pods
 .SH SYNOPSIS

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pipod/cli",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pipod/cli",
-      "version": "0.1.22",
+      "version": "0.1.23",
       "license": "AGPL-3.0-only",
       "dependencies": {
         "@earendil-works/pi-coding-agent": "1.0.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipod/cli",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "Run pi coding-agent sessions in server-managed pods",
   "type": "module",
   "license": "AGPL-3.0-only",

package/dist/stdin-fragment-guard-SPIJC7GT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/client/runtime/stdin-fragment-guard.ts"],"sourcesContent":["/**\n * src/client/runtime/stdin-fragment-guard.ts — an incomplete escape fragment is never typed.\n *\n * pi-tui's StdinBuffer splits stdin into whole key sequences; whatever it cannot complete after\n * a short wait is flushed as keyboard input (50 ms for a partial sequence, 10 ms for a lone\n * ESC). That timeout exists so a real Escape key press is not held forever, but it also turns a\n * *fragment* into text: a key release arriving in two pieces types its tail — \"3\", \"u\" — at the\n * cursor, and behind a multiplexer a split is routine (measured: tmux forwards a split\n * verbatim). The same window swallows keystrokes that land while an unterminated terminal reply\n * is buffered.\n *\n * At the moment of the flush the distinction is exact: the buffer is either a lone ESC (a key)\n * or an unterminated escape sequence (never a key). Dropping the latter would leave its tail to\n * be typed instead, so the fragment is held for exactly one more read: if the bytes that follow\n * complete a key, the key is delivered as if it had never been split; if they do not, the\n * fragment is discarded and those bytes are read on their own. Bounded by construction — a held\n * fragment never survives the next chunk, so a stray fragment cannot swallow typing. Upstream\n * pi-tui still flushes these fragments (1.4.0 only rescues recognizable terminal *replies*), so\n * a version bump cannot fix it for us.\n *\n * This patches a pinned dependency's class, not our own code: it is deliberately narrow (only\n * the timeout flush and the read that may complete it), feature-detected, applied once, and\n * coupled to pi-tui 1.0.2's StdinBuffer contract. Re-check it on a pi-tui bump (the pin is\n * enforced by `npm run lint`).\n */\nimport {\n  decodeKittyPrintable,\n  isKeyRelease,\n  isKeyRepeat,\n  parseKey,\n  StdinBuffer,\n} from \"@earendil-works/pi-tui\";\nimport { debug } from \"../../log.js\";\n\nconst LONE_ESCAPE = \"\\x1b\";\n/** Pasted runs arrive complete; never drop a chunk that carries one. */\nconst PASTE_START = \"\\x1b[200~\";\n/**\n * pi-tui's terminal reassembles these *above* the buffer: a split kitty-flags or DA1 reply is\n * held there for its own window and joined to the next bytes. Leaving them untouched keeps that\n * working — the fragment guard only owns what nothing else would interpret.\n */\nconst CSI_START = \"\\x1b[\";\nconst NEGOTIATION_PREFIX = /^\\x1b\\[\\?[\\d;]*$/;\n/** Set on the patched method so a second import (or a re-wire) cannot double-wrap it. */\nconst PATCHED = Symbol.for(\"pi-pod.stdin-fragment-guard\");\n/** Count of fragments dropped this process — reported only through debug logging. */\nlet dropped = 0;\n\n/** The fragment a timed-out flush released, waiting for the read that may complete it. */\nconst held = new WeakMap<StdinBuffer, string>();\n\ntype Flush = (this: StdinBuffer) => string[];\ntype Process = (this: StdinBuffer, data: string | Uint8Array) => void;\n\n/** True when `data` is one complete key, whatever the terminal encoded it as. */\nfunction isKey(data: string): boolean {\n  return (\n    parseKey(data) !== undefined ||\n    decodeKittyPrintable(data) !== undefined ||\n    isKeyRelease(data) ||\n    isKeyRepeat(data)\n  );\n}\n\n/**\n * Install the guard once per process. Safe to call from every session start: the prototype is\n * shared by the TUI pi builds and by this launcher, so one patch covers both.\n */\nexport function guardStdinFragments(): void {\n  const prototype = StdinBuffer.prototype as unknown as Record<PropertyKey, unknown> & {\n    flush: Flush;\n  };\n  if (prototype[PATCHED] === true) return;\n\n  const flush = prototype.flush;\n  const process = prototype.process;\n  if (typeof flush !== \"function\" || typeof process !== \"function\") return;\n  prototype[PATCHED] = true;\n  prototype.flush = function guardedFlush(this: StdinBuffer): string[] {\n    return flush.call(this).filter((sequence) => {\n      if (!sequence.startsWith(LONE_ESCAPE) || sequence === LONE_ESCAPE) return true;\n      if (sequence.includes(PASTE_START)) return true;\n      if (sequence === CSI_START || NEGOTIATION_PREFIX.test(sequence)) return true;\n      // A complete sequence would have been emitted already; anything here that does not parse\n      // is the unterminated remainder the timeout released.\n      if (parseKey(sequence) !== undefined) return true;\n      held.set(this, sequence);\n      return false;\n    });\n  };\n\n  prototype.process = function guardedProcess(this: StdinBuffer, data: string | Uint8Array): void {\n    const fragment = held.get(this);\n    if (fragment === undefined) {\n      process.call(this, data);\n      return;\n    }\n    held.delete(this);\n    const text = typeof data === \"string\" ? data : Buffer.from(data).toString(\"utf8\");\n    const rejoined = fragment + text;\n    if (isKey(rejoined)) {\n      process.call(this, rejoined);\n      return;\n    }\n    // The tail never came: drop the fragment, keep the user's bytes intact.\n    dropped += 1;\n    debug(`stdin fragment guard: dropped ${JSON.stringify(fragment)} (${dropped} this session)`);\n    process.call(this, data);\n  };\n}\n"],"mappings":";;;;;AAyBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP,IAAM,cAAc;AAEpB,IAAM,cAAc;AAMpB,IAAM,YAAY;AAClB,IAAM,qBAAqB;AAE3B,IAAM,UAAU,uBAAO,IAAI,6BAA6B;AAExD,IAAI,UAAU;AAGd,IAAM,OAAO,oBAAI,QAA6B;AAM9C,SAAS,MAAM,MAAuB;AACpC,SACE,SAAS,IAAI,MAAM,UACnB,qBAAqB,IAAI,MAAM,UAC/B,aAAa,IAAI,KACjB,YAAY,IAAI;AAEpB;AAMO,SAAS,sBAA4B;AAC1C,QAAM,YAAY,YAAY;AAG9B,MAAI,UAAU,OAAO,MAAM,KAAM;AAEjC,QAAM,QAAQ,UAAU;AACxB,QAAM,UAAU,UAAU;AAC1B,MAAI,OAAO,UAAU,cAAc,OAAO,YAAY,WAAY;AAClE,YAAU,OAAO,IAAI;AACrB,YAAU,QAAQ,SAAS,eAA0C;AACnE,WAAO,MAAM,KAAK,IAAI,EAAE,OAAO,CAAC,aAAa;AAC3C,UAAI,CAAC,SAAS,WAAW,WAAW,KAAK,aAAa,YAAa,QAAO;AAC1E,UAAI,SAAS,SAAS,WAAW,EAAG,QAAO;AAC3C,UAAI,aAAa,aAAa,mBAAmB,KAAK,QAAQ,EAAG,QAAO;AAGxE,UAAI,SAAS,QAAQ,MAAM,OAAW,QAAO;AAC7C,WAAK,IAAI,MAAM,QAAQ;AACvB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAEA,YAAU,UAAU,SAAS,eAAkC,MAAiC;AAC9F,UAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,QAAI,aAAa,QAAW;AAC1B,cAAQ,KAAK,MAAM,IAAI;AACvB;AAAA,IACF;AACA,SAAK,OAAO,IAAI;AAChB,UAAM,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO,KAAK,IAAI,EAAE,SAAS,MAAM;AAChF,UAAM,WAAW,WAAW;AAC5B,QAAI,MAAM,QAAQ,GAAG;AACnB,cAAQ,KAAK,MAAM,QAAQ;AAC3B;AAAA,IACF;AAEA,eAAW;AACX,UAAM,iCAAiC,KAAK,UAAU,QAAQ,CAAC,KAAK,OAAO,gBAAgB;AAC3F,YAAQ,KAAK,MAAM,IAAI;AAAA,EACzB;AACF;","names":[]}