@yusukeshib/pi-babysit 0.6.35 → 0.6.37

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -265,8 +265,13 @@ Keys: `q` / `Ctrl-C` quit, `Ctrl-O` expand or collapse tool output, `t`
265
265
  toggle thinking blocks. `--print` renders the current transcript once to stdout;
266
266
  `--cwd DIR` overrides the worker directory used to shorten tool paths. Pi
267
267
  packages are loaded from the managed install (`~/.pi/agent/install`), the `pi`
268
- on `PATH`, or `PI_BABYSIT_PI_PACKAGE_DIR`. Built-in tools use Pi's renderers;
269
- extension tools fall back to generic rendering. Live `/babysit` and attach views render either profile, as well as logs
268
+ on `PATH`, or `PI_BABYSIT_PI_PACKAGE_DIR`. The viewer sets up the worker's
269
+ environment the way Pi does for its directory: settings (global and, for a
270
+ trusted project, project), themes from `settings.themes` and packages, terminal
271
+ colors, keybindings, and the extensions' tool, message and Markdown renderers.
272
+ Extensions are loaded but no session starts, so their session handlers never
273
+ run; missing packages are skipped, never installed; a project that Pi has not
274
+ been told to trust is loaded without its project-local resources. Live `/babysit` and attach views render either profile, as well as logs
270
275
  written by older pi-babysit releases.
271
276
 
272
277
  ## Execution timeouts
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@yusukeshib/pi-babysit",
3
- "version": "0.6.35",
3
+ "version": "0.6.37",
4
4
  "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
5
5
  "keywords": [
6
6
  "pi-package",
@@ -27,6 +27,7 @@
27
27
  "rpc-stream-format.mjs",
28
28
  "transcript-view.mjs",
29
29
  "pi-runtime.mjs",
30
+ "pi-environment.mjs",
30
31
  "view.mjs",
31
32
  "search-log.mjs",
32
33
  "gc.mjs",
@@ -0,0 +1,176 @@
1
+ /**
2
+ * pi-environment.mjs — reproduce the parts of Pi's interactive startup that
3
+ * decide how a transcript looks: settings, themes (including ones registered
4
+ * through `settings.themes` and packages), terminal capability overrides,
5
+ * keybindings, and extension tool / message renderers.
6
+ *
7
+ * Extensions are loaded the way Pi loads them (DefaultResourceLoader), but no
8
+ * session is started: extension factories run, session events never fire.
9
+ * Missing packages are skipped, never installed.
10
+ */
11
+ import os from "node:os";
12
+ import path from "node:path";
13
+
14
+ const SYSTEM_THEME_NAME = "system";
15
+
16
+ function call(target, method, ...args) {
17
+ return typeof target?.[method] === "function" ? target[method](...args) : undefined;
18
+ }
19
+
20
+ function defaultAgentDir(agent) {
21
+ return (
22
+ call(agent, "getAgentDir") ?? process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent")
23
+ );
24
+ }
25
+
26
+ /**
27
+ * Pi's project trust decision without prompting: a remembered decision, then
28
+ * "trusted" when the project has no trust-requiring resources, then the
29
+ * `defaultProjectTrust` setting. An undecided project stays untrusted, so the
30
+ * viewer never runs project-local extension code the user has not approved.
31
+ */
32
+ function resolveProjectTrusted({ runtime, cwd, agentDir }) {
33
+ const trust = runtime.internal?.trust;
34
+ const { SettingsManager } = runtime.agent;
35
+ try {
36
+ const remembered = trust?.ProjectTrustStore ? new trust.ProjectTrustStore(agentDir).get(cwd) : undefined;
37
+ if (remembered === true || remembered === false) return remembered;
38
+ const requiresTrust = trust?.hasTrustRequiringProjectResources?.(cwd) ?? true;
39
+ if (!requiresTrust) return true;
40
+ const global = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
41
+ return call(global, "getDefaultProjectTrust") === "always";
42
+ } catch {
43
+ return false;
44
+ }
45
+ }
46
+
47
+ async function loadResources({ runtime, cwd, agentDir, settingsManager, diagnostics }) {
48
+ const { DefaultResourceLoader } = runtime.agent;
49
+ if (typeof DefaultResourceLoader !== "function") return undefined;
50
+ const loader = new DefaultResourceLoader({
51
+ cwd,
52
+ agentDir,
53
+ settingsManager,
54
+ extensionFactories: runtime.internal?.builtInExtensions?.builtInExtensions ?? [],
55
+ noSkills: true,
56
+ noPromptTemplates: true,
57
+ noContextFiles: true,
58
+ });
59
+ const packageManager = loader.packageManager;
60
+ if (typeof packageManager?.resolve !== "function") {
61
+ diagnostics.push("Extensions not loaded: this Pi release does not allow resolving packages without installing them");
62
+ return undefined;
63
+ }
64
+ // A viewer must not install packages; Pi's startup prompts do the same.
65
+ const resolve = packageManager.resolve.bind(packageManager);
66
+ packageManager.resolve = (onMissing) => resolve(onMissing ?? (async () => "skip"));
67
+ await loader.reload();
68
+ return loader;
69
+ }
70
+
71
+ function createRenderContext({ runtime, settingsManager, extensions }) {
72
+ const { ExtensionRunner, getMarkdownTheme } = runtime.agent;
73
+ const runner =
74
+ extensions && typeof ExtensionRunner === "function"
75
+ ? new ExtensionRunner(extensions.extensions, extensions.runtime, undefined, undefined, undefined)
76
+ : undefined;
77
+ const builtIn = (name, definition) => runtime.withBuiltInRenderers?.(name, definition) ?? definition;
78
+ const mermaid = runtime.internal?.mermaid?.createMermaidMarkdownTransformer;
79
+ const themeProxy = runtime.internal?.theme?.theme;
80
+ const mermaidTransformer =
81
+ mermaid && themeProxy && typeof settingsManager?.getMermaidRenderingMode === "function"
82
+ ? mermaid({ getMode: () => settingsManager.getMermaidRenderingMode(), theme: themeProxy })
83
+ : undefined;
84
+ return {
85
+ // Same lookup as InteractiveMode.getRegisteredToolDefinition().
86
+ getToolDefinition(name) {
87
+ const base = () => builtIn(name, runner?.getToolDefinition(name));
88
+ return runner ? runner.resolveToolRenderers(name, base) : base();
89
+ },
90
+ getMessageRenderer: (customType) => runner?.getMessageRenderer(customType),
91
+ getMarkdownTransformers: () => [
92
+ ...(mermaidTransformer ? [mermaidTransformer] : []),
93
+ ...(runner?.getMarkdownTransformers() ?? []),
94
+ ],
95
+ markdownTheme: () => {
96
+ const codeBlockIndent = call(settingsManager, "getCodeBlockIndent");
97
+ return codeBlockIndent === undefined ? getMarkdownTheme() : { ...getMarkdownTheme(), codeBlockIndent };
98
+ },
99
+ hideThinkingBlock: call(settingsManager, "getHideThinkingBlock") === true,
100
+ outputPad: call(settingsManager, "getOutputPad"),
101
+ showImages: call(settingsManager, "getShowImages") ?? false,
102
+ imageWidthCells: call(settingsManager, "getImageWidthCells"),
103
+ };
104
+ }
105
+
106
+ /**
107
+ * Load { settingsManager, themes, render, diagnostics } for a worker running in
108
+ * `cwd`. `render` is the transcript-view render context.
109
+ */
110
+ export async function loadPiEnvironment(runtime, { cwd, agentDir = defaultAgentDir(runtime.agent) } = {}) {
111
+ const diagnostics = [];
112
+ const { SettingsManager } = runtime.agent;
113
+ let settingsManager;
114
+ let loader;
115
+ try {
116
+ settingsManager = SettingsManager.create(cwd, agentDir, {
117
+ projectTrusted: resolveProjectTrusted({ runtime, cwd, agentDir }),
118
+ });
119
+ loader = await loadResources({ runtime, cwd, agentDir, settingsManager, diagnostics });
120
+ } catch (error) {
121
+ diagnostics.push(`Pi resources not loaded: ${error instanceof Error ? error.message : String(error)}`);
122
+ }
123
+ const extensions = loader?.getExtensions();
124
+ for (const { path: extensionPath, error } of extensions?.errors ?? []) {
125
+ diagnostics.push(`Failed to load extension "${extensionPath}": ${error}`);
126
+ }
127
+ return {
128
+ settingsManager,
129
+ themes: loader?.getThemes().themes ?? [],
130
+ render: createRenderContext({ runtime, settingsManager, extensions }),
131
+ diagnostics,
132
+ };
133
+ }
134
+
135
+ /** Terminal capability overrides and keybindings, as interactive mode sets them. */
136
+ export function applyTerminalSettings(runtime, environment) {
137
+ const overrides = call(environment.settingsManager, "getTerminalCapabilityOverrides");
138
+ if (overrides) call(runtime.tui, "setCapabilityOverrides", overrides);
139
+ const KeybindingsManager = runtime.internal?.keybindings?.KeybindingsManager;
140
+ if (KeybindingsManager && typeof runtime.tui.setKeybindings === "function") {
141
+ try {
142
+ runtime.tui.setKeybindings(KeybindingsManager.create());
143
+ } catch {
144
+ /* default keybindings */
145
+ }
146
+ }
147
+ }
148
+
149
+ function themeName(runtime, settingsManager) {
150
+ const themeModule = runtime.internal?.theme;
151
+ const setting = call(settingsManager, "getThemeSetting") ?? call(settingsManager, "getTheme");
152
+ if (typeof themeModule?.resolveThemeSetting !== "function") return setting;
153
+ return themeModule.resolveThemeSetting(setting, call(themeModule, "getTerminalTheme")) ?? SYSTEM_THEME_NAME;
154
+ }
155
+
156
+ /**
157
+ * Apply the theme setting. With a `ui`, follow interactive mode: the returned
158
+ * `start()` (call after `ui.start()`) queries the terminal's colors and keeps
159
+ * the system theme and light/dark pairs in sync with the terminal. Without a
160
+ * `ui` (print mode) the theme is applied once.
161
+ */
162
+ export function initPiTheme(runtime, environment, ui) {
163
+ const themeModule = runtime.internal?.theme;
164
+ call(themeModule, "setRegisteredThemes", environment.themes);
165
+ const Controller = runtime.internal?.themeController?.InteractiveThemeController;
166
+ if (ui && Controller && environment.settingsManager) {
167
+ const controller = new Controller(ui, {
168
+ getSettingsManager: () => environment.settingsManager,
169
+ showError: () => {},
170
+ onChanged: () => {},
171
+ });
172
+ return { start: () => controller.applyFromSettings() };
173
+ }
174
+ runtime.agent.initTheme(themeName(runtime, environment.settingsManager), false);
175
+ return { start() {} };
176
+ }
package/pi-runtime.mjs CHANGED
@@ -67,32 +67,54 @@ function siblingPackageEntry(agentDir, name) {
67
67
  }
68
68
 
69
69
  /**
70
- * Load { agent, tui, withBuiltInRenderers, packageDir, version }.
71
- * withBuiltInRenderers is optional (an internal module of pi-coding-agent).
70
+ * Internal (non-exported) modules of pi-coding-agent that interactive mode
71
+ * uses to set up its chat. Each is optional: a pi release that moved or lacks
72
+ * one degrades to the closest public behavior instead of failing.
73
+ */
74
+ const INTERNAL_MODULES = {
75
+ renderers: "dist/core/tools/renderers/index.js",
76
+ builtInExtensions: "dist/extensions/index.js",
77
+ trust: "dist/core/trust-manager.js",
78
+ keybindings: "dist/core/keybindings.js",
79
+ theme: "dist/modes/interactive/theme/theme.js",
80
+ themeController: "dist/modes/interactive/theme/theme-controller.js",
81
+ mermaid: "dist/modes/interactive/components/mermaid.js",
82
+ };
83
+
84
+ async function importInternal(packageDir, relativePath) {
85
+ const file = path.join(packageDir, relativePath);
86
+ if (!fs.existsSync(file)) return undefined;
87
+ try {
88
+ return await import(pathToFileURL(file).href);
89
+ } catch {
90
+ return undefined;
91
+ }
92
+ }
93
+
94
+ /**
95
+ * Load { agent, tui, withBuiltInRenderers, internal, packageDir, version }.
96
+ * `internal` holds the optional internal modules (see INTERNAL_MODULES); they
97
+ * resolve to the same module instances the public entry point uses, so module
98
+ * state such as registered themes is shared.
72
99
  */
73
100
  export async function loadPiRuntime() {
74
101
  const packageDir = findPiPackageDir();
75
102
  let agent;
76
103
  let tui;
77
- let withBuiltInRenderers;
78
104
  let version;
105
+ const internal = {};
79
106
  if (packageDir) {
80
107
  const pkg = JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf8"));
81
108
  version = pkg.version;
82
109
  agent = await import(pathToFileURL(path.join(packageDir, pkg.exports?.["."]?.import ?? "dist/index.js")).href);
83
110
  const tuiEntry = siblingPackageEntry(packageDir, "pi-tui");
84
111
  tui = await import(tuiEntry ?? "@earendil-works/pi-tui");
85
- try {
86
- const renderers = await import(
87
- pathToFileURL(path.join(packageDir, "dist", "core", "tools", "renderers", "index.js")).href
88
- );
89
- withBuiltInRenderers = renderers.withBuiltInRenderers;
90
- } catch {
91
- /* generic tool rendering */
112
+ for (const [key, relativePath] of Object.entries(INTERNAL_MODULES)) {
113
+ internal[key] = await importInternal(packageDir, relativePath);
92
114
  }
93
115
  } else {
94
116
  agent = await import(AGENT_PACKAGE);
95
117
  tui = await import("@earendil-works/pi-tui");
96
118
  }
97
- return { agent, tui, withBuiltInRenderers, packageDir, version };
119
+ return { agent, tui, withBuiltInRenderers: internal.renderers?.withBuiltInRenderers, internal, packageDir, version };
98
120
  }
@@ -60,7 +60,24 @@ export function applyAssistantDelta(message, update) {
60
60
  }
61
61
  }
62
62
 
63
- export function createTranscriptView({ runtime, tui, cwd = process.cwd(), hideThinkingBlock = false }) {
63
+ /**
64
+ * Render context without a loaded Pi environment: built-in tool renderers only
65
+ * and default settings. pi-environment.mjs builds the full one.
66
+ */
67
+ export function defaultRenderContext(runtime) {
68
+ return {
69
+ getToolDefinition: (name) => runtime.withBuiltInRenderers?.(name, undefined),
70
+ getMessageRenderer: () => undefined,
71
+ getMarkdownTransformers: () => [],
72
+ markdownTheme: () => runtime.agent.getMarkdownTheme(),
73
+ hideThinkingBlock: false,
74
+ outputPad: undefined,
75
+ showImages: false,
76
+ imageWidthCells: undefined,
77
+ };
78
+ }
79
+
80
+ export function createTranscriptView({ runtime, tui, cwd = process.cwd(), render = defaultRenderContext(runtime) }) {
64
81
  const {
65
82
  AssistantMessageComponent,
66
83
  ToolExecutionComponent,
@@ -68,7 +85,8 @@ export function createTranscriptView({ runtime, tui, cwd = process.cwd(), hideTh
68
85
  CustomMessageComponent,
69
86
  CompactionSummaryMessageComponent,
70
87
  BranchSummaryMessageComponent,
71
- getMarkdownTheme,
88
+ SkillInvocationMessageComponent,
89
+ parseSkillBlock,
72
90
  } = runtime.agent;
73
91
  const { Container, Spacer, Text } = runtime.tui;
74
92
 
@@ -77,11 +95,14 @@ export function createTranscriptView({ runtime, tui, cwd = process.cwd(), hideTh
77
95
  const expandables = [];
78
96
  const assistants = [];
79
97
  let expanded = false;
80
- let hideThinking = hideThinkingBlock;
98
+ let hideThinking = render.hideThinkingBlock === true;
81
99
  let streaming;
82
100
 
83
- const markdownTheme = () => getMarkdownTheme();
84
- const toolDefinition = (name) => runtime.withBuiltInRenderers?.(name, undefined);
101
+ // Constructor arguments below follow interactive mode (InteractiveMode.handleEvent / addMessageToChat).
102
+ const markdownTheme = () => render.markdownTheme();
103
+ const transformers = () => render.getMarkdownTransformers();
104
+ const outputPad = render.outputPad;
105
+ const toolOptions = { showImages: render.showImages, imageWidthCells: render.imageWidthCells, outputPad };
85
106
  const add = (component) => {
86
107
  container.addChild(component);
87
108
  return component;
@@ -99,7 +120,7 @@ export function createTranscriptView({ runtime, tui, cwd = process.cwd(), hideTh
99
120
  function toolComponent(name, id, args) {
100
121
  let component = pendingTools.get(id);
101
122
  if (component) return component;
102
- component = new ToolExecutionComponent(name, id, args ?? {}, { showImages: false }, toolDefinition(name), tui, cwd);
123
+ component = new ToolExecutionComponent(name, id, args ?? {}, toolOptions, render.getToolDefinition(name), tui, cwd);
103
124
  addExpandable(component);
104
125
  pendingTools.set(id, component);
105
126
  return component;
@@ -115,7 +136,15 @@ export function createTranscriptView({ runtime, tui, cwd = process.cwd(), hideTh
115
136
  }
116
137
 
117
138
  function newAssistant(message) {
118
- const component = new AssistantMessageComponent(undefined, hideThinking, markdownTheme());
139
+ // undefined label: the component's default, as in interactive mode before an extension changes it.
140
+ const component = new AssistantMessageComponent(
141
+ undefined,
142
+ hideThinking,
143
+ markdownTheme(),
144
+ undefined,
145
+ outputPad,
146
+ transformers(),
147
+ );
119
148
  assistants.push(component);
120
149
  add(component);
121
150
  component.updateContent(message, true);
@@ -142,19 +171,35 @@ export function createTranscriptView({ runtime, tui, cwd = process.cwd(), hideTh
142
171
  const text = userText(message);
143
172
  if (!text) return;
144
173
  if (container.children.length > 0) add(new Spacer(1));
145
- add(new UserMessageComponent(text, markdownTheme()));
174
+ const skillBlock = parseSkillBlock?.(text);
175
+ if (skillBlock && SkillInvocationMessageComponent) {
176
+ addExpandable(
177
+ new SkillInvocationMessageComponent(skillBlock, markdownTheme(), outputPad, transformers()),
178
+ );
179
+ if (skillBlock.userMessage) {
180
+ add(new Spacer(1));
181
+ add(new UserMessageComponent(skillBlock.userMessage, markdownTheme(), outputPad, transformers()));
182
+ }
183
+ return;
184
+ }
185
+ add(new UserMessageComponent(text, markdownTheme(), outputPad, transformers()));
146
186
  return;
147
187
  }
148
188
  case "custom":
149
- if (message.display) addExpandable(new CustomMessageComponent(message, undefined, markdownTheme()));
189
+ if (message.display) {
190
+ const renderer = render.getMessageRenderer(message.customType);
191
+ addExpandable(new CustomMessageComponent(message, renderer, markdownTheme(), outputPad, transformers()));
192
+ }
150
193
  return;
151
194
  case "compactionSummary":
152
195
  add(new Spacer(1));
153
- addExpandable(new CompactionSummaryMessageComponent(message, markdownTheme()));
196
+ addExpandable(
197
+ new CompactionSummaryMessageComponent(message, markdownTheme(), outputPad, transformers()),
198
+ );
154
199
  return;
155
200
  case "branchSummary":
156
201
  add(new Spacer(1));
157
- addExpandable(new BranchSummaryMessageComponent(message, markdownTheme()));
202
+ addExpandable(new BranchSummaryMessageComponent(message, markdownTheme(), outputPad, transformers()));
158
203
  return;
159
204
  default:
160
205
  return;
package/view.mjs CHANGED
@@ -13,6 +13,7 @@ import fs from "node:fs";
13
13
  import os from "node:os";
14
14
  import path from "node:path";
15
15
  import { pathToFileURL } from "node:url";
16
+ import { applyTerminalSettings, initPiTheme, loadPiEnvironment } from "./pi-environment.mjs";
16
17
  import { loadPiRuntime } from "./pi-runtime.mjs";
17
18
  import { createRpcEventRestorer } from "./rpc-stream-format.mjs";
18
19
  import { createTranscriptView } from "./transcript-view.mjs";
@@ -72,11 +73,6 @@ function sessionInfo(logPath) {
72
73
  };
73
74
  }
74
75
 
75
- function piSettings() {
76
- const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
77
- return readJson(path.join(agentDir, "settings.json")) ?? {};
78
- }
79
-
80
76
  /** Incremental JSONL reader: feed bytes, get complete event objects. */
81
77
  export function createLogReader(onEvent) {
82
78
  const restorer = createRpcEventRestorer();
@@ -122,6 +118,23 @@ function readFrom(file, offset) {
122
118
  return { text: buffer, offset: size, truncated: false };
123
119
  }
124
120
 
121
+ export function createViewerInputListener({ tui, getView, quit, onChange }) {
122
+ const key = (data, name) => tui.matchesKey?.(data, name) ?? false;
123
+ return (data) => {
124
+ // Input listeners run before Pi's focused-component key-release filter.
125
+ // Toggle once per press, not again on release or while holding the key.
126
+ if (tui.isKeyRelease?.(data) || tui.isKeyRepeat?.(data)) return { consume: true };
127
+ if (key(data, "q") || key(data, "ctrl+c") || data === "q" || data === "\x03") quit();
128
+ else if (key(data, "ctrl+o") || data === "\x0f") {
129
+ const view = getView();
130
+ view.setToolsExpanded(!view.expanded);
131
+ } else if (key(data, "t") || data === "t") getView().toggleThinking();
132
+ else return { consume: true };
133
+ onChange();
134
+ return { consume: true };
135
+ };
136
+ }
137
+
125
138
  export async function main(argv = process.argv.slice(2)) {
126
139
  const options = parseArgs(argv);
127
140
  if (options.help || !options.target) {
@@ -132,28 +145,44 @@ export async function main(argv = process.argv.slice(2)) {
132
145
  const info = sessionInfo(logPath);
133
146
  const cwd = options.cwd ?? info.meta?.cwd ?? process.cwd();
134
147
  const runtime = await loadPiRuntime();
135
- const settings = piSettings();
136
- runtime.agent.initTheme(settings.theme, false);
148
+ // The worker's settings, themes and extension renderers, as Pi loads them for its cwd.
149
+ const environment = await loadPiEnvironment(runtime, { cwd });
150
+ applyTerminalSettings(runtime, environment);
151
+ const newView = (tui) => createTranscriptView({ runtime, tui, cwd, render: environment.render });
137
152
 
138
153
  const decoder = new TextDecoder();
139
154
  if (options.print) {
140
- const stub = { requestRender() {} };
141
- const view = createTranscriptView({ runtime, tui: stub, cwd, hideThinkingBlock: settings.hideThinkingBlock === true });
155
+ initPiTheme(runtime, environment);
156
+ for (const message of environment.diagnostics) process.stderr.write(`${message}\n`);
157
+ const view = newView({ requestRender() {} });
142
158
  const reader = createLogReader((event) => view.apply(event));
143
159
  reader.push(decoder.decode(fs.readFileSync(logPath)));
144
160
  reader.end();
145
161
  const width = process.stdout.columns || 120;
146
- process.stdout.write(`${view.container.render(width).join("\n")}\n`);
162
+ await new Promise((resolve) => process.stdout.write(`${view.container.render(width).join("\n")}\n`, resolve));
147
163
  return 0;
148
164
  }
149
165
 
150
- const { ProcessTerminal, Text } = runtime.tui;
166
+ const { Container, ProcessTerminal, Spacer, Text } = runtime.tui;
151
167
  // Pi >= 1.5 renders regular (scrollback) mode with TuiMainScreen; older
152
168
  // pi-tui releases export the TUI class itself.
153
169
  const Screen = runtime.tui.TuiMainScreen ?? runtime.tui.TUI;
154
170
  if (typeof Screen !== "function") throw new Error("Unsupported pi-tui: no TuiMainScreen or TUI export");
155
- const ui = new Screen(new ProcessTerminal());
156
- let view = createTranscriptView({ runtime, tui: ui, cwd, hideThinkingBlock: settings.hideThinkingBlock === true });
171
+ const settingsManager = environment.settingsManager;
172
+ const ui = new Screen(
173
+ new ProcessTerminal(),
174
+ settingsManager?.getShowHardwareCursor?.(),
175
+ runtime.agent.getAgentDir?.(),
176
+ );
177
+ if (settingsManager?.getClearOnShrink) ui.setClearOnShrink?.(settingsManager.getClearOnShrink());
178
+ const theme = initPiTheme(runtime, environment, ui);
179
+ if (environment.diagnostics.length > 0) {
180
+ const diagnostics = new Container();
181
+ for (const message of environment.diagnostics) diagnostics.addChild(new Text(`\x1b[31m${message}\x1b[0m`, 1, 0));
182
+ diagnostics.addChild(new Spacer(1));
183
+ ui.addChild(diagnostics);
184
+ }
185
+ let view = newView(ui);
157
186
  let reader = createLogReader((event) => view.apply(event));
158
187
  const status = new Text("", 1, 0);
159
188
  const statusLine = () => {
@@ -171,10 +200,10 @@ export async function main(argv = process.argv.slice(2)) {
171
200
  const chunk = readFrom(logPath, offset);
172
201
  if (chunk.truncated) {
173
202
  // The log was replaced; start over.
174
- ui.removeChild(view.container);
175
- view = createTranscriptView({ runtime, tui: ui, cwd, hideThinkingBlock: settings.hideThinkingBlock === true });
203
+ const index = ui.children.indexOf(view.container);
204
+ view = newView(ui);
176
205
  reader = createLogReader((event) => view.apply(event));
177
- ui.children.unshift(view.container);
206
+ ui.children.splice(index, 1, view.container);
178
207
  }
179
208
  offset = chunk.offset;
180
209
  if (chunk.text.length) reader.push(decoder.decode(chunk.text, { stream: true }));
@@ -187,20 +216,19 @@ export async function main(argv = process.argv.slice(2)) {
187
216
  ui.stop();
188
217
  process.exit(0);
189
218
  };
190
- // pi-tui may enable the kitty keyboard protocol, so compare parsed keys.
191
- const key = (data, name) => runtime.tui.matchesKey?.(data, name) ?? false;
192
- ui.addInputListener((data) => {
193
- if (key(data, "q") || key(data, "ctrl+c") || data === "q" || data === "\x03") quit();
194
- else if (key(data, "ctrl+o") || data === "\x0f") view.setToolsExpanded(!view.expanded);
195
- else if (key(data, "t") || data === "t") view.toggleThinking();
196
- else return { consume: true };
197
- statusLine();
198
- ui.requestRender();
199
- return { consume: true };
200
- });
219
+ ui.addInputListener(createViewerInputListener({
220
+ tui: runtime.tui,
221
+ getView: () => view,
222
+ quit,
223
+ onChange() {
224
+ statusLine();
225
+ ui.requestRender();
226
+ },
227
+ }));
201
228
 
202
229
  poll();
203
230
  ui.start();
231
+ theme.start();
204
232
  const timer = setInterval(poll, 200);
205
233
  return undefined;
206
234
  }
@@ -209,11 +237,12 @@ const entry = process.argv[1] ? pathToFileURL(fs.realpathSync(process.argv[1])).
209
237
  if (entry === import.meta.url) {
210
238
  main().then(
211
239
  (code) => {
212
- if (typeof code === "number") process.exitCode = code;
240
+ // Loaded extensions may keep timers alive; a finished one-shot run exits.
241
+ if (typeof code === "number") process.exit(code);
213
242
  },
214
243
  (error) => {
215
244
  console.error(error instanceof Error ? error.message : String(error));
216
- process.exitCode = 1;
245
+ process.exit(1);
217
246
  },
218
247
  );
219
248
  }