@aliou/pi-processes 0.5.0 → 0.6.1

package/src/commands/logs/command.ts

@@ -0,0 +1,47 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { LogOverlayComponent } from "../../components/log-overlay-component";
+import type { ProcessManager } from "../../manager";
+import { allProcessCompletions } from "../completions";
+
+export function registerPsLogsCommand(
+  pi: ExtensionAPI,
+  manager: ProcessManager,
+): void {
+  pi.registerCommand("ps:logs", {
+    description:
+      "Open log viewer for a process (search, scroll, stream filter)",
+    getArgumentCompletions: allProcessCompletions(manager),
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) return;
+
+      const arg = args.trim();
+      let processId: string | undefined;
+
+      if (arg) {
+        const proc = manager.find(arg);
+        if (!proc) return;
+        processId = proc.id;
+      }
+
+      await ctx.ui.custom<null>(
+        (_tui, theme, _kb, done) => {
+          return new LogOverlayComponent({
+            tui: _tui,
+            theme,
+            manager,
+            initialProcessId: processId,
+            done: () => done(null),
+          });
+        },
+        {
+          overlay: true,
+          overlayOptions: {
+            width: "90%",
+            maxHeight: "80%",
+            anchor: "center",
+          },
+        },
+      );
+    },
+  });
+}

package/src/commands/logs/index.ts

@@ -0,0 +1 @@
+export { registerPsLogsCommand } from "./command";

package/src/commands/pick-process.ts

@@ -0,0 +1,34 @@
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { ProcessPickerComponent } from "../components/process-picker-component";
+import type { ProcessInfo } from "../constants";
+import type { ProcessManager } from "../manager";
+
+export async function pickProcess(
+  ctx: ExtensionCommandContext,
+  manager: ProcessManager,
+  title: string,
+  filter?: (proc: ProcessInfo) => boolean,
+): Promise<string | undefined> {
+  if (!ctx.hasUI) {
+    return undefined;
+  }
+
+  const result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+    return new ProcessPickerComponent(
+      tui,
+      theme,
+      (processId?: string) => {
+        done(processId ?? null);
+      },
+      manager,
+      title,
+      filter,
+    );
+  });
+
+  if (result === undefined || result === null) {
+    return undefined;
+  }
+
+  return result;
+}

package/src/commands/pin/command.ts

@@ -0,0 +1,33 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { DockActions } from "../../hooks/widget";
+import type { ProcessManager } from "../../manager";
+import { allProcessCompletions } from "../completions";
+import { pickProcess } from "../pick-process";
+
+export function registerPsPinCommand(
+  pi: ExtensionAPI,
+  manager: ProcessManager,
+  dockActions: DockActions,
+): void {
+  pi.registerCommand("ps:pin", {
+    description: "Pin the dock to a specific process",
+    getArgumentCompletions: allProcessCompletions(manager),
+    handler: async (args, ctx) => {
+      const arg = args.trim();
+      let processId: string | undefined;
+
+      if (arg) {
+        const proc = manager.find(arg);
+        if (!proc) {
+          return;
+        }
+        processId = proc.id;
+      } else {
+        processId = await pickProcess(ctx, manager, "Select process to pin");
+        if (!processId) return;
+      }
+
+      dockActions.setFocus(processId);
+    },
+  });
+}

package/src/commands/pin/index.ts

@@ -0,0 +1 @@
+export { registerPsPinCommand } from "./command";

package/src/commands/processes/command.ts

@@ -0,0 +1,39 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { ProcessesComponent } from "../../components/processes-component";
+import type { DockActions } from "../../hooks/widget";
+import type { ProcessManager } from "../../manager";
+
+export function registerPsCommand(
+  pi: ExtensionAPI,
+  manager: ProcessManager,
+  dockActions: DockActions,
+): void {
+  pi.registerCommand("ps", {
+    description: "View and manage background processes",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        return;
+      }
+
+      const result = await ctx.ui.custom<string | null>(
+        (tui, theme, _keybindings, done) => {
+          return new ProcessesComponent(
+            tui,
+            theme,
+            (processId?: string) => {
+              if (processId) {
+                dockActions.setFocus(processId);
+              }
+              done(processId ?? null);
+            },
+            manager,
+          );
+        },
+      );
+
+      if (result === undefined) {
+        return;
+      }
+    },
+  });
+}

package/src/commands/processes/index.ts

@@ -0,0 +1 @@
+export { registerPsCommand } from "./command";

package/src/commands/settings/apply-setting-change.ts

@@ -0,0 +1,72 @@
+import type { ProcessesConfig } from "../../config";
+
+export function applySettingChange(
+  id: string,
+  newValue: string,
+  config: ProcessesConfig,
+): ProcessesConfig | null {
+  const updated = structuredClone(config);
+
+  if (id === "interception.blockBackgroundCommands") {
+    if (!updated.interception) updated.interception = {};
+    updated.interception.blockBackgroundCommands = newValue === "on";
+    return updated;
+  }
+  if (id === "widget.showStatusWidget") {
+    if (!updated.widget) updated.widget = {};
+    updated.widget.showStatusWidget = newValue === "on";
+    return updated;
+  }
+  if (id === "widget.dockDefaultState") {
+    if (!updated.widget) updated.widget = {};
+    updated.widget.dockDefaultState =
+      newValue === "hidden" ? "hidden" : "collapsed";
+    return updated;
+  }
+  if (id === "widget.dockHeight") {
+    if (!updated.widget) updated.widget = {};
+    updated.widget.dockHeight = Number.parseInt(newValue, 10);
+    return updated;
+  }
+  if (id === "follow.enabledByDefault") {
+    if (!updated.follow) updated.follow = {};
+    updated.follow.enabledByDefault = newValue === "on";
+    return updated;
+  }
+  if (id === "follow.autoHideOnFinish") {
+    if (!updated.follow) updated.follow = {};
+    updated.follow.autoHideOnFinish = newValue === "on";
+    return updated;
+  }
+  if (id === "execution.shellPath") {
+    if (!updated.execution) updated.execution = {};
+    updated.execution.shellPath = newValue === "auto" ? undefined : newValue;
+    return updated;
+  }
+
+  const num = Number.parseInt(newValue, 10);
+  if (Number.isNaN(num)) return null;
+
+  switch (id) {
+    case "processList.maxVisibleProcesses":
+      if (!updated.processList) updated.processList = {};
+      updated.processList.maxVisibleProcesses = num;
+      break;
+    case "processList.maxPreviewLines":
+      if (!updated.processList) updated.processList = {};
+      updated.processList.maxPreviewLines = num;
+      break;
+    case "output.defaultTailLines":
+      if (!updated.output) updated.output = {};
+      updated.output.defaultTailLines = num;
+      break;
+    case "output.maxOutputLines":
+      if (!updated.output) updated.output = {};
+      updated.output.maxOutputLines = num;
+      break;
+    default:
+      return null;
+  }
+
+  return updated;
+}

package/src/commands/settings/build-sections.ts

@@ -0,0 +1,160 @@
+import type { SettingsSection } from "@aliou/pi-utils-settings";
+import type { ProcessesConfig, ResolvedProcessesConfig } from "../../config";
+
+export function buildSettingsSections(
+  tabConfig: ProcessesConfig | null,
+  resolved: ResolvedProcessesConfig,
+): SettingsSection[] {
+  return [
+    {
+      label: "Process List",
+      items: [
+        {
+          id: "processList.maxVisibleProcesses",
+          label: "Max visible processes",
+          description:
+            "Maximum processes shown in the /processes list before scrolling",
+          currentValue: String(
+            tabConfig?.processList?.maxVisibleProcesses ??
+              resolved.processList.maxVisibleProcesses,
+          ),
+          values: ["4", "6", "8", "12", "16"],
+        },
+        {
+          id: "processList.maxPreviewLines",
+          label: "Max preview lines",
+          description: "Log preview lines shown below the selected process",
+          currentValue: String(
+            tabConfig?.processList?.maxPreviewLines ??
+              resolved.processList.maxPreviewLines,
+          ),
+          values: ["6", "8", "12", "16", "24"],
+        },
+      ],
+    },
+    {
+      label: "Output Limits",
+      items: [
+        {
+          id: "output.defaultTailLines",
+          label: "Default tail lines",
+          description: "Number of tail lines returned to the agent by default",
+          currentValue: String(
+            tabConfig?.output?.defaultTailLines ??
+              resolved.output.defaultTailLines,
+          ),
+          values: ["50", "100", "200", "500"],
+        },
+        {
+          id: "output.maxOutputLines",
+          label: "Max output lines",
+          description: "Hard cap on output lines returned to the agent",
+          currentValue: String(
+            tabConfig?.output?.maxOutputLines ?? resolved.output.maxOutputLines,
+          ),
+          values: ["100", "200", "500", "1000"],
+        },
+      ],
+    },
+    {
+      label: "Execution",
+      items: [
+        {
+          id: "execution.shellPath",
+          label: "Shell path",
+          description: "Absolute shell path override used to execute commands",
+          currentValue:
+            tabConfig?.execution?.shellPath ??
+            resolved.execution.shellPath ??
+            "auto",
+          values: [
+            "auto",
+            "/run/current-system/sw/bin/bash",
+            "/bin/bash",
+            "/usr/bin/bash",
+            "/usr/local/bin/bash",
+          ],
+        },
+      ],
+    },
+    {
+      label: "Interception",
+      items: [
+        {
+          id: "interception.blockBackgroundCommands",
+          label: "Block background commands",
+          description:
+            "Block bash background commands (&, nohup, disown, setsid) and guide the model to use the process tool",
+          currentValue:
+            (tabConfig?.interception?.blockBackgroundCommands ??
+            resolved.interception.blockBackgroundCommands)
+              ? "on"
+              : "off",
+          values: ["on", "off"],
+        },
+      ],
+    },
+    {
+      label: "Widget",
+      items: [
+        {
+          id: "widget.showStatusWidget",
+          label: "Show status widget",
+          description: "Show process status widget below the editor",
+          currentValue:
+            (tabConfig?.widget?.showStatusWidget ??
+            resolved.widget.showStatusWidget)
+              ? "on"
+              : "off",
+          values: ["on", "off"],
+        },
+        {
+          id: "widget.dockDefaultState",
+          label: "Dock default state",
+          description:
+            "Default visibility state of the log dock when follow mode is on",
+          currentValue:
+            tabConfig?.widget?.dockDefaultState ??
+            resolved.widget.dockDefaultState,
+          values: ["hidden", "collapsed"],
+        },
+        {
+          id: "widget.dockHeight",
+          label: "Dock height",
+          description: "Height of the log dock in lines when open",
+          currentValue: String(
+            tabConfig?.widget?.dockHeight ?? resolved.widget.dockHeight,
+          ),
+          values: ["8", "10", "12", "16", "20"],
+        },
+      ],
+    },
+    {
+      label: "Follow Mode",
+      items: [
+        {
+          id: "follow.enabledByDefault",
+          label: "Enable by default",
+          description: "Automatically show logs when a process starts",
+          currentValue:
+            (tabConfig?.follow?.enabledByDefault ??
+            resolved.follow.enabledByDefault)
+              ? "on"
+              : "off",
+          values: ["on", "off"],
+        },
+        {
+          id: "follow.autoHideOnFinish",
+          label: "Auto-hide on finish",
+          description: "Hide dock when all processes finish",
+          currentValue:
+            (tabConfig?.follow?.autoHideOnFinish ??
+            resolved.follow.autoHideOnFinish)
+              ? "on"
+              : "off",
+          values: ["on", "off"],
+        },
+      ],
+    },
+  ];
+}

package/src/commands/settings/command.ts

@@ -0,0 +1,20 @@
+import { registerSettingsCommand } from "@aliou/pi-utils-settings";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ProcessesConfig, ResolvedProcessesConfig } from "../../config";
+import { configLoader } from "../../config";
+import { applySettingChange } from "./apply-setting-change";
+import { buildSettingsSections } from "./build-sections";
+
+export function registerProcessesSettings(
+  pi: ExtensionAPI,
+  onSave?: () => void,
+): void {
+  registerSettingsCommand<ProcessesConfig, ResolvedProcessesConfig>(pi, {
+    commandName: "ps:settings",
+    title: "Processes Settings",
+    configStore: configLoader,
+    buildSections: buildSettingsSections,
+    onSettingChange: applySettingChange,
+    onSave,
+  });
+}

package/src/commands/settings/index.ts

@@ -0,0 +1 @@
+export { registerProcessesSettings } from "./command";

package/src/components/log-dock-component.ts

@@ -0,0 +1,238 @@
+/**
+ * Log Dock Component - shows process logs in the bottom dock.
+ *
+ * Collapsed view: one-line summary (running procs) + last log line.
+ * Open view: LogFileViewer for the focused process (or first running), follow mode on.
+ */
+
+import {
+  createPanelPadder,
+  renderPanelRule,
+  renderPanelTitleLine,
+} from "@aliou/pi-utils-ui";
+import type { Theme, ThemeColor } from "@mariozechner/pi-coding-agent";
+import type { Component } from "@mariozechner/pi-tui";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { LIVE_STATUSES } from "../constants";
+import type { ProcessManager } from "../manager";
+import { LogFileViewer } from "./log-file-viewer";
+
+const POLL_INTERVAL_MS = 500;
+
+const PROCESS_COLORS: ThemeColor[] = [
+  "accent",
+  "warning",
+  "success",
+  "error",
+  "accent",
+  "dim",
+  "accent",
+  "warning",
+];
+
+interface LogDockOptions {
+  manager: ProcessManager;
+  theme: Theme;
+  tui: { requestRender: () => void };
+  mode: "collapsed" | "open";
+  focusedProcessId: string | null;
+  dockHeight?: number;
+}
+
+export class LogDockComponent implements Component {
+  private manager: ProcessManager;
+  private theme: Theme;
+  private tui: { requestRender: () => void };
+  private dockHeight: number;
+  private mode: "collapsed" | "open";
+  private focusedProcessId: string | null;
+
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private unsubscribeManager: (() => void) | null = null;
+
+  /** One viewer per process, lazily created, follow:true. */
+  private viewers: Map<string, LogFileViewer> = new Map();
+
+  private processColors: Map<string, ThemeColor> = new Map();
+  private colorCounter = 0;
+
+  constructor(options: LogDockOptions) {
+    this.manager = options.manager;
+    this.theme = options.theme;
+    this.tui = options.tui;
+    this.dockHeight = options.dockHeight ?? 12;
+    this.mode = options.mode;
+    this.focusedProcessId = options.focusedProcessId;
+
+    this.timer = setInterval(() => {
+      this.tui.requestRender();
+    }, POLL_INTERVAL_MS);
+
+    this.unsubscribeManager = this.manager.onEvent(() => {
+      this.tui.requestRender();
+    });
+  }
+
+  update(opts: {
+    mode: "collapsed" | "open";
+    focusedProcessId: string | null;
+    dockHeight: number;
+  }): void {
+    this.mode = opts.mode;
+    this.focusedProcessId = opts.focusedProcessId;
+    this.dockHeight = opts.dockHeight;
+    this.tui.requestRender();
+  }
+
+  handleInput(_data: string): boolean {
+    return false;
+  }
+
+  invalidate(): void {
+    // No local cache; always renders fresh.
+  }
+
+  private getProcessColor(processId: string): ThemeColor {
+    const existing = this.processColors.get(processId);
+    if (existing) return existing;
+    const color = PROCESS_COLORS[this.colorCounter % PROCESS_COLORS.length];
+    this.colorCounter++;
+    this.processColors.set(processId, color);
+    return color;
+  }
+
+  private getViewer(processId: string, combinedFile: string): LogFileViewer {
+    let viewer = this.viewers.get(processId);
+    if (!viewer) {
+      viewer = new LogFileViewer({
+        filePath: combinedFile,
+        format: "combined",
+        theme: this.theme,
+        follow: true,
+      });
+      this.viewers.set(processId, viewer);
+    }
+    return viewer;
+  }
+
+  render(width: number): string[] {
+    if (this.mode === "collapsed") return this.renderCollapsed(width);
+    return this.renderOpen(width);
+  }
+
+  private renderCollapsed(width: number): string[] {
+    const theme = this.theme;
+    const dim = (s: string) => theme.fg("dim", s);
+    const fg = (color: ThemeColor, s: string) => theme.fg(color, s);
+
+    const processes = this.manager.list();
+    const innerWidth = width - 2;
+    const padLine = (content: string) => {
+      const w = visibleWidth(content);
+      const line =
+        w > innerWidth ? truncateToWidth(content, innerWidth) : content;
+      return ` ${line}${" ".repeat(Math.max(0, width - 1 - visibleWidth(line)))}`;
+    };
+
+    if (processes.length === 0) {
+      return [renderPanelRule(width, theme), padLine(dim("No processes"))];
+    }
+
+    const running = processes.filter((p) => LIVE_STATUSES.has(p.status));
+    const finished = processes.filter((p) => !LIVE_STATUSES.has(p.status));
+
+    const parts: string[] = [];
+    for (const proc of running) {
+      const color = this.getProcessColor(proc.id);
+      parts.push(`${fg(color, "●")} ${proc.name}`);
+    }
+    if (finished.length > 0) {
+      parts.push(dim(`+${finished.length} finished`));
+    }
+
+    const firstLine = parts.join(" | ");
+    const lines = [
+      renderPanelRule(width, theme),
+      padLine(truncateToWidth(firstLine, innerWidth)),
+    ];
+
+    if (running.length > 0) {
+      const lastLogs = this.manager.getCombinedOutput(running[0].id, 1);
+      if (lastLogs && lastLogs.length > 0) {
+        const lastLog = truncateToWidth(
+          lastLogs[lastLogs.length - 1].text,
+          innerWidth,
+        );
+        lines.push(padLine(dim(lastLog)));
+      }
+    }
+
+    return lines;
+  }
+
+  private renderOpen(width: number): string[] {
+    const theme = this.theme;
+    const dim = (s: string) => theme.fg("dim", s);
+
+    const innerWidth = width - 2;
+    const basePadLine = createPanelPadder(width);
+    const padLine = (content: string): string => {
+      const w = visibleWidth(content);
+      return basePadLine(
+        w > innerWidth ? truncateToWidth(content, innerWidth) : content,
+      );
+    };
+
+    const processes = this.manager.list();
+    const running = processes.filter((p) => LIVE_STATUSES.has(p.status));
+
+    const targetProc =
+      (this.focusedProcessId
+        ? processes.find((p) => p.id === this.focusedProcessId)
+        : null) ??
+      running[0] ??
+      processes[0] ??
+      null;
+
+    if (!targetProc) {
+      return [
+        renderPanelTitleLine("Process Logs", width, theme),
+        padLine(dim("No processes")),
+        padLine(dim("Run a command to start")),
+      ];
+    }
+
+    const logFiles = this.manager.getLogFiles(targetProc.id);
+    if (!logFiles) {
+      return [
+        renderPanelTitleLine("Process Logs", width, theme),
+        padLine(dim("Log files unavailable")),
+      ];
+    }
+
+    const viewer = this.getViewer(targetProc.id, logFiles.combinedFile);
+
+    const logRows = Math.max(1, this.dockHeight - 2);
+
+    const title = `${targetProc.name} ${dim(`(${targetProc.id})`)}`;
+    const lines: string[] = [];
+    lines.push(renderPanelTitleLine(title, width, theme));
+
+    const contentLines = viewer.renderLines(innerWidth, logRows);
+    for (let i = 0; i < logRows; i++) {
+      lines.push(padLine(contentLines[i] ?? ""));
+    }
+
+    return lines.slice(0, this.dockHeight);
+  }
+
+  dispose(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.unsubscribeManager?.();
+    this.viewers.clear();
+    this.processColors.clear();
+  }
+}