@aliou/pi-processes 0.9.5 → 0.10.1

package/extensions/processes/commands/kill.ts

@@ -0,0 +1,152 @@
+import {
+  type EventBus,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  getSelectListTheme,
+} from "@earendil-works/pi-coding-agent";
+import {
+  type AutocompleteItem,
+  type SelectItem,
+  SelectList,
+} from "@earendil-works/pi-tui";
+import { LIVE_STATUSES } from "../../../src/types";
+import { formatProcessSelectionDescription } from "../../shared/ui";
+import { requestKill, requestProcess, requestProcessList } from "../client";
+
+/**
+ * Register `/ps:kill`.
+ *
+ * Stops a running managed process via the kill protocol channel. With no
+ * argument it picks a target from the live processes (or kills the sole
+ * running one outright); with an explicit id it stops that one. The dock
+ * auto-unpins a killed focused process on the next processes-changed tick, so
+ * this command does not touch the dock directly.
+ */
+export function registerKillCommand(pi: ExtensionAPI): void {
+  const events = pi.events;
+  pi.registerCommand("ps:kill", {
+    description: "Stop a running managed process.",
+    getArgumentCompletions: (prefix: string) => completions(events, prefix),
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const rawId = args.trim().split(/\s+/, 1)[0];
+      const processes = requestProcessList(events);
+      const live = processes.filter((process) =>
+        LIVE_STATUSES.has(process.status),
+      );
+
+      let id: string | null = null;
+      if (rawId) {
+        const proc = requestProcess(events, rawId);
+        if (!proc) {
+          ctx.ui.notify(`Process not found: ${rawId}`, "warning");
+          return;
+        }
+        if (!LIVE_STATUSES.has(proc.status)) {
+          ctx.ui.notify(`${proc.name} (${proc.id}) is not running.`, "warning");
+          return;
+        }
+        id = proc.id;
+      } else if (live.length === 0) {
+        ctx.ui.notify("No running processes to kill.", "warning");
+        return;
+      } else if (live.length === 1 && live[0]) {
+        id = live[0].id;
+      } else {
+        id = await pickTarget(ctx, events, "Select process to kill");
+        if (!id) return;
+      }
+
+      if (!id) return;
+      const proc = requestProcess(events, id);
+      if (!proc) {
+        ctx.ui.notify(`Process not found: ${id}`, "warning");
+        return;
+      }
+
+      const signal =
+        proc.status === "terminate_timeout" ? "SIGKILL" : "SIGTERM";
+      const timeoutMs = signal === "SIGKILL" ? 200 : 3000;
+      const result = await requestKill(events, id, { signal, timeoutMs });
+      if (result.ok) {
+        ctx.ui.notify(`Killed ${proc.name} (${proc.id}).`, "info");
+      } else {
+        ctx.ui.notify(
+          `Failed to kill ${proc.name} (${proc.id}): ${result.reason}.`,
+          "warning",
+        );
+      }
+    },
+  });
+}
+
+async function pickTarget(
+  ctx: ExtensionCommandContext,
+  events: EventBus,
+  title: string,
+): Promise<string | null> {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify("Usage: /ps:kill <process-id>", "warning");
+    return null;
+  }
+
+  const items: SelectItem[] = requestProcessList(events)
+    .filter((process) => LIVE_STATUSES.has(process.status))
+    .map((process) => ({
+      label: `${process.name} (${process.id})`,
+      value: process.id,
+      description: formatProcessSelectionDescription(process),
+    }));
+
+  if (items.length === 0) {
+    ctx.ui.notify("No running processes to kill.", "warning");
+    return null;
+  }
+
+  const result = await ctx.ui.custom<string | null>(
+    (tui, theme, _keybindings, done) => {
+      const list = new SelectList(
+        items,
+        Math.min(items.length, 10),
+        getSelectListTheme(),
+      );
+      list.onSelect = (item) => done(String(item.value));
+      list.onCancel = () => done(null);
+
+      return {
+        render: (width: number) => [
+          theme.fg("accent", title),
+          theme.fg("muted", "─".repeat(Math.max(0, width))),
+          ...list.render(width),
+          theme.fg("muted", "─".repeat(Math.max(0, width))),
+        ],
+        invalidate: () => list.invalidate(),
+        handleInput: (data: string) => {
+          list.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    },
+  );
+
+  return result ?? null;
+}
+
+function completions(
+  events: EventBus,
+  prefix: string,
+): AutocompleteItem[] | null {
+  const normalized = prefix.trim().toLowerCase();
+  const items = requestProcessList(events)
+    .filter(
+      (process) =>
+        LIVE_STATUSES.has(process.status) &&
+        (process.id.toLowerCase().startsWith(normalized) ||
+          process.name.toLowerCase().includes(normalized)),
+    )
+    .map((process) => ({
+      value: process.id,
+      label: `${process.name} (${process.id})`,
+      description: formatProcessSelectionDescription(process),
+    }));
+  return items.length > 0 ? items : null;
+}

package/extensions/processes/commands/overview.ts

@@ -0,0 +1,102 @@
+import type {
+  EventBus,
+  ExtensionAPI,
+  ExtensionCommandContext,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+import type { ProcessProtocolConfig } from "../../../src/protocol";
+import type { ProcessInfo } from "../../../src/types";
+import { requestConfig, requestProcess, requestProcessList } from "../client";
+import { OverviewComponent } from "../components/overview-component";
+
+export interface OpenOverviewOptions {
+  events: EventBus;
+  registerOverlay: (overlay: { dispose: () => void }) => () => void;
+}
+
+/**
+ * Register the `/ps` overview/control panel.
+ *
+ * `/ps` replaces the editor while open (non-overlay `ctx.ui.custom`). It lives
+ * in the core extension but talks to the manager exclusively over `pi.events`
+ * protocol channels, so a future split-out stays cheap.
+ */
+export function registerOverviewCommand(
+  pi: Pick<ExtensionAPI, "registerCommand">,
+  options: OpenOverviewOptions,
+): void {
+  pi.registerCommand("ps", {
+    description: "Open the managed process overview panel.",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      await openOverview(args, ctx, options);
+    },
+  });
+}
+
+async function openOverview(
+  args: string,
+  ctx: ExtensionCommandContext,
+  options: OpenOverviewOptions,
+): Promise<void> {
+  const requestedId = args.trim().split(/\s+/, 1)[0] || undefined;
+  const initialProcessId = requestedId
+    ? requestProcess(options.events, requestedId)?.id
+    : undefined;
+
+  if (requestedId && !initialProcessId) {
+    const message = `Process not found: ${requestedId}`;
+    if (ctx.hasUI) ctx.ui.notify(message, "warning");
+    else console.log(message);
+    return;
+  }
+
+  if (ctx.mode !== "tui") {
+    const processes = requestProcessList(options.events);
+    const message = formatPlainProcessList(processes);
+    if (ctx.hasUI) ctx.ui.notify(message, "info");
+    else console.log(message);
+    return;
+  }
+
+  let config: ProcessProtocolConfig;
+  try {
+    config = requestConfig(options.events);
+  } catch (error) {
+    ctx.ui.notify(String(error), "error");
+    return;
+  }
+
+  const result = await ctx.ui.custom<"closed">(
+    (tui, theme: Theme, _keybindings, done) => {
+      let unregister: () => void = () => undefined;
+      const overlay = new OverviewComponent({
+        events: options.events,
+        tui,
+        theme,
+        config,
+        initialProcessId,
+        onClose: () => {
+          unregister();
+          done("closed");
+        },
+      });
+      unregister = options.registerOverlay(overlay);
+      return overlay;
+    },
+  );
+
+  if (result === undefined) {
+    const processes = requestProcessList(options.events);
+    ctx.ui.notify(formatPlainProcessList(processes), "info");
+  }
+}
+
+function formatPlainProcessList(processes: ProcessInfo[]): string {
+  if (processes.length === 0) return "No managed processes.";
+  return processes
+    .map(
+      (process) =>
+        `${process.id}\t${process.name}\t${process.status}\t${process.command}`,
+    )
+    .join("\n");
+}