pi-one-ui 0.7.0 → 0.7.1

package/extensions/app/config/store.ts

@@ -173,6 +173,17 @@ export function mutateConfigFile(
 
 export type ConfigStoreListener = (record: ConfigRecord) => void;
 
+/** 文件已经提交；调用方可以显示已保存的配置及应用错误。 */
+export class ConfigApplicationError extends AggregateError {
+  constructor(
+    readonly record: ConfigRecord,
+    errors: unknown[],
+  ) {
+    super(errors, "Configuration was saved but could not be applied");
+    this.name = "ConfigApplicationError";
+  }
+}
+
 /**
  * Process-wide raw configuration store. Domain config modules own parsing and
  * selectors; this module owns canonical persistence.
@@ -205,7 +216,17 @@ export class ConfigStore {
       state.record,
       state.kind === "valid" ? state.mode : undefined,
     );
-    for (const listener of this.listeners) listener(state.record);
+    const errors: unknown[] = [];
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(state.record);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw new ConfigApplicationError(state.record, errors);
+    }
     return state.record;
   }
 

package/extensions/app/config/values.ts

@@ -0,0 +1,33 @@
+import type { ConfigRecord } from "./store.ts";
+
+export function isRecord(value: unknown): value is ConfigRecord {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function recordValue(value: unknown): ConfigRecord {
+  return isRecord(value) ? value : {};
+}
+
+export function booleanValue(value: unknown, defaultValue: boolean): boolean {
+  return typeof value === "boolean" ? value : defaultValue;
+}
+
+/** 更新已知字段，同时保留配置中其他字段及其属性名称。 */
+export function overlayKnown(raw: unknown, known: unknown): unknown {
+  if (known === undefined) {
+    return raw;
+  }
+  if (!isRecord(known)) {
+    return known;
+  }
+  const output: ConfigRecord = { ...recordValue(raw) };
+  for (const [key, value] of Object.entries(known)) {
+    Object.defineProperty(output, key, {
+      value: overlayKnown(output[key], value),
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+  }
+  return output;
+}

package/extensions/app/config/working-line.ts

@@ -0,0 +1,100 @@
+import { normalizeWorkingLineMessages } from "../../shared/working-line-text.ts";
+import { booleanValue, recordValue } from "./values.ts";
+import { PI_WORKING_LINE_MESSAGES } from "./working-line-messages.ts";
+
+export type WorkingLineSpinner =
+  | "braille"
+  | "star-bloom"
+  | "pinwheel"
+  | "claude-inspired"
+  | "pulse";
+export type WorkingLineTextAnimation = "classic" | "kitt" | "disabled";
+export type WorkingLineMessagesConfig = { custom: boolean; values: string[] };
+export type WorkingLineSegmentsConfig = {
+  tool: boolean;
+  elapsed: boolean;
+  thought: boolean;
+  tokens: boolean;
+};
+export type WorkingLineComponentConfig = {
+  enabled: boolean;
+  turnSummary: boolean;
+  spinner: WorkingLineSpinner;
+  spinnerIntervalMs: number;
+  animateSpinnerColor: boolean;
+  textIntervalMs: number;
+  textAnimation: WorkingLineTextAnimation;
+  messages: WorkingLineMessagesConfig;
+  segments: WorkingLineSegmentsConfig;
+};
+export type WorkingLineComponentPatch = Partial<
+  Omit<WorkingLineComponentConfig, "messages" | "segments">
+> & {
+  messages?: Partial<WorkingLineMessagesConfig>;
+  segments?: Partial<WorkingLineSegmentsConfig>;
+};
+export const DEFAULT_WORKING_LINE_SPINNER_INTERVAL_MS = 100;
+export const DEFAULT_WORKING_LINE_TEXT_INTERVAL_MS = 60;
+export const MIN_WORKING_LINE_INTERVAL_MS = 30;
+export const MAX_WORKING_LINE_INTERVAL_MS = 1000;
+export const defaultWorkingLine: WorkingLineComponentConfig = {
+  enabled: false,
+  turnSummary: true,
+  spinner: "star-bloom",
+  spinnerIntervalMs: DEFAULT_WORKING_LINE_SPINNER_INTERVAL_MS,
+  animateSpinnerColor: false,
+  textIntervalMs: DEFAULT_WORKING_LINE_TEXT_INTERVAL_MS,
+  textAnimation: "classic",
+  messages: { custom: true, values: [...PI_WORKING_LINE_MESSAGES] },
+  segments: { tool: true, elapsed: true, thought: true, tokens: true },
+};
+export function isValidWorkingLineIntervalMs(value: unknown): value is number {
+  return (
+    typeof value === "number" &&
+    Number.isSafeInteger(value) &&
+    value >= MIN_WORKING_LINE_INTERVAL_MS &&
+    value <= MAX_WORKING_LINE_INTERVAL_MS
+  );
+}
+
+export function normalizeWorkingLine(
+  value: unknown,
+): WorkingLineComponentConfig {
+  const source = recordValue(value);
+  const messages = recordValue(source.messages);
+  const segments = recordValue(source.segments);
+  return {
+    enabled: booleanValue(source.enabled, false),
+    turnSummary: booleanValue(source.turnSummary, true),
+    spinner:
+      source.spinner === "braille" ||
+      source.spinner === "pinwheel" ||
+      source.spinner === "claude-inspired" ||
+      source.spinner === "pulse"
+        ? source.spinner
+        : "star-bloom",
+    spinnerIntervalMs: isValidWorkingLineIntervalMs(source.spinnerIntervalMs)
+      ? source.spinnerIntervalMs
+      : DEFAULT_WORKING_LINE_SPINNER_INTERVAL_MS,
+    animateSpinnerColor: booleanValue(source.animateSpinnerColor, false),
+    textIntervalMs: isValidWorkingLineIntervalMs(source.textIntervalMs)
+      ? source.textIntervalMs
+      : DEFAULT_WORKING_LINE_TEXT_INTERVAL_MS,
+    textAnimation:
+      source.textAnimation === "kitt" || source.textAnimation === "disabled"
+        ? source.textAnimation
+        : "classic",
+    messages: {
+      custom: booleanValue(messages.custom, true),
+      values: Object.hasOwn(messages, "values")
+        ? normalizeWorkingLineMessages(messages.values)
+        : [...PI_WORKING_LINE_MESSAGES],
+    },
+    segments: {
+      tool: booleanValue(segments.tool, true),
+      elapsed: booleanValue(segments.elapsed, true),
+      thought: booleanValue(segments.thought, true),
+      tokens: booleanValue(segments.tokens, true),
+    },
+  };
+}

package/extensions/app/overlay/input-router.ts

@@ -1,32 +1,22 @@
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+
 export type InputRouteResult = { consume?: boolean; data?: string } | undefined;
 export type InputRoute = (data: string) => InputRouteResult;
+type InputHost = Pick<ExtensionUIContext, "onTerminalInput">;
+type RegisteredRoute = { priority: number; order: number; route: InputRoute };
+type HostRegistration = { remove: () => void; leases: Set<object> };
 
-type RegisteredRoute = {
-  priority: number;
-  order: number;
-  route: InputRoute;
-};
-
-/**
- * Routes raw terminal input by descending priority and stops at a consumer.
- */
+/** 输入路由与 Pi listener 共同注册、共同释放。 */
 export class InputRouter {
   private nextOrder = 0;
   private readonly routes: RegisteredRoute[] = [];
+  private readonly hosts = new Map<
+    InputHost["onTerminalInput"],
+    HostRegistration
+  >();
 
-  /**
-   * Registers an input route.
-   *
-   * @param route Handler that may consume one input packet.
-   * @param priority Higher-priority routes receive input first.
-   * @returns A function that removes the route.
-   */
   register(route: InputRoute, priority = 0): () => void {
-    const entry: RegisteredRoute = {
-      priority,
-      order: this.nextOrder++,
-      route,
-    };
+    const entry = { priority, order: this.nextOrder++, route };
     this.routes.push(entry);
     this.routes.sort(
       (left, right) =>
@@ -34,29 +24,63 @@ export class InputRouter {
     );
     return () => {
       const index = this.routes.indexOf(entry);
-      if (index >= 0) this.routes.splice(index, 1);
+      if (index >= 0) {
+        this.routes.splice(index, 1);
+      }
+    };
+  }
+
+  bind(host: InputHost, route: InputRoute, priority = 0): () => void {
+    const removeRoute = this.register(route, priority);
+    const key = host.onTerminalInput;
+    let registration = this.hosts.get(key);
+    try {
+      if (!registration) {
+        registration = {
+          remove: host.onTerminalInput((data) => this.dispatch(data)),
+          leases: new Set(),
+        };
+        this.hosts.set(key, registration);
+      }
+    } catch (error) {
+      removeRoute();
+      throw error;
+    }
+    const current = registration;
+    const token = {};
+    current.leases.add(token);
+    return () => {
+      removeRoute();
+      if (
+        !current.leases.delete(token) ||
+        current.leases.size > 0 ||
+        this.hosts.get(key) !== current
+      ) {
+        return;
+      }
+      this.hosts.delete(key);
+      current.remove();
     };
   }
 
-  /**
-   * Routes one input packet until a registered handler consumes it.
-   *
-   * @param data Raw terminal input packet.
-   * @returns The consuming route result, if any.
-   */
   dispatch(data: string): InputRouteResult {
     for (const entry of [...this.routes]) {
       const result = entry.route(data);
-      if (result?.consume) return result;
+      if (result?.consume) {
+        return result;
+      }
     }
     return undefined;
   }
 
-  /**
-   * Removes all registered routes, normally during runtime teardown.
-   */
   clear(): void {
     this.routes.length = 0;
+    const registrations = [...this.hosts.values()];
+    this.hosts.clear();
+    for (const registration of registrations) {
+      registration.leases.clear();
+      registration.remove();
+    }
   }
 }
 

package/extensions/app/overlay/overlay-manager.ts

@@ -1,38 +1,200 @@
+import type {
+  ExtensionContext,
+  ExtensionUIContext,
+  KeybindingsManager,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+import type {
+  Component,
+  OverlayHandle,
+  OverlayOptions,
+  TUI,
+} from "@earendil-works/pi-tui";
+
 export type OverlayTask<T> = () => Promise<T>;
+export type OverlayFactory<T> = (
+  tui: TUI,
+  theme: Theme,
+  keybindings: KeybindingsManager,
+  done: (result: T | undefined) => void,
+) =>
+  | (Component & { dispose?(): void })
+  | Promise<Component & { dispose?(): void }>;
+export type ManagedOverlayOptions = {
+  overlayOptions?: OverlayOptions | (() => OverlayOptions);
+  preserveEditorFocus?: boolean;
+  onHandle?: (handle: OverlayHandle) => void;
+};
+type FocusTui = TUI & {
+  getFocusedComponent?: () => Component | null;
+  isOverlayFocused?: () => boolean;
+};
+
+/** 配置更新可能替换 Editor；只恢复本面板仍然拥有的返回目标。 */
+class EditorFocusCoordinator {
+  private readonly originalFocus: Component | null | undefined;
+  private editorFocus:
+    | {
+        component: Component;
+        factory: ReturnType<ExtensionUIContext["getEditorComponent"]>;
+      }
+    | undefined;
+  handle: OverlayHandle | undefined;
+
+  constructor(
+    private readonly tui: FocusTui,
+    private readonly ui: ExtensionUIContext,
+    private readonly active: () => boolean,
+  ) {
+    this.originalFocus = tui.getFocusedComponent?.();
+  }
+
+  change(action: () => void): void {
+    if (this.originalFocus !== undefined) {
+      this.handle?.unfocus({
+        target: this.editorFocus?.component ?? this.originalFocus,
+      });
+    }
+    const previous = this.tui.getFocusedComponent?.();
+    try {
+      action();
+    } finally {
+      const next = this.tui.getFocusedComponent?.();
+      if (next && next !== previous && !this.tui.isOverlayFocused?.()) {
+        this.editorFocus = {
+          component: next,
+          factory: this.ui.getEditorComponent(),
+        };
+      }
+      if (this.active()) {
+        this.handle?.focus();
+      }
+    }
+  }
+
+  close(done: () => void): void {
+    done();
+    if (
+      !this.active() ||
+      !this.editorFocus ||
+      this.tui.hasOverlay() ||
+      this.tui.getFocusedComponent?.() !== this.originalFocus ||
+      this.ui.getEditorComponent() !== this.editorFocus.factory
+    ) {
+      return;
+    }
+    this.tui.setFocus(this.editorFocus.component);
+    this.tui.requestRender();
+  }
+}
 
-/**
- * Tracks plugin-owned overlay activity across settings and context dialogs.
- */
+/** 管理本扩展的 Overlay、取消操作和跨组件焦点协作。 */
 export class OverlayManager {
-  private activeCount = 0;
-
-  /**
-   * Runs one asynchronous overlay task and balances its active count.
-   *
-   * @param task Function that opens and waits for the overlay.
-   * @returns The value produced when the overlay closes.
-   */
+  private session = {};
+  private active = true;
+  private readonly tasks = new Set<object>();
+  private readonly closers = new Map<object, () => void>();
+  private readonly editorFocus = new Map<object, EditorFocusCoordinator>();
+
   async run<T>(task: OverlayTask<T>): Promise<T> {
-    this.activeCount += 1;
+    const token = {};
+    this.tasks.add(token);
     try {
       return await task();
     } finally {
-      this.activeCount = Math.max(0, this.activeCount - 1);
+      this.tasks.delete(token);
+    }
+  }
+
+  async open<T = void>(
+    ctx: Pick<ExtensionContext, "ui">,
+    factory: OverlayFactory<T>,
+    options: ManagedOverlayOptions = {},
+  ): Promise<T | undefined> {
+    if (!this.active) {
+      return undefined;
+    }
+    const token = {};
+    this.tasks.add(token);
+    let focus: EditorFocusCoordinator | undefined;
+    try {
+      return await ctx.ui.custom<T | undefined>(
+        (tui, theme, keybindings, done) => {
+          if (options.preserveEditorFocus) {
+            focus = new EditorFocusCoordinator(tui, ctx.ui, () =>
+              this.tasks.has(token),
+            );
+            this.editorFocus.set(token, focus);
+          }
+          let closed = false;
+          const complete = (result: T | undefined): void => {
+            if (closed) {
+              return;
+            }
+            closed = true;
+            if (focus) {
+              focus.close(() => done(result));
+            } else {
+              done(result);
+            }
+          };
+          this.closers.set(token, () => complete(undefined));
+          return factory(tui, theme, keybindings, complete);
+        },
+        {
+          overlay: true,
+          overlayOptions: options.overlayOptions,
+          onHandle: (handle) => {
+            if (focus) {
+              focus.handle = handle;
+            }
+            options.onHandle?.(handle);
+          },
+        },
+      );
+    } finally {
+      this.tasks.delete(token);
+      this.closers.delete(token);
+      this.editorFocus.delete(token);
+    }
+  }
+
+  updateEditor(action: () => void): void {
+    const focus = [...this.editorFocus.values()].at(-1);
+    if (focus) {
+      focus.change(action);
+    } else {
+      action();
+    }
+  }
+
+  sessionGuard(): () => boolean {
+    const session = this.session;
+    return () => this.active && this.session === session;
+  }
+
+  startSession(): void {
+    this.reset();
+    this.active = true;
+  }
+
+  reset(): void {
+    this.active = false;
+    this.session = {};
+    this.tasks.clear();
+    for (const close of [...this.closers.values()]) {
+      close();
     }
+    this.closers.clear();
+    this.editorFocus.clear();
   }
 
-  /**
-   * Reports whether at least one plugin-owned overlay is active.
-   */
   hasActive(): boolean {
-    return this.activeCount > 0;
+    return this.tasks.size > 0;
   }
 
-  /**
-   * Returns the current plugin-owned overlay depth.
-   */
   depth(): number {
-    return this.activeCount;
+    return this.tasks.size;
   }
 }
 

package/extensions/app/runtime/event-coordinator.ts

@@ -1,4 +1,9 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ExtensionEvent,
+  MessageEndEvent,
+} from "@earendil-works/pi-coding-agent";
 
 export const RUNTIME_EVENTS = [
   "session_start",
@@ -17,68 +22,111 @@ export const RUNTIME_EVENTS = [
   "session_compact",
   "session_tree",
 ] as const;
-
 export type RuntimeEventName = (typeof RUNTIME_EVENTS)[number];
-export type RuntimeEventHandler = (
-  event: unknown,
-  ctx: ExtensionContext,
-) => void | Promise<void>;
-
+type RuntimeEvent<K extends RuntimeEventName> = Extract<
+  ExtensionEvent,
+  { type: K }
+>;
+type MessageReplacement = { message: MessageEndEvent["message"] };
+export type RuntimeEventHandler<K extends RuntimeEventName = RuntimeEventName> =
+  (
+    event: RuntimeEvent<K>,
+    ctx: ExtensionContext,
+  ) => void | MessageReplacement | Promise<void | MessageReplacement>;
 export type EventRegistrar = {
   on(event: RuntimeEventName, handler: RuntimeEventHandler): void;
 };
 
-/**
- * Provides the central host event seam used while legacy listeners migrate.
- */
+/** 共享事件保留注册顺序、同步执行和 message_end 的替换语义。 */
 export class EventCoordinator {
-  private readonly registrar: EventRegistrar;
   private readonly handlers = new Map<
     RuntimeEventName,
     Set<RuntimeEventHandler>
   >();
   private installed = false;
 
-  /**
-   * Creates a coordinator backed by the host event registrar.
-   *
-   * @param registrar Host adapter used to install event listeners.
-   */
-  constructor(registrar: EventRegistrar) {
-    this.registrar = registrar;
-  }
+  constructor(private readonly registrar: EventRegistrar) {}
 
-  /**
-   * Registers a handler for one coordinated runtime event.
-   *
-   * @returns A function that removes the handler.
-   */
-  on(event: RuntimeEventName, handler: RuntimeEventHandler): () => void {
+  on<K extends RuntimeEventName>(
+    event: K,
+    handler: RuntimeEventHandler<K>,
+  ): () => void {
     const handlers = this.handlers.get(event) ?? new Set<RuntimeEventHandler>();
-    handlers.add(handler);
+    const registered: RuntimeEventHandler = (payload, ctx) =>
+      handler(payload as RuntimeEvent<K>, ctx);
+    handlers.add(registered);
     this.handlers.set(event, handlers);
-    return () => handlers.delete(handler);
+    return () => {
+      handlers.delete(registered);
+    };
+  }
+
+  /** 专用 hook 直接使用 Pi；共享生命周期统一经过本协调器。 */
+  coordinate(pi: ExtensionAPI): ExtensionAPI {
+    const on = ((event: string, handler: RuntimeEventHandler) => {
+      if ((RUNTIME_EVENTS as readonly string[]).includes(event)) {
+        return this.on(event as RuntimeEventName, handler);
+      }
+      return pi.on(event as never, handler as never);
+    }) as ExtensionAPI["on"];
+    return new Proxy(pi, {
+      get(target, property, receiver) {
+        return property === "on" ? on : Reflect.get(target, property, receiver);
+      },
+    });
   }
 
-  /**
-   * Installs one host listener per coordinated event.
-   */
   install(): void {
-    if (this.installed) return;
+    if (this.installed) {
+      return;
+    }
     this.installed = true;
     for (const event of RUNTIME_EVENTS) {
-      this.registrar.on(event, (payload, ctx) => {
-        let pending: Promise<void> | undefined;
-        for (const handler of this.handlers.get(event) ?? []) {
-          if (pending) {
-            pending = pending.then(() => handler(payload, ctx)).then(() => {});
-            continue;
-          }
-          const result = handler(payload, ctx);
-          if (result instanceof Promise) pending = result.then(() => {});
+      this.registrar.on(event, (payload, ctx) =>
+        this.dispatch(event, payload, ctx),
+      );
+    }
+  }
+
+  dispatch<K extends RuntimeEventName>(
+    event: K,
+    payload: RuntimeEvent<K>,
+    ctx: ExtensionContext,
+  ): void | MessageReplacement | Promise<void | MessageReplacement>;
+  dispatch(
+    event: RuntimeEventName,
+    payload: RuntimeEvent<RuntimeEventName>,
+    ctx: ExtensionContext,
+  ): void | MessageReplacement | Promise<void | MessageReplacement> {
+    let replacement: MessageReplacement | undefined;
+    let pending: Promise<void> | undefined;
+    const accept = (result: void | MessageReplacement): void => {
+      if (!result) {
+        return;
+      }
+      if (
+        payload.type !== "message_end" ||
+        result.message.role !== payload.message.role
+      ) {
+        throw new TypeError(
+          "Only message_end may replace a message, with the same role",
+        );
+      }
+      replacement = result;
+      payload.message = result.message;
+    };
+    for (const handler of [...(this.handlers.get(event) ?? [])]) {
+      if (pending) {
+        pending = pending.then(() => handler(payload, ctx)).then(accept);
+      } else {
+        const result = handler(payload, ctx);
+        if (result instanceof Promise) {
+          pending = result.then(accept);
+        } else {
+          accept(result);
         }
-        return pending;
-      });
+      }
     }
+    return pending ? pending.then(() => replacement) : replacement;
   }
 }