pi-ui-extend 1.0.42 → 1.0.45

package/dist/app/subagents/subagents-widget-controller.d.ts

@@ -4,6 +4,7 @@ export type SubagentsToolResultObserveOptions = {
 };
 export type SubagentsWidgetControllerHost = {
     readonly cwd: string;
+    hasActiveRuntime(): boolean;
     sessionFile(): string | undefined;
     isRunning(): boolean;
     render(): void;

package/dist/app/subagents/subagents-widget-controller.js

@@ -22,6 +22,8 @@ export class AppSubagentsWidgetController {
         this.host = host;
     }
     get widgetState() {
+        if (!this.host.hasActiveRuntime())
+            return undefined;
         return this.state;
     }
     startPolling() {
@@ -51,6 +53,8 @@ export class AppSubagentsWidgetController {
             return;
         if (!isSubagentRunRenderDetails(details))
             return;
+        if (!this.host.hasActiveRuntime())
+            return;
         const runDir = resolveSubagentRunDir(this.host.cwd, details.runDir);
         const normalizedDetails = { ...details, runDir };
         if (normalizedDetails.tasks)
@@ -372,6 +376,8 @@ export class AppSubagentsWidgetController {
         return activeSubagentStates(this.state?.agents ?? []).length > 0;
     }
     eventMatchesCurrentSession(eventSessionFile) {
+        if (!this.host.hasActiveRuntime())
+            return false;
         if (!eventSessionFile)
             return true;
         const sessionFile = this.host.sessionFile();

package/dist/app/types.d.ts

@@ -235,6 +235,8 @@ export type RenderedLine = {
         index: number;
     } | {
         kind: "popup-menu-close";
+    } | {
+        kind: "model-visibility-clear";
     } | {
         kind: "todo-panel";
     } | {
@@ -346,6 +348,7 @@ export type SessionTab = {
     id: string;
     title: string;
     titlePlaceholder?: "loading" | "new";
+    draft?: boolean;
     isFork?: boolean;
     status: SessionTabStatus;
     activity?: SessionActivity;
@@ -542,6 +545,7 @@ export type ModelMenuValue = {
     model: SessionModel;
     ref: string;
     current: boolean;
+    visible?: boolean;
 };
 export type ScopedSessionModel = {
     model: SessionModel;
@@ -551,6 +555,12 @@ export type ThinkingMenuValue = {
     level: ThinkingLevel;
     current: boolean;
 };
+export type ModelThinkingMenuState = {
+    thinkingLevel: ThinkingLevel;
+    availableThinkingLevels: readonly ThinkingLevel[];
+    source: "model" | "thinking";
+    visibilityMode: boolean;
+};
 export type UserMessageMenuValue = "copy" | "fork" | "fork-new-tab" | "undo";
 export type UserMessageJumpMenuValue = {
     entryId?: string;
@@ -567,7 +577,7 @@ export type ResumeMenuValue = {
     session: SessionInfo;
 };
 export type ActivePopupMenu = "slash" | "model" | "thinking" | "resume" | "user-message" | "user-message-jump" | "queue-message" | "sdk-menu";
-export type PopupMenuPlacement = "default" | "under-tabs";
+export type PopupMenuPlacement = "default" | "under-tabs" | "draft-surface";
 export type StatusThinkingTarget = {
     row: number;
     startColumn: number;

package/dist/app/workspace/workspace-actions-controller.js

@@ -2,7 +2,7 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { copyTextToClipboard } from "../screen/clipboard.js";
 import { isRecord } from "../guards.js";
 import { createId } from "../id.js";
-import { loadWorkspaceUndoIndex, prepareWorkspaceMutation, revertWorkspaceMutations, saveWorkspaceUndoIndex, workspaceMutationFromToolExecution, workspaceUndoIndexKey, } from "./workspace-undo.js";
+import { loadWorkspaceUndoIndex, prepareWorkspaceMutation, revertWorkspaceMutations, saveWorkspaceUndoIndex, workspaceMutationFromToolExecution, WORKSPACE_MUTATION_ENTRY_TYPE, workspaceUndoIndexKey, } from "./workspace-undo.js";
 export class AppWorkspaceActionsController {
     host;
     workspaceUndoIndex = loadWorkspaceUndoIndex(getAgentDir());
@@ -23,8 +23,16 @@ export class AppWorkspaceActionsController {
             return;
         entry.workspaceMutations = [...(entry.workspaceMutations ?? []), mutation];
         const sessionEntryId = this.resolveUserSessionEntryId(entry);
-        if (sessionEntryId)
+        if (sessionEntryId) {
             this.persistWorkspaceMutations(sessionEntryId, entry.workspaceMutations);
+            // Also persist each new mutation in the session branch so Desktop and
+            // future renderers can perform the same message-scoped undo without
+            // relying on this process-wide compatibility index.
+            this.host.runtime()?.session.sessionManager.appendCustomEntry?.(WORKSPACE_MUTATION_ENTRY_TYPE, {
+                userEntryId: sessionEntryId,
+                mutation,
+            });
+        }
         this.host.touchEntry(entry);
     }
     scheduleUserSessionEntryMetadataSync() {

package/dist/app/workspace/workspace-undo.d.ts

@@ -36,6 +36,7 @@ export type WorkspaceRevertResult = {
     ok: false;
     error: string;
 };
+export declare const WORKSPACE_MUTATION_ENTRY_TYPE = "pix-workspace-mutation";
 export declare function workspaceUndoIndexKey(_sessionFile: string | undefined, _sessionId: string, entryId: string): string;
 export declare function loadWorkspaceUndoIndex(agentDir: string): WorkspaceUndoIndex;
 export declare function saveWorkspaceUndoIndex(agentDir: string, index: WorkspaceUndoIndex): void;

package/dist/app/workspace/workspace-undo.js

@@ -3,6 +3,7 @@ import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { runProcess } from "../process.js";
 const UNDO_INDEX_VERSION = 1;
+export const WORKSPACE_MUTATION_ENTRY_TYPE = "pix-workspace-mutation";
 export function workspaceUndoIndexKey(_sessionFile, _sessionId, entryId) {
     return entryId;
 }

package/dist/bundled-extensions/question/index.js

@@ -3,6 +3,7 @@ import { questionParameters, normalizeQuestionInput } from "./contract.js";
 import { renderQuestionCall, renderQuestionResult } from "./render.js";
 import { createCanceledQuestionResult, createQuestionToolResult, createSuccessfulQuestionResult } from "./result.js";
 import { runDesktopQuestionnaire, shouldUseDesktopQuestionBridge } from "./desktop.js";
+import { runRemoteQuestionnaire } from "./remote.js";
 import { runQuestionnaire } from "./tui.js";
 export default function questionExtension(pi) {
     pi.registerTool({
@@ -14,8 +15,15 @@ export default function questionExtension(pi) {
         renderResult(result, _options, theme, context) {
             return renderQuestionResult(result, theme, context.args);
         },
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
             const questions = normalizeQuestionInput(params);
+            const sessionId = ctx.sessionManager?.getSessionId();
+            const remoteSelections = sessionId ? await runRemoteQuestionnaire(sessionId, questions, signal) : undefined;
+            if (remoteSelections !== undefined) {
+                if (remoteSelections === null)
+                    return createQuestionToolResult(createCanceledQuestionResult("user_canceled"), questions);
+                return createQuestionToolResult(createSuccessfulQuestionResult(questions, remoteSelections), questions);
+            }
             if (!ctx.hasUI)
                 return createQuestionToolResult(createCanceledQuestionResult("ui_unavailable", questions), questions);
             const selections = shouldUseDesktopQuestionBridge(ctx)

package/dist/bundled-extensions/question/remote.d.ts

@@ -0,0 +1,4 @@
+import type { NormalizedQuestion, QuestionSelection } from "./types.js";
+export type RemoteQuestionHandler = (questions: NormalizedQuestion[], signal?: AbortSignal) => Promise<QuestionSelection[] | null | undefined>;
+export declare function registerRemoteQuestionHandler(sessionId: string, handler: RemoteQuestionHandler): () => void;
+export declare function runRemoteQuestionnaire(sessionId: string, questions: NormalizedQuestion[], signal?: AbortSignal): Promise<QuestionSelection[] | null | undefined>;

package/dist/bundled-extensions/question/remote.js

@@ -0,0 +1,33 @@
+const REGISTRY_KEY = Symbol.for("pix.question.remote-registry.v1");
+export function registerRemoteQuestionHandler(sessionId, handler) {
+    const registry = remoteQuestionRegistry();
+    registry.set(sessionId, handler);
+    let active = true;
+    return () => {
+        if (!active)
+            return;
+        active = false;
+        if (registry.get(sessionId) === handler)
+            registry.delete(sessionId);
+    };
+}
+export async function runRemoteQuestionnaire(sessionId, questions, signal) {
+    const handler = remoteQuestionRegistry().get(sessionId);
+    if (!handler)
+        return undefined;
+    try {
+        return await handler(questions, signal);
+    }
+    catch {
+        if (signal?.aborted)
+            return null;
+        // Remote integrations are optional. If Telegram/networking fails before an
+        // answer is obtained, fall back to the normal local question UI.
+        return undefined;
+    }
+}
+function remoteQuestionRegistry() {
+    const root = globalThis;
+    root[REGISTRY_KEY] ??= new Map();
+    return root[REGISTRY_KEY];
+}

package/dist/bundled-extensions/telegram-connector/bot.d.ts

@@ -0,0 +1,43 @@
+export type TelegramBotClientOptions = {
+    sendTimeoutMs?: number;
+    pollRequestTimeoutMs?: number;
+};
+export type TelegramIncomingMessage = {
+    messageId: number;
+    chatId: string;
+    text: string;
+    replyToMessageId?: number;
+};
+type TelegramUpdate = {
+    update_id?: unknown;
+    message?: {
+        message_id?: unknown;
+        chat?: {
+            id?: unknown;
+        };
+        text?: unknown;
+        reply_to_message?: {
+            message_id?: unknown;
+        };
+    };
+};
+export type TelegramFetch = typeof fetch;
+export declare class TelegramBotClient {
+    private readonly botToken;
+    private readonly chatId;
+    private readonly fetchFn;
+    private readonly options;
+    private running;
+    private abortController;
+    private nextOffset;
+    constructor(botToken: string, chatId: string, fetchFn?: TelegramFetch, options?: TelegramBotClientOptions);
+    start(onMessage: (message: TelegramIncomingMessage) => void | Promise<void>, onError?: (error: Error) => void): void;
+    stop(): void;
+    sendMessage(text: string, signal?: AbortSignal): Promise<number>;
+    private pollLoop;
+    private sanitizeError;
+    private call;
+}
+export declare function normalizeIncomingMessage(update: TelegramUpdate): TelegramIncomingMessage | undefined;
+export declare function trimTelegramText(text: string): string;
+export {};

package/dist/bundled-extensions/telegram-connector/bot.js

@@ -0,0 +1,166 @@
+const TELEGRAM_API_BASE = "https://api.telegram.org";
+const MAX_TELEGRAM_TEXT = 4000;
+const POLL_TIMEOUT_SECONDS = 25;
+const DEFAULT_SEND_TIMEOUT_MS = 10_000;
+const DEFAULT_POLL_REQUEST_TIMEOUT_MS = (POLL_TIMEOUT_SECONDS + 10) * 1000;
+export class TelegramBotClient {
+    botToken;
+    chatId;
+    fetchFn;
+    options;
+    running = false;
+    abortController;
+    nextOffset;
+    constructor(botToken, chatId, fetchFn = fetch, options = {}) {
+        this.botToken = botToken;
+        this.chatId = chatId;
+        this.fetchFn = fetchFn;
+        this.options = options;
+    }
+    start(onMessage, onError = () => { }) {
+        if (this.running)
+            return;
+        this.running = true;
+        this.abortController = new AbortController();
+        void this.pollLoop(onMessage, onError, this.abortController.signal);
+    }
+    stop() {
+        this.running = false;
+        this.abortController?.abort();
+        this.abortController = undefined;
+    }
+    async sendMessage(text, signal) {
+        try {
+            const body = await this.call("sendMessage", {
+                chat_id: this.chatId,
+                text: trimTelegramText(text),
+                disable_web_page_preview: true,
+            }, signal);
+            if (!body || typeof body.message_id !== "number")
+                throw new Error("Telegram sendMessage returned no message id");
+            return body.message_id;
+        }
+        catch (error) {
+            throw this.sanitizeError(error);
+        }
+    }
+    async pollLoop(onMessage, onError, signal) {
+        let failures = 0;
+        let baselineReady = false;
+        while (this.running && !signal.aborted) {
+            try {
+                if (!baselineReady) {
+                    const pending = await this.call("getUpdates", {
+                        offset: -1,
+                        limit: 1,
+                        timeout: 0,
+                        allowed_updates: ["message"],
+                    }, signal);
+                    const latestUpdateId = pending
+                        ?.map((update) => update.update_id)
+                        .filter((updateId) => typeof updateId === "number")
+                        .at(-1);
+                    if (latestUpdateId !== undefined)
+                        this.nextOffset = latestUpdateId + 1;
+                    baselineReady = true;
+                    failures = 0;
+                    continue;
+                }
+                const updates = await this.call("getUpdates", {
+                    ...(this.nextOffset === undefined ? {} : { offset: this.nextOffset }),
+                    timeout: POLL_TIMEOUT_SECONDS,
+                    allowed_updates: ["message"],
+                }, signal);
+                failures = 0;
+                for (const update of updates ?? []) {
+                    if (typeof update.update_id === "number")
+                        this.nextOffset = update.update_id + 1;
+                    const message = normalizeIncomingMessage(update);
+                    if (!message || message.chatId !== this.chatId)
+                        continue;
+                    await onMessage(message);
+                }
+            }
+            catch (error) {
+                if (signal.aborted || !this.running)
+                    return;
+                failures += 1;
+                onError(this.sanitizeError(error));
+                await sleep(Math.min(30_000, 500 * 2 ** Math.min(failures - 1, 6)), signal);
+            }
+        }
+    }
+    sanitizeError(error) {
+        const message = asError(error).message.replaceAll(this.botToken, "[redacted]");
+        return new Error(message);
+    }
+    async call(method, payload, signal) {
+        const requestSignal = combineAbortSignals([
+            signal,
+            this.abortController?.signal,
+        ], method === "getUpdates"
+            ? this.options.pollRequestTimeoutMs ?? DEFAULT_POLL_REQUEST_TIMEOUT_MS
+            : this.options.sendTimeoutMs ?? DEFAULT_SEND_TIMEOUT_MS);
+        const response = await this.fetchFn(`${TELEGRAM_API_BASE}/bot${this.botToken}/${method}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            signal: requestSignal,
+        });
+        let parsed;
+        try {
+            parsed = await response.json();
+        }
+        catch {
+            // Fall through to the sanitized HTTP error below.
+        }
+        if (!response.ok || parsed?.ok !== true) {
+            const description = typeof parsed?.description === "string" ? `: ${parsed.description}` : "";
+            throw new Error(`Telegram ${method} failed (${response.status})${description}`);
+        }
+        return parsed.result;
+    }
+}
+function combineAbortSignals(signals, timeoutMs) {
+    const active = signals.filter((signal) => signal !== undefined);
+    active.push(AbortSignal.timeout(Math.max(1, timeoutMs)));
+    return active.length === 1 ? active[0] : AbortSignal.any(active);
+}
+export function normalizeIncomingMessage(update) {
+    const message = update.message;
+    if (!message || typeof message.message_id !== "number" || typeof message.text !== "string")
+        return undefined;
+    const rawChatId = message.chat?.id;
+    if (typeof rawChatId !== "number" && typeof rawChatId !== "string")
+        return undefined;
+    const text = message.text.trim();
+    if (!text)
+        return undefined;
+    const rawReplyId = message.reply_to_message?.message_id;
+    return {
+        messageId: message.message_id,
+        chatId: String(rawChatId),
+        text,
+        ...(typeof rawReplyId === "number" ? { replyToMessageId: rawReplyId } : {}),
+    };
+}
+export function trimTelegramText(text) {
+    if (text.length <= MAX_TELEGRAM_TEXT)
+        return text;
+    return `${text.slice(0, MAX_TELEGRAM_TEXT - 2)}…`;
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+async function sleep(ms, signal) {
+    if (signal.aborted)
+        return;
+    await new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        timer.unref?.();
+        signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}

package/dist/bundled-extensions/telegram-connector/config.d.ts

@@ -0,0 +1,8 @@
+export type TelegramConnectorConfig = {
+    enabled: boolean;
+    botToken?: string;
+    chatId?: string;
+};
+export declare function getTelegramConnectorConfigPath(homeDir?: string): string;
+export declare function readTelegramConnectorConfig(configPath?: string): TelegramConnectorConfig;
+export declare function resolveTelegramConnectorConfig(configPath?: string, environment?: NodeJS.ProcessEnv): TelegramConnectorConfig;

package/dist/bundled-extensions/telegram-connector/config.js

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+const CONFIG_KEY = "telegramConnector";
+const ENV_ENABLED = "PIX_TELEGRAM_CONNECTOR";
+const ENV_BOT_TOKEN = "PIX_TELEGRAM_BOT_TOKEN";
+const ENV_CHAT_ID = "PIX_TELEGRAM_CHAT_ID";
+export function getTelegramConnectorConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".config", "pi", "pi-tools-suite.jsonc");
+}
+export function readTelegramConnectorConfig(configPath = getTelegramConnectorConfigPath()) {
+    return readTelegramConnectorConfigState(configPath).config;
+}
+function readTelegramConnectorConfigState(configPath) {
+    if (!existsSync(configPath))
+        return { config: { enabled: false }, explicitlyDisabled: false };
+    try {
+        const parsed = parseJsonc(readFileSync(configPath, "utf-8"));
+        if (!isRecord(parsed))
+            return { config: { enabled: false }, explicitlyDisabled: false };
+        const raw = parsed[CONFIG_KEY];
+        if (!isRecord(raw))
+            return { config: { enabled: false }, explicitlyDisabled: false };
+        const botToken = nonEmptyString(raw.botToken);
+        const chatId = normalizeChatId(raw.chatId);
+        const explicitlyDisabled = raw.enabled === false;
+        return {
+            config: {
+                enabled: !explicitlyDisabled && Boolean(botToken && chatId),
+                ...(botToken ? { botToken } : {}),
+                ...(chatId ? { chatId } : {}),
+            },
+            explicitlyDisabled,
+        };
+    }
+    catch {
+        return { config: { enabled: false }, explicitlyDisabled: false };
+    }
+}
+export function resolveTelegramConnectorConfig(configPath = getTelegramConnectorConfigPath(), environment = process.env) {
+    const { config: fromConfig, explicitlyDisabled } = readTelegramConnectorConfigState(configPath);
+    const envBotToken = nonEmptyString(environment[ENV_BOT_TOKEN]);
+    const envChatId = normalizeChatId(environment[ENV_CHAT_ID]);
+    const botToken = envBotToken ?? fromConfig.botToken;
+    const chatId = envChatId ?? fromConfig.chatId;
+    const envEnabled = parseBooleanEnv(environment[ENV_ENABLED]);
+    const enabled = envEnabled === false
+        ? false
+        : envEnabled === true
+            ? Boolean(botToken && chatId)
+            : explicitlyDisabled
+                ? false
+                : Boolean(botToken && chatId);
+    return {
+        enabled,
+        ...(botToken ? { botToken } : {}),
+        ...(chatId ? { chatId } : {}),
+    };
+}
+function normalizeChatId(value) {
+    if (typeof value === "number" && Number.isSafeInteger(value))
+        return String(value);
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return /^-?\d+$/.test(trimmed) ? trimmed : undefined;
+}
+function nonEmptyString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function parseBooleanEnv(value) {
+    if (value === undefined || value.trim() === "")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "off"].includes(normalized))
+        return false;
+    return undefined;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/bundled-extensions/telegram-connector/coordinator.d.ts

@@ -0,0 +1,66 @@
+import type { NormalizedQuestion, QuestionSelection } from "../question/types.js";
+import { TelegramBotClient, type TelegramIncomingMessage } from "./bot.js";
+import type { TelegramConnectorConfig } from "./config.js";
+export type TelegramCompletionKind = "complete" | "error";
+export type TelegramSessionEndpoint = {
+    sessionId: string;
+    cwd: string;
+    getTitle(): string;
+    isIdle(): boolean;
+    sendUserMessage(text: string): void;
+    dispatchNewSession(requestId: string): void;
+};
+type BotLike = Pick<TelegramBotClient, "start" | "stop" | "sendMessage">;
+type BotFactory = (botToken: string, chatId: string) => BotLike;
+export declare class TelegramConnectorCoordinator {
+    private readonly createBot;
+    private readonly reportError;
+    private readonly sessions;
+    private readonly completionRoutes;
+    private readonly pendingQuestions;
+    private readonly newSessionRequests;
+    private readonly newSessionSources;
+    private bot;
+    private botKey;
+    private focusSessionId;
+    private stopTimer;
+    constructor(createBot?: BotFactory, reportError?: (message: string) => void);
+    attachSession(endpoint: TelegramSessionEndpoint, config: TelegramConnectorConfig): void;
+    detachSession(sessionId: string, endpoint?: TelegramSessionEndpoint): void;
+    notifyCompletion(sessionId: string, kind: TelegramCompletionKind, summary?: string): Promise<void>;
+    askQuestions(sessionId: string, questions: NormalizedQuestion[], signal?: AbortSignal): Promise<QuestionSelection[] | null | undefined>;
+    createNewSessionRequest(sourceSessionId: string, task: string): string | undefined;
+    consumeNewSessionRequest(requestId: string, sourceSessionId: string): string | undefined;
+    finishNewSessionRequest(sourceSessionId: string): void;
+    announceNewSession(sessionId: string): Promise<void>;
+    sendStatus(): Promise<void>;
+    sendHelp(): Promise<void>;
+    sendNotice(text: string): Promise<void>;
+    handleIncoming(message: TelegramIncomingMessage): Promise<void>;
+    stop(): void;
+    private ensureBot;
+    private waitForQuestionReply;
+    private resolvePendingQuestion;
+    private cancelPendingQuestion;
+    private rememberCompletionRoute;
+    private hasPendingQuestionFor;
+    private pruneExpiredNewSessionRequests;
+    private scheduleStop;
+    private clearStopTimer;
+}
+type ParsedTelegramCommand = {
+    kind: "new";
+    task: string;
+} | {
+    kind: "help";
+} | {
+    kind: "status";
+} | {
+    kind: "message";
+    text: string;
+};
+export declare function parseTelegramCommand(text: string): ParsedTelegramCommand;
+export declare function parseQuestionAnswer(question: NormalizedQuestion, answer: string): QuestionSelection | undefined;
+export declare function getTelegramConnectorCoordinator(): TelegramConnectorCoordinator;
+export declare function resetTelegramConnectorCoordinatorForTests(): void;
+export {};