creator-mcp 1.0.4 → 1.0.5

package/dist/auth.js

@@ -6,17 +6,23 @@
  * 2. Supabase JWT: validated via Supabase Auth API (backward compatible)
  */
 import { createUserClient, exchangeMcpToken } from "./client.js";
+import { attachAuthToUsageContext } from "./usage.js";
 const MCP_TOKEN_PREFIX = "mcp_";
 /**
  * Exchange an MCP API token (mcp_...) for a short-lived Supabase session.
  */
 async function authenticateWithMcpToken(token) {
     const session = await exchangeMcpToken(token);
-    return {
+    const authContext = {
         userId: session.userId,
         email: session.email,
         token: session.accessToken,
+        tokenId: session.tokenId,
+        tokenName: session.tokenName,
+        authType: "mcp_token",
     };
+    attachAuthToUsageContext(authContext);
+    return authContext;
 }
 /**
  * Validate a Supabase JWT token via the Auth API.
@@ -27,11 +33,16 @@ async function authenticateWithJwt(token) {
     const { data: sessionData, error: sessionError } = await client.auth.getSession();
     if (!sessionError && sessionData?.session?.user) {
         const user = sessionData.session.user;
-        return {
+        const authContext = {
             userId: user.id,
             email: user.email ?? null,
             token,
+            tokenId: null,
+            tokenName: "JWT Session",
+            authType: "supabase_jwt",
         };
+        attachAuthToUsageContext(authContext);
+        return authContext;
     }
     // Fallback: validate via getUser
     const { data: { user }, error, } = await client.auth.getUser(token);
@@ -39,11 +50,16 @@ async function authenticateWithJwt(token) {
         throw new Error("Invalid Supabase token — authentication failed. " +
             "Ensure your CREATOR_OS_TOKEN is a valid access token.");
     }
-    return {
+    const authContext = {
         userId: user.id,
         email: user.email ?? null,
         token,
+        tokenId: null,
+        tokenName: "JWT Session",
+        authType: "supabase_jwt",
     };
+    attachAuthToUsageContext(authContext);
+    return authContext;
 }
 /**
  * Authenticate using the CREATOR_OS_TOKEN environment variable.

package/dist/client.d.ts

@@ -12,6 +12,8 @@ interface ExchangedSession {
     expiresAt: number;
     userId: string;
     email: string | null;
+    tokenId: string;
+    tokenName: string | null;
 }
 export declare function getRuntimeConfig(): RuntimeConfig;
 /**

package/dist/client.js

@@ -91,6 +91,8 @@ export async function exchangeMcpToken(token) {
         expiresAt: data.session.expires_at ?? now + 3600,
         userId: data.user.id,
         email: data.user.email ?? payload.email,
+        tokenId: payload.token_id,
+        tokenName: payload.token_name ?? null,
     };
     exchangedSessionCache.set(token, session);
     return session;

package/dist/index.js

@@ -21,9 +21,10 @@ import { registerSupportTools } from "./tools/support.js";
 import { registerAdminTools } from "./tools/admin.js";
 import { registerResources } from "./resources.js";
 import { registerPrompts } from "./prompts.js";
+import { recordCurrentUsage, runWithUsageContext } from "./usage.js";
 const server = new McpServer({
     name: "creator-os-mcp",
-    version: "1.0.4",
+    version: "1.0.5",
 }, {
     instructions: [
         "Creator OS MCP Server — a comprehensive toolkit for YouTube creators.",
@@ -47,6 +48,32 @@ const server = new McpServer({
         logging: {},
     },
 });
+const instrumentedServer = server;
+function instrumentHandlerRegistration(targetType, register) {
+    return (...args) => {
+        const name = typeof args[0] === "string" ? args[0] : "unknown";
+        const handler = args.at(-1);
+        if (typeof handler !== "function") {
+            return register(...args);
+        }
+        const wrappedArgs = [...args];
+        wrappedArgs[wrappedArgs.length - 1] = async (...handlerArgs) => runWithUsageContext(targetType, name, async () => {
+            try {
+                const result = await handler(...handlerArgs);
+                await recordCurrentUsage("success");
+                return result;
+            }
+            catch (error) {
+                await recordCurrentUsage("error", error);
+                throw error;
+            }
+        });
+        return register(...wrappedArgs);
+    };
+}
+instrumentedServer.tool = instrumentHandlerRegistration("tool", instrumentedServer.tool.bind(server));
+instrumentedServer.resource = instrumentHandlerRegistration("resource", instrumentedServer.resource.bind(server));
+instrumentedServer.prompt = instrumentHandlerRegistration("prompt", instrumentedServer.prompt.bind(server));
 // ── Register all capabilities ──────────────────────────────────────
 registerPipelineTools(server);
 registerDealTools(server);

package/dist/types.d.ts

@@ -106,4 +106,7 @@ export interface AuthContext {
     userId: string;
     email: string | null;
     token: string;
+    tokenId: string | null;
+    tokenName: string | null;
+    authType: "mcp_token" | "supabase_jwt";
 }

package/dist/usage.d.ts

@@ -0,0 +1,5 @@
+import type { AuthContext } from "./types.js";
+export type UsageTargetType = "tool" | "resource" | "prompt";
+export declare function runWithUsageContext<T>(targetType: UsageTargetType, targetName: string, fn: () => Promise<T>): Promise<T>;
+export declare function attachAuthToUsageContext(auth: AuthContext): void;
+export declare function recordCurrentUsage(status: "success" | "error", error?: unknown): Promise<void>;

package/dist/usage.js

@@ -0,0 +1,64 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createUserClient } from "./client.js";
+const usageStorage = new AsyncLocalStorage();
+function getCurrentContext() {
+    return usageStorage.getStore();
+}
+function normalizeErrorMessage(error) {
+    if (!error)
+        return null;
+    if (error instanceof Error)
+        return error.message.slice(0, 2000);
+    if (typeof error === "string")
+        return error.slice(0, 2000);
+    try {
+        return JSON.stringify(error).slice(0, 2000);
+    }
+    catch {
+        return "Unknown MCP error";
+    }
+}
+export function runWithUsageContext(targetType, targetName, fn) {
+    return usageStorage.run({
+        targetType,
+        targetName,
+        startedAt: Date.now(),
+        auth: null,
+    }, fn);
+}
+export function attachAuthToUsageContext(auth) {
+    const context = getCurrentContext();
+    if (context) {
+        context.auth = auth;
+    }
+}
+export async function recordCurrentUsage(status, error) {
+    const context = getCurrentContext();
+    if (!context?.auth) {
+        return;
+    }
+    try {
+        const client = createUserClient(context.auth.token);
+        const durationMs = Date.now() - context.startedAt;
+        await client.from("mcp_usage_events").insert({
+            user_id: context.auth.userId,
+            token_id: context.auth.tokenId,
+            token_name: context.auth.tokenName ??
+                (context.auth.authType === "supabase_jwt"
+                    ? "JWT Session"
+                    : "Unknown token"),
+            auth_type: context.auth.authType,
+            target_type: context.targetType,
+            target_name: context.targetName,
+            status,
+            duration_ms: durationMs,
+            error_message: normalizeErrorMessage(error),
+            metadata: {
+                source: "creator-mcp",
+            },
+        });
+    }
+    catch (trackingError) {
+        console.error("Failed to record MCP usage event:", trackingError);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "creator-mcp",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "MCP server for Creator OS — access your pipeline, deals, analytics, AI tools, and more via any MCP-compatible client",
   "type": "module",
   "license": "MIT",