pi-ui-extend 1.0.41 → 1.0.45

package/dist/app/subagents/subagents-files.js

@@ -1,7 +1,8 @@
-import { readFile, readdir, realpath, stat } from "node:fs/promises";
+import { open, readFile, readdir, realpath, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { SUBAGENT_PARENT_SESSION_FILE, SUBAGENTS_REGISTRY_FILE, SUBAGENTS_RUN_ROOT } from "../constants.js";
 import { isSubagentRegistry } from "./subagents-model.js";
+const LAST_ACTIVITY_TAIL_BYTES = 64 * 1024;
 export function subagentsRegistryPath(cwd) {
     return join(cwd, SUBAGENTS_RUN_ROOT, SUBAGENTS_REGISTRY_FILE);
 }
@@ -110,6 +111,9 @@ async function readSubagentAgentState(runDir, agentId, options) {
     const finishedAt = await readTrimmedFile(join(agentDir, "finished_at"));
     if (finishedAt)
         state.finishedAt = finishedAt;
+    const lastActivity = await readLastActivity(join(agentDir, "progress.jsonl"));
+    if (lastActivity)
+        state.lastActivity = lastActivity;
     const retryPending = await fileExists(join(agentDir, "retry_pending"));
     const stopRequested = await fileExists(join(agentDir, "stop_requested"));
     if (retryPending && !stopRequested && state.status !== "running" && state.status !== "done") {
@@ -179,6 +183,61 @@ async function readNumberFile(filePath) {
     const value = Number.parseInt(raw, 10);
     return Number.isFinite(value) ? value : undefined;
 }
+async function readLastActivity(filePath) {
+    let handle;
+    try {
+        handle = await open(filePath, "r");
+        const size = (await handle.stat()).size;
+        if (size <= 0)
+            return undefined;
+        const start = Math.max(0, size - LAST_ACTIVITY_TAIL_BYTES);
+        const buffer = Buffer.allocUnsafe(size - start);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+        if (bytesRead <= 0)
+            return undefined;
+        const lines = buffer.toString("utf8", 0, bytesRead).split(/\r?\n/);
+        if (start > 0) {
+            const previousByte = Buffer.allocUnsafe(1);
+            const previousRead = await handle.read(previousByte, 0, 1, start - 1);
+            if (previousRead.bytesRead === 1 && previousByte[0] !== 0x0a)
+                lines.shift();
+        }
+        for (let index = lines.length - 1; index >= 0; index--) {
+            const line = lines[index]?.trim();
+            if (!line)
+                continue;
+            try {
+                const value = JSON.parse(line);
+                if (!isProgressActivityRecord(value))
+                    continue;
+                const toolName = typeof value.toolName === "string" ? value.toolName.trim() : "";
+                if (toolName)
+                    return { label: toolName, at: value.at };
+                if (value.type === "message_start" || value.type === "message_end")
+                    return { label: "Thinking", at: value.at };
+            }
+            catch {
+                // Ignore malformed or partially written tail lines and keep scanning.
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    return undefined;
+}
+function isProgressActivityRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const record = value;
+    return record.stage === "rpc_event"
+        && typeof record.at === "string"
+        && record.at.trim().length > 0
+        && typeof record.type === "string";
+}
 async function countFileLines(filePath) {
     try {
         const content = await readFile(filePath, "utf8");

package/dist/app/subagents/subagents-model.d.ts

@@ -32,5 +32,6 @@ export declare function allSubagentStatesTerminal(agents: readonly SubagentAgent
 export declare function taskPreviewMap(tasks: readonly SubagentTaskPreview[] | undefined): Map<string, SubagentTaskPreview>;
 export declare function formatSubagentTimestamp(value: string | undefined): string | undefined;
 export declare function formatElapsedSince(value: string | undefined, now?: number): string;
+export declare function formatSubagentLastActivity(activity: SubagentAgentState["lastActivity"]): string | undefined;
 export declare function subagentRunName(runDir: string): string;
 export declare function resolveSubagentRunDir(cwd: string, runDir: string): string;

package/dist/app/subagents/subagents-model.js

@@ -43,6 +43,14 @@ export function isSubagentAgentState(value) {
         return false;
     if (value.retryCount !== undefined && typeof value.retryCount !== "number")
         return false;
+    if (value.lastActivity !== undefined) {
+        if (!isRecord(value.lastActivity))
+            return false;
+        if (typeof value.lastActivity.label !== "string" || !value.lastActivity.label.trim())
+            return false;
+        if (typeof value.lastActivity.at !== "string" || !value.lastActivity.at.trim())
+            return false;
+    }
     return true;
 }
 export function isSubagentTaskPreview(value) {
@@ -219,11 +227,19 @@ export function formatSubagentTimestamp(value) {
     return new Date(time).toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit", second: "2-digit" });
 }
 export function formatElapsedSince(value, now = Date.now()) {
+    return formatDurationSince(value, now) ?? "elapsed:—";
+}
+export function formatSubagentLastActivity(activity) {
+    if (!activity)
+        return undefined;
+    return activity.label.trim() || undefined;
+}
+function formatDurationSince(value, now) {
     if (!value)
-        return "elapsed:—";
+        return undefined;
     const started = Date.parse(value);
     if (!Number.isFinite(started))
-        return "elapsed:—";
+        return undefined;
     const seconds = Math.max(0, Math.floor((now - started) / 1000));
     if (seconds < 60)
         return `${seconds}s`;

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

@@ -139,6 +139,10 @@ export type SubagentStatus = (typeof SUBAGENT_STATUSES)[number];
 export type SubagentActiveStatus = (typeof SUBAGENT_ACTIVE_STATUSES)[number];
 export type SubagentTerminalStatus = (typeof SUBAGENT_TERMINAL_STATUSES)[number];
 export type SubagentRenderMode = (typeof SUBAGENT_RENDER_MODES)[number];
+export type SubagentActivity = {
+    label: string;
+    at: string;
+};
 export type SubagentAgentState = {
     id: string;
     status: SubagentStatus;
@@ -151,6 +155,7 @@ export type SubagentAgentState = {
     stderrLines?: number;
     eventLines?: number;
     retryCount?: number;
+    lastActivity?: SubagentActivity;
 };
 export type SubagentTaskPreview = {
     id: string;
@@ -230,6 +235,8 @@ export type RenderedLine = {
         index: number;
     } | {
         kind: "popup-menu-close";
+    } | {
+        kind: "model-visibility-clear";
     } | {
         kind: "todo-panel";
     } | {
@@ -341,6 +348,7 @@ export type SessionTab = {
     id: string;
     title: string;
     titlePlaceholder?: "loading" | "new";
+    draft?: boolean;
     isFork?: boolean;
     status: SessionTabStatus;
     activity?: SessionActivity;
@@ -537,6 +545,7 @@ export type ModelMenuValue = {
     model: SessionModel;
     ref: string;
     current: boolean;
+    visible?: boolean;
 };
 export type ScopedSessionModel = {
     model: SessionModel;
@@ -546,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;
@@ -562,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);
+}