tavus-cli 0.9.2__tar.gz → 0.9.3__tar.gz

tavus_cli-0.9.3/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.9.3"
+}

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.9.3](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.9.2...v0.9.3) (2026-10-13)
+
+
+### Bug Fixes
+
+* **worker:** accept any loopback port and legacy MCP client IDs at sign-in ([#70](https://github.com/Tavus-Engineering/tavus-mcp/issues/70)) ([231a42c](https://github.com/Tavus-Engineering/tavus-mcp/commit/231a42c39806646c21ae07af3330927dbba5ea4a))
+
 ## [0.9.2](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.9.1...v0.9.2) (2026-10-10)
 
 

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tavus-cli
-Version: 0.9.2
+Version: 0.9.3
 Summary: Tavus CLI and MCP server for agentic PAL creation and editing.
 Requires-Python: >=3.11
 Requires-Dist: fastmcp>=2.0.0

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/packages/tavus/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "tavus"
-version = "0.9.2" # x-release-please-version
+version = "0.9.3" # x-release-please-version
 description = "Official alias for tavus-cli, the Tavus CLI and MCP server."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-  "tavus-cli==0.9.2", # x-release-please-version
+  "tavus-cli==0.9.3", # x-release-please-version
 ]
 
 [project.urls]

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/packages/tavus-mcp/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "tavus-mcp"
-version = "0.9.2" # x-release-please-version
+version = "0.9.3" # x-release-please-version
 description = "Official alias for tavus-cli, which provides the tavus-mcp MCP server."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-  "tavus-cli==0.9.2", # x-release-please-version
+  "tavus-cli==0.9.3", # x-release-please-version
 ]
 
 [project.urls]

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/plugins/tavus-pal/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "tavus-pal",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Create, edit, and test Tavus PALs: digital humans with a face, voice, knowledge, and conversational behavior. Uses the Tavus hosted MCP server and your connected Tavus account.",
   "author": {
     "name": "Tavus",
@@ -37,6 +37,7 @@
         "logoDark": "./assets/icon-dark.svg"
       },
       "review": {
+        "demo_recording_url": "https://tavus-mcp-review.pages.dev/tavus-openai-review-demo-2026-09-10-19f4128cd7a5cbc4.mp4",
         "commerce": false,
         "commerce_description": "Users access their existing Tavus account entitlements. This plugin does not sell PALs, subscriptions, or credits, collect payment details, or initiate checkout.",
         "test_cases": {

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tavus-cli"
-version = "0.9.2"
+version = "0.9.3"
 description = "Tavus CLI and MCP server for agentic PAL creation and editing."
 readme = "README.md"
 requires-python = ">=3.11"

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/src/tavus_mcp/__init__.py

@@ -1,4 +1,4 @@
 """Tavus CLI and MCP server package."""
 
 __all__ = ["__version__"]
-__version__ = "0.9.2"  # x-release-please-version
+__version__ = "0.9.3"  # x-release-please-version

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/uv.lock

@@ -1303,7 +1303,7 @@ wheels = [
 
 [[package]]
 name = "tavus-cli"
-version = "0.9.2"
+version = "0.9.3"
 source = { editable = "." }
 dependencies = [
     { name = "fastmcp" },

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/workers/tavus-mcp/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@tavus/tavus-mcp-worker",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@tavus/tavus-mcp-worker",
-      "version": "0.9.2",
+      "version": "0.9.3",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.29.0",
         "agents": "^0.12.2",

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/workers/tavus-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tavus/tavus-mcp-worker",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "private": true,
   "type": "module",
   "scripts": {

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/workers/tavus-mcp/src/oauth.ts

@@ -18,6 +18,13 @@ const REGISTER_ROUTE = "/register";
 const CALLBACK_ROUTE = "/oauth/callback";
 const AUTHORIZATION_REQUEST_ROUTE = "/oauth/authorization-request";
 const DYNAMIC_CLIENT_PREFIX = "tavus-mcp-dcr";
+// Client IDs that /register issued before 2026-08-06 (#21). The Worker never
+// stored them, and /authorize accepted any client ID whose redirect was a
+// loopback URL. Clients such as Claude Code keep replaying the ID they cached
+// instead of registering again (anthropics/claude-code#84614), and the
+// rejection they get is a browser page they never see. Keeping the old rule
+// for these IDs, loopback only, lets them sign in without any stored state.
+const LEGACY_DYNAMIC_CLIENT_ID = /^tavus-mcp-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/;
 const AUTHORIZATION_STATE_TTL_SECONDS = 10 * 60;
 const AUTHORIZATION_CODE_TTL_SECONDS = 5 * 60;
 
@@ -191,10 +198,37 @@ function findRegisteredRedirect(
   redirectUri: string,
 ): RegisteredOAuthClient | undefined {
   return clients.find(
-    (c) => c.client_id === clientId && c.redirect_uris.includes(redirectUri),
+    (c) =>
+      c.client_id === clientId &&
+      c.redirect_uris.some((registered) => redirectUriMatches(registered, redirectUri)),
   );
 }
 
+// RFC 8252 section 7.3: a native client takes an ephemeral port when it starts
+// the flow, so the authorization server MUST accept any port on a loopback
+// redirect URI. Everything else about the URI still has to match. HTTPS
+// callbacks need an exact match.
+function redirectUriMatches(registered: string, requested: string): boolean {
+  if (registered === requested) {
+    return true;
+  }
+  if (!isLoopbackUrl(registered) || !isLoopbackUrl(requested)) {
+    return false;
+  }
+  const a = new URL(registered);
+  const b = new URL(requested);
+  return (
+    a.protocol === b.protocol &&
+    a.hostname === b.hostname &&
+    a.pathname === b.pathname &&
+    a.search === b.search
+  );
+}
+
+function isLegacyDynamicClient(clientId: string): boolean {
+  return LEGACY_DYNAMIC_CLIENT_ID.test(clientId);
+}
+
 async function resolveRegisteredRedirect(
   env: Env,
   clientId: string,
@@ -208,7 +242,7 @@ async function resolveRegisteredRedirect(
   const signingSecret = oauthSigningSecret(env);
   if (signingSecret) {
     const dynamic = await verifyClientPayload(clientId, signingSecret);
-    if (dynamic?.redirect_uris.includes(redirectUri)) {
+    if (dynamic?.redirect_uris.some((registered) => redirectUriMatches(registered, redirectUri))) {
       return {
         client_id: clientId,
         redirect_uris: dynamic.redirect_uris,
@@ -217,6 +251,10 @@ async function resolveRegisteredRedirect(
     }
   }
 
+  if (isLegacyDynamicClient(clientId) && isLoopbackUrl(redirectUri)) {
+    return { client_id: clientId, redirect_uris: [redirectUri], name: "Tavus MCP Client" };
+  }
+
   return undefined;
 }
 
@@ -378,9 +416,10 @@ async function handleAuthorize(request: Request, env: Env, mcpRoute: string): Pr
 
   const registeredRedirect = await resolveRegisteredRedirect(env, clientId, redirectUri);
   if (!registeredRedirect) {
+    // This page is all the person sees; the MCP client never learns about it.
     return oauthError(
       "invalid_request",
-      "redirect_uri is not registered for this client.",
+      "redirect_uri is not registered for this client. Remove and re-add the Tavus MCP server in your client so it registers again.",
       400,
     );
   }
@@ -654,6 +693,10 @@ async function authenticateClient(request: Request, params: URLSearchParams, env
     }
     return secret ? null : clientId;
   }
+  // Legacy IDs were always public clients; see LEGACY_DYNAMIC_CLIENT_ID.
+  if (isLegacyDynamicClient(clientId)) {
+    return !secret && !basic ? clientId : null;
+  }
   const signingSecret = oauthSigningSecret(env);
   const dynamic = signingSecret ? await verifyClientPayload(clientId, signingSecret) : null;
   if (!dynamic || !signingSecret) return null;

tavus_cli-0.9.3/workers/tavus-mcp/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = "0.9.3"; // x-release-please-version

{tavus_cli-0.9.2 → tavus_cli-0.9.3}/workers/tavus-mcp/test/tavus.test.ts

@@ -1017,6 +1017,226 @@ describe("Cloudflare Tavus MCP helpers", () => {
     expect(response?.status).toBe(400);
   });
 
+  function authorizeUrl(clientId: string, redirectUri: string): URL {
+    const url = new URL("https://mcp.tavus-preview.io/authorize");
+    url.search = new URLSearchParams({
+      response_type: "code",
+      client_id: clientId,
+      redirect_uri: redirectUri,
+      state: "state-token",
+      code_challenge: "challenge",
+      code_challenge_method: "S256",
+      resource: "https://mcp.tavus-preview.io/mcp",
+      scope: "tavus",
+    }).toString();
+    return url;
+  }
+
+  async function registerLoopbackClient(env: Env, redirectUri: string): Promise<string> {
+    const registration = await handleOAuthRequest(
+      new Request("https://mcp.tavus-preview.io/register", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ redirect_uris: [redirectUri], client_name: "Claude Code" }),
+      }),
+      env,
+      "/mcp",
+    );
+    expect(registration?.status).toBe(201);
+    return ((await registration?.json()) as { client_id: string }).client_id;
+  }
+
+  // RFC 8252 section 7.3: loopback clients take an ephemeral port per attempt.
+  it("accepts any loopback port for a dynamically registered callback", async () => {
+    const env = withOAuthGrants({
+      MCP_OAUTH_SIGNING_SECRET: "s".repeat(32),
+      TAVUS_DEV_PORTAL_URL: "https://platform.example.test",
+    });
+    const clientId = await registerLoopbackClient(env, "http://localhost:4000/callback");
+
+    const response = await handleOAuthRequest(
+      new Request(authorizeUrl(clientId, "http://localhost:53117/callback")),
+      env,
+      "/mcp",
+    );
+
+    expect(response?.status).toBe(302);
+    const location = new URL(response?.headers.get("Location") ?? "");
+    expect(location.origin + location.pathname).toBe("https://platform.example.test/dev/cli-authorize");
+  });
+
+  it.each([
+    ["a different path", "http://localhost:4000/other"],
+    ["a different loopback host", "http://127.0.0.1:4000/callback"],
+    ["an added query string", "http://localhost:4000/callback?next=https://attacker.example"],
+    ["an HTTPS callback", "https://example.test/callback"],
+  ])("rejects a dynamically registered loopback client's callback with %s", async (_label, redirectUri) => {
+    const env = withOAuthGrants({ MCP_OAUTH_SIGNING_SECRET: "s".repeat(32) });
+    const clientId = await registerLoopbackClient(env, "http://localhost:4000/callback");
+
+    const response = await handleOAuthRequest(new Request(authorizeUrl(clientId, redirectUri)), env, "/mcp");
+
+    expect(response?.status).toBe(400);
+  });
+
+  it("accepts any loopback port for a pre-registered loopback callback", async () => {
+    const env = withOAuthGrants({
+      MCP_OAUTH_SIGNING_SECRET: "s".repeat(32),
+      MCP_OAUTH_CLIENTS: JSON.stringify([
+        { client_id: "static-cli", redirect_uris: ["http://127.0.0.1:4000/callback"] },
+      ]),
+    });
+
+    const response = await handleOAuthRequest(
+      new Request(authorizeUrl("static-cli", "http://127.0.0.1:4001/callback")),
+      env,
+      "/mcp",
+    );
+
+    expect(response?.status).toBe(302);
+  });
+
+  it("still needs an exact match for a pre-registered HTTPS callback", async () => {
+    const env = withOAuthGrants({
+      MCP_OAUTH_SIGNING_SECRET: "s".repeat(32),
+      MCP_OAUTH_CLIENTS: JSON.stringify([
+        { client_id: "static-web", redirect_uris: ["https://example.test/callback"] },
+      ]),
+    });
+
+    const response = await handleOAuthRequest(
+      new Request(authorizeUrl("static-web", "https://example.test:8443/callback")),
+      env,
+      "/mcp",
+    );
+
+    expect(response?.status).toBe(400);
+  });
+
+  // Issued by /register before #21; the Worker never stored them.
+  const legacyClientId = "tavus-mcp-db38e103-83e8-4046-87d6-026739d5133c";
+
+  it("accepts a legacy dynamic client ID with a loopback callback", async () => {
+    const env = withOAuthGrants({
+      MCP_OAUTH_SIGNING_SECRET: "s".repeat(32),
+      TAVUS_DEV_PORTAL_URL: "https://platform.example.test",
+    });
+
+    const response = await handleOAuthRequest(
+      new Request(authorizeUrl(legacyClientId, "http://localhost:3118/callback")),
+      env,
+      "/mcp",
+    );
+
+    expect(response?.status).toBe(302);
+    const location = new URL(response?.headers.get("Location") ?? "");
+    const requestInfoUrl = new URL("https://mcp.tavus-preview.io/oauth/authorization-request");
+    requestInfoUrl.searchParams.set("state", location.searchParams.get("state")!);
+    const requestInfo = await handleOAuthRequest(
+      new Request(requestInfoUrl, { headers: { Origin: "https://platform.example.test" } }),
+      env,
+      "/mcp",
+    );
+    await expect(requestInfo?.json()).resolves.toMatchObject({
+      client_name: "Tavus MCP Client",
+      redirect_uri: "http://localhost:3118/callback",
+    });
+  });
+
+  it("rejects a legacy dynamic client ID with a non-loopback callback", async () => {
+    const env = withOAuthGrants({ MCP_OAUTH_SIGNING_SECRET: "s".repeat(32) });
+
+    const response = await handleOAuthRequest(
+      new Request(authorizeUrl(legacyClientId, "https://attacker.example/callback")),
+      env,
+      "/mcp",
+    );
+
+    expect(response?.status).toBe(400);
+  });
+
+  it.each([
+    ["a signed-looking ID with a bad signature", "tavus-mcp-dcr.bad.sig"],
+    ["an unknown ID", "random-client"],
+    ["a legacy-looking ID that is not a UUID", "tavus-mcp-not-a-uuid"],
+  ])("tells the person how to recover when %s is used", async (_label, clientId) => {
+    const env = withOAuthGrants({ MCP_OAUTH_SIGNING_SECRET: "s".repeat(32) });
+
+    const response = await handleOAuthRequest(
+      new Request(authorizeUrl(clientId, "http://localhost:3118/callback")),
+      env,
+      "/mcp",
+    );
+
+    expect(response?.status).toBe(400);
+    await expect(response?.json()).resolves.toEqual({
+      error: "invalid_request",
+      error_description:
+        "redirect_uri is not registered for this client. Remove and re-add the Tavus MCP server in your client so it registers again.",
+    });
+  });
+
+  it("exchanges a legacy dynamic client's code as a public client only", async () => {
+    const env = withOAuthGrants({
+      MCP_OAUTH_SIGNING_SECRET: "s".repeat(32),
+      TAVUS_DEV_PORTAL_URL: "https://platform.example.test",
+    });
+    const redirectUri = "http://localhost:3118/callback";
+    const resource = "https://mcp.tavus-preview.io/mcp";
+    const verifier = "legacy-verifier-0123456789abcdefghijklmnopqrstuvwxyz";
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+    const challenge = btoa(String.fromCharCode(...new Uint8Array(digest)))
+      .replace(/\+/g, "-")
+      .replace(/\//g, "_")
+      .replace(/=+$/g, "");
+
+    const authorizationUrl = authorizeUrl(legacyClientId, redirectUri);
+    authorizationUrl.searchParams.set("code_challenge", challenge);
+    const authorization = await handleOAuthRequest(new Request(authorizationUrl), env, "/mcp");
+    const portalUrl = new URL(authorization?.headers.get("Location") ?? "");
+    const callback = await handleOAuthRequest(
+      new Request("https://mcp.tavus-preview.io/oauth/callback", {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded",
+          Origin: "https://platform.example.test",
+        },
+        body: new URLSearchParams({ code: "tavus-user-key", state: portalUrl.searchParams.get("state")! }),
+      }),
+      env,
+      "/mcp",
+    );
+    const callbackResult = (await callback?.json()) as { redirect_uri: string };
+    const clientUrl = new URL(callbackResult.redirect_uri);
+    expect(clientUrl.origin + clientUrl.pathname).toBe(redirectUri);
+
+    const tokenRequest = (withSecret: boolean) =>
+      new Request("https://mcp.tavus-preview.io/token", {
+        method: "POST",
+        body: new URLSearchParams({
+          grant_type: "authorization_code",
+          code: clientUrl.searchParams.get("code")!,
+          client_id: legacyClientId,
+          ...(withSecret ? { client_secret: "guess" } : {}),
+          redirect_uri: redirectUri,
+          code_verifier: verifier,
+          resource,
+        }),
+      });
+    const withSecret = await handleOAuthRequest(tokenRequest(true), env, "/mcp");
+    expect(withSecret?.status).toBe(401);
+    await expect(withSecret?.json()).resolves.toMatchObject({ error: "invalid_client" });
+
+    const token = await handleOAuthRequest(tokenRequest(false), env, "/mcp");
+    expect(token?.status).toBe(200);
+    await expect(token?.json()).resolves.toMatchObject({
+      access_token: expect.stringMatching(/^tavus_mcp_access\./),
+      token_type: "Bearer",
+      scope: "tavus",
+    });
+  });
+
   it("validates client_secret before exchanging a pre-registered client code", async () => {
     const env = {
       MCP_OAUTH_CLIENTS: JSON.stringify([

tavus_cli-0.9.2/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.9.2"
-}

tavus_cli-0.9.2/workers/tavus-mcp/src/version.ts

@@ -1 +0,0 @@
-export const VERSION = "0.9.2"; // x-release-please-version