@okostream/mcp 0.9.0 → 0.9.2

package/dist/env.js

@@ -3,9 +3,16 @@ import { homedir } from "node:os";
 import { delimiter, isAbsolute, join, parse, resolve } from "node:path";
 import { DEFAULT_EXCHANGE_URL, DEFAULT_FIREBASE_CONFIG } from "./firebaseDefaults.js";
 config({ path: join(homedir(), ".env"), quiet: true });
+const USER_CONFIG_PLACEHOLDER = /^\$\{user_config\.[^{}\s]+\}$/;
+function normalizeOptionalEnv(value) {
+    const normalized = value?.trim();
+    if (!normalized || USER_CONFIG_PLACEHOLDER.test(normalized))
+        return null;
+    return normalized;
+}
 function readOptionalEnv(...names) {
     for (const name of names) {
-        const value = process.env[name]?.trim();
+        const value = normalizeOptionalEnv(process.env[name]);
         if (value)
             return value;
     }
@@ -13,33 +20,39 @@ function readOptionalEnv(...names) {
 }
 function readEnvWithDefault(defaultValue, ...names) {
     for (const name of names) {
-        const value = process.env[name]?.trim();
+        const value = normalizeOptionalEnv(process.env[name]);
         if (value)
             return value;
     }
     return defaultValue;
 }
+function disableImageRoots(reason) {
+    console.error(`[oko-mcp] Local image reads disabled: ${reason}`);
+    return [];
+}
 function readImageRoots() {
-    const rawRoots = process.env.OKO_IMAGE_ROOTS?.trim();
+    const rawRoots = readOptionalEnv("OKO_IMAGE_ROOTS");
     if (!rawRoots)
         return [];
-    return rawRoots.split(delimiter).map((value) => {
+    const roots = [];
+    for (const value of rawRoots.split(delimiter)) {
         const root = value.trim();
         if (!root) {
-            throw new Error("OKO_IMAGE_ROOTS contains an empty directory entry.");
+            return disableImageRoots("OKO_IMAGE_ROOTS contains an empty directory entry.");
         }
         const expanded = root === "~" || root.startsWith("~/")
             ? join(homedir(), root.slice(2))
             : root;
         if (!isAbsolute(expanded)) {
-            throw new Error(`OKO_IMAGE_ROOTS entries must be absolute paths: ${root}`);
+            return disableImageRoots("OKO_IMAGE_ROOTS entries must be absolute paths.");
         }
         const resolved = resolve(expanded);
         if (resolved === parse(resolved).root) {
-            throw new Error("OKO_IMAGE_ROOTS must not allow an entire filesystem root.");
+            return disableImageRoots("OKO_IMAGE_ROOTS must not allow an entire filesystem root.");
         }
-        return resolved;
-    });
+        roots.push(resolved);
+    }
+    return roots;
 }
 export const env = {
     apiKey: readOptionalEnv("OKO_API_KEY"),

package/dist/sessionRepair.js

@@ -0,0 +1,37 @@
+export function summarizeSessionRepair(input) {
+    const fixed = !input.verificationError
+        && input.firestorePointer === null
+        && input.rtdbPointer === null;
+    const fulfilled = new Set(input.attempts
+        .filter((attempt) => attempt.status === "fulfilled")
+        .map((attempt) => attempt.path));
+    const cleared = [
+        ...(input.firestorePointer === null ? ["events.activeAnalyticsSessionId"] : []),
+        ...(input.rtdbPointer === null ? ["ctrl/activeSessionId"] : []),
+        ...(input.sessionId && fulfilled.has(`activeSessions/${input.sessionId}`)
+            ? [`activeSessions/${input.sessionId}`]
+            : []),
+        ...(input.sessionId
+            && input.deleteRtdbSessionData
+            && fulfilled.has(`events/${input.eventId}/sessions/${input.sessionId}`)
+            ? [`events/${input.eventId}/sessions/${input.sessionId}`]
+            : []),
+    ];
+    const warnings = input.attempts
+        .filter((attempt) => attempt.status === "rejected")
+        .map((attempt) => `${attempt.path}: ${attempt.error || "cleanup failed"}`);
+    if (input.verificationError) {
+        warnings.push(`postcondition verification: ${input.verificationError}`);
+    }
+    return {
+        eventId: input.eventId,
+        sessionId: input.sessionId,
+        fixed,
+        cleared,
+        warnings,
+        remainingPointers: {
+            firestore: input.firestorePointer,
+            rtdb: input.rtdbPointer,
+        },
+    };
+}

package/dist/telegramChannelSchema.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const telegramChannelSchema = z.object({
+    chatId: z.number().int(),
+    title: z.string().max(200).optional(),
+    username: z.string().max(120).nullable().optional(),
+}).strict();
+export const canonicalTelegramChannelSchema = telegramChannelSchema.extend({
+    workspaceIds: z.array(z.string()).max(50),
+    owned: z.boolean(),
+    subscriberCount: z.number().int().nonnegative().nullable().optional(),
+    health: z.enum(["connected", "needs_attention", "unknown"]).optional(),
+    healthCheckedAt: z.number().int().nonnegative().nullable().optional(),
+}).strict();

package/dist/tools.js

@@ -13,6 +13,8 @@ import { env } from "./env.js";
 import { ipLiteralFamily, isPublicUnicastAddress, normalizeIpLiteralHostname, } from "./networkPolicy.js";
 import { chatRtdb, firestore, functions, rtdb } from "./firebase.js";
 import { OKO_CONNECTION_STATUSES } from "./onboarding.js";
+import { summarizeSessionRepair } from "./sessionRepair.js";
+import { canonicalTelegramChannelSchema, telegramChannelSchema, } from "./telegramChannelSchema.js";
 import { csvCell, requireConfirm, safeString, serialize, textResult } from "./utils.js";
 import { detectAndNormalize, extractIframeSrc } from "./videoUrl.js";
 const boolOrNull = z.boolean().nullable();
@@ -206,7 +208,7 @@ const workspaceAccessOutputSchema = z.object({
     invites: z.array(unknownRecordSchema),
 }).passthrough();
 const telegramChannelsOutputSchema = z.object({
-    channels: z.array(unknownRecordSchema),
+    channels: z.array(canonicalTelegramChannelSchema),
     count: z.number().int().nonnegative(),
 }).passthrough();
 const telegramPostsOutputSchema = z.object({
@@ -273,15 +275,6 @@ const cardItemInputSchema = z.object({
     buttonUrl: z.string().max(MAX_CARD_BUTTON_URL_LENGTH).nullable().optional(),
     formId: cardIdSchema.nullable().optional(),
 }).strict();
-const telegramChannelSchema = z.object({
-    chatId: z.number().int(),
-    title: z.string().max(200).optional(),
-    username: z.string().max(120).nullable().optional(),
-}).strict();
-const canonicalTelegramChannelSchema = telegramChannelSchema.extend({
-    workspaceIds: z.array(z.string()).max(50),
-    owned: z.boolean(),
-}).strict();
 const profileDisplayNameSchema = z.string().max(40).nullable();
 const timezoneSchema = z.string()
     .min(1)
@@ -2412,24 +2405,65 @@ export function registerTools(server) {
         const sessionId = safeString(event.activeAnalyticsSessionId) || safeString(ctrlSnap.val());
         requireConfirm(confirm, "oko_fix_orphan_session", { eventId, sessionId: sessionId || null, deleteRtdbSessionData });
         const cleanup = [
-            updateDoc(doc(firestore, "events", eventId), { activeAnalyticsSessionId: deleteField() }),
-            remove(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)),
+            {
+                path: "events.activeAnalyticsSessionId",
+                promise: updateDoc(doc(firestore, "events", eventId), { activeAnalyticsSessionId: deleteField() }),
+            },
+            {
+                path: "ctrl/activeSessionId",
+                promise: remove(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)),
+            },
         ];
-        if (sessionId)
-            cleanup.push(remove(ref(rtdb, `activeSessions/${sessionId}`)));
-        if (sessionId && deleteRtdbSessionData)
-            cleanup.push(remove(ref(rtdb, `events/${eventId}/sessions/${sessionId}`)));
-        const results = await Promise.allSettled(cleanup);
-        const warnings = results
-            .filter((result) => result.status === "rejected")
-            .map((result) => result.reason instanceof Error ? result.reason.message : String(result.reason));
-        return textResult({
+        if (sessionId) {
+            cleanup.push({
+                path: `activeSessions/${sessionId}`,
+                promise: remove(ref(rtdb, `activeSessions/${sessionId}`)),
+            });
+        }
+        if (sessionId && deleteRtdbSessionData) {
+            cleanup.push({
+                path: `events/${eventId}/sessions/${sessionId}`,
+                promise: remove(ref(rtdb, `events/${eventId}/sessions/${sessionId}`)),
+            });
+        }
+        const settled = await Promise.allSettled(cleanup.map((operation) => operation.promise));
+        const attempts = settled.map((result, index) => {
+            const operation = cleanup[index];
+            if (!operation)
+                throw new Error("Session repair result has no matching cleanup operation.");
+            return {
+                path: operation.path,
+                status: result.status,
+                ...(result.status === "rejected" ? {
+                    error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+                } : {}),
+            };
+        });
+        let firestorePointer = null;
+        let rtdbPointer = null;
+        let verificationError;
+        try {
+            const [eventAfter, ctrlAfter] = await Promise.all([
+                getDoc(doc(firestore, "events", eventId)),
+                get(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)),
+            ]);
+            firestorePointer = eventAfter.exists()
+                ? safeString(eventAfter.data().activeAnalyticsSessionId) || null
+                : null;
+            rtdbPointer = safeString(ctrlAfter.val()) || null;
+        }
+        catch (error) {
+            verificationError = error instanceof Error ? error.message : String(error);
+        }
+        return textResult(summarizeSessionRepair({
             eventId,
             sessionId: sessionId || null,
-            fixed: warnings.length === 0,
-            cleared: ["events.activeAnalyticsSessionId", "ctrl/activeSessionId", ...(sessionId ? [`activeSessions/${sessionId}`] : []), ...(sessionId && deleteRtdbSessionData ? [`events/${eventId}/sessions/${sessionId}`] : [])],
-            warnings,
-        });
+            deleteRtdbSessionData,
+            attempts,
+            firestorePointer,
+            rtdbPointer,
+            verificationError,
+        }));
     });
     server.registerTool("oko_delete_session", {
         title: "Delete analytics session",
@@ -2937,7 +2971,7 @@ export function registerTools(server) {
                 "eventId: optional event; when provided, include channels explicitly shared to that event's workspace.",
                 "includeWorkspaceChannels: deprecated compatibility field; eventId is required to resolve workspace sharing safely.",
             ],
-            returns: "canonical channels with chatId, title, username, workspaceIds, and owned flag.",
+            returns: "canonical channels with identity, workspace sharing, ownership, subscriber count, and connection health.",
             examples: ["Use before oko_publish_telegram_post so the user can choose a channel by title instead of numeric id."],
         }),
         inputSchema: {

package/dist/version.js

@@ -1 +1,2 @@
-export const OKO_MCP_VERSION = "0.9.0";
+// Generated by scripts/generateMcpVersion.mjs from mcp/package.json. Do not edit.
+export const OKO_MCP_VERSION = "0.9.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@okostream/mcp",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Control OKO Stream webinars from Claude, Codex, and other MCP clients.",
   "license": "UNLICENSED",
   "author": {
@@ -31,7 +31,7 @@
     "oko-mcp": "dist/server.js"
   },
   "scripts": {
-    "prebuild": "node ../scripts/generateMcpContract.mjs --check",
+    "prebuild": "node ../scripts/generateMcpVersion.mjs && node ../scripts/generateMcpContract.mjs --check",
     "build": "tsc && node -e \"require('node:fs').chmodSync('dist/server.js', 0o755)\"",
     "test": "npm run build && node --test test/*.test.mjs",
     "smoke:tarball": "node test/tarball-smoke.mjs",