@pi-unipi/background-tasks 2.6.1

package/src/ui/fusion-model-selector.ts

@@ -0,0 +1,322 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { Key, matchesKey, truncateToWidth, type Component } from '@earendil-works/pi-tui';
+import { CURRENT_MODEL_SELECTION, defaultFusionModelConfig } from '../fusion/config.js';
+import type { FusionModelConfigV1, FusionModelSelection } from '../fusion/types.js';
+
+export const FUSION_MODEL_SLOT_IDS = [
+  'candidate-1',
+  'candidate-2',
+  'candidate-3',
+  'evaluator',
+  'merger',
+] as const;
+
+export type FusionModelSlotId = (typeof FUSION_MODEL_SLOT_IDS)[number];
+
+export interface FusionModelChoice {
+  value: FusionModelSelection;
+  label: string;
+  description: string;
+  available: boolean;
+}
+
+export type FusionModelSelectorResult =
+  | { type: 'saved'; config: FusionModelConfigV1 }
+  | { type: 'cancelled' };
+
+export interface FusionModelSelectorOptions {
+  initialConfig: FusionModelConfigV1;
+  choices: readonly FusionModelChoice[];
+  theme: Theme;
+  onSave: (config: FusionModelConfigV1) => Promise<void>;
+  onDone: (result: FusionModelSelectorResult) => void;
+  onRenderRequest?: (() => void) | undefined;
+}
+
+type SelectorMode = 'slots' | 'models';
+
+interface SlotView {
+  id: FusionModelSlotId;
+  label: string;
+  value: FusionModelSelection;
+}
+
+function slotLabel(id: FusionModelSlotId): string {
+  if (id === 'candidate-1') return 'Candidate 1';
+  if (id === 'candidate-2') return 'Candidate 2';
+  if (id === 'candidate-3') return 'Candidate 3';
+  if (id === 'evaluator') return 'Evaluator';
+  return 'Merger';
+}
+
+function configValue(config: FusionModelConfigV1, id: FusionModelSlotId): FusionModelSelection {
+  if (id === 'candidate-1') return config.candidates[0];
+  if (id === 'candidate-2') return config.candidates[1];
+  if (id === 'candidate-3') return config.candidates[2];
+  if (id === 'evaluator') return config.evaluator;
+  return config.merger;
+}
+
+function updateConfig(
+  config: FusionModelConfigV1,
+  id: FusionModelSlotId,
+  value: FusionModelSelection,
+): FusionModelConfigV1 {
+  if (id === 'candidate-1')
+    return { ...config, candidates: [value, config.candidates[1], config.candidates[2]] };
+  if (id === 'candidate-2')
+    return { ...config, candidates: [config.candidates[0], value, config.candidates[2]] };
+  if (id === 'candidate-3')
+    return { ...config, candidates: [config.candidates[0], config.candidates[1], value] };
+  if (id === 'evaluator') return { ...config, evaluator: value };
+  return { ...config, merger: value };
+}
+
+function queryMatches(choice: FusionModelChoice, query: string): boolean {
+  if (query.length === 0) return true;
+  const haystack = `${choice.label} ${choice.description} ${choice.value}`.toLowerCase();
+  return haystack.includes(query.toLowerCase());
+}
+
+function printable(data: string): string | undefined {
+  if (data.length !== 1) return undefined;
+  const code = data.charCodeAt(0);
+  if (code < 32 || code === 127) return undefined;
+  return data;
+}
+
+function modelChoiceLine(choice: FusionModelChoice): string {
+  const status = choice.available ? '' : ' (unavailable)';
+  return `${choice.label}${status}${choice.description ? ` — ${choice.description}` : ''}`;
+}
+
+function slotViews(config: FusionModelConfigV1): SlotView[] {
+  return FUSION_MODEL_SLOT_IDS.map((id) => ({
+    id,
+    label: slotLabel(id),
+    value: configValue(config, id),
+  }));
+}
+
+export class FusionModelSelector implements Component {
+  private readonly choices: readonly FusionModelChoice[];
+  private readonly theme: Theme;
+  private readonly onSave: (config: FusionModelConfigV1) => Promise<void>;
+  private readonly onDone: (result: FusionModelSelectorResult) => void;
+  private readonly onRenderRequest: (() => void) | undefined;
+  private draft: FusionModelConfigV1;
+  private mode: SelectorMode = 'slots';
+  private selectedSlot = 0;
+  private selectedChoice = 0;
+  private search = '';
+  private saving = false;
+  private error: string | undefined;
+  private cachedWidth: number | undefined;
+  private cachedLines: string[] | undefined;
+
+  constructor(options: FusionModelSelectorOptions) {
+    this.draft = options.initialConfig;
+    this.choices = options.choices;
+    this.theme = options.theme;
+    this.onSave = options.onSave;
+    this.onDone = options.onDone;
+    this.onRenderRequest = options.onRenderRequest;
+  }
+
+  render(width: number): string[] {
+    if (this.cachedWidth === width && this.cachedLines !== undefined) return this.cachedLines;
+    const lines = this.mode === 'slots' ? this.renderSlots(width) : this.renderChoices(width);
+    this.cachedWidth = width;
+    this.cachedLines = lines.map((line) => truncateToWidth(line, Math.max(1, width)));
+    return this.cachedLines;
+  }
+
+  handleInput(data: string): void {
+    if (this.saving) return;
+    if (this.mode === 'slots') this.handleSlotInput(data);
+    else this.handleChoiceInput(data);
+  }
+
+  invalidate(): void {
+    this.cachedWidth = undefined;
+    this.cachedLines = undefined;
+  }
+
+  private renderSlots(width: number): string[] {
+    const slots = slotViews(this.draft);
+    const lines = [
+      this.theme.fg('accent', this.theme.bold('Fusion models')),
+      this.theme.fg('dim', 'Select five slots. Duplicate models are allowed.'),
+      '',
+    ];
+    for (const [index, slot] of slots.entries()) {
+      const marker = index === this.selectedSlot ? this.theme.fg('accent', '›') : ' ';
+      const value = this.describeSelection(slot.value);
+      lines.push(`${marker} ${slot.label.padEnd(12)} ${value}`);
+    }
+    lines.push('');
+    if (this.error !== undefined) lines.push(this.theme.fg('error', this.error));
+    const saveText = this.saving ? 'saving…' : 's save';
+    lines.push(this.theme.fg('dim', `↑↓ slot • enter choose • r reset • ${saveText} • esc cancel`));
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+
+  private renderChoices(width: number): string[] {
+    const selectedSlot = FUSION_MODEL_SLOT_IDS[this.selectedSlot];
+    const title =
+      selectedSlot === undefined ? 'Choose model' : `Choose model for ${slotLabel(selectedSlot)}`;
+    const filtered = this.filteredChoices();
+    const lines = [
+      this.theme.fg('accent', this.theme.bold(title)),
+      `${this.theme.fg('dim', 'Search:')} ${this.search || this.theme.fg('dim', '(type to filter)')}`,
+      '',
+    ];
+    if (filtered.length === 0) {
+      lines.push(this.theme.fg('warning', 'No matching models.'));
+    } else {
+      const windowStart = Math.max(
+        0,
+        Math.min(this.selectedChoice - 6, Math.max(0, filtered.length - 12)),
+      );
+      const windowItems = filtered.slice(windowStart, windowStart + 12);
+      for (const [offset, choice] of windowItems.entries()) {
+        const index = windowStart + offset;
+        const marker = index === this.selectedChoice ? this.theme.fg('accent', '›') : ' ';
+        const label = choice.available ? choice.label : this.theme.fg('warning', choice.label);
+        const description = choice.description
+          ? this.theme.fg('dim', ` — ${choice.description}`)
+          : '';
+        const stale = choice.available ? '' : this.theme.fg('warning', ' (unavailable)');
+        lines.push(`${marker} ${label}${stale}${description}`);
+      }
+      if (filtered.length > windowItems.length) {
+        lines.push(
+          this.theme.fg(
+            'dim',
+            `${String(windowStart + 1)}-${String(windowStart + windowItems.length)} of ${String(filtered.length)}`,
+          ),
+        );
+      }
+    }
+    lines.push('');
+    lines.push(this.theme.fg('dim', '↑↓ choose • enter apply • backspace edit search • esc back'));
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+
+  private handleSlotInput(data: string): void {
+    if (matchesKey(data, Key.up)) {
+      this.selectedSlot = Math.max(0, this.selectedSlot - 1);
+      this.changed();
+      return;
+    }
+    if (matchesKey(data, Key.down)) {
+      this.selectedSlot = Math.min(FUSION_MODEL_SLOT_IDS.length - 1, this.selectedSlot + 1);
+      this.changed();
+      return;
+    }
+    if (matchesKey(data, Key.enter) || data === '\r') {
+      this.mode = 'models';
+      this.search = '';
+      this.selectedChoice = this.selectedChoiceForCurrentSlot();
+      this.changed();
+      return;
+    }
+    if (data === 'r') {
+      this.draft = defaultFusionModelConfig();
+      this.error = undefined;
+      this.changed();
+      return;
+    }
+    if (data === 's') {
+      void this.save();
+      return;
+    }
+    if (matchesKey(data, Key.escape) || data === 'q') {
+      this.onDone({ type: 'cancelled' });
+    }
+  }
+
+  private handleChoiceInput(data: string): void {
+    const filtered = this.filteredChoices();
+    if (matchesKey(data, Key.up)) {
+      this.selectedChoice = Math.max(0, this.selectedChoice - 1);
+      this.changed();
+      return;
+    }
+    if (matchesKey(data, Key.down)) {
+      this.selectedChoice = Math.min(Math.max(0, filtered.length - 1), this.selectedChoice + 1);
+      this.changed();
+      return;
+    }
+    if (matchesKey(data, Key.enter) || data === '\r') {
+      const choice = filtered[this.selectedChoice];
+      const slot = FUSION_MODEL_SLOT_IDS[this.selectedSlot];
+      if (choice !== undefined && slot !== undefined) {
+        this.draft = updateConfig(this.draft, slot, choice.value);
+        this.mode = 'slots';
+        this.error = undefined;
+      }
+      this.changed();
+      return;
+    }
+    if (matchesKey(data, Key.escape)) {
+      this.mode = 'slots';
+      this.changed();
+      return;
+    }
+    if (matchesKey(data, Key.backspace) || data === '\x7f') {
+      this.search = this.search.slice(0, -1);
+      this.selectedChoice = 0;
+      this.changed();
+      return;
+    }
+    const char = printable(data);
+    if (char !== undefined) {
+      this.search += char;
+      this.selectedChoice = 0;
+      this.changed();
+    }
+  }
+
+  private async save(): Promise<void> {
+    this.saving = true;
+    this.error = undefined;
+    this.changed();
+    try {
+      await this.onSave(this.draft);
+      this.onDone({ type: 'saved', config: this.draft });
+    } catch (error) {
+      this.error = error instanceof Error ? error.message : String(error);
+      this.saving = false;
+      this.changed();
+    }
+  }
+
+  private changed(): void {
+    this.invalidate();
+    this.onRenderRequest?.();
+  }
+
+  private filteredChoices(): readonly FusionModelChoice[] {
+    return this.choices.filter((choice) => queryMatches(choice, this.search));
+  }
+
+  private selectedChoiceForCurrentSlot(): number {
+    const slot = FUSION_MODEL_SLOT_IDS[this.selectedSlot];
+    if (slot === undefined) return 0;
+    const current = configValue(this.draft, slot);
+    const filtered = this.filteredChoices();
+    const index = filtered.findIndex((choice) => choice.value === current);
+    return index >= 0 ? index : 0;
+  }
+
+  private describeSelection(value: FusionModelSelection): string {
+    if (value === CURRENT_MODEL_SELECTION) {
+      const current = this.choices.find((choice) => choice.value === CURRENT_MODEL_SELECTION);
+      return current === undefined ? CURRENT_MODEL_SELECTION : modelChoiceLine(current);
+    }
+    const found = this.choices.find((choice) => choice.value === value);
+    if (found === undefined) return `${value} (unavailable)`;
+    return modelChoiceLine(found);
+  }
+}

package/src/windows-taskkill.ts

@@ -0,0 +1,250 @@
+import { spawn as nodeSpawn, type SpawnOptions } from 'node:child_process';
+import { win32 } from 'node:path';
+
+export type WindowsKillPhase = 'terminate' | 'force';
+
+export interface TaskkillOutcome {
+  readonly exitCode: number | null;
+  readonly signal: NodeJS.Signals | null;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly stdoutTruncated: boolean;
+  readonly stderrTruncated: boolean;
+}
+
+interface TaskkillOutputStream {
+  on(event: 'data', listener: (data: Buffer | string) => void): unknown;
+}
+
+interface WindowsTaskkillChildProcess {
+  readonly stdout?: TaskkillOutputStream | null | undefined;
+  readonly stderr?: TaskkillOutputStream | null | undefined;
+  kill(signal?: NodeJS.Signals): boolean;
+  on(event: 'error', listener: (error: Error) => void): unknown;
+  on(
+    event: 'close',
+    listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+  ): unknown;
+}
+
+type WindowsTaskkillSpawn = (
+  command: string,
+  args: string[],
+  options: SpawnOptions,
+) => WindowsTaskkillChildProcess;
+
+export interface WindowsTaskkillOptions {
+  readonly spawn?: WindowsTaskkillSpawn;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly timeoutMs?: number;
+  readonly signal?: AbortSignal;
+  readonly maxCaptureBytes?: number;
+}
+
+const DEFAULT_TIMEOUT_MS = 5000;
+const DEFAULT_MAX_CAPTURE_BYTES = 8 * 1024;
+
+class BoundedCapture {
+  private readonly chunks: Buffer[] = [];
+  private capturedBytes = 0;
+  private truncated = false;
+
+  constructor(private readonly maxBytes: number) {}
+
+  append(data: Buffer | string): void {
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
+    if (buffer.length === 0) return;
+    const remaining = this.maxBytes - this.capturedBytes;
+    if (remaining > 0) {
+      const kept = buffer.length <= remaining ? buffer : buffer.subarray(0, remaining);
+      this.chunks.push(kept);
+      this.capturedBytes += kept.length;
+    }
+    if (buffer.length > Math.max(0, remaining)) this.truncated = true;
+  }
+
+  text(): string {
+    return Buffer.concat(this.chunks, this.capturedBytes).toString('utf8');
+  }
+
+  isTruncated(): boolean {
+    return this.truncated;
+  }
+}
+
+function lookupEnv(env: NodeJS.ProcessEnv, name: string): string | undefined {
+  const direct = env[name];
+  if (direct !== undefined) return direct;
+  const lowerName = name.toLowerCase();
+  for (const key of Object.keys(env)) {
+    if (key.toLowerCase() === lowerName) return env[key];
+  }
+  return undefined;
+}
+
+function validateWindowsRoot(raw: string, label: string): string {
+  const value = raw.trim();
+  if (value.length === 0) throw new Error(`${label} is empty; cannot resolve taskkill.exe`);
+  if (value.includes('\0')) throw new Error(`${label} contains a NUL byte; cannot resolve taskkill.exe`);
+  if (!win32.isAbsolute(value)) {
+    throw new Error(`${label} must be an absolute Windows path; cannot resolve taskkill.exe`);
+  }
+  return value;
+}
+
+export function resolveTaskkillPath(env: NodeJS.ProcessEnv = process.env): string {
+  const systemRoot = lookupEnv(env, 'SystemRoot');
+  if (systemRoot !== undefined) {
+    return win32.join(validateWindowsRoot(systemRoot, 'SystemRoot'), 'System32', 'taskkill.exe');
+  }
+
+  const windir = lookupEnv(env, 'WINDIR');
+  if (windir !== undefined) {
+    return win32.join(validateWindowsRoot(windir, 'WINDIR'), 'System32', 'taskkill.exe');
+  }
+
+  throw new Error('Cannot resolve taskkill.exe: SystemRoot is missing and WINDIR fallback is missing');
+}
+
+function validatePid(pid: number): void {
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    throw new Error(`Invalid Windows taskkill pid ${String(pid)}; expected a positive safe integer`);
+  }
+}
+
+function validatePhase(phase: WindowsKillPhase): void {
+  if (phase !== 'terminate' && phase !== 'force') {
+    throw new Error(`Invalid Windows taskkill phase ${String(phase)}`);
+  }
+}
+
+function positiveFiniteInteger(value: number | undefined, fallback: number, label: string): number {
+  const candidate = value ?? fallback;
+  if (!Number.isFinite(candidate) || candidate <= 0) {
+    throw new Error(`${label} must be a positive finite number`);
+  }
+  return Math.max(1, Math.floor(candidate));
+}
+
+function outcome(
+  exitCode: number | null,
+  signal: NodeJS.Signals | null,
+  stdout: BoundedCapture,
+  stderr: BoundedCapture,
+): TaskkillOutcome {
+  return {
+    exitCode,
+    signal,
+    stdout: stdout.text(),
+    stderr: stderr.text(),
+    stdoutTruncated: stdout.isTruncated(),
+    stderrTruncated: stderr.isTruncated(),
+  };
+}
+
+function defaultSpawn(command: string, args: string[], options: SpawnOptions): WindowsTaskkillChildProcess {
+  return nodeSpawn(command, args, options);
+}
+
+export function runWindowsTaskkill(
+  pid: number,
+  phase: WindowsKillPhase,
+  options: WindowsTaskkillOptions = {},
+): Promise<TaskkillOutcome> {
+  validatePid(pid);
+  validatePhase(phase);
+  const env = options.env ?? process.env;
+  const taskkill = resolveTaskkillPath(env);
+  const timeoutMs = positiveFiniteInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, 'timeoutMs');
+  const maxCaptureBytes = positiveFiniteInteger(
+    options.maxCaptureBytes,
+    DEFAULT_MAX_CAPTURE_BYTES,
+    'maxCaptureBytes',
+  );
+  const spawn = options.spawn ?? defaultSpawn;
+  const abortSignal = options.signal;
+
+  const args = ['/PID', String(pid), '/T'];
+  if (phase === 'force') args.push('/F');
+
+  if (abortSignal?.aborted) {
+    const stdout = new BoundedCapture(maxCaptureBytes);
+    const stderr = new BoundedCapture(maxCaptureBytes);
+    stderr.append('Windows taskkill was aborted before launch');
+    return Promise.resolve(outcome(null, null, stdout, stderr));
+  }
+
+  return new Promise<TaskkillOutcome>((resolve) => {
+    const stdout = new BoundedCapture(maxCaptureBytes);
+    const stderr = new BoundedCapture(maxCaptureBytes);
+    let settled = false;
+    let timeout: NodeJS.Timeout | undefined;
+    let child: WindowsTaskkillChildProcess | undefined;
+    let abortListener: (() => void) | undefined;
+
+    const settle = (result: TaskkillOutcome): void => {
+      if (settled) return;
+      settled = true;
+      if (timeout !== undefined) clearTimeout(timeout);
+      if (abortSignal !== undefined && abortListener !== undefined) {
+        abortSignal.removeEventListener('abort', abortListener);
+      }
+      resolve(result);
+    };
+
+    const stopHelper = (reason: string): void => {
+      stderr.append(reason);
+      if (child !== undefined) {
+        try {
+          child.kill('SIGKILL');
+        } catch (error) {
+          stderr.append(`; helper kill failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      settle(outcome(null, null, stdout, stderr));
+    };
+
+    const spawnOptions: SpawnOptions = {
+      env,
+      shell: false,
+      windowsVerbatimArguments: false,
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    };
+
+    try {
+      child = spawn(taskkill, args, spawnOptions);
+    } catch (error) {
+      stderr.append(`Windows taskkill spawn failed: ${error instanceof Error ? error.message : String(error)}`);
+      settle(outcome(null, null, stdout, stderr));
+      return;
+    }
+
+    child.stdout?.on('data', (data) => {
+      stdout.append(data);
+    });
+    child.stderr?.on('data', (data) => {
+      stderr.append(data);
+    });
+    child.on('error', (error) => {
+      stderr.append(`Windows taskkill spawn error: ${error.message}`);
+      settle(outcome(null, null, stdout, stderr));
+    });
+    child.on('close', (code, signal) => {
+      settle(outcome(code, signal, stdout, stderr));
+    });
+
+    abortListener = () => {
+      stopHelper('Windows taskkill was aborted');
+    };
+    abortSignal?.addEventListener('abort', abortListener, { once: true });
+
+    // This timeout is the settlement guarantee for a taskkill helper that never
+    // exits. It must keep the event loop alive: an unref'd timer lets the loop
+    // drain first and leaves this promise pending forever. `settle()` always
+    // clears it, so keeping it referenced cannot leak.
+    timeout = setTimeout(() => {
+      stopHelper(`Windows taskkill timed out after ${String(timeoutMs)}ms`);
+    }, timeoutMs);
+  });
+}