pockcode 0.0.1

package/dist/assets/manager.server-Cru4ZxHo.js

@@ -0,0 +1,1334 @@
+import { c as readWorkspaceTree, n as onProviderEvent, p as __exportAll } from "./socket.server-7dC-9Fnw.js";
+import { E as listAccounts, H as ensureDatabase, T as listAccountModels, U as prisma, _ as serializeChat, a as executeMessage, b as updateChat, h as respondToServerRequest, l as listChats, s as getChat, u as listMessages } from "./chats.service-H6m23Fna.js";
+import { randomBytes, randomUUID } from "node:crypto";
+import { Bot, InlineKeyboard } from "grammy";
+//#region app/server/workspace-history.service.ts
+async function listWorkspaceHistory() {
+	await ensureDatabase();
+	return (await prisma.$queryRaw`
+    SELECT "id", "path", "name", "lastOpenedAt", "createdAt", "updatedAt"
+    FROM "WorkspaceHistory"
+    ORDER BY "lastOpenedAt" DESC
+  `).map(serializeWorkspaceHistory);
+}
+async function saveWorkspaceHistory(inputPath) {
+	await ensureDatabase();
+	const tree = await readWorkspaceTree(inputPath, false);
+	const id = randomUUID();
+	await prisma.$executeRaw`
+    INSERT INTO "WorkspaceHistory" ("id", "path", "name", "lastOpenedAt", "createdAt", "updatedAt")
+    VALUES (${id}, ${tree.path}, ${tree.name}, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+    ON CONFLICT("path") DO UPDATE SET
+      "name" = excluded."name",
+      "lastOpenedAt" = CURRENT_TIMESTAMP,
+      "updatedAt" = CURRENT_TIMESTAMP
+  `;
+	return readWorkspaceHistory(tree.path);
+}
+async function deleteWorkspaceHistory(inputPath) {
+	await ensureDatabase();
+	await prisma.$executeRaw`DELETE FROM "WorkspaceHistory" WHERE "path" = ${inputPath}`;
+	return { path: inputPath };
+}
+async function readWorkspaceHistory(path) {
+	const row = (await prisma.$queryRaw`
+    SELECT "id", "path", "name", "lastOpenedAt", "createdAt", "updatedAt"
+    FROM "WorkspaceHistory"
+    WHERE "path" = ${path}
+    LIMIT 1
+  `)[0];
+	if (!row) throw new Error("Workspace history was not saved.");
+	return serializeWorkspaceHistory(row);
+}
+function serializeWorkspaceHistory(row) {
+	return {
+		id: row.id,
+		path: row.path,
+		name: row.name,
+		lastOpenedAt: toIsoString(row.lastOpenedAt),
+		createdAt: toIsoString(row.createdAt),
+		updatedAt: toIsoString(row.updatedAt)
+	};
+}
+function toIsoString(value) {
+	return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+//#endregion
+//#region app/server/plugins/telegram.server.ts
+var telegramPluginId = "telegram";
+var callbackTtlMs = 3600 * 1e3;
+var telegramListPageSize = 4;
+var telegramMessageMaxLength = 3900;
+var telegramMessageTailLines = 20;
+async function verifyTelegramBotToken(token) {
+	if (!token.trim()) throw new Error("Telegram bot token is required.");
+	try {
+		await new Bot(token.trim()).api.getMe();
+	} catch (error) {
+		throw new Error(`Telegram bot token is invalid: ${readErrorMessage$1(error)}`);
+	}
+}
+var telegramPluginRegistration = {
+	definition: {
+		id: telegramPluginId,
+		label: "Telegram",
+		description: "Receive chat updates, browse workspaces, and reply from Telegram.",
+		icon: "telegram",
+		defaultSettings: {},
+		settingsFields: [],
+		secretFields: [{
+			key: "botToken",
+			label: "Bot token",
+			placeholder: "123456:ABC...",
+			required: true,
+			secret: true,
+			type: "secret"
+		}]
+	},
+	runtime: () => new TelegramPluginRuntime(),
+	actions: {
+		async clearOwner(context) {
+			const pairingCode = createPairingCode();
+			await context.updateState((state) => serializeTelegramState({
+				botUsername: readTelegramState(state).botUsername,
+				owner: null,
+				pairingCode,
+				selectedChats: {},
+				subscriptions: {}
+			}));
+			return { message: "Telegram owner cleared." };
+		},
+		async refreshPairingCode(context) {
+			const pairingCode = createPairingCode();
+			await context.updateState((state) => serializeTelegramState({
+				...readTelegramState(state),
+				pairingCode
+			}));
+			return { message: "Pairing code refreshed." };
+		}
+	},
+	summarizeState(state) {
+		const telegramState = readTelegramState(state);
+		return {
+			ownerChatId: telegramState.owner?.chatId ?? null,
+			ownerLabel: telegramState.owner?.displayName ?? null,
+			ownerUserId: telegramState.owner?.userId ?? null,
+			botUsername: telegramState.botUsername,
+			pairingCode: telegramState.pairingCode,
+			subscriptionCount: Object.keys(telegramState.subscriptions).length
+		};
+	}
+};
+var TelegramPluginRuntime = class {
+	constructor() {
+		this.bot = null;
+		this.callbackTokens = /* @__PURE__ */ new Map();
+		this.context = null;
+		this.pollingPromise = null;
+		this.replyTargetsByTelegramMessageId = /* @__PURE__ */ new Map();
+		this.subscriptionTailUpdateQueue = /* @__PURE__ */ new Map();
+	}
+	async start(context) {
+		this.context = context;
+		const token = readRecordString(context.secrets, "botToken");
+		await verifyTelegramBotToken(token);
+		await this.ensurePairingCode();
+		const bot = new Bot(token);
+		this.bot = bot;
+		this.installHandlers(bot);
+		bot.catch((error) => {
+			context.setStatus({
+				state: "error",
+				message: error.error instanceof Error ? error.error.message : "Telegram bot failed."
+			});
+		});
+		const me = await bot.api.getMe();
+		await context.updateState((state) => serializeTelegramState({
+			...readTelegramState(state),
+			botUsername: me.username ?? null
+		}));
+		await bot.api.setMyCommands([
+			{
+				command: "start",
+				description: "Pair or open Pockcode"
+			},
+			{
+				command: "workspaces",
+				description: "List workspaces"
+			},
+			{
+				command: "subscriptions",
+				description: "List chat subscriptions"
+			},
+			{
+				command: "help",
+				description: "Show actions"
+			}
+		]).catch(() => void 0);
+		await this.rememberSubscriptionReplyTargets();
+		context.setStatus({
+			state: "running",
+			message: `Connected as @${me.username ?? me.first_name}`
+		});
+		this.pollingPromise = this.runPolling(bot, context);
+	}
+	async stop() {
+		const bot = this.bot;
+		const pollingPromise = this.pollingPromise;
+		this.bot = null;
+		this.context = null;
+		this.pollingPromise = null;
+		this.callbackTokens.clear();
+		this.replyTargetsByTelegramMessageId.clear();
+		this.subscriptionTailUpdateQueue.clear();
+		if (!bot) return;
+		try {
+			if (bot.isRunning()) await bot.stop();
+		} catch {}
+		await pollingPromise?.catch(() => void 0);
+	}
+	async runPolling(bot, context) {
+		try {
+			await bot.start({ drop_pending_updates: true });
+		} catch (error) {
+			if (this.bot === bot) {
+				this.bot = null;
+				context.setStatus({
+					state: "error",
+					message: readTelegramPollingError(error)
+				});
+			}
+		}
+	}
+	async handleProviderEvent(event) {
+		if (!this.bot || !this.context) return;
+		if (event.type === "message.created") {
+			const message = readChatMessage(event.payload);
+			if (message && shouldUpdateSubscriptionTailForMessage(message)) await this.queueSubscribedChatTailUpdate(message.chatId);
+			return;
+		}
+	}
+	installHandlers(bot) {
+		bot.command("start", (ctx) => this.handleStart(ctx));
+		bot.command("help", (ctx) => this.showMainMenu(ctx));
+		bot.command("workspaces", (ctx) => this.showWorkspaces(ctx));
+		bot.command("subscriptions", (ctx) => this.showSubscriptions(ctx));
+		bot.on("callback_query:data", (ctx) => this.handleCallback(ctx));
+		bot.on("message:text", (ctx) => this.handleTextMessage(ctx));
+	}
+	async handleStart(ctx) {
+		const payload = (ctx.message?.text ?? "").split(/\s+/)[1]?.trim();
+		const subscribeChatId = readSubscribeStartPayload(payload);
+		const from = ctx.from;
+		const chat = ctx.chat;
+		if (!from || !chat) return;
+		const state = await this.readState();
+		if (!state.owner) {
+			if (!payload || subscribeChatId || payload.toUpperCase() !== state.pairingCode?.toUpperCase()) {
+				await ctx.reply("Open Pockcode Plugins and send /start followed by the current pairing code.");
+				return;
+			}
+			const owner = {
+				chatId: chat.id,
+				displayName: displayNameForTelegramUser(from),
+				pairedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				userId: from.id,
+				username: from.username ?? null
+			};
+			await this.writeState({
+				...state,
+				owner,
+				pairingCode: null
+			});
+			await ctx.reply("Telegram is paired with Pockcode.", { reply_markup: this.mainKeyboard() });
+			return;
+		}
+		if (!this.isOwner(from.id, state)) {
+			await ctx.reply("This bot is already paired.");
+			return;
+		}
+		const nextState = await this.rememberOwnerChat(ctx, state);
+		if (subscribeChatId) {
+			try {
+				await this.subscribeChatForTelegramChat(ctx, subscribeChatId, nextState);
+			} catch (error) {
+				await ctx.reply(readErrorMessage$1(error), { reply_markup: this.mainKeyboard() });
+			}
+			return;
+		}
+		await this.showMainMenu(ctx);
+	}
+	async handleTextMessage(ctx) {
+		const text = ctx.message?.text?.trim();
+		if (!text || text.startsWith("/")) return;
+		const state = await this.requireOwner(ctx);
+		if (!state) return;
+		const replyMessageId = ctx.message?.reply_to_message?.message_id;
+		const chatId = (replyMessageId ? this.replyTargetsByTelegramMessageId.get(replyMessageId) : null) ?? state.selectedChats[String(ctx.chat?.id ?? state.owner?.chatId ?? "")];
+		if (!chatId) {
+			await ctx.reply("Choose a chat first.", { reply_markup: this.mainKeyboard() });
+			return;
+		}
+		try {
+			await executeMessage(chatId, { content: text });
+			await ctx.reply("Sent to chat.");
+		} catch (error) {
+			await ctx.reply(readErrorMessage$1(error));
+		}
+	}
+	async handleCallback(ctx) {
+		const state = await this.requireOwner(ctx);
+		if (!state) {
+			await ctx.answerCallbackQuery().catch(() => void 0);
+			return;
+		}
+		const payload = this.readCallbackPayload(ctx.callbackQuery?.data);
+		if (!payload) {
+			await ctx.answerCallbackQuery({ text: "This action expired." }).catch(() => void 0);
+			return;
+		}
+		await ctx.answerCallbackQuery().catch(() => void 0);
+		await this.rememberOwnerChat(ctx, state);
+		try {
+			await this.runCallback(ctx, payload);
+		} catch (error) {
+			await this.replyOrEdit(ctx, readErrorMessage$1(error), this.mainKeyboard());
+		}
+	}
+	async runCallback(ctx, payload) {
+		if (payload.type === "main") {
+			await this.showMainMenu(ctx);
+			return;
+		}
+		if (payload.type === "workspaces") {
+			await this.showWorkspaces(ctx, payload.page);
+			return;
+		}
+		if (payload.type === "workspace") {
+			await this.showWorkspaceChats(ctx, payload.path, payload.page);
+			return;
+		}
+		if (payload.type === "subscriptions") {
+			await this.showSubscriptions(ctx, payload.page);
+			return;
+		}
+		if (payload.type === "chat") {
+			await this.showChat(ctx, payload.chatId);
+			return;
+		}
+		if (payload.type === "subscribe") {
+			await this.toggleSubscription(ctx, payload.chatId);
+			return;
+		}
+		if (payload.type === "reply") {
+			await this.selectReplyChat(ctx, payload.chatId);
+			return;
+		}
+		if (payload.type === "settings") {
+			await this.showChatSettings(ctx, payload.chatId);
+			return;
+		}
+		if (payload.type === "accountMenu") {
+			await this.showAccountMenu(ctx, payload.chatId, payload.page);
+			return;
+		}
+		if (payload.type === "setAccount") {
+			await this.updateChatSetting(ctx, payload.chatId, { accountId: payload.accountId }, "Provider account updated.");
+			return;
+		}
+		if (payload.type === "modelMenu") {
+			await this.showModelMenu(ctx, payload.chatId, payload.page);
+			return;
+		}
+		if (payload.type === "model") {
+			await this.updateChatSetting(ctx, payload.chatId, { model: payload.value }, "Model updated.");
+			return;
+		}
+		if (payload.type === "reasoningMenu") {
+			await this.showReasoningMenu(ctx, payload.chatId);
+			return;
+		}
+		if (payload.type === "reasoning") {
+			await this.updateChatSetting(ctx, payload.chatId, { reasoningEffort: payload.value }, "Reasoning updated.");
+			return;
+		}
+		if (payload.type === "serviceTierMenu") {
+			await this.showServiceTierMenu(ctx, payload.chatId);
+			return;
+		}
+		if (payload.type === "serviceTier") {
+			await this.updateChatSetting(ctx, payload.chatId, { serviceTier: payload.value }, "Speed updated.");
+			return;
+		}
+		if (payload.type === "permissionMenu") {
+			await this.showPermissionMenu(ctx, payload.chatId);
+			return;
+		}
+		if (payload.type === "permission") {
+			await this.updateChatSetting(ctx, payload.chatId, { permissionMode: payload.value }, "Security mode updated.");
+			return;
+		}
+		if (payload.type === "mode") {
+			await this.updateChatSetting(ctx, payload.chatId, { collaborationMode: payload.value }, "Mode updated.");
+			return;
+		}
+		if (payload.type === "serverRequest") {
+			await this.respondToServerRequest(ctx, payload);
+			return;
+		}
+		if (payload.type === "userInput") await this.respondToUserInput(ctx, payload);
+	}
+	async showMainMenu(ctx) {
+		if (!await this.requireOwner(ctx)) return;
+		await this.replyOrEdit(ctx, "Pockcode Telegram", this.mainKeyboard());
+	}
+	async showWorkspaces(ctx, requestedPage = 0) {
+		if (!await this.requireOwner(ctx)) return;
+		const workspaces = await listWorkspaceHistory();
+		const page = paginatedItems(workspaces, requestedPage);
+		const keyboard = new InlineKeyboard();
+		for (const workspace of page.items) keyboard.text(workspace.name, this.callbackData({
+			type: "workspace",
+			path: workspace.path
+		})).row();
+		this.addPaginationControls(keyboard, page, (nextPage) => ({
+			type: "workspaces",
+			page: nextPage
+		}));
+		keyboard.text("Subscriptions", this.callbackData({ type: "subscriptions" })).text("Back", this.callbackData({ type: "main" }));
+		await this.replyOrEdit(ctx, workspaces.length ? listTitle("Workspaces", page) : "No workspaces yet.", keyboard);
+	}
+	async showWorkspaceChats(ctx, workspacePath, requestedPage = 0) {
+		const chats = await listChats(workspacePath);
+		const page = paginatedItems(chats, requestedPage);
+		const keyboard = new InlineKeyboard();
+		for (const chat of page.items) keyboard.text(compactLabel(chat.title, 36), this.callbackData({
+			type: "chat",
+			chatId: chat.id
+		})).row();
+		this.addPaginationControls(keyboard, page, (nextPage) => ({
+			type: "workspace",
+			path: workspacePath,
+			page: nextPage
+		}));
+		keyboard.text("Workspaces", this.callbackData({ type: "workspaces" })).text("Back", this.callbackData({ type: "main" }));
+		await this.replyOrEdit(ctx, chats.length ? `${listTitle("Chats", page)}\n${workspacePath}` : `No chats\n${workspacePath}`, keyboard);
+	}
+	async showSubscriptions(ctx, requestedPage = 0) {
+		const state = await this.readState();
+		const keyboard = new InlineKeyboard();
+		const chatIds = Object.keys(state.subscriptions);
+		const page = paginatedItems(chatIds, requestedPage);
+		for (const chatId of page.items) {
+			const chat = await this.readChatResponse(chatId).catch(() => null);
+			keyboard.text(compactLabel(chat?.title ?? chatId, 36), this.callbackData({
+				type: "chat",
+				chatId
+			})).row();
+		}
+		this.addPaginationControls(keyboard, page, (nextPage) => ({
+			type: "subscriptions",
+			page: nextPage
+		}));
+		keyboard.text("Workspaces", this.callbackData({ type: "workspaces" })).text("Back", this.callbackData({ type: "main" }));
+		await this.replyOrEdit(ctx, chatIds.length ? listTitle("Subscriptions", page) : "No subscriptions.", keyboard);
+	}
+	async showChat(ctx, chatId) {
+		const chat = await this.readChatResponse(chatId);
+		const state = await this.readState();
+		await this.writeState({
+			...state,
+			selectedChats: {
+				...state.selectedChats,
+				[String(ctx.chat?.id ?? state.owner?.chatId ?? "")]: chatId
+			}
+		});
+		const recent = (await listMessages(chatId, 5).catch(() => ({ data: [] }))).data.filter(isAssistantChatMessage).slice(-3).map(formatAssistantTailBlock).join("\n\n");
+		await this.replyOrEdit(ctx, [
+			chat.title,
+			chat.workingDirectory ?? "",
+			`Status: ${chat.status}`,
+			`Model: ${chat.model ?? "default"}`,
+			`Security: ${chat.permissionMode}`,
+			recent ? `\nRecent\n${recent}` : ""
+		].filter(Boolean).join("\n"), this.chatKeyboard(chat, state));
+	}
+	async showChatSettings(ctx, chatId) {
+		const chat = await this.readChatResponse(chatId);
+		const keyboard = new InlineKeyboard().text("Account", this.callbackData({
+			type: "accountMenu",
+			chatId
+		})).text("Model", this.callbackData({
+			type: "modelMenu",
+			chatId
+		})).row().text("Reasoning", this.callbackData({
+			type: "reasoningMenu",
+			chatId
+		})).text("Speed", this.callbackData({
+			type: "serviceTierMenu",
+			chatId
+		})).row().text(chat.collaborationMode === "plan" ? "Mode: Plan" : "Mode: Default", this.callbackData({
+			type: "mode",
+			chatId,
+			value: chat.collaborationMode === "plan" ? "default" : "plan"
+		})).row().text("Security", this.callbackData({
+			type: "permissionMenu",
+			chatId
+		})).text("Back", this.callbackData({
+			type: "chat",
+			chatId
+		}));
+		await this.replyOrEdit(ctx, [
+			"Chat settings",
+			`Account: ${chat.accountId ?? "none"}`,
+			`Model: ${chat.model ?? "default"}`,
+			`Reasoning: ${chat.reasoningEffort ?? "default"}`,
+			`Speed: ${chat.serviceTier ?? "default"}`,
+			`Mode: ${chat.collaborationMode}`,
+			`Security: ${chat.permissionMode}`
+		].join("\n"), keyboard);
+	}
+	async showAccountMenu(ctx, chatId, requestedPage = 0) {
+		const chat = await this.readChatResponse(chatId);
+		const accounts = (await listAccounts()).filter((account) => account.status === "CONNECTED" && account.providerId === chat.providerId);
+		const page = paginatedItems(accounts, requestedPage);
+		const keyboard = new InlineKeyboard();
+		for (const account of page.items) keyboard.text(`${account.id === chat.accountId ? "* " : ""}${account.displayName}`, this.callbackData({
+			type: "setAccount",
+			chatId,
+			accountId: account.id
+		})).row();
+		this.addPaginationControls(keyboard, page, (nextPage) => ({
+			type: "accountMenu",
+			chatId,
+			page: nextPage
+		}));
+		keyboard.text("Back", this.callbackData({
+			type: "settings",
+			chatId
+		}));
+		await this.replyOrEdit(ctx, accounts.length ? listTitle("Provider accounts", page) : "No connected accounts for this provider.", keyboard);
+	}
+	async showModelMenu(ctx, chatId, requestedPage = 0) {
+		const accountId = (await this.readChatResponse(chatId)).accountId;
+		const keyboard = new InlineKeyboard();
+		let page = null;
+		if (accountId) {
+			page = paginatedItems((await listAccountModels(accountId).catch(() => ({ data: [] }))).data.filter((item) => !item.hidden), requestedPage);
+			for (const option of page.items) keyboard.text(option.displayName, this.callbackData({
+				type: "model",
+				chatId,
+				value: option.model
+			})).row();
+			this.addPaginationControls(keyboard, page, (nextPage) => ({
+				type: "modelMenu",
+				chatId,
+				page: nextPage
+			}));
+		}
+		keyboard.text("Back", this.callbackData({
+			type: "settings",
+			chatId
+		}));
+		await this.replyOrEdit(ctx, accountId ? page && page.total ? listTitle("Models", page) : "No models." : "Choose a provider account first.", keyboard);
+	}
+	async showReasoningMenu(ctx, chatId) {
+		const keyboard = new InlineKeyboard();
+		for (const option of [
+			"none",
+			"minimal",
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		]) keyboard.text(option, this.callbackData({
+			type: "reasoning",
+			chatId,
+			value: option
+		})).row();
+		keyboard.text("Back", this.callbackData({
+			type: "settings",
+			chatId
+		}));
+		await this.replyOrEdit(ctx, "Reasoning", keyboard);
+	}
+	async showServiceTierMenu(ctx, chatId) {
+		const keyboard = new InlineKeyboard().text("standard", this.callbackData({
+			type: "serviceTier",
+			chatId,
+			value: "standard"
+		})).row().text("fast", this.callbackData({
+			type: "serviceTier",
+			chatId,
+			value: "fast"
+		})).row().text("Back", this.callbackData({
+			type: "settings",
+			chatId
+		}));
+		await this.replyOrEdit(ctx, "Speed", keyboard);
+	}
+	async showPermissionMenu(ctx, chatId) {
+		const keyboard = new InlineKeyboard().text("Ask for approval", this.callbackData({
+			type: "permission",
+			chatId,
+			value: "askForApproval"
+		})).row().text("Full access", this.callbackData({
+			type: "permission",
+			chatId,
+			value: "fullAccess"
+		})).row().text("Back", this.callbackData({
+			type: "settings",
+			chatId
+		}));
+		await this.replyOrEdit(ctx, "Security mode", keyboard);
+	}
+	async updateChatSetting(ctx, chatId, data, message) {
+		await updateChat(chatId, data);
+		await this.replyOrEdit(ctx, message, new InlineKeyboard().text("Back", this.callbackData({
+			type: "settings",
+			chatId
+		})));
+	}
+	async toggleSubscription(ctx, chatId) {
+		const state = await this.readState();
+		const subscriptions = { ...state.subscriptions };
+		const existingSubscription = subscriptions[chatId];
+		if (existingSubscription) {
+			delete subscriptions[chatId];
+			await this.writeState({
+				...state,
+				subscriptions
+			});
+			if (existingSubscription.messageId) this.replyTargetsByTelegramMessageId.delete(existingSubscription.messageId);
+			await this.replyOrEdit(ctx, "Unsubscribed.", new InlineKeyboard().text("Subscribe", this.callbackData({
+				type: "subscribe",
+				chatId
+			})));
+		} else await this.subscribeChatForTelegramChat(ctx, chatId, state);
+	}
+	async subscribeChatForTelegramChat(ctx, chatId, state) {
+		const chat = await this.readChatResponse(chatId);
+		const telegramChatId = ctx.chat?.id ?? state.owner?.chatId ?? 0;
+		const startedAt = state.subscriptions[chatId]?.tailStartedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		const nextState = {
+			...state,
+			selectedChats: {
+				...state.selectedChats,
+				[String(telegramChatId)]: chatId
+			},
+			subscriptions: {
+				...state.subscriptions,
+				[chatId]: {
+					messageId: state.subscriptions[chatId]?.messageId ?? null,
+					subscribedAt: state.subscriptions[chatId]?.subscribedAt ?? startedAt,
+					tailStartedAt: startedAt,
+					telegramChatId,
+					workspacePath: chat.workingDirectory ?? null
+				}
+			}
+		};
+		await this.writeState(nextState);
+		return this.queueSubscribedChatTailUpdate(chatId, nextState, ctx, chat);
+	}
+	async selectReplyChat(ctx, chatId) {
+		const state = await this.readState();
+		await this.writeState({
+			...state,
+			selectedChats: {
+				...state.selectedChats,
+				[String(ctx.chat?.id ?? state.owner?.chatId ?? "")]: chatId
+			}
+		});
+		await this.replyOrEdit(ctx, "Send a Telegram message now, or reply to a chat update.", new InlineKeyboard().text("Back", this.callbackData({
+			type: "chat",
+			chatId
+		})));
+	}
+	async respondToServerRequest(ctx, payload) {
+		const requestId = payload.message.requestId;
+		if (!requestId) {
+			await this.replyOrEdit(ctx, "Request is missing an id.", this.mainKeyboard());
+			return;
+		}
+		await respondToServerRequest(payload.chatId, requestId, serverRequestResponseFor(payload.message, payload.approved));
+		await this.replyOrEdit(ctx, payload.approved ? "Approved." : "Declined.", new InlineKeyboard().text("Chat", this.callbackData({
+			type: "chat",
+			chatId: payload.chatId
+		})));
+	}
+	async respondToUserInput(ctx, payload) {
+		const requestId = payload.message.requestId;
+		if (!requestId) {
+			await this.replyOrEdit(ctx, "Request is missing an id.", this.mainKeyboard());
+			return;
+		}
+		await respondToServerRequest(payload.chatId, requestId, {
+			kind: "userInput",
+			result: { answers: payload.answers }
+		});
+		await this.replyOrEdit(ctx, "Submitted.", new InlineKeyboard().text("Chat", this.callbackData({
+			type: "chat",
+			chatId: payload.chatId
+		})));
+	}
+	async updateSubscribedChatTail(chatId, state, ctx, chat) {
+		const currentState = state ?? await this.readState();
+		const subscription = currentState.subscriptions[chatId];
+		if (!subscription) return currentState;
+		const targetChatId = subscription.telegramChatId || currentState.owner?.chatId;
+		if (!targetChatId || !this.bot) return currentState;
+		let activeState = currentState;
+		let activeSubscription = subscription;
+		const tailStartedAt = activeSubscription.tailStartedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		if (!activeSubscription.tailStartedAt) {
+			activeSubscription = {
+				...activeSubscription,
+				tailStartedAt
+			};
+			activeState = {
+				...currentState,
+				subscriptions: {
+					...currentState.subscriptions,
+					[chatId]: activeSubscription
+				}
+			};
+			await this.writeState(activeState);
+		}
+		const text = await this.formatSubscribedChatTail(chatId, tailStartedAt, chat);
+		const messageId = await this.sendOrEditSubscriptionMessage(ctx, targetChatId, subscription.messageId ?? null, text, this.subscriptionTailKeyboard(chatId));
+		this.replyTargetsByTelegramMessageId.set(messageId, chatId);
+		if (messageId === subscription.messageId) return activeState;
+		const latestState = await this.readState();
+		const latestSubscription = latestState.subscriptions[chatId];
+		if (!latestSubscription) return latestState;
+		const nextState = {
+			...latestState,
+			subscriptions: {
+				...latestState.subscriptions,
+				[chatId]: {
+					...latestSubscription,
+					messageId
+				}
+			}
+		};
+		await this.writeState(nextState);
+		return nextState;
+	}
+	async queueSubscribedChatTailUpdate(chatId, state, ctx, chat) {
+		const previous = this.subscriptionTailUpdateQueue.get(chatId);
+		const queued = (async () => {
+			await previous?.catch(() => void 0);
+			return this.updateSubscribedChatTail(chatId, previous ? void 0 : state, ctx, chat);
+		})();
+		this.subscriptionTailUpdateQueue.set(chatId, queued);
+		try {
+			return await queued;
+		} finally {
+			if (this.subscriptionTailUpdateQueue.get(chatId) === queued) this.subscriptionTailUpdateQueue.delete(chatId);
+		}
+	}
+	async sendOrEditSubscriptionMessage(ctx, telegramChatId, messageId, text, keyboard) {
+		const bot = this.bot;
+		if (!bot) throw new Error("Telegram bot is not running.");
+		const messageText = fitTelegramMessage(text, telegramMessageMaxLength);
+		const callbackMessage = ctx?.callbackQuery?.message;
+		const callbackMessageId = typeof callbackMessage?.chat.id === "number" && callbackMessage.chat.id === telegramChatId ? callbackMessage.message_id : null;
+		const editableMessageId = messageId ?? callbackMessageId;
+		if (editableMessageId) try {
+			await bot.api.editMessageText(telegramChatId, editableMessageId, messageText, { reply_markup: keyboard });
+			return editableMessageId;
+		} catch (error) {
+			if (readErrorMessage$1(error).toLowerCase().includes("message is not modified")) return editableMessageId;
+			if (messageId) await bot.api.deleteMessage(telegramChatId, messageId).catch(() => void 0);
+		}
+		return (await bot.api.sendMessage(telegramChatId, messageText, { reply_markup: keyboard })).message_id;
+	}
+	async formatSubscribedChatTail(chatId, since, chat) {
+		const chatResponse = chat ?? await this.readChatResponse(chatId);
+		const tail = tailLines((await listMessages(chatId, 50).catch(() => ({ data: [] }))).data.filter((message) => isAssistantChatMessage(message) && isMessageAtOrAfter(message, since)).map(formatAssistantTailBlock).flatMap((block, index) => [...index > 0 ? [""] : [], ...block.split("\n")]), telegramMessageTailLines).join("\n").trim();
+		return [compactLabel(chatResponse.title, 80), tail || "(no assistant messages yet)"].join("\n");
+	}
+	async replyOrEdit(ctx, text, keyboard) {
+		const options = keyboard ? { reply_markup: keyboard } : void 0;
+		if (ctx.callbackQuery?.message) try {
+			await ctx.editMessageText(text, options);
+			return;
+		} catch {}
+		await ctx.reply(text, options);
+	}
+	chatKeyboard(chat, state) {
+		const subscribed = Boolean(state.subscriptions[chat.id]);
+		return new InlineKeyboard().text(subscribed ? "Unsubscribe" : "Subscribe", this.callbackData({
+			type: "subscribe",
+			chatId: chat.id
+		})).text("Reply", this.callbackData({
+			type: "reply",
+			chatId: chat.id
+		})).row().text("Settings", this.callbackData({
+			type: "settings",
+			chatId: chat.id
+		})).text("Chats", this.callbackData({
+			type: "workspace",
+			path: chat.workingDirectory ?? ""
+		}));
+	}
+	subscriptionTailKeyboard(chatId) {
+		return new InlineKeyboard().text("Unsubscribe", this.callbackData({
+			type: "subscribe",
+			chatId
+		}));
+	}
+	mainKeyboard() {
+		return new InlineKeyboard().text("Workspaces", this.callbackData({ type: "workspaces" })).text("Subscriptions", this.callbackData({ type: "subscriptions" }));
+	}
+	addPaginationControls(keyboard, page, payloadForPage) {
+		if (page.totalPages <= 1) return;
+		if (page.page > 0) keyboard.text("Prev", this.callbackData(payloadForPage(page.page - 1)));
+		if (page.page < page.totalPages - 1) keyboard.text("Next", this.callbackData(payloadForPage(page.page + 1)));
+		keyboard.row();
+	}
+	serverRequestKeyboard(message) {
+		if (message.kind === "USER_INPUT_PROMPT") {
+			const question = readUserInputQuestions(message.rawPayload)[0];
+			const keyboard = new InlineKeyboard();
+			if (question) for (const option of question.options.slice(0, 8)) keyboard.text(option.label, this.callbackData({
+				answers: { [question.id]: { answers: [option.label] } },
+				chatId: message.chatId,
+				message,
+				type: "userInput"
+			})).row();
+			keyboard.text("Submit empty", this.callbackData({
+				answers: {},
+				chatId: message.chatId,
+				message,
+				type: "userInput"
+			}));
+			keyboard.text("Chat", this.callbackData({
+				type: "chat",
+				chatId: message.chatId
+			}));
+			return keyboard;
+		}
+		return new InlineKeyboard().text("Approve", this.callbackData({
+			type: "serverRequest",
+			chatId: message.chatId,
+			message,
+			approved: true
+		})).text("Decline", this.callbackData({
+			type: "serverRequest",
+			chatId: message.chatId,
+			message,
+			approved: false
+		})).row().text("Chat", this.callbackData({
+			type: "chat",
+			chatId: message.chatId
+		}));
+	}
+	callbackData(payload) {
+		const direct = directCallbackData(payload);
+		if (direct && direct.length <= 64) return direct;
+		this.collectExpiredCallbackTokens();
+		const token = randomToken(8);
+		this.callbackTokens.set(token, {
+			expiresAt: Date.now() + callbackTtlMs,
+			payload
+		});
+		return `t:${token}`;
+	}
+	readCallbackPayload(data) {
+		if (!data) return null;
+		if (data.startsWith("t:")) {
+			const token = this.callbackTokens.get(data.slice(2));
+			if (!token || token.expiresAt < Date.now()) return null;
+			return token.payload;
+		}
+		if (data === "m") return { type: "main" };
+		if (data === "wl") return { type: "workspaces" };
+		if (data === "subs") return { type: "subscriptions" };
+		if (data.startsWith("c:")) return {
+			type: "chat",
+			chatId: data.slice(2)
+		};
+		return null;
+	}
+	collectExpiredCallbackTokens() {
+		const now = Date.now();
+		for (const [token, value] of this.callbackTokens) if (value.expiresAt < now) this.callbackTokens.delete(token);
+	}
+	async requireOwner(ctx) {
+		const from = ctx.from;
+		if (!from) return null;
+		const state = await this.readState();
+		if (!state.owner) {
+			await ctx.reply("Open Pockcode Plugins and pair this bot with /start <code>.").catch(() => void 0);
+			return null;
+		}
+		if (!this.isOwner(from.id, state)) {
+			await ctx.reply("Only the paired Telegram owner can control Pockcode.").catch(() => void 0);
+			return null;
+		}
+		return state;
+	}
+	isOwner(userId, state) {
+		return state.owner?.userId === userId;
+	}
+	async rememberOwnerChat(ctx, state) {
+		if (!ctx.chat || !state.owner || state.owner.chatId === ctx.chat.id) return state;
+		const nextState = {
+			...state,
+			owner: {
+				...state.owner,
+				chatId: ctx.chat.id
+			}
+		};
+		await this.writeState(nextState);
+		return nextState;
+	}
+	async ensurePairingCode() {
+		const state = await this.readState();
+		if (!state.owner && !state.pairingCode) await this.writeState({
+			...state,
+			pairingCode: createPairingCode()
+		});
+	}
+	async readState() {
+		return this.context ? readTelegramState(await this.context.getState()) : emptyTelegramState();
+	}
+	async writeState(state) {
+		await this.context?.setState(serializeTelegramState(state));
+	}
+	async rememberSubscriptionReplyTargets() {
+		const state = await this.readState();
+		for (const [chatId, subscription] of Object.entries(state.subscriptions)) if (subscription.messageId) this.replyTargetsByTelegramMessageId.set(subscription.messageId, chatId);
+	}
+	async readChatResponse(chatId) {
+		return serializeChat(await getChat(chatId));
+	}
+};
+function directCallbackData(payload) {
+	if (payload.type === "main") return "m";
+	if (payload.type === "workspaces" && !payload.page) return "wl";
+	if (payload.type === "subscriptions" && !payload.page) return "subs";
+	if (payload.type === "chat") return `c:${payload.chatId}`;
+	return null;
+}
+function paginatedItems(items, requestedPage) {
+	const total = items.length;
+	const totalPages = Math.max(1, Math.ceil(total / telegramListPageSize));
+	const page = Math.min(Math.max(typeof requestedPage === "number" && Number.isFinite(requestedPage) ? Math.trunc(requestedPage) : 0, 0), totalPages - 1);
+	const start = page * telegramListPageSize;
+	return {
+		items: items.slice(start, start + telegramListPageSize),
+		page,
+		total,
+		totalPages
+	};
+}
+function listTitle(title, page) {
+	return page.totalPages > 1 ? `${title}\nPage ${page.page + 1}/${page.totalPages}` : title;
+}
+function readTelegramState(value) {
+	const record = readRecord(value);
+	return {
+		botUsername: readRecordString(record, "botUsername") || null,
+		owner: readOwner(record.owner),
+		pairingCode: readRecordString(record, "pairingCode") || null,
+		selectedChats: readStringRecord(record.selectedChats),
+		subscriptions: readSubscriptions(record.subscriptions)
+	};
+}
+function emptyTelegramState() {
+	return {
+		botUsername: null,
+		owner: null,
+		pairingCode: null,
+		selectedChats: {},
+		subscriptions: {}
+	};
+}
+function serializeTelegramState(state) {
+	return {
+		botUsername: state.botUsername,
+		owner: state.owner,
+		pairingCode: state.pairingCode,
+		selectedChats: state.selectedChats,
+		subscriptions: state.subscriptions
+	};
+}
+function readSubscribeStartPayload(value) {
+	if (!value?.startsWith("sub_")) return null;
+	return value.slice(4).trim() || null;
+}
+function readOwner(value) {
+	const record = readRecord(value);
+	const userId = readNumber(record.userId);
+	const chatId = readNumber(record.chatId);
+	if (!userId || !chatId) return null;
+	return {
+		chatId,
+		displayName: readRecordString(record, "displayName") || String(userId),
+		pairedAt: readRecordString(record, "pairedAt") || (/* @__PURE__ */ new Date()).toISOString(),
+		userId,
+		username: readRecordString(record, "username") || null
+	};
+}
+function readSubscriptions(value) {
+	const record = readRecord(value);
+	const subscriptions = {};
+	for (const [chatId, subscriptionValue] of Object.entries(record)) {
+		const subscription = readRecord(subscriptionValue);
+		const telegramChatId = readNumber(subscription.telegramChatId);
+		if (!telegramChatId) continue;
+		subscriptions[chatId] = {
+			messageId: readNumber(subscription.messageId),
+			subscribedAt: readRecordString(subscription, "subscribedAt") || (/* @__PURE__ */ new Date()).toISOString(),
+			tailStartedAt: readRecordString(subscription, "tailStartedAt") || null,
+			telegramChatId,
+			workspacePath: readRecordString(subscription, "workspacePath") || null
+		};
+	}
+	return subscriptions;
+}
+function readStringRecord(value) {
+	const record = readRecord(value);
+	const result = {};
+	for (const [key, recordValue] of Object.entries(record)) if (typeof recordValue === "string") result[key] = recordValue;
+	return result;
+}
+function readChatMessage(value) {
+	const record = readRecord(value);
+	const chatId = readRecordString(record, "chatId");
+	const id = readRecordString(record, "id");
+	const role = readRecordString(record, "role");
+	if (!chatId || !id || !isMessageRole(role)) return null;
+	return {
+		chatId,
+		completedAt: readRecordString(record, "completedAt") || null,
+		content: readRecordString(record, "content"),
+		createdAt: readRecordString(record, "createdAt") || (/* @__PURE__ */ new Date()).toISOString(),
+		id,
+		itemId: readRecordString(record, "itemId") || null,
+		kind: readMessageKind(readRecordString(record, "kind")),
+		metadata: readRecord(record.metadata),
+		rawPayload: readRecord(record.rawPayload),
+		requestId: readRecordString(record, "requestId") || null,
+		role,
+		runId: readRecordString(record, "runId") || null,
+		sequence: readNumber(record.sequence) ?? 0,
+		status: readMessageStatus(readRecordString(record, "status")),
+		turnId: readRecordString(record, "turnId") || null
+	};
+}
+function serverRequestResponseFor(message, approved) {
+	const method = readRecordString(readRecord(message.metadata), "serverRequestMethod");
+	if (method === "item/permissions/requestApproval") return {
+		kind: "permissions",
+		result: {
+			permissions: approved ? grantedPermissionsFromRequest(message) : {},
+			scope: "turn"
+		}
+	};
+	if (method === "item/tool/requestUserInput") return {
+		kind: "userInput",
+		result: { answers: {} }
+	};
+	return {
+		decision: approved ? "accept" : "decline",
+		kind: "approval",
+		result: { decision: approved ? "accept" : "decline" }
+	};
+}
+function grantedPermissionsFromRequest(message) {
+	const requested = readRecord(readRecord(message.rawPayload).permissions);
+	const granted = {};
+	const network = readRecord(requested.network);
+	const fileSystem = readRecord(requested.fileSystem);
+	if (Object.keys(network).length) granted.network = network;
+	if (Object.keys(fileSystem).length) granted.fileSystem = fileSystem;
+	return granted;
+}
+function readUserInputQuestions(value) {
+	const questions = readRecord(value).questions;
+	if (!Array.isArray(questions)) return [];
+	return questions.flatMap((questionValue) => {
+		const question = readRecord(questionValue);
+		const id = readRecordString(question, "id");
+		if (!id) return [];
+		return [{
+			id,
+			options: readUserInputOptions(question.options)
+		}];
+	});
+}
+function readUserInputOptions(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((optionValue) => {
+		const label = readRecordString(optionValue, "label");
+		return label ? [{ label }] : [];
+	});
+}
+function formatAssistantTailBlock(message) {
+	return `Assistant:\n${normalizeTailText(message.content) || "(empty)"}`;
+}
+function isAssistantChatMessage(message) {
+	return message.role === "ASSISTANT" && message.kind === "CHAT";
+}
+function shouldUpdateSubscriptionTailForMessage(message) {
+	return isAssistantChatMessage(message);
+}
+function isMessageAtOrAfter(message, since) {
+	if (message.status === "STREAMING") return true;
+	const messageTime = Date.parse(message.createdAt);
+	const completedTime = Date.parse(message.completedAt ?? "");
+	const sinceTime = Date.parse(since);
+	if (!Number.isFinite(sinceTime)) return true;
+	if (Number.isFinite(completedTime) && completedTime >= sinceTime) return true;
+	return Number.isFinite(messageTime) ? messageTime >= sinceTime : true;
+}
+function tailLines(lines, maxLines) {
+	return lines.slice(-maxLines);
+}
+function normalizeTailText(value) {
+	return value.trim().replace(/\r\n?/gu, "\n").replace(/\n{3,}/g, "\n\n");
+}
+function fitTelegramMessage(value, maxLength) {
+	const normalized = value.trim();
+	if (normalized.length <= maxLength) return normalized;
+	return "...\n" + normalized.slice(-(maxLength - 4));
+}
+function compactLabel(value, maxLength) {
+	const normalized = value.trim().replace(/\s+/g, " ");
+	return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}...` : normalized || "Untitled";
+}
+function displayNameForTelegramUser(user) {
+	return [user.first_name, user.last_name].filter(Boolean).join(" ") || user.username || String(user.id);
+}
+function createPairingCode() {
+	return randomToken(4).toUpperCase();
+}
+function randomToken(bytes) {
+	const length = Math.max(8, bytes);
+	let token = "";
+	while (token.length < length) token += randomBytes(bytes).toString("base64url").replace(/[^a-z0-9]/giu, "");
+	return token.slice(0, length);
+}
+function readRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readRecordString(value, key) {
+	const recordValue = readRecord(value)[key];
+	return typeof recordValue === "string" ? recordValue.trim() : "";
+}
+function readNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isMessageRole(value) {
+	return value === "USER" || value === "ASSISTANT" || value === "SYSTEM" || value === "TOOL";
+}
+function readMessageKind(value) {
+	return value === "THINKING" || value === "TOOL_ACTIVITY" || value === "COMMAND_EXECUTION" || value === "FILE_CHANGE" || value === "PLAN" || value === "APPROVAL" || value === "USER_INPUT_PROMPT" || value === "ERROR" ? value : "CHAT";
+}
+function readMessageStatus(value) {
+	return value === "PENDING" || value === "STREAMING" || value === "FAILED" ? value : "COMPLETED";
+}
+function readErrorMessage$1(error) {
+	return error instanceof Error ? error.message : "Telegram action failed.";
+}
+function readTelegramPollingError(error) {
+	const message = readErrorMessage$1(error);
+	return message.includes("409") ? "Telegram polling conflict. Stop the other bot instance, then restart this plugin." : message || "Telegram polling stopped.";
+}
+//#endregion
+//#region app/server/plugins/registry.server.ts
+var registrations = new Map([[telegramPluginRegistration.definition.id, telegramPluginRegistration]]);
+function listPluginRegistrations() {
+	return [...registrations.values()];
+}
+function readPluginRegistration(pluginId) {
+	const registration = registrations.get(pluginId);
+	if (!registration) throw new Error(`Unknown plugin: ${pluginId}`);
+	return registration;
+}
+//#endregion
+//#region app/server/plugins/storage.server.ts
+async function readPluginSetting(pluginId, defaults = {}) {
+	await ensureDatabase();
+	const row = (await prisma.$queryRawUnsafe(`SELECT "pluginId", "enabled", "settings", "secrets" FROM "PluginSetting" WHERE "pluginId" = ? LIMIT 1`, pluginId))[0];
+	if (!row) return {
+		enabled: false,
+		pluginId,
+		secrets: {},
+		settings: defaults
+	};
+	return {
+		enabled: row.enabled === true || row.enabled === 1,
+		pluginId: row.pluginId,
+		secrets: readJsonObject(row.secrets),
+		settings: {
+			...defaults,
+			...readJsonObject(row.settings)
+		}
+	};
+}
+async function writePluginSetting(record) {
+	await ensureDatabase();
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	await prisma.$executeRawUnsafe(`INSERT INTO "PluginSetting" ("pluginId", "enabled", "settings", "secrets", "createdAt", "updatedAt")
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT("pluginId") DO UPDATE SET
+        "enabled" = excluded."enabled",
+        "settings" = excluded."settings",
+        "secrets" = excluded."secrets",
+        "updatedAt" = excluded."updatedAt"`, record.pluginId, record.enabled ? 1 : 0, JSON.stringify(record.settings), JSON.stringify(record.secrets), timestamp, timestamp);
+	return record;
+}
+async function readPluginState(pluginId) {
+	await ensureDatabase();
+	return readJsonObject((await prisma.$queryRawUnsafe(`SELECT "pluginId", "state" FROM "PluginState" WHERE "pluginId" = ? LIMIT 1`, pluginId))[0]?.state);
+}
+async function writePluginState(pluginId, state) {
+	await ensureDatabase();
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	await prisma.$executeRawUnsafe(`INSERT INTO "PluginState" ("pluginId", "state", "createdAt", "updatedAt")
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT("pluginId") DO UPDATE SET
+        "state" = excluded."state",
+        "updatedAt" = excluded."updatedAt"`, pluginId, JSON.stringify(state), timestamp, timestamp);
+	return state;
+}
+async function updatePluginState(pluginId, updater) {
+	return writePluginState(pluginId, await updater(await readPluginState(pluginId)));
+}
+function readJsonObject(value) {
+	if (typeof value === "string") try {
+		return readJsonObject(JSON.parse(value));
+	} catch {
+		return {};
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
+}
+//#endregion
+//#region app/server/plugins/manager.server.ts
+var manager_server_exports = /* @__PURE__ */ __exportAll({
+	createPluginContext: () => createPluginContext,
+	getPluginStatus: () => getPluginStatus,
+	reconcilePlugins: () => reconcilePlugins,
+	restartPlugin: () => restartPlugin,
+	setPluginStatus: () => setPluginStatus,
+	startPluginRuntimeManager: () => startPluginRuntimeManager,
+	stopPlugin: () => stopPlugin
+});
+var globalForPlugins = globalThis;
+var managerState = globalForPlugins.pockcodePluginRuntimeManager ?? {
+	activePlugins: /* @__PURE__ */ new Map(),
+	pluginStatuses: /* @__PURE__ */ new Map(),
+	unsubscribeProviderEvents: null
+};
+globalForPlugins.pockcodePluginRuntimeManager = managerState;
+var activePlugins = managerState.activePlugins;
+var pluginStatuses = managerState.pluginStatuses;
+function startPluginRuntimeManager() {
+	if (managerState.unsubscribeProviderEvents) managerState.unsubscribeProviderEvents();
+	managerState.unsubscribeProviderEvents = onProviderEvent((event) => {
+		dispatchProviderEvent(event).catch(() => void 0);
+	});
+	reconcilePlugins().catch((error) => {
+		for (const registration of listPluginRegistrations()) setPluginStatus(registration.definition.id, {
+			state: "error",
+			message: readErrorMessage(error)
+		});
+	});
+}
+async function reconcilePlugins() {
+	for (const registration of listPluginRegistrations()) await restartPlugin(registration.definition.id);
+}
+async function restartPlugin(pluginId) {
+	const registration = readPluginRegistration(pluginId);
+	await stopPlugin(pluginId);
+	const setting = await readPluginSetting(pluginId, registration.definition.defaultSettings);
+	if (!setting.enabled) {
+		setPluginStatus(pluginId, {
+			state: "disabled",
+			message: null
+		});
+		return;
+	}
+	setPluginStatus(pluginId, {
+		state: "starting",
+		message: null
+	});
+	const runtime = registration.runtime();
+	activePlugins.set(pluginId, { runtime });
+	try {
+		await runtime.start(createPluginContext(pluginId, setting));
+		if (getPluginStatus(pluginId).state === "starting") setPluginStatus(pluginId, {
+			state: "running",
+			message: null
+		});
+	} catch (error) {
+		activePlugins.delete(pluginId);
+		setPluginStatus(pluginId, {
+			state: "error",
+			message: readErrorMessage(error)
+		});
+		await Promise.resolve(runtime.stop()).catch(() => void 0);
+	}
+}
+async function stopPlugin(pluginId) {
+	const active = activePlugins.get(pluginId);
+	activePlugins.delete(pluginId);
+	if (!active) return;
+	try {
+		await active.runtime.stop();
+	} catch (error) {
+		setPluginStatus(pluginId, {
+			state: "error",
+			message: readErrorMessage(error)
+		});
+	}
+}
+function getPluginStatus(pluginId) {
+	return pluginStatuses.get(pluginId) ?? {
+		state: "disabled",
+		message: null,
+		updatedAt: null
+	};
+}
+function setPluginStatus(pluginId, status) {
+	pluginStatuses.set(pluginId, {
+		...status,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function createPluginContext(pluginId, setting) {
+	return {
+		async getState() {
+			return readPluginState(pluginId);
+		},
+		pluginId,
+		secrets: setting.secrets,
+		async setState(state) {
+			await writePluginState(pluginId, state);
+		},
+		setStatus(status) {
+			setPluginStatus(pluginId, status);
+		},
+		settings: setting.settings,
+		updateState(updater) {
+			return updatePluginState(pluginId, updater);
+		}
+	};
+}
+async function dispatchProviderEvent(event) {
+	await Promise.all([...activePlugins.values()].map(async (active) => {
+		try {
+			await active.runtime.handleProviderEvent?.(event);
+		} catch {}
+	}));
+}
+function readErrorMessage(error) {
+	return error instanceof Error ? error.message : "Plugin failed.";
+}
+//#endregion
+export { readPluginSetting as a, listPluginRegistrations as c, deleteWorkspaceHistory as d, listWorkspaceHistory as f, restartPlugin as i, readPluginRegistration as l, getPluginStatus as n, readPluginState as o, saveWorkspaceHistory as p, manager_server_exports as r, writePluginSetting as s, createPluginContext as t, verifyTelegramBotToken as u };