@plaud-ai/mcp 0.2.4 → 0.3.0

package/dist/index.js

@@ -1,16 +1,29 @@
 #!/usr/bin/env node
 import {
   getClient
-} from "./chunk-GZ7QPRKV.js";
+} from "./chunk-BU3JMO4H.js";
 import {
   loadSkills
 } from "./chunk-4QBEOJPX.js";
 import {
+  normalizeMcpHost,
   registerTools
-} from "./chunk-BZOIX6WC.js";
+} from "./chunk-QXV7KYGD.js";
 import {
-  runOAuthCallback
-} from "./chunk-3XRFIJUG.js";
+  capture,
+  classifyError,
+  clearUser,
+  extractIdentity,
+  initTelemetry,
+  oauthCallbackErrorType,
+  runOAuthCallback,
+  setMcpHost,
+  setUser,
+  shutdown
+} from "./chunk-TPGKCGTQ.js";
+import "./chunk-NPCCDRWQ.js";
+import "./chunk-RUFCT6DQ.js";
+import "./chunk-MCKGQKYU.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -18,7 +31,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import open from "open";
 var server = new McpServer({
   name: "plaud",
-  version: "0.2.4"
+  version: "0.3.0"
 });
 var CALLBACK_PORT = 8199;
 var LOGIN_TIMEOUT_MS = 12e4;
@@ -56,8 +69,23 @@ server.registerTool("login", {
       });
     }
   });
+  if (result.status === "success") {
+    capture("auth:oauth_callback:success", { passive: true });
+  } else {
+    capture("auth:oauth_callback:error", {
+      passive: true,
+      error_type: oauthCallbackErrorType(result.status)
+    });
+  }
   switch (result.status) {
     case "success":
+      try {
+        const user = await client.getCurrentUser();
+        if (user && typeof user.id === "string") {
+          await setUser(user.id, extractIdentity(user));
+        }
+      } catch {
+      }
       return { content: [{ type: "text", text: "Successfully authenticated with Plaud!" }] };
     case "timeout":
       return {
@@ -97,10 +125,19 @@ server.registerTool("logout", {
     return { content: [{ type: "text", text: "Already logged out." }] };
   }
   try {
-    await client.revokeCurrentUser();
+    try {
+      await client.revokeCurrentUser();
+    } catch {
+    }
+    await client.auth.logout();
+    capture("auth:logout:success", { passive: true });
+  } catch (err) {
+    capture("auth:logout:error", { passive: true, error_type: classifyError(err) });
+  }
+  try {
+    await clearUser();
   } catch {
   }
-  await client.auth.logout();
   return {
     content: [{ type: "text", text: "Logged out and revoked authorization." }]
   };
@@ -117,7 +154,7 @@ async function main() {
   const sub = process.argv[2];
   const sub2 = process.argv[3];
   if (sub === "install") {
-    const { runInstall } = await import("./install-ALLWR7CL.js");
+    const { runInstall } = await import("./install-2EIB7ZP3.js");
     const args = process.argv.slice(3);
     const yes = args.some((a) => a === "--yes" || a === "-y");
     const noLogin = args.some((a) => a === "--no-login");
@@ -125,32 +162,34 @@ async function main() {
     return;
   }
   if (sub === "clean-plugin") {
-    const { runCleanPlugin } = await import("./setup-QXZHVVDP.js");
+    const { runCleanPlugin } = await import("./setup-GLWZYNRW.js");
     await runCleanPlugin();
     return;
   }
   if (sub === "setup" && sub2 === "codex") {
-    const { runSetupCodex } = await import("./setup-QXZHVVDP.js");
+    const { runSetupCodex } = await import("./setup-GLWZYNRW.js");
     await runSetupCodex();
     return;
   }
   if (sub === "unsetup" && sub2 === "codex") {
-    const { runUnsetupCodex } = await import("./setup-QXZHVVDP.js");
+    const { runUnsetupCodex } = await import("./setup-GLWZYNRW.js");
     await runUnsetupCodex();
     return;
   }
   if (sub === "setup") {
-    const { runSetup } = await import("./setup-QXZHVVDP.js");
+    const { runSetup } = await import("./setup-GLWZYNRW.js");
     await runSetup();
     return;
   }
   if (sub === "unsetup") {
-    const { runUnsetup } = await import("./setup-QXZHVVDP.js");
+    const { runUnsetup } = await import("./setup-GLWZYNRW.js");
     await runUnsetup();
     return;
   }
   if (sub === "http") {
-    const { startHttpServer } = await import("./server-VY7ANVCH.js");
+    const { startHttpServer } = await import("./server-ZVB7U2VZ.js");
+    const { startMetricsServer } = await import("./server-BOR5EZLF.js");
+    startMetricsServer();
     startHttpServer();
     return;
   }
@@ -171,8 +210,37 @@ Usage:
 `);
     return;
   }
+  try {
+    await initTelemetry({
+      surface: "mcp",
+      appVersion: "0.3.0",
+      transport: "stdio"
+    });
+  } catch {
+  }
+  const exitWithFlush = async (code) => {
+    try {
+      await shutdown();
+    } catch {
+    }
+    process.exit(code);
+  };
+  process.on("SIGINT", () => void exitWithFlush(130));
+  process.on("SIGTERM", () => void exitWithFlush(143));
   await registerSkillPrompts();
+  server.server.oninitialized = () => {
+    try {
+      setMcpHost(normalizeMcpHost(server.server.getClientVersion()?.name));
+    } catch {
+    }
+  };
   const transport = new StdioServerTransport();
-  await server.connect(transport);
+  try {
+    await server.connect(transport);
+    capture("mcp:server:success", { passive: true });
+  } catch (err) {
+    capture("mcp:server:error", { passive: true, error_type: classifyError(err) });
+    await exitWithFlush(1);
+  }
 }
 main().catch(console.error);

package/dist/{install-ALLWR7CL.js → install-2EIB7ZP3.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-GZ7QPRKV.js";
+} from "./chunk-BU3JMO4H.js";
 import {
   copyToClipboard,
   getMcpEntry,
@@ -11,7 +11,9 @@ import {
 } from "./chunk-4QBEOJPX.js";
 import {
   runOAuthCallback
-} from "./chunk-3XRFIJUG.js";
+} from "./chunk-TPGKCGTQ.js";
+import "./chunk-RUFCT6DQ.js";
+import "./chunk-MCKGQKYU.js";
 
 // src/install.ts
 import { createInterface } from "readline/promises";

package/dist/server-BOR5EZLF.js

@@ -0,0 +1,35 @@
+import {
+  logger
+} from "./chunk-NPCCDRWQ.js";
+import {
+  registry
+} from "./chunk-RUFCT6DQ.js";
+import "./chunk-MCKGQKYU.js";
+
+// src/metrics/server.ts
+import express from "express";
+var METRICS_PORT = Number(process.env.PLAUD_METRICS_PORT ?? 9080);
+var METRICS_HOST = process.env.PLAUD_METRICS_HOST ?? "0.0.0.0";
+function startMetricsServer() {
+  const app = express();
+  app.get("/metrics", async (_req, res, next) => {
+    try {
+      res.setHeader("Content-Type", registry.contentType);
+      res.end(await registry.metrics());
+    } catch (err) {
+      next(err);
+    }
+  });
+  app.get("/healthz", (_req, res) => {
+    res.status(200).send("ok");
+  });
+  const server = app.listen(METRICS_PORT, METRICS_HOST, () => {
+    logger.info({ event: "metrics_server_started", port: METRICS_PORT, host: METRICS_HOST });
+  });
+  server.on("error", (err) => {
+    logger.error({ event: "metrics_server_error", err: err.message });
+  });
+}
+export {
+  startMetricsServer
+};

package/dist/{server-VY7ANVCH.js → server-ZVB7U2VZ.js}

@@ -1,10 +1,18 @@
 import {
-  logger,
   registerTools
-} from "./chunk-BZOIX6WC.js";
+} from "./chunk-QXV7KYGD.js";
 import {
   PlaudClient
-} from "./chunk-3XRFIJUG.js";
+} from "./chunk-TPGKCGTQ.js";
+import {
+  logger
+} from "./chunk-NPCCDRWQ.js";
+import {
+  httpRequestDuration,
+  httpRequestsInProgress,
+  oauthTokenRefresh
+} from "./chunk-RUFCT6DQ.js";
+import "./chunk-MCKGQKYU.js";
 
 // src/http/server.ts
 import express from "express";
@@ -680,17 +688,21 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
       }
       logger.error({ event: "oauth_token_refresh_failed", status: fetchRes.status, body: text.slice(0, 500) });
       if (fetchRes.status >= 500) {
+        oauthTokenRefresh.inc({ result: "upstream_error" });
         throw new McpServerError(`Upstream refresh endpoint error: ${fetchRes.status} ${text.slice(0, 200)}`);
       }
+      oauthTokenRefresh.inc({ result: "invalid_grant" });
       throw new InvalidGrantError(`Plaud token refresh: ${fetchRes.status} ${text.slice(0, 200)}`);
     }
     let data;
     try {
       data = await fetchRes.json();
     } catch (err) {
+      oauthTokenRefresh.inc({ result: "parse_failed" });
       logger.error({ event: "oauth_refresh_json_parse_failed", error: String(err) });
       throw new McpServerError("Refresh endpoint returned non-JSON response");
     }
+    oauthTokenRefresh.inc({ result: "success" });
     logger.info({
       event: "oauth_token_refresh_ok",
       has_refresh_token: !!data.refresh_token,
@@ -805,6 +817,22 @@ function startHttpServer() {
   };
   const app = createMcpExpressApp({ host: HTTP_HOST });
   app.set("trust proxy", 1);
+  app.use((req, res, next) => {
+    const start = process.hrtime.bigint();
+    const method = req.method;
+    const inProgressLabels = { method, handler: req.path };
+    httpRequestsInProgress.inc(inProgressLabels);
+    res.on("finish", () => {
+      const handler = req.route?.path ?? req.path;
+      const durSec = Number(process.hrtime.bigint() - start) / 1e9;
+      httpRequestDuration.observe(
+        { method, handler, status: String(res.statusCode) },
+        durSec
+      );
+      httpRequestsInProgress.dec(inProgressLabels);
+    });
+    next();
+  });
   app.get("/.well-known/openai-apps-challenge", (_req, res) => {
     res.type("text/plain").send(OPENAI_APPS_CHALLENGE_TOKEN);
   });
@@ -982,7 +1010,7 @@ function startHttpServer() {
         apiBase,
         staticToken: token
       });
-      const mcpServer = new McpServer({ name: "plaud", version: "0.2.4" });
+      const mcpServer = new McpServer({ name: "plaud", version: "0.3.0" });
       registerTools(mcpServer, client);
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: void 0,

package/dist/{setup-QXZHVVDP.js → setup-GLWZYNRW.js}

@@ -7,6 +7,7 @@ import {
 import {
   skillsCombined
 } from "./chunk-4QBEOJPX.js";
+import "./chunk-MCKGQKYU.js";
 
 // src/setup.ts
 import { readFile, writeFile, mkdir, rm } from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaud-ai/mcp",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -25,10 +25,12 @@
     "express": "^5.2.1",
     "open": "^10.2.0",
     "pino": "^10.3.1",
+    "prom-client": "^15.1.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@plaud-ai/shared": "workspace:*",
+    "@plaud-ai/telemetry": "workspace:*",
     "@types/express": "^5.0.6",
     "@types/node": "^25.5.0",
     "typescript": "^5.7.0"

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "plaud",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Access your Plaud recordings in Claude",
   "author": {
     "name": "Plaud AI"

package/dist/chunk-3XRFIJUG.js

@@ -1,352 +0,0 @@
-// ../shared/dist/oauth.js
-import { randomBytes, createHash } from "crypto";
-
-// ../shared/dist/token-store.js
-import { readFile, writeFile, mkdir, rm } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-var TokenStore = class {
-  configDir;
-  tokenPath;
-  constructor(filename = "tokens.json") {
-    this.configDir = join(homedir(), ".plaud");
-    this.tokenPath = join(this.configDir, filename);
-  }
-  async save(tokenSet) {
-    await mkdir(this.configDir, { recursive: true });
-    await writeFile(this.tokenPath, JSON.stringify(tokenSet, null, 2), "utf-8");
-  }
-  async load() {
-    try {
-      const data = await readFile(this.tokenPath, "utf-8");
-      return JSON.parse(data);
-    } catch {
-      return null;
-    }
-  }
-  async clear() {
-    try {
-      await rm(this.tokenPath);
-    } catch {
-    }
-  }
-};
-
-// ../shared/dist/oauth.js
-var DEFAULT_AUTHORIZATION_URL = "https://web.plaud.ai/platform/oauth";
-var DEFAULT_TOKEN_URL = "https://platform.plaud.ai/developer/api/oauth/third-party/access-token";
-var DEFAULT_REFRESH_URL = "https://platform.plaud.ai/developer/api/oauth/third-party/access-token/refresh";
-function generateCodeVerifier() {
-  return randomBytes(32).toString("base64url");
-}
-function generateCodeChallenge(verifier) {
-  return createHash("sha256").update(verifier).digest("base64url");
-}
-function generateState() {
-  return randomBytes(16).toString("base64url");
-}
-var OAuth = class {
-  config;
-  tokenStore;
-  authorizationUrl;
-  tokenUrl;
-  refreshUrl;
-  constructor(config) {
-    this.config = config;
-    this.tokenStore = new TokenStore(config.tokenFile);
-    this.authorizationUrl = config.authorizationUrl ?? DEFAULT_AUTHORIZATION_URL;
-    this.tokenUrl = config.tokenUrl ?? DEFAULT_TOKEN_URL;
-    this.refreshUrl = config.refreshUrl ?? DEFAULT_REFRESH_URL;
-  }
-  createAuthorizationRequest() {
-    const codeVerifier = generateCodeVerifier();
-    const codeChallenge = generateCodeChallenge(codeVerifier);
-    const state = generateState();
-    const params = new URLSearchParams({
-      client_id: this.config.clientId,
-      redirect_uri: this.config.redirectUri,
-      response_type: "code",
-      code_challenge: codeChallenge,
-      code_challenge_method: "S256",
-      state
-    });
-    return {
-      url: `${this.authorizationUrl}?${params.toString()}`,
-      codeVerifier,
-      state
-    };
-  }
-  /**
-   * @deprecated Use createAuthorizationRequest() for PKCE flow
-   */
-  getAuthorizationUrl() {
-    return this.createAuthorizationRequest().url;
-  }
-  async exchangeCode(code, codeVerifier, state) {
-    const basicAuth = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString("base64");
-    const body = {
-      code,
-      redirect_uri: this.config.redirectUri
-    };
-    if (codeVerifier) {
-      body.code_verifier = codeVerifier;
-    }
-    if (state) {
-      body.state = state;
-    }
-    const res = await fetch(this.tokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json",
-        Authorization: `Basic ${basicAuth}`,
-        ...this.config.extraHeaders
-      },
-      body: new URLSearchParams(body)
-    });
-    if (!res.ok) {
-      throw new Error(`Token exchange failed: ${res.status} ${await res.text()}`);
-    }
-    const data = await res.json();
-    const tokenSet = {
-      access_token: data.access_token,
-      refresh_token: data.refresh_token,
-      token_type: data.token_type ?? "Bearer",
-      expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
-    };
-    await this.tokenStore.save(tokenSet);
-    return tokenSet;
-  }
-  async getAccessToken() {
-    const tokenSet = await this.tokenStore.load();
-    if (!tokenSet)
-      return null;
-    if (tokenSet.expires_at && Date.now() > tokenSet.expires_at - 6e4) {
-      if (tokenSet.refresh_token) {
-        try {
-          const refreshed = await this.refresh(tokenSet.refresh_token);
-          return refreshed.access_token;
-        } catch {
-          return null;
-        }
-      }
-      return null;
-    }
-    return tokenSet.access_token;
-  }
-  async refresh(refreshToken) {
-    const res = await fetch(this.refreshUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json",
-        ...this.config.extraHeaders
-      },
-      body: new URLSearchParams({
-        refresh_token: refreshToken
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Token refresh failed: ${res.status} ${body}`);
-    }
-    const data = await res.json();
-    const tokenSet = {
-      access_token: data.access_token,
-      refresh_token: data.refresh_token ?? refreshToken,
-      token_type: data.token_type ?? "Bearer",
-      expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
-    };
-    await this.tokenStore.save(tokenSet);
-    return tokenSet;
-  }
-  async logout() {
-    await this.tokenStore.clear();
-  }
-};
-
-// ../shared/dist/client.js
-var DEFAULT_API_BASE = "https://platform.plaud.ai/developer/api";
-var PlaudClient = class {
-  oauth;
-  apiBase;
-  extraHeaders;
-  staticToken;
-  constructor(config) {
-    this.oauth = new OAuth(config);
-    this.apiBase = config.apiBase ?? DEFAULT_API_BASE;
-    this.extraHeaders = config.extraHeaders ?? {};
-    this.staticToken = config.staticToken;
-  }
-  get auth() {
-    return this.oauth;
-  }
-  async request(path, init) {
-    const token = this.staticToken ?? await this.oauth.getAccessToken();
-    if (!token) {
-      throw new Error("Not authenticated. Please login first.");
-    }
-    const url = `${this.apiBase}${path}`;
-    const method = init?.method ?? "GET";
-    const headers = {
-      Authorization: `Bearer ${token}`,
-      Accept: "application/json",
-      ...this.extraHeaders,
-      ...init?.headers
-    };
-    const res = await fetch(url, { ...init, headers });
-    if (!res.ok) {
-      const body = await res.text();
-      if (res.status === 422) {
-        try {
-          const parsed = JSON.parse(body);
-          const messages = parsed.detail.map((d) => `${d.loc.at(-1)}: ${d.msg}`).join("; ");
-          throw new Error(messages);
-        } catch (e) {
-          if (e instanceof SyntaxError)
-            throw new Error(`API error: ${res.status} ${res.statusText}`);
-          throw e;
-        }
-      }
-      throw new Error(`API error: ${res.status} ${res.statusText}`);
-    }
-    const json = await res.json();
-    return json;
-  }
-  async getCurrentUser() {
-    return this.request("/open/third-party/users/current");
-  }
-  async revokeCurrentUser() {
-    await this.request("/open/third-party/users/current/revoke", {
-      method: "POST"
-    });
-  }
-  async listFiles(page = 1, pageSize = 20) {
-    return this.request(`/open/third-party/files/?page=${page}&page_size=${pageSize}`);
-  }
-  async getFile(fileId) {
-    return this.request(`/open/third-party/files/${fileId}`);
-  }
-};
-
-// ../shared/dist/oauth-callback-server.js
-import { createServer } from "http";
-var SUCCESS_HTML = '<!doctype html><html><head><meta charset="utf-8"><title>Plaud</title></head><body style="font-family:system-ui;padding:2rem;text-align:center;"><h1>Authorization successful!</h1><p>You can close this tab.</p></body></html>';
-var NEUTRAL_HTML = '<!doctype html><html><head><meta charset="utf-8"><title>Plaud</title></head><body style="font-family:system-ui;padding:2rem;text-align:center;"><h1>Continue authorization in the original window.</h1><p>This page can be closed.</p></body></html>';
-function errorHtml(message) {
-  const escaped = message.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
-  return '<!doctype html><html><head><meta charset="utf-8"><title>Plaud</title></head><body style="font-family:system-ui;padding:2rem;text-align:center;"><h1>Authorization failed</h1><pre style="white-space:pre-wrap;">' + escaped + "</pre></body></html>";
-}
-var CORS_HEADERS = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "GET, OPTIONS",
-  "Access-Control-Allow-Headers": "*"
-};
-function runOAuthCallback(opts) {
-  const { port, expectedState, exchangeCode, timeoutMs = 12e4, onListening, postSuccessDelayMs = 1500 } = opts;
-  return new Promise((resolve) => {
-    let settled = false;
-    let exchangeStarted = false;
-    let exchangeSucceeded = false;
-    let timeoutId = null;
-    let closeTimeoutId = null;
-    const server = createServer((req, res) => {
-      if (req.method === "OPTIONS") {
-        res.writeHead(204, CORS_HEADERS);
-        res.end();
-        return;
-      }
-      const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
-      if (reqUrl.pathname !== "/auth/callback") {
-        res.writeHead(404, CORS_HEADERS);
-        res.end();
-        return;
-      }
-      const params = reqUrl.searchParams;
-      const error = params.get("error");
-      const state = params.get("state");
-      const code = params.get("code");
-      if (error) {
-        const desc = params.get("error_description") ?? error;
-        res.writeHead(400, { "Content-Type": "text/html", ...CORS_HEADERS });
-        res.end(errorHtml(`Authorization denied: ${desc}`));
-        finalize({ status: "denied", error: new Error(desc) });
-        return;
-      }
-      if (!state || state !== expectedState) {
-        respondNeutral(res);
-        return;
-      }
-      if (exchangeSucceeded) {
-        respondSuccess(res);
-        return;
-      }
-      if (!code) {
-        respondNeutral(res);
-        return;
-      }
-      if (exchangeStarted) {
-        respondNeutral(res);
-        return;
-      }
-      exchangeStarted = true;
-      exchangeCode(code).then(() => {
-        exchangeSucceeded = true;
-        respondSuccess(res);
-        finalize({ status: "success" });
-      }, (err) => {
-        const e = err instanceof Error ? err : new Error(String(err));
-        res.writeHead(500, { "Content-Type": "text/html", ...CORS_HEADERS });
-        res.end(errorHtml(e.message));
-        finalize({ status: "exchange-failed", error: e });
-      });
-    });
-    server.on("error", (err) => {
-      if (settled)
-        return;
-      const message = err.code === "EADDRINUSE" ? `port ${port} is in use \u2014 another \`plaud login\` may still be running. Wait a few seconds and retry.` : `callback server error: ${err.message}`;
-      finalize({ status: "listen-failed", error: new Error(message) }, true);
-    });
-    timeoutId = setTimeout(() => {
-      finalize({ status: "timeout" }, true);
-    }, timeoutMs);
-    server.listen(port, () => {
-      onListening?.();
-    });
-    function respondSuccess(res) {
-      res.writeHead(200, { "Content-Type": "text/html", ...CORS_HEADERS });
-      res.end(SUCCESS_HTML);
-    }
-    function respondNeutral(res) {
-      res.writeHead(200, { "Content-Type": "text/html", ...CORS_HEADERS });
-      res.end(NEUTRAL_HTML);
-    }
-    function finalize(result, immediate = false) {
-      if (settled)
-        return;
-      settled = true;
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = null;
-      }
-      const close = () => {
-        try {
-          server.closeAllConnections?.();
-        } catch {
-        }
-        server.close(() => resolve(result));
-      };
-      if (immediate || result.status !== "success") {
-        close();
-      } else {
-        closeTimeoutId = setTimeout(close, postSuccessDelayMs);
-        closeTimeoutId.unref?.();
-      }
-    }
-  });
-}
-
-export {
-  PlaudClient,
-  runOAuthCallback
-};