pi-ui-extend 0.1.13 → 0.1.17

package/dist/app/commands/command-registry.js

@@ -32,6 +32,14 @@ export function createSlashCommands(actions, host) {
             allowArguments: true,
             run: (argumentsText) => actions.runAutocompleteSlashCommand(argumentsText),
         },
+        {
+            name: "no-context-files",
+            description: "Set project AGENTS.md/CLAUDE.md loading off or on",
+            kind: "builtin",
+            keywords: ["context", "agents", "claude", "project", "config"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runNoContextFilesSlashCommand(argumentsText),
+        },
         {
             name: "scoped-models",
             description: "Show or set models used by the model selector/cycling",
@@ -177,6 +185,14 @@ export function createSlashCommands(actions, host) {
             allowArguments: true,
             run: (argumentsText) => actions.runJumpCommand(argumentsText),
         },
+        {
+            name: "history",
+            description: "Search command history and restore a match",
+            kind: "builtin",
+            keywords: ["command", "request", "prompt", "find", "recent"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runHistoryCommand(argumentsText),
+        },
         {
             name: "search",
             description: "Search sessions and open a match in a new tab",

package/dist/app/constants.d.ts

@@ -42,7 +42,6 @@ export declare const GIT_BRANCH_CACHE_MS = 30000;
 export declare const TODO_TOOL_NAME = "todo";
 export declare const TODO_ACTIONS: readonly ["create", "update", "batch_create", "batch_update", "list", "get", "delete", "clear", "export", "import"];
 export declare const TODO_STATUSES: readonly ["pending", "in_progress", "deferred", "completed", "deleted"];
-export declare const TODO_PRIORITIES: readonly ["low", "medium", "high", "urgent"];
 export declare const SUBAGENT_STATUSES: readonly ["planned", "running", "retrying", "done", "failed", "stopped"];
 export declare const SUBAGENT_ACTIVE_STATUSES: readonly ["planned", "running", "retrying"];
 export declare const SUBAGENT_TERMINAL_STATUSES: readonly ["done", "failed", "stopped"];

package/dist/app/constants.js

@@ -90,7 +90,6 @@ export const TODO_ACTIONS = [
     "import",
 ];
 export const TODO_STATUSES = ["pending", "in_progress", "deferred", "completed", "deleted"];
-export const TODO_PRIORITIES = ["low", "medium", "high", "urgent"];
 export const SUBAGENT_STATUSES = ["planned", "running", "retrying", "done", "failed", "stopped"];
 export const SUBAGENT_ACTIVE_STATUSES = ["planned", "running", "retrying"];
 export const SUBAGENT_TERMINAL_STATUSES = ["done", "failed", "stopped"];

package/dist/app/extensions/extension-ui-controller.d.ts

@@ -7,10 +7,14 @@ export type ExtensionTerminalInputResult = {
 };
 export type ExtensionUiControllerHost = {
     readonly theme: Theme;
+    activeExtensionUiScope?(): string | undefined;
     isRunning(): boolean;
     render(): void;
-    showToast(message: string, kind?: ToastKind): void;
+    showToast(message: string, kind?: ToastKind, options?: {
+        scopeKey?: string;
+    }): void;
     readonly toastNotifier: ToastNotifier;
+    toastNotifierForScope?(scopeKey: string | undefined): ToastNotifier;
     readonly menuController: PixMenuController;
     setStatus(status: string): void;
     restoreSessionStatus(): void;
@@ -23,22 +27,24 @@ export declare class ExtensionUiController {
     private readonly host;
     private readonly extensionWidgets;
     private readonly terminalInputHandlers;
-    private activeCustomUi;
-    private readonly aboveInputRenderer;
+    private readonly activeCustomUis;
     constructor(host: ExtensionUiControllerHost);
     get widgets(): ReadonlyMap<string, ExtensionWidgetRegistration>;
     createExtensionTheme(): ExtensionWidgetTheme;
     setWidget(key: string, content: unknown, options?: {
         placement?: WidgetPlacement;
+        scopeKey?: string;
+    }): void;
+    clearWidgets(scopeKey?: string, options?: {
+        cancelCustomUi?: boolean;
     }): void;
-    clearWidgets(): void;
     suppressWidget(key: string): void;
     handleTerminalInput(data: string): ExtensionTerminalInputResult;
     renderActiveCustomUi(width: number): string[] | undefined;
     activeCustomUiUsesEditor(): boolean;
     handleCustomUiMouse(event: ExtensionInputMouseEvent): boolean;
     widgetTuiHandle(): WidgetTuiHandle;
-    createExtensionUIContext(): PixExtensionUIContext;
+    createExtensionUIContext(scopeKey?: string): PixExtensionUIContext;
     private setAboveInputWidget;
     private clearAboveInputWidget;
     private selectDialog;
@@ -53,5 +59,10 @@ export declare class ExtensionUiController {
     private cancelActiveCustomUi;
     private rejectActiveCustomUi;
     private finishActiveCustomUi;
+    private activeCustomUiForActiveScope;
+    private activeScopeKey;
+    private normalizeScopeKey;
+    private scopedWidgetKey;
+    private unscopedWidgetKey;
     private invalidateWidget;
 }

package/dist/app/extensions/extension-ui-controller.js

@@ -6,20 +6,15 @@ export class ExtensionUiController {
     host;
     extensionWidgets = new Map();
     terminalInputHandlers = new Set();
-    activeCustomUi;
-    aboveInputRenderer = {
-        set: (key, content) => {
-            this.setAboveInputWidget(key, content);
-        },
-        clear: (key) => {
-            this.clearAboveInputWidget(key);
-        },
-    };
+    activeCustomUis = new Map();
     constructor(host) {
         this.host = host;
     }
     get widgets() {
-        return this.extensionWidgets;
+        const activeScopeKey = this.activeScopeKey();
+        return new Map([...this.extensionWidgets.entries()]
+            .filter(([, widget]) => widget.scopeKey === activeScopeKey)
+            .map(([scopedKey, widget]) => [this.unscopedWidgetKey(scopedKey, widget.scopeKey), widget]));
     }
     createExtensionTheme() {
         const colors = this.host.theme.colors;
@@ -47,44 +42,54 @@ export class ExtensionUiController {
         };
     }
     setWidget(key, content, options) {
-        const existing = this.extensionWidgets.get(key);
+        const scopeKey = this.normalizeScopeKey(options?.scopeKey);
+        const scopedKey = this.scopedWidgetKey(scopeKey, key);
+        const existing = this.extensionWidgets.get(scopedKey);
         if (existing)
             this.invalidateWidget(existing);
         if (content === undefined) {
-            this.extensionWidgets.delete(key);
+            this.extensionWidgets.delete(scopedKey);
             if (this.host.isRunning())
                 this.host.render();
             return;
         }
         if (!Array.isArray(content) && typeof content !== "function")
             return;
-        this.extensionWidgets.set(key, {
+        this.extensionWidgets.set(scopedKey, {
             key,
+            scopeKey,
             placement: options?.placement === "belowEditor" ? "belowEditor" : "aboveEditor",
             content: content,
         });
         if (this.host.isRunning())
             this.host.render();
     }
-    clearWidgets() {
-        this.cancelActiveCustomUi();
-        for (const widget of this.extensionWidgets.values())
+    clearWidgets(scopeKey, options = {}) {
+        const normalizedScopeKey = this.normalizeScopeKey(scopeKey);
+        if (options.cancelCustomUi !== false)
+            this.cancelActiveCustomUi(normalizedScopeKey);
+        for (const [key, widget] of this.extensionWidgets.entries()) {
+            if (widget.scopeKey !== normalizedScopeKey)
+                continue;
             this.invalidateWidget(widget);
-        this.extensionWidgets.clear();
+            this.extensionWidgets.delete(key);
+        }
     }
     suppressWidget(key) {
-        const widget = this.extensionWidgets.get(key);
+        const scopedKey = this.scopedWidgetKey(this.activeScopeKey(), key);
+        const widget = this.extensionWidgets.get(scopedKey);
         if (!widget)
             return;
         this.invalidateWidget(widget);
-        this.extensionWidgets.delete(key);
+        this.extensionWidgets.delete(scopedKey);
     }
     handleTerminalInput(data) {
-        if (this.activeCustomUi) {
+        const active = this.activeCustomUiForActiveScope();
+        if (active) {
             if (data === "\u0003")
                 return { consume: false };
             try {
-                const result = this.activeCustomUi.component.handleInput?.(data);
+                const result = active.component.handleInput?.(data);
                 if (result && typeof result === "object") {
                     return {
                         consume: result.consume !== false,
@@ -98,7 +103,10 @@ export class ExtensionUiController {
             return { consume: true };
         }
         let current = data;
-        for (const handler of [...this.terminalInputHandlers]) {
+        const activeScopeKey = this.activeScopeKey();
+        for (const { scopeKey, handler } of [...this.terminalInputHandlers]) {
+            if (scopeKey !== activeScopeKey)
+                continue;
             const result = handler(current);
             if (result?.data !== undefined)
                 current = result.data;
@@ -108,7 +116,7 @@ export class ExtensionUiController {
         return current === data ? { consume: false } : { consume: false, data: current };
     }
     renderActiveCustomUi(width) {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return undefined;
         try {
@@ -119,7 +127,7 @@ export class ExtensionUiController {
         }
     }
     activeCustomUiUsesEditor() {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return false;
         try {
@@ -130,7 +138,7 @@ export class ExtensionUiController {
         }
     }
     handleCustomUiMouse(event) {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return false;
         try {
@@ -142,13 +150,14 @@ export class ExtensionUiController {
         }
     }
     widgetTuiHandle() {
+        const activeScopeToastNotifier = this.host.toastNotifierForScope?.(this.activeScopeKey()) ?? this.host.toastNotifier;
         return {
             requestRender: () => {
                 if (this.host.isRunning())
                     this.host.render();
             },
-            showToast: this.host.toastNotifier.show,
-            toast: this.host.toastNotifier,
+            showToast: activeScopeToastNotifier.show,
+            toast: activeScopeToastNotifier,
             showMenu: this.host.menuController.show,
             menu: this.host.menuController,
             pix: {
@@ -157,9 +166,11 @@ export class ExtensionUiController {
             },
         };
     }
-    createExtensionUIContext() {
+    createExtensionUIContext(scopeKey) {
+        const contextScopeKey = this.normalizeScopeKey(scopeKey);
+        const scopedToastNotifier = this.host.toastNotifierForScope?.(contextScopeKey) ?? this.host.toastNotifier;
         const notify = (message, type) => {
-            this.host.showToast(message, isToastKind(type) ? type : "info");
+            this.host.showToast(message, isToastKind(type) ? type : "info", { scopeKey: contextScopeKey });
         };
         const extensionTheme = this.createExtensionTheme();
         const renderIfRunning = () => {
@@ -169,17 +180,24 @@ export class ExtensionUiController {
         return {
             select: async (title, options, opts) => await this.selectDialog(title, options, opts),
             confirm: async (title, message, opts) => await this.confirmDialog(title, message, opts),
-            input: async (title, placeholder, opts) => await this.inputDialog(title, placeholder, opts),
+            input: async (title, placeholder, opts) => await this.inputDialog(title, placeholder, opts, contextScopeKey),
             notify,
-            toast: this.host.toastNotifier,
-            aboveInput: this.aboveInputRenderer,
+            toast: scopedToastNotifier,
+            aboveInput: {
+                set: (key, content) => {
+                    this.setAboveInputWidget(key, content, contextScopeKey);
+                },
+                clear: (key) => {
+                    this.clearAboveInputWidget(key, contextScopeKey);
+                },
+            },
             renderAboveInput: (key, content) => {
-                this.setAboveInputWidget(key, content);
+                this.setAboveInputWidget(key, content, contextScopeKey);
             },
             showMenu: this.host.menuController.show,
             menu: this.host.menuController,
             onTerminalInput: (handler) => {
-                const terminalInputHandler = handler;
+                const terminalInputHandler = { scopeKey: contextScopeKey, handler: handler };
                 this.terminalInputHandlers.add(terminalInputHandler);
                 return () => {
                     this.terminalInputHandlers.delete(terminalInputHandler);
@@ -187,13 +205,13 @@ export class ExtensionUiController {
             },
             setStatus: (_key, text) => {
                 if (text)
-                    this.host.showToast(text, "info");
+                    this.host.showToast(text, "info", { scopeKey: contextScopeKey });
                 this.host.restoreSessionStatus();
                 renderIfRunning();
             },
             setWorkingMessage: (message) => {
                 if (message)
-                    this.host.showToast(message, "info");
+                    this.host.showToast(message, "info", { scopeKey: contextScopeKey });
                 this.host.restoreSessionStatus();
                 renderIfRunning();
             },
@@ -201,7 +219,7 @@ export class ExtensionUiController {
             setWorkingIndicator: () => undefined,
             setHiddenThinkingLabel: () => undefined,
             setWidget: ((key, content, options) => {
-                this.setWidget(key, content, options);
+                this.setWidget(key, content, { ...options, scopeKey: contextScopeKey });
             }),
             setFooter: () => undefined,
             setHeader: () => undefined,
@@ -209,7 +227,7 @@ export class ExtensionUiController {
                 process.title = title;
                 renderIfRunning();
             },
-            custom: (async (factory) => await this.showCustomUi(factory)),
+            custom: (async (factory) => await this.showCustomUi(factory, { scopeKey: contextScopeKey })),
             pasteToEditor: (text) => {
                 this.host.setInput(text);
                 renderIfRunning();
@@ -219,7 +237,7 @@ export class ExtensionUiController {
                 renderIfRunning();
             },
             getEditorText: () => this.host.getInput(),
-            editor: async (title, prefill) => await this.editorDialog(title, prefill),
+            editor: async (title, prefill) => await this.editorDialog(title, prefill, contextScopeKey),
             addAutocompleteProvider: () => undefined,
             setEditorComponent: () => undefined,
             getEditorComponent: () => undefined,
@@ -241,11 +259,11 @@ export class ExtensionUiController {
             },
         };
     }
-    setAboveInputWidget(key, content) {
-        this.setWidget(key, content, { placement: "aboveEditor" });
+    setAboveInputWidget(key, content, scopeKey = this.activeScopeKey()) {
+        this.setWidget(key, content, { placement: "aboveEditor", scopeKey });
     }
-    clearAboveInputWidget(key) {
-        this.setWidget(key, undefined, { placement: "aboveEditor" });
+    clearAboveInputWidget(key, scopeKey = this.activeScopeKey()) {
+        this.setWidget(key, undefined, { placement: "aboveEditor", scopeKey });
     }
     async selectDialog(title, options, opts) {
         if (opts?.signal?.aborted)
@@ -265,7 +283,7 @@ export class ExtensionUiController {
         });
         return selected === true;
     }
-    async inputDialog(title, placeholder, opts) {
+    async inputDialog(title, placeholder, opts, scopeKey = this.activeScopeKey()) {
         if (opts?.signal?.aborted)
             return undefined;
         return await this.editorBackedDialog({
@@ -274,21 +292,21 @@ export class ExtensionUiController {
             mode: "input",
             ...(placeholder === undefined ? {} : { placeholder }),
             ...(opts === undefined ? {} : { opts }),
-        });
+        }, scopeKey);
     }
-    async editorDialog(title, prefill = "") {
+    async editorDialog(title, prefill = "", scopeKey = this.activeScopeKey()) {
         return await this.editorBackedDialog({
             title,
             initialValue: prefill,
             mode: "editor",
-        });
+        }, scopeKey);
     }
-    async editorBackedDialog(options) {
+    async editorBackedDialog(options, scopeKey = this.activeScopeKey()) {
         if (options.opts?.signal?.aborted)
             return undefined;
         if (!this.host.isRunning())
             return undefined;
-        if (this.activeCustomUi)
+        if (this.activeCustomUis.has(scopeKey))
             throw new Error("Another extension custom UI is already active.");
         const savedInput = this.host.getInput();
         this.host.setInput(options.initialValue);
@@ -315,9 +333,9 @@ export class ExtensionUiController {
                     return { consume: false, data };
                 },
             };
-        }, { savedInput });
+        }, { savedInput, scopeKey });
         return await this.withDialogAutoDismiss(promise, options.opts, () => {
-            this.cancelActiveCustomUi();
+            this.cancelActiveCustomUi(scopeKey);
         });
     }
     renderEditorBackedDialog(options, width) {
@@ -356,7 +374,8 @@ export class ExtensionUiController {
     async showCustomUi(factory, options = {}) {
         if (!this.host.isRunning())
             return undefined;
-        if (this.activeCustomUi)
+        const scopeKey = this.normalizeScopeKey(options.scopeKey);
+        if (this.activeCustomUis.has(scopeKey))
             throw new Error("Another extension custom UI is already active.");
         const savedInput = options.savedInput ?? this.host.getInput();
         return await new Promise((resolve, reject) => {
@@ -365,7 +384,7 @@ export class ExtensionUiController {
                 if (settled)
                     return;
                 settled = true;
-                this.finishActiveCustomUi(value, { resolve: true });
+                this.finishActiveCustomUi(scopeKey, value, { resolve: true });
                 resolve(value);
             };
             void (async () => {
@@ -375,8 +394,9 @@ export class ExtensionUiController {
                         component.dispose?.();
                         return;
                     }
-                    this.activeCustomUi = {
+                    this.activeCustomUis.set(scopeKey, {
                         key: CUSTOM_UI_WIDGET_KEY,
+                        scopeKey,
                         component,
                         savedInput,
                         resolve: (value) => {
@@ -391,7 +411,7 @@ export class ExtensionUiController {
                             settled = true;
                             reject(error);
                         },
-                    };
+                    });
                     if (this.host.isRunning())
                         this.host.render();
                 }
@@ -404,17 +424,20 @@ export class ExtensionUiController {
             })();
         });
     }
-    cancelActiveCustomUi() {
-        this.finishActiveCustomUi(undefined, { resolve: true });
+    cancelActiveCustomUi(scopeKey = this.activeScopeKey()) {
+        this.finishActiveCustomUi(scopeKey, undefined, { resolve: true });
     }
     rejectActiveCustomUi(error) {
-        this.finishActiveCustomUi(error, { resolve: false });
+        const active = this.activeCustomUiForActiveScope();
+        if (!active)
+            return;
+        this.finishActiveCustomUi(active.scopeKey, error, { resolve: false });
     }
-    finishActiveCustomUi(value, options) {
-        const active = this.activeCustomUi;
+    finishActiveCustomUi(scopeKey, value, options) {
+        const active = this.activeCustomUis.get(scopeKey);
         if (!active)
             return;
-        this.activeCustomUi = undefined;
+        this.activeCustomUis.delete(scopeKey);
         if (this.host.getInput() !== active.savedInput)
             this.host.setInput(active.savedInput);
         try {
@@ -436,6 +459,21 @@ export class ExtensionUiController {
         if (this.host.isRunning())
             this.host.render();
     }
+    activeCustomUiForActiveScope() {
+        return this.activeCustomUis.get(this.activeScopeKey());
+    }
+    activeScopeKey() {
+        return this.normalizeScopeKey(this.host.activeExtensionUiScope?.());
+    }
+    normalizeScopeKey(scopeKey) {
+        return scopeKey ?? "";
+    }
+    scopedWidgetKey(scopeKey, key) {
+        return `${scopeKey.length}:${scopeKey}:${key}`;
+    }
+    unscopedWidgetKey(scopedKey, scopeKey) {
+        return scopedKey.slice(`${scopeKey.length}:${scopeKey}:`.length);
+    }
     invalidateWidget(widget) {
         try {
             widget.component?.dispose?.();

package/dist/app/icons.d.ts

@@ -12,6 +12,7 @@ declare const NERD_FONT_ICONS: {
     readonly deleted: "󰅙";
     readonly deferred: "󰍷";
     readonly info: "󰋼";
+    readonly lightbulb: "󰌵";
     readonly microphone: "󰍬";
     readonly plus: "󰐕";
     readonly pause: "󰏤";

package/dist/app/icons.js

@@ -18,6 +18,7 @@ const NERD_FONT_ICONS = {
     deleted: "\u{f0159}",
     deferred: "\u{f0377}",
     info: "\u{f02fc}",
+    lightbulb: "\u{f0335}",
     microphone: "\u{f036c}",
     plus: "\u{f0415}",
     pause: "\u{f03e4}",
@@ -44,6 +45,7 @@ const FALLBACK_ICONS = {
     deleted: "×",
     deferred: "↷",
     info: "i",
+    lightbulb: "💡",
     microphone: "m",
     plus: "+",
     pause: "⏸",

package/dist/app/input/input-action-controller.d.ts

@@ -19,6 +19,7 @@ export type AppInputActionControllerHost = {
     addEntry(entry: Entry): void;
     addSessionAbortedEntry(): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    dismissActiveDialog?(): boolean;
     stopVoiceInput(): Promise<void>;
     isShellCommandRunning(): boolean;
     runChatShellCommand(command: string): Promise<InteractiveShellCommandResult>;
@@ -39,6 +40,7 @@ export declare class AppInputActionController {
     queueInputFromEditor(): Promise<void>;
     handleInterrupt(): Promise<void>;
     handleEscape(): Promise<void>;
+    private closeActiveGlobalUi;
     private abortStreamingSession;
     private restoreSessionState;
     private sessionActivity;

package/dist/app/input/input-action-controller.js

@@ -63,6 +63,8 @@ export class AppInputActionController {
         await this.host.stop();
     }
     async handleEscape() {
+        if (this.closeActiveGlobalUi())
+            return;
         const session = this.host.runtime()?.session;
         if (session?.isCompacting) {
             this.host.setStatus("aborting compaction");
@@ -76,8 +78,13 @@ export class AppInputActionController {
                 await this.abortStreamingSession(runtime, { stopIfAlreadyAborting: false });
             return;
         }
-        if (this.popupMenus.syncActivePopupMenu())
+    }
+    closeActiveGlobalUi() {
+        if (this.popupMenus.syncActivePopupMenu()) {
             this.popupMenus.cancelActivePopupMenu();
+            return true;
+        }
+        return this.host.dismissActiveDialog?.() ?? false;
     }
     async abortStreamingSession(runtime, options) {
         const session = runtime.session;

package/dist/app/logger.d.ts

@@ -0,0 +1,25 @@
+export declare const PIX_LOG_MAX_LINES = 1000;
+export type PixLogLevel = "debug" | "info" | "warn" | "error";
+export type PixLogDetails = Record<string, unknown>;
+export type PixFileLoggerOptions = {
+    logPath?: string;
+    maxLines?: number;
+};
+export declare function getPixLogPath(homeDir?: string): string;
+export declare class PixFileLogger {
+    readonly logPath: string;
+    private readonly maxLines;
+    private pending;
+    constructor(options?: PixFileLoggerOptions);
+    log(level: PixLogLevel, event: string, details?: PixLogDetails): Promise<void>;
+    debug(event: string, details?: PixLogDetails): Promise<void>;
+    info(event: string, details?: PixLogDetails): Promise<void>;
+    warn(event: string, details?: PixLogDetails): Promise<void>;
+    error(event: string, details?: PixLogDetails): Promise<void>;
+    flush(): Promise<void>;
+    private formatLine;
+    private writeLine;
+}
+export declare const pixLogger: PixFileLogger;
+export declare function logPixEvent(level: PixLogLevel, event: string, details?: PixLogDetails): void;
+export declare function trimLogFile(logPath: string, maxLines?: number): Promise<void>;

package/dist/app/logger.js

@@ -0,0 +1,90 @@
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const PIX_LOG_MAX_LINES = 1000;
+export function getPixLogPath(homeDir = homedir()) {
+    return join(homeDir, ".config", "pi", "pix.log");
+}
+export class PixFileLogger {
+    logPath;
+    maxLines;
+    pending = Promise.resolve();
+    constructor(options = {}) {
+        this.logPath = options.logPath ?? getPixLogPath();
+        this.maxLines = Math.max(1, Math.floor(options.maxLines ?? PIX_LOG_MAX_LINES));
+    }
+    log(level, event, details = {}) {
+        const line = this.formatLine(level, event, details);
+        this.pending = this.pending
+            .then(() => this.writeLine(line))
+            .catch(() => undefined);
+        return this.pending;
+    }
+    debug(event, details) {
+        return this.log("debug", event, details);
+    }
+    info(event, details) {
+        return this.log("info", event, details);
+    }
+    warn(event, details) {
+        return this.log("warn", event, details);
+    }
+    error(event, details) {
+        return this.log("error", event, details);
+    }
+    async flush() {
+        await this.pending;
+    }
+    formatLine(level, event, details) {
+        return `${new Date().toISOString()} ${level.toUpperCase()} ${sanitizeToken(event)} ${safeJson(details)}\n`;
+    }
+    async writeLine(line) {
+        await mkdir(dirname(this.logPath), { recursive: true });
+        await appendFile(this.logPath, line, "utf8");
+        await trimLogFile(this.logPath, this.maxLines);
+    }
+}
+export const pixLogger = new PixFileLogger();
+export function logPixEvent(level, event, details) {
+    void pixLogger.log(level, event, details);
+}
+export async function trimLogFile(logPath, maxLines = PIX_LOG_MAX_LINES) {
+    const text = await readFile(logPath, "utf8").catch((error) => {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (text === undefined)
+        return;
+    const lines = text.split(/\r?\n/u);
+    if (lines.at(-1) === "")
+        lines.pop();
+    if (lines.length <= maxLines)
+        return;
+    await writeFile(logPath, `${lines.slice(-maxLines).join("\n")}\n`, "utf8");
+}
+function sanitizeToken(value) {
+    return value
+        .replace(/[\t\r\n]+/gu, " ")
+        .replace(/\s+/gu, "_")
+        .replace(/[^\w:.-]+/gu, "_")
+        .replace(/^_+|_+$/gu, "")
+        .slice(0, 120) || "event";
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value, (_key, item) => {
+            if (item instanceof Error)
+                return { name: item.name, message: item.message, stack: item.stack };
+            if (typeof item === "bigint")
+                return item.toString();
+            return item;
+        });
+    }
+    catch (error) {
+        return JSON.stringify({ logSerializationError: error instanceof Error ? error.message : String(error) });
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}