@agimon-ai/doompi-runner 0.0.1-alpha.9 → 0.0.1-alpha.91

package/README.md

@@ -1,47 +1,244 @@
 # @agimon-ai/doompi-runner
 
-Pi bash tool replacement with background process supervision.
+Supervised shell execution, background process control, durable logs, and Runner Space for Pi.
 
-Replaces the built-in bash tool with a supervised one. Long commands are backgrounded
-instead of blocking, a process tool manages them, and detached runs reconcile themselves
-after the context is rewritten.
+Part of the [DoomPi distribution](https://www.npmjs.com/package/@agimon-ai/doompi).
 
-Part of [Doompi](https://www.npmjs.com/package/@agimon-ai/doompi), a coding agent that loads
-only the skills and tools you name. This package is composed by Doompi and is not usually
-installed on its own.
+Runner replaces Pi's built-in `bash` tool only in sessions that load it. Short commands return
+inline; long commands can be promoted to a background runner instead of blocking the agent.
+
+> **Alpha:** tool and process contracts may change between releases.
+
+## Requirements
+
+- Node.js 22.19.0 or newer
+- Pi 0.85.0 and Pi TUI 0.85.0
+- `/bin/bash`
+- macOS or Linux on arm64 or x64 for bundled RMUX and RTK support
+
+Linux native loading also depends on a compatible system loader and libc. The bundled binaries are
+glibc-linked, so a musl host such as Alpine cannot run them.
+
+RTK is optional. Eligible commands return bounded raw output with an "RTK is unavailable" note
+when its binary is missing or cannot start. A synchronous spawn failure or an `ENOENT`, `EACCES`,
+or `ENOEXEC` spawn error disables further attempts for that `RtkProcessor` instance. Missing-path
+resolution and ordinary processing failures are not latched.
+
+Panes come from the first backend that answers: bundled RMUX, then `rmux` on PATH, then `tmux` on
+PATH. Only when none is available does a non-interactive command fall back to a supervised
+subprocess, and interactive commands need one of them. A tmux-backed run is supervised by the same
+host process as an RMUX one, so exit metadata and logs behave the same; its session names carry a
+`doom-tmux-` prefix rather than `doom-runner-`.
 
 ## Install
 
+`doompi init` and `dpi init` include Runner in `default.packages` in `.doom/modes.yaml`. Remove
+it to keep Pi's `bash`, or move it to a named layer to enable it only in selected major modes.
+For direct Pi installation:
+
+```bash
+pi install npm:@agimon-ai/doompi-runner
+```
+
+Pi discovers Runner's sole extension factory from `package.json.pi.extensions`. The extension joins
+the runner-scoped Cordis host and releases its plugin resources and host lease when the Pi session
+shuts down.
+
+## Use the `bash` tool
+
+```json
+{
+  "command": "pnpm test",
+  "timeout": 60
+}
+```
+
+Commands crossing the promotion threshold move to a supervised runner. The default threshold is 60
+seconds. Set `background: true` to detach immediately, or `interactive: true` only when a command
+needs terminal input.
+
+Runner requires `PI_SESSION_ID` for session ownership. Processes, controls, and logs remain
+addressable after transcript compaction because their identity is outside model context.
+
+### RTK result processing
+
+Runner keeps the complete original log, then uses the matching RTK stdin filter only for
+conservatively recognized single commands. Current safe mappings cover `cargo test`, `pytest`, plain
+unified `git diff`, structured `grep` or `rg`, `go test -json`, and JSON-formatted `ruff check`.
+Compound commands, pipelines, redirects, substitutions, incompatible formats, unsupported commands,
+and logs above RTK's 10 MiB stdin limit return bounded raw output instead. An eligible RTK failure
+also returns bounded raw output with a warning and does not change the command exit result.
+
+## Inspect and control runs
+
+Use `/runners` or `SPC r l` in the TUI. The `doom-runner` CLI supports:
+
 ```bash
-npm install @agimon-ai/doompi-runner
+doom-runner list
+doom-runner status <runner-id>
+doom-runner logs <runner-id>
+doom-runner input <runner-id> --text "y" --enter
+doom-runner stop <runner-id>
+doom-runner stop-all
 ```
 
-## How it loads
+The `input` command requires a running interactive process backed by RMUX or tmux.
+
+Stop runs that are no longer required.
 
-Name it in a layer in `.doom/modes.yaml`, then add that layer to a major mode:
+## Storage and limits
 
-```yaml
-layers:
-  runner:
-    packages: ['@agimon-ai/doompi-runner/extensions/pi']
+By default, session-scoped logs and registry data live under:
 
-majorMode:
-  dev: [runner]
+```text
+~/.pi/agent/doom-runner/<session>/
 ```
 
-## Leader
+Logs remain complete until TTL cleanup and are eligible for cleanup after seven days by default. The
+legacy log-size configuration exports remain available for compatibility but no longer rotate log
+content. Result limits, retention, and the promotion threshold remain environment-configurable.
+
+### Result excerpts
+
+A result that exceeds the ceiling is returned as an excerpt: roughly the first fifth of the budget
+holds the opening lines, the rest holds the closing ones, and a marker between them states how many
+lines were dropped.
+
+The budget depends on the exit status. A command that **failed** gets 8 KiB and 120 lines, because
+its output is the evidence. A command that **succeeded** gets 2 KiB, because exiting 0 has already
+reported the outcome and the rest is mostly progress lines and repeated warnings:
+
+```text
+Log excerpt (71 of 604 lines):
+$ pnpm build
+Compiling 1200 modules...
+  compiled src/module-0.ts
+… [5 lines elided] …
+  compiled src/module-599.ts
+Build succeeded in 12.4s
+exit status 0
+Full log: /path/to/run.log (17.0 KB, 604 lines); inspect with doom-runner logs run-a
+```
 
-`SPC r r` opens background processes, once the extension is loaded.
+Three ceilings apply and whichever binds first wins: bytes, lines, and tokens. Tokens are there
+because bytes do not track context cost. Measured against `gpt-tokenizer`, real text runs from about
+1.4 characters per token for base64 to 4.7 for English prose, so 8 KiB of one costs several times
+what 8 KiB of the other does. The defaults are 2,048 tokens on failure and 512 on success.
+
+Token counts are estimated rather than tokenized: truncation runs on every command and is
+synchronous, so loading a vocabulary would charge every session for a table most never need. The
+estimator models how BPE behaves, with punctuation forcing boundaries, natural words cheap, and
+letter-digit runs expensive. Its worst error against `gpt-tokenizer` is a factor of about 1.46
+either way, which is why the byte ceiling stays behind it as the hard bound.
+
+`DOOM_RUNNER_RESULT_MAX_BYTES`, `DOOM_RUNNER_RESULT_MAX_TOKENS`, and their
+`DOOM_RUNNER_SUCCESS_*` counterparts move these for one invocation. A pragma overrides all of
+them, which is how one noisy successful command can still ask for the wider result. Raising only
+`maxResultBytes` will not help when the token ceiling is the one binding.
+
+Error lines found in the dropped span are rescued into that marker's block, up to ten entries.
+Matching looks for a severity word in the first 60 characters, so `[widget] build: error TS2322`
+and a line behind a timestamp both count, while `0 errors`, `no failures`, and `--error-format` do
+not. Byte-identical lines collapse to one entry with an occurrence count. Lines that share a shape
+but differ in detail keep every variant, joined inside brackets so nothing actionable is lost:
+
+```text
+ERROR in [src/widget-100.ts:100:7|src/widget-200.ts:200:7] - Type mismatch
+error: connection refused (×40)
+```
 
-## Notes
+The complete raw log on disk is never truncated.
 
-Ships a prebuilt `rmux` binary per platform through the `@agimon-ai/doompi-runner-rmux-*`
-optional dependencies.
+### Configuration
 
-## Entry points
+Four layers, most specific first: a per-command pragma, then an environment variable, then project
+configuration, then the built-in default. Project configuration is the project's baseline, so an
+environment variable set for one invocation still wins over it.
 
-51 subpaths are declared in the `exports` field of `package.json`.
+One command that needs a wider result can say so on its first line. The pragma is a shell comment,
+so it stays harmless to the command itself:
+
+```bash
+# @doom: {"maxResultBytes": 32768, "maxResultTokens": 8192, "maxResultLines": 300}
+pnpm build
+```
+
+Project settings follow Pi's convention for extension configuration: one JSON file per extension
+under the config directory, at `.pi/doompi-runner.json`. It is read only when the project is
+trusted, and an unrecognized or out-of-range key is reported rather than silently ignored.
+
+```json
+{
+  "maxResultBytes": 16384,
+  "maxResultLines": 200,
+  "successMaxResultBytes": 2048,
+  "maxResultTokens": 2048,
+  "successMaxResultTokens": 512,
+  "headRatio": 0.2,
+  "errorPatterns": ["^FEHLER", "^\\s*FAILED\\b"],
+  "errorMaxEntries": 10,
+  "errorMaxVariantsJoined": 6,
+  "errorBudgetRatio": 0.2
+}
+```
+
+`errorPatterns` extends the built-in matcher rather than replacing it, which is what makes output
+it does not recognize reachable. Ceilings apply to every numeric key so a checked-in file cannot
+flood the model's context.
+
+Commands inherit the DoomPi process environment and the operating system user's privileges. Logs
+may contain prompts, source, command output, credentials, or other secrets; restrict access and
+retention accordingly.
+
+## Native artifacts
+
+Runner selects the matching optional dependencies automatically:
+
+| Host        | RMUX package                                 | RTK package                                 |
+| ----------- | -------------------------------------------- | ------------------------------------------- |
+| macOS arm64 | `@agimon-ai/doompi-runner-rmux-darwin-arm64` | `@agimon-ai/doompi-runner-rtk-darwin-arm64` |
+| macOS x64   | `@agimon-ai/doompi-runner-rmux-darwin-x64`   | `@agimon-ai/doompi-runner-rtk-darwin-x64`   |
+| Linux arm64 | `@agimon-ai/doompi-runner-rmux-linux-arm64`  | `@agimon-ai/doompi-runner-rtk-linux-arm64`  |
+| Linux x64   | `@agimon-ai/doompi-runner-rmux-linux-x64`    | `@agimon-ai/doompi-runner-rtk-linux-x64`    |
+
+Do not install platform packages directly. They contain native executables and export only package
+metadata. RMUX is dual-licensed under MIT or Apache-2.0. RTK v0.45.0 is licensed under Apache-2.0.
+
+## Public API
+
+```ts
+import {
+  createRunnerDependencies,
+  DEFAULT_BG_THRESHOLD_MS,
+  DEFAULT_LOG_MAX_BYTES,
+  DEFAULT_LOG_TTL_MS,
+  RmuxBackend,
+  rtkPackageForTarget,
+} from '@agimon-ai/doompi-runner';
+```
+
+Declared subpaths expose process supervision, configuration, tools, response envelopes, and TUI
+integration for host authors.
+
+## Development
+
+```bash
+pnpm build
+pnpm typecheck
+pnpm test
+pnpm lint
+```
+
+Maintained by [Agimon](https://agimon.ai/about).
 
 ## License
 
 MIT
+
+## Extension lifecycle and source layout
+
+`extensions/pi.ts` assembles the Runner UI runtime and native Bash tool declaration. `onStart` resolves the lazy service graph, subscribes to registry updates, and starts retention/status polling. `onStop` awaits initialization and pending operations, stops owned processes, closes PTYs and the registry, and releases telemetry. Partial startup closes an already opened registry.
+
+The Pi UI orchestration is in `tui/runnerRuntime.ts`; process and filesystem implementations live in `services/<name>/`. Controllers implement HTTP, CLI, and server command handling. `extensions/server.ts` composes the per-session supervision activity with those controllers. Model state, constants, and schemas have dedicated roots. The browser declaration lives directly in `extensions/web.ts`.
+
+Public capabilities use flat kebab-case subpaths such as `runner-dependencies`, `rmux-backend`, `runner-paths`, `bash-tool`, and `response-envelope`. Flat `src/exports/` files only forward these capabilities. Executable `bin/*` paths remain unchanged. The former nested service aliases and container entry are removed.

package/dist/ansiScrub-CsqTSaVT.mjs

@@ -0,0 +1,71 @@
+//#region src/constants/ansiScrub.ts
+const CONTROL_PATTERN = /[\u0007\u0008]/g;
+//#endregion
+//#region src/services/ansiScrub/index.ts
+/**
+* Turns terminal output into text worth grepping.
+*
+* PTY output is written for a screen, not a file: colours, cursor moves and
+* carriage-return redraws all end up in the byte stream. Without this a single
+* progress bar becomes thousands of near-identical log lines.
+*/
+/**
+* CSI sequences (colours, cursor moves), OSC strings, the two-byte Fe escapes,
+* and the keypad-mode escapes shells emit around every prompt.
+*/
+const ANSI_PATTERN = new RegExp([
+	"\\u001B\\[[0-9;?]*[ -/]*[@-~]",
+	"\\u001B\\][^\\u0007\\u001B]*(?:\\u0007|\\u001B\\\\)",
+	"\\u001B[@-Z\\\\-_]",
+	"\\u001B[=><]"
+].join("|"), "g");
+/** Bell and backspace, which a terminal consumes rather than displays. */
+/**
+* The same set minus SGR, the sequence that only sets colour and weight.
+*
+* The final byte class omits `m`, so `ESC[32m` survives while cursor moves,
+* OSC strings and keypad escapes are still removed.
+*/
+const ANSI_PATTERN_KEEPING_COLOUR = new RegExp([
+	"\\u001B\\[[0-9;?]*[ -/]*[@-ln-~]",
+	"\\u001B\\][^\\u0007\\u001B]*(?:\\u0007|\\u001B\\\\)",
+	"\\u001B[@-Z\\\\-_]",
+	"\\u001B[=><]"
+].join("|"), "g");
+/** Removes escape sequences, leaving the characters a user would have seen. */
+function stripAnsi(text) {
+	return text.replace(ANSI_PATTERN, "").replace(CONTROL_PATTERN, "");
+}
+/**
+* Removes everything `stripAnsi` does except colour.
+*
+* Logs are read back by a terminal renderer as well as by grep, and a command
+* that colours its own output has already said how it should look.
+*/
+function stripAnsiKeepingColour(text) {
+	return text.replace(ANSI_PATTERN_KEEPING_COLOUR, "").replace(CONTROL_PATTERN, "");
+}
+/**
+* Collapses carriage-return redraws.
+*
+* A bare `\r` returns the cursor to the start of the current line, so whatever
+* follows overwrites it. Only the final state of each line is kept. The `\r` of
+* a CRLF pair is a line terminator rather than a redraw, so it is normalised
+* away first: a pseudo terminal ends every line that way, and treating it as a
+* redraw would blank the whole log.
+*/
+function collapseCarriageReturns(text) {
+	return text.replace(/\r\n/g, "\n").split("\n").map((line) => line.includes("\r") ? line.split("\r").at(-1) ?? "" : line).join("\n");
+}
+/** Full scrub applied to PTY output before it reaches the log file. */
+function scrubTerminalOutput(text) {
+	return collapseCarriageReturns(stripAnsiKeepingColour(text));
+}
+/** Plain-text scrub, for the copy the model reads. */
+function scrubTerminalOutputToPlainText(text) {
+	return collapseCarriageReturns(stripAnsi(text));
+}
+//#endregion
+export { stripAnsiKeepingColour as a, stripAnsi as i, scrubTerminalOutput as n, scrubTerminalOutputToPlainText as r, collapseCarriageReturns as t };
+
+//# sourceMappingURL=ansiScrub-CsqTSaVT.mjs.map

package/dist/ansiScrub-CsqTSaVT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ansiScrub-CsqTSaVT.mjs","names":[],"sources":["../src/constants/ansiScrub.ts","../src/services/ansiScrub/index.ts"],"sourcesContent":["// oxlint-disable-next-line no-control-regex -- matching terminal control bytes is the whole job\nexport const CONTROL_PATTERN = /[\\u0007\\u0008]/g;\n","import { CONTROL_PATTERN } from '../../constants/ansiScrub';\n/**\n * Turns terminal output into text worth grepping.\n *\n * PTY output is written for a screen, not a file: colours, cursor moves and\n * carriage-return redraws all end up in the byte stream. Without this a single\n * progress bar becomes thousands of near-identical log lines.\n */\n\n/**\n * CSI sequences (colours, cursor moves), OSC strings, the two-byte Fe escapes,\n * and the keypad-mode escapes shells emit around every prompt.\n */\nconst ANSI_PATTERN = new RegExp(\n  [\n    '\\\\u001B\\\\[[0-9;?]*[ -/]*[@-~]',\n    '\\\\u001B\\\\][^\\\\u0007\\\\u001B]*(?:\\\\u0007|\\\\u001B\\\\\\\\)',\n    '\\\\u001B[@-Z\\\\\\\\-_]',\n    '\\\\u001B[=><]',\n  ].join('|'),\n  'g',\n);\n\n/** Bell and backspace, which a terminal consumes rather than displays. */\n// oxlint-disable-next-line no-control-regex -- matching terminal control bytes is the whole job\n\n/**\n * The same set minus SGR, the sequence that only sets colour and weight.\n *\n * The final byte class omits `m`, so `ESC[32m` survives while cursor moves,\n * OSC strings and keypad escapes are still removed.\n */\nconst ANSI_PATTERN_KEEPING_COLOUR = new RegExp(\n  [\n    '\\\\u001B\\\\[[0-9;?]*[ -/]*[@-ln-~]',\n    '\\\\u001B\\\\][^\\\\u0007\\\\u001B]*(?:\\\\u0007|\\\\u001B\\\\\\\\)',\n    '\\\\u001B[@-Z\\\\\\\\-_]',\n    '\\\\u001B[=><]',\n  ].join('|'),\n  'g',\n);\n\n/** Removes escape sequences, leaving the characters a user would have seen. */\nexport function stripAnsi(text: string): string {\n  return text.replace(ANSI_PATTERN, '').replace(CONTROL_PATTERN, '');\n}\n\n/**\n * Removes everything `stripAnsi` does except colour.\n *\n * Logs are read back by a terminal renderer as well as by grep, and a command\n * that colours its own output has already said how it should look.\n */\nexport function stripAnsiKeepingColour(text: string): string {\n  return text.replace(ANSI_PATTERN_KEEPING_COLOUR, '').replace(CONTROL_PATTERN, '');\n}\n\n/**\n * Collapses carriage-return redraws.\n *\n * A bare `\\r` returns the cursor to the start of the current line, so whatever\n * follows overwrites it. Only the final state of each line is kept. The `\\r` of\n * a CRLF pair is a line terminator rather than a redraw, so it is normalised\n * away first: a pseudo terminal ends every line that way, and treating it as a\n * redraw would blank the whole log.\n */\nexport function collapseCarriageReturns(text: string): string {\n  return text\n    .replace(/\\r\\n/g, '\\n')\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? (line.split('\\r').at(-1) ?? '') : line))\n    .join('\\n');\n}\n\n/** Full scrub applied to PTY output before it reaches the log file. */\nexport function scrubTerminalOutput(text: string): string {\n  return collapseCarriageReturns(stripAnsiKeepingColour(text));\n}\n\n/** Plain-text scrub, for the copy the model reads. */\nexport function scrubTerminalOutputToPlainText(text: string): string {\n  return collapseCarriageReturns(stripAnsi(text));\n}\n"],"mappings":";AACA,MAAa,kBAAkB;;;;;;;;;;;;;;ACY/B,MAAM,eAAe,IAAI,OACvB;CACE;CACA;CACA;CACA;AACF,CAAC,CAAC,KAAK,GAAG,GACV,GACF;;;;;;;;AAWA,MAAM,8BAA8B,IAAI,OACtC;CACE;CACA;CACA;CACA;AACF,CAAC,CAAC,KAAK,GAAG,GACV,GACF;;AAGA,SAAgB,UAAU,MAAsB;CAC9C,OAAO,KAAK,QAAQ,cAAc,EAAE,CAAC,CAAC,QAAQ,iBAAiB,EAAE;AACnE;;;;;;;AAQA,SAAgB,uBAAuB,MAAsB;CAC3D,OAAO,KAAK,QAAQ,6BAA6B,EAAE,CAAC,CAAC,QAAQ,iBAAiB,EAAE;AAClF;;;;;;;;;;AAWA,SAAgB,wBAAwB,MAAsB;CAC5D,OAAO,KACJ,QAAQ,SAAS,IAAI,CAAC,CACtB,MAAM,IAAI,CAAC,CACX,KAAK,SAAU,KAAK,SAAS,IAAI,IAAK,KAAK,MAAM,IAAI,CAAC,CAAC,GAAG,EAAE,KAAK,KAAM,IAAK,CAAC,CAC7E,KAAK,IAAI;AACd;;AAGA,SAAgB,oBAAoB,MAAsB;CACxD,OAAO,wBAAwB,uBAAuB,IAAI,CAAC;AAC7D;;AAGA,SAAgB,+BAA+B,MAAsB;CACnE,OAAO,wBAAwB,UAAU,IAAI,CAAC;AAChD"}

package/dist/ansiScrub-D5gpHDch.cjs

@@ -0,0 +1,100 @@
+//#region src/constants/ansiScrub.ts
+const CONTROL_PATTERN = /[\u0007\u0008]/g;
+//#endregion
+//#region src/services/ansiScrub/index.ts
+/**
+* Turns terminal output into text worth grepping.
+*
+* PTY output is written for a screen, not a file: colours, cursor moves and
+* carriage-return redraws all end up in the byte stream. Without this a single
+* progress bar becomes thousands of near-identical log lines.
+*/
+/**
+* CSI sequences (colours, cursor moves), OSC strings, the two-byte Fe escapes,
+* and the keypad-mode escapes shells emit around every prompt.
+*/
+const ANSI_PATTERN = new RegExp([
+	"\\u001B\\[[0-9;?]*[ -/]*[@-~]",
+	"\\u001B\\][^\\u0007\\u001B]*(?:\\u0007|\\u001B\\\\)",
+	"\\u001B[@-Z\\\\-_]",
+	"\\u001B[=><]"
+].join("|"), "g");
+/** Bell and backspace, which a terminal consumes rather than displays. */
+/**
+* The same set minus SGR, the sequence that only sets colour and weight.
+*
+* The final byte class omits `m`, so `ESC[32m` survives while cursor moves,
+* OSC strings and keypad escapes are still removed.
+*/
+const ANSI_PATTERN_KEEPING_COLOUR = new RegExp([
+	"\\u001B\\[[0-9;?]*[ -/]*[@-ln-~]",
+	"\\u001B\\][^\\u0007\\u001B]*(?:\\u0007|\\u001B\\\\)",
+	"\\u001B[@-Z\\\\-_]",
+	"\\u001B[=><]"
+].join("|"), "g");
+/** Removes escape sequences, leaving the characters a user would have seen. */
+function stripAnsi(text) {
+	return text.replace(ANSI_PATTERN, "").replace(CONTROL_PATTERN, "");
+}
+/**
+* Removes everything `stripAnsi` does except colour.
+*
+* Logs are read back by a terminal renderer as well as by grep, and a command
+* that colours its own output has already said how it should look.
+*/
+function stripAnsiKeepingColour(text) {
+	return text.replace(ANSI_PATTERN_KEEPING_COLOUR, "").replace(CONTROL_PATTERN, "");
+}
+/**
+* Collapses carriage-return redraws.
+*
+* A bare `\r` returns the cursor to the start of the current line, so whatever
+* follows overwrites it. Only the final state of each line is kept. The `\r` of
+* a CRLF pair is a line terminator rather than a redraw, so it is normalised
+* away first: a pseudo terminal ends every line that way, and treating it as a
+* redraw would blank the whole log.
+*/
+function collapseCarriageReturns(text) {
+	return text.replace(/\r\n/g, "\n").split("\n").map((line) => line.includes("\r") ? line.split("\r").at(-1) ?? "" : line).join("\n");
+}
+/** Full scrub applied to PTY output before it reaches the log file. */
+function scrubTerminalOutput(text) {
+	return collapseCarriageReturns(stripAnsiKeepingColour(text));
+}
+/** Plain-text scrub, for the copy the model reads. */
+function scrubTerminalOutputToPlainText(text) {
+	return collapseCarriageReturns(stripAnsi(text));
+}
+//#endregion
+Object.defineProperty(exports, "collapseCarriageReturns", {
+	enumerable: true,
+	get: function() {
+		return collapseCarriageReturns;
+	}
+});
+Object.defineProperty(exports, "scrubTerminalOutput", {
+	enumerable: true,
+	get: function() {
+		return scrubTerminalOutput;
+	}
+});
+Object.defineProperty(exports, "scrubTerminalOutputToPlainText", {
+	enumerable: true,
+	get: function() {
+		return scrubTerminalOutputToPlainText;
+	}
+});
+Object.defineProperty(exports, "stripAnsi", {
+	enumerable: true,
+	get: function() {
+		return stripAnsi;
+	}
+});
+Object.defineProperty(exports, "stripAnsiKeepingColour", {
+	enumerable: true,
+	get: function() {
+		return stripAnsiKeepingColour;
+	}
+});
+
+//# sourceMappingURL=ansiScrub-D5gpHDch.cjs.map

package/dist/ansiScrub-D5gpHDch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ansiScrub-D5gpHDch.cjs","names":[],"sources":["../src/constants/ansiScrub.ts","../src/services/ansiScrub/index.ts"],"sourcesContent":["// oxlint-disable-next-line no-control-regex -- matching terminal control bytes is the whole job\nexport const CONTROL_PATTERN = /[\\u0007\\u0008]/g;\n","import { CONTROL_PATTERN } from '../../constants/ansiScrub';\n/**\n * Turns terminal output into text worth grepping.\n *\n * PTY output is written for a screen, not a file: colours, cursor moves and\n * carriage-return redraws all end up in the byte stream. Without this a single\n * progress bar becomes thousands of near-identical log lines.\n */\n\n/**\n * CSI sequences (colours, cursor moves), OSC strings, the two-byte Fe escapes,\n * and the keypad-mode escapes shells emit around every prompt.\n */\nconst ANSI_PATTERN = new RegExp(\n  [\n    '\\\\u001B\\\\[[0-9;?]*[ -/]*[@-~]',\n    '\\\\u001B\\\\][^\\\\u0007\\\\u001B]*(?:\\\\u0007|\\\\u001B\\\\\\\\)',\n    '\\\\u001B[@-Z\\\\\\\\-_]',\n    '\\\\u001B[=><]',\n  ].join('|'),\n  'g',\n);\n\n/** Bell and backspace, which a terminal consumes rather than displays. */\n// oxlint-disable-next-line no-control-regex -- matching terminal control bytes is the whole job\n\n/**\n * The same set minus SGR, the sequence that only sets colour and weight.\n *\n * The final byte class omits `m`, so `ESC[32m` survives while cursor moves,\n * OSC strings and keypad escapes are still removed.\n */\nconst ANSI_PATTERN_KEEPING_COLOUR = new RegExp(\n  [\n    '\\\\u001B\\\\[[0-9;?]*[ -/]*[@-ln-~]',\n    '\\\\u001B\\\\][^\\\\u0007\\\\u001B]*(?:\\\\u0007|\\\\u001B\\\\\\\\)',\n    '\\\\u001B[@-Z\\\\\\\\-_]',\n    '\\\\u001B[=><]',\n  ].join('|'),\n  'g',\n);\n\n/** Removes escape sequences, leaving the characters a user would have seen. */\nexport function stripAnsi(text: string): string {\n  return text.replace(ANSI_PATTERN, '').replace(CONTROL_PATTERN, '');\n}\n\n/**\n * Removes everything `stripAnsi` does except colour.\n *\n * Logs are read back by a terminal renderer as well as by grep, and a command\n * that colours its own output has already said how it should look.\n */\nexport function stripAnsiKeepingColour(text: string): string {\n  return text.replace(ANSI_PATTERN_KEEPING_COLOUR, '').replace(CONTROL_PATTERN, '');\n}\n\n/**\n * Collapses carriage-return redraws.\n *\n * A bare `\\r` returns the cursor to the start of the current line, so whatever\n * follows overwrites it. Only the final state of each line is kept. The `\\r` of\n * a CRLF pair is a line terminator rather than a redraw, so it is normalised\n * away first: a pseudo terminal ends every line that way, and treating it as a\n * redraw would blank the whole log.\n */\nexport function collapseCarriageReturns(text: string): string {\n  return text\n    .replace(/\\r\\n/g, '\\n')\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? (line.split('\\r').at(-1) ?? '') : line))\n    .join('\\n');\n}\n\n/** Full scrub applied to PTY output before it reaches the log file. */\nexport function scrubTerminalOutput(text: string): string {\n  return collapseCarriageReturns(stripAnsiKeepingColour(text));\n}\n\n/** Plain-text scrub, for the copy the model reads. */\nexport function scrubTerminalOutputToPlainText(text: string): string {\n  return collapseCarriageReturns(stripAnsi(text));\n}\n"],"mappings":";AACA,MAAa,kBAAkB;;;;;;;;;;;;;;ACY/B,MAAM,eAAe,IAAI,OACvB;CACE;CACA;CACA;CACA;AACF,CAAC,CAAC,KAAK,GAAG,GACV,GACF;;;;;;;;AAWA,MAAM,8BAA8B,IAAI,OACtC;CACE;CACA;CACA;CACA;AACF,CAAC,CAAC,KAAK,GAAG,GACV,GACF;;AAGA,SAAgB,UAAU,MAAsB;CAC9C,OAAO,KAAK,QAAQ,cAAc,EAAE,CAAC,CAAC,QAAQ,iBAAiB,EAAE;AACnE;;;;;;;AAQA,SAAgB,uBAAuB,MAAsB;CAC3D,OAAO,KAAK,QAAQ,6BAA6B,EAAE,CAAC,CAAC,QAAQ,iBAAiB,EAAE;AAClF;;;;;;;;;;AAWA,SAAgB,wBAAwB,MAAsB;CAC5D,OAAO,KACJ,QAAQ,SAAS,IAAI,CAAC,CACtB,MAAM,IAAI,CAAC,CACX,KAAK,SAAU,KAAK,SAAS,IAAI,IAAK,KAAK,MAAM,IAAI,CAAC,CAAC,GAAG,EAAE,KAAK,KAAM,IAAK,CAAC,CAC7E,KAAK,IAAI;AACd;;AAGA,SAAgB,oBAAoB,MAAsB;CACxD,OAAO,wBAAwB,uBAAuB,IAAI,CAAC;AAC7D;;AAGA,SAAgB,+BAA+B,MAAsB;CACnE,OAAO,wBAAwB,UAAU,IAAI,CAAC;AAChD"}

package/dist/ansiScrub.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ansiScrub = require("./ansiScrub-D5gpHDch.cjs");
+exports.collapseCarriageReturns = require_ansiScrub.collapseCarriageReturns;
+exports.scrubTerminalOutput = require_ansiScrub.scrubTerminalOutput;
+exports.scrubTerminalOutputToPlainText = require_ansiScrub.scrubTerminalOutputToPlainText;
+exports.stripAnsi = require_ansiScrub.stripAnsi;
+exports.stripAnsiKeepingColour = require_ansiScrub.stripAnsiKeepingColour;

package/dist/{services/AnsiScrub/ansiScrub.d.mts → ansiScrub.d.mts}

@@ -1,20 +1,13 @@
-//#region src/services/AnsiScrub/ansiScrub.d.ts
-/**
- * Turns terminal output into text worth grepping.
- *
- * PTY output is written for a screen, not a file: colours, cursor moves and
- * carriage-return redraws all end up in the byte stream. Without this a single
- * progress bar becomes thousands of near-identical log lines.
- */
+//#region src/services/ansiScrub/index.d.ts
 /** Removes escape sequences, leaving the characters a user would have seen. */
-declare function stripAnsi(text: string): string;
+export declare function stripAnsi(text: string): string;
 /**
  * Removes everything `stripAnsi` does except colour.
  *
  * Logs are read back by a terminal renderer as well as by grep, and a command
  * that colours its own output has already said how it should look.
  */
-declare function stripAnsiKeepingColour(text: string): string;
+export declare function stripAnsiKeepingColour(text: string): string;
 /**
  * Collapses carriage-return redraws.
  *
@@ -24,11 +17,10 @@ declare function stripAnsiKeepingColour(text: string): string;
  * away first: a pseudo terminal ends every line that way, and treating it as a
  * redraw would blank the whole log.
  */
-declare function collapseCarriageReturns(text: string): string;
+export declare function collapseCarriageReturns(text: string): string;
 /** Full scrub applied to PTY output before it reaches the log file. */
-declare function scrubTerminalOutput(text: string): string;
+export declare function scrubTerminalOutput(text: string): string;
 /** Plain-text scrub, for the copy the model reads. */
-declare function scrubTerminalOutputToPlainText(text: string): string;
+export declare function scrubTerminalOutputToPlainText(text: string): string;
 //#endregion
-export { collapseCarriageReturns, scrubTerminalOutput, scrubTerminalOutputToPlainText, stripAnsi, stripAnsiKeepingColour };
 //# sourceMappingURL=ansiScrub.d.mts.map

package/dist/ansiScrub.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ansiScrub.d.mts","names":[],"sources":["../src/services/ansiScrub/index.ts"],"mappings":";;wBA2CgB,UAAU;;;;;;;wBAUV,uBAAuB;;;;;;;;;;wBAavB,wBAAwB;;wBASxB,oBAAoB;;wBAKpB,+BAA+B"}

package/dist/ansiScrub.mjs

@@ -0,0 +1,2 @@
+import { a as stripAnsiKeepingColour, i as stripAnsi, n as scrubTerminalOutput, r as scrubTerminalOutputToPlainText, t as collapseCarriageReturns } from "./ansiScrub-CsqTSaVT.mjs";
+export { collapseCarriageReturns, scrubTerminalOutput, scrubTerminalOutputToPlainText, stripAnsi, stripAnsiKeepingColour };

package/dist/apiContracts.cjs

@@ -0,0 +1,154 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+let _agimon_ai_doompi_core_apiContracts = require("@agimon-ai/doompi-core/apiContracts");
+let typebox = require("typebox");
+//#region src/schemas/apiContracts.ts
+const S = typebox.Type.String();
+const N = typebox.Type.Number();
+const B = typebox.Type.Boolean();
+const O = typebox.Type.Optional;
+const literals = (values) => typebox.Type.Union(values.map((value) => typebox.Type.Literal(value)));
+const Run = typebox.Type.Object({
+	id: S,
+	name: S,
+	pid: N,
+	command: S,
+	cwd: S,
+	interactive: B,
+	backend: literals([
+		"rmux",
+		"tmux",
+		"native"
+	]),
+	state: literals(["running", "completed"]),
+	promoted: B,
+	startedAt: S,
+	logPath: S,
+	exit: O(typebox.Type.Object({
+		reason: literals([
+			"completed",
+			"failed",
+			"signaled",
+			"stopped",
+			"timed_out",
+			"launcher_error",
+			"backend_lost"
+		]),
+		code: typebox.Type.Union([N, typebox.Type.Null()]),
+		signal: typebox.Type.Union([S, typebox.Type.Null()]),
+		stopReason: O(S),
+		finishedAt: S
+	}))
+});
+const RunnerPayloadSchema = typebox.Type.Object({ runs: typebox.Type.Array(Run) });
+const RunnerLogSchema = typebox.Type.Object({
+	runId: S,
+	running: B,
+	text: S,
+	lineCount: N,
+	totalLines: N,
+	fileSize: N,
+	completeBytes: N,
+	path: S,
+	exists: B,
+	lineNumbers: O(typebox.Type.Array(N))
+});
+const RunnerAppendSchema = typebox.Type.Object({
+	lines: typebox.Type.Array(S),
+	offset: O(N),
+	ended: O(B)
+});
+const RunnerScreenSchema = typebox.Type.Object({
+	chunk: S,
+	offset: O(N),
+	ended: O(B)
+});
+const apiContracts = (0, _agimon_ai_doompi_core_apiContracts.defineApiContract)({
+	version: 1,
+	dynamic: [],
+	http: [
+		{
+			id: "runner.log",
+			scope: "session",
+			basePath: "runner",
+			path: "/runners/{runId}/log",
+			method: "GET",
+			authentication: "owner",
+			description: "Read a runner log tail or literal substring search.",
+			parameters: [
+				"lines",
+				"grep",
+				"ignoreCase",
+				"contextLines"
+			].map((name) => ({
+				name,
+				in: "query",
+				required: false,
+				schema: S
+			})),
+			responses: (0, _agimon_ai_doompi_core_apiContracts.jsonApiResponses)(RunnerLogSchema)
+		},
+		...["log", "screen"].map((kind) => ({
+			id: `runner.${kind}.stream`,
+			scope: "session",
+			basePath: "runner",
+			path: `/runners/{runId}/${kind}/stream`,
+			method: "GET",
+			authentication: "owner",
+			description: `Follow runner ${kind}. SSE data is JSON; ping events carry empty data.`,
+			parameters: [{
+				name: "from",
+				in: "query",
+				required: false,
+				schema: N
+			}],
+			responses: {
+				"200": {
+					description: "Event stream.",
+					contentType: "text/event-stream",
+					schema: S,
+					events: {
+						[kind === "log" ? "append" : "screen"]: kind === "log" ? RunnerAppendSchema : RunnerScreenSchema,
+						ping: typebox.Type.Literal("")
+					}
+				},
+				"404": {
+					description: "Runner unavailable.",
+					schema: typebox.Type.Object({ error: S })
+				}
+			}
+		})),
+		{
+			id: "runner.input",
+			scope: "session",
+			basePath: "runner",
+			path: "/runners/{runId}/screen/input",
+			method: "POST",
+			authentication: "owner",
+			description: "Send text to an interactive runner.",
+			body: {
+				required: true,
+				contentType: "application/json",
+				schema: typebox.Type.Object({ text: typebox.Type.String({ minLength: 1 }) })
+			},
+			responses: (0, _agimon_ai_doompi_core_apiContracts.jsonApiResponses)(typebox.Type.Object({ delivered: typebox.Type.Literal(true) }))
+		}
+	],
+	sockets: ["global", "workspace"].map((scope) => ({
+		id: "runner.channel",
+		scope,
+		service: "doompi.hub.v1",
+		member: "runner_runs",
+		kind: "channel",
+		direction: "server-to-client",
+		description: "Runner channel payload in the hub frame payload property.",
+		input: RunnerPayloadSchema
+	}))
+});
+//#endregion
+exports.apiContracts = apiContracts;
+exports.default = apiContracts;
+
+//# sourceMappingURL=apiContracts.cjs.map