@cursor/bdk 0.2.2 → 0.2.4

package/src/internal/resolve-prod-target.ts

@@ -1,334 +0,0 @@
-/**
- * Resolve a hosted (managed) agent-sdk deployment into a base URL +
- * request headers for chat/run/call/eval `--prod`.
- *
- * Uses short-lived `engineAccess` from the deployment status route
- * (Cursor API key on the management API; `X-Anyrun-Port-Token` on the
- * engine). Alias tokens are out of scope here.
- */
-
-import { basename, resolve } from "node:path";
-import { type ResolvedDeployAuth, resolveDeployAuth } from "./cli-deploy.js";
-import { cursorWebsiteUrl } from "./cursor/credentials.js";
-import {
-  DeployApiError,
-  type DeploymentDetail,
-  slugFromDirectoryName,
-  validateDeploymentSlug,
-} from "./deploy-client.js";
-import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
-import { deploymentArchitecture, rejectV2ForLegacyCommand } from "./legacy-command-guard.js";
-import { sleep as defaultSleep } from "./sleep.js";
-import { stderrPalette } from "./terminal-style.js";
-
-/**
- * Interactive CLI keep-alive for hosted engines. Without these, a hibernated
- * Anyrun pod returns 417 `pod_hibernated` and never wakes. Matches the
- * cloud-agent interactive keep-alive shape (lower ≤ upper, seconds).
- */
-export const PROD_ENGINE_WAKE_HEADERS: Readonly<Record<string, string>> = {
-  "x-anyrun-hibernation-lower-bound-s": "1800",
-  "x-anyrun-hibernation-upper-bound-s": "3600",
-};
-
-export interface ResolveProdTargetOptions {
-  dir: string;
-  cwd?: string;
-  /** Explicit deployment slug; otherwise derived from `--dir` basename. */
-  slug?: string;
-  team?: string;
-  apiKey?: string;
-  fetchImpl?: typeof fetch;
-  err?: (text: string) => void;
-  /** Skip when the caller already ran {@link rejectV2ForLegacyCommand}. */
-  skipLegacyArchitectureCheck?: boolean;
-  /** Test seam for reachability-retry backoff. */
-  sleep?: (ms: number) => Promise<void>;
-}
-
-export interface ResolvedProdTarget {
-  agentUrl: string;
-  headers: Record<string, string>;
-  slug: string;
-  expiresAt: string;
-}
-
-/**
- * Thrown when a hosted deployment cannot be resolved. `notFound` is true
- * when the deployment does not exist, so callers can suggest deploying
- * (or running locally) instead of surfacing a bare API error.
- */
-export class ProdTargetError extends Error {
-  constructor(
-    message: string,
-    readonly options: { slug: string; notFound?: boolean } = { slug: "" },
-  ) {
-    super(message);
-    this.name = "ProdTargetError";
-  }
-
-  get slug(): string {
-    return this.options.slug;
-  }
-
-  get notFound(): boolean {
-    return this.options.notFound === true;
-  }
-}
-
-/**
- * Look up a running deployment and return its engineAccess URL/headers.
- * Throws {@link Error} with a CLI-ready message on failure.
- */
-export async function resolveProdTarget(
-  options: ResolveProdTargetOptions,
-): Promise<ResolvedProdTarget> {
-  const err = options.err ?? ((text: string) => void process.stderr.write(text));
-  const slug = resolveProdSlug(options);
-  const auth = await resolveDeployAuth({
-    team: options.team,
-    apiKey: options.apiKey,
-    fetchImpl: options.fetchImpl,
-    err,
-  });
-  if (typeof auth === "number") {
-    // Not "--prod": `eval` resolves the hosted deployment by default,
-    // without any flag.
-    throw new Error(
-      `Could not resolve Cursor credentials/team for the hosted deployment (see above).`,
-    );
-  }
-  if (options.skipLegacyArchitectureCheck !== true) {
-    await rejectV2ForLegacyCommand({
-      client: auth.client,
-      teamId: auth.teamId,
-      slug,
-    });
-  }
-
-  // A hibernated engine can briefly omit engineAccess while getPod fails
-  // during wake. Retry a few times before surfacing "not reachable yet".
-  const maxReachabilityAttempts = 5;
-  const sleep = options.sleep ?? defaultSleep;
-  let detail: DeploymentDetail | undefined;
-  for (let attempt = 0; attempt < maxReachabilityAttempts; attempt++) {
-    try {
-      detail = await auth.client.getDeployment({
-        teamId: auth.teamId,
-        slug,
-      });
-    } catch (error) {
-      if (error instanceof DeployApiError) {
-        throw new ProdTargetError(`Deployment "${slug}" (team ${auth.teamId}): ${error.message}`, {
-          slug,
-          notFound: error.status === 404,
-        });
-      }
-      throw error;
-    }
-
-    // `degraded` still serves the previous ACTIVE engine; allow runtime access
-    // when the control plane minted engineAccess for it.
-    const statusOk = detail.status === "running" || detail.status === "degraded";
-    if (!statusOk) {
-      const lastError =
-        detail.lastError === null || detail.lastError === undefined
-          ? ""
-          : ` ${sanitizeCustomerFacingDetail(detail.lastError)}`;
-      throw new Error(
-        `Deployment "${slug}" is ${detail.status}, not running.${lastError}\n` +
-          `Deploy or wait: \`${CLI} deploy --slug ${slug}\` / \`${CLI} deployment ${slug}\``,
-      );
-    }
-    if (detail.engineAccess !== null && detail.engineAccess !== undefined) {
-      break;
-    }
-    if (attempt + 1 < maxReachabilityAttempts) {
-      if (attempt === 0) {
-        err(
-          `${stderrPalette().dim(`Deployment "${slug}" is waking; waiting for engine access…`)}\n`,
-        );
-      }
-      await sleep(1000 * (attempt + 1));
-    }
-  }
-
-  if (detail === undefined) {
-    throw new Error(`Deployment "${slug}" lookup failed.`);
-  }
-  const access = detail.engineAccess;
-  if (access === null || access === undefined) {
-    throw new Error(
-      `Deployment "${slug}" is ${detail.status} but is not reachable yet. ` +
-        `Try \`${CLI} deployment ${slug}\` or redeploy.`,
-    );
-  }
-
-  err(`${stderrPalette().dim(`Using hosted deployment "${slug}".`)}\n`);
-
-  return {
-    agentUrl: access.url.replace(/\/$/, ""),
-    headers: {
-      ...access.headers,
-      ...PROD_ENGINE_WAKE_HEADERS,
-    },
-    slug,
-    expiresAt: access.expiresAt,
-  };
-}
-
-export interface ResolvedProdAliasPlayground {
-  /** Hosted playground URL on the API alias (SPA owns alias-token sign-in). */
-  playgroundUrl: string;
-  slug: string;
-}
-
-export interface ResolvedProdPlayground {
-  playgroundUrl: string;
-  slug: string;
-  architecture: "v1" | "v2";
-}
-
-export async function resolveProdPlaygroundUrl(
-  options: ResolveProdTargetOptions & { sessionId?: string },
-): Promise<ResolvedProdPlayground> {
-  const err = options.err ?? ((text: string) => void process.stderr.write(text));
-  const slug = resolveProdSlug(options);
-  const auth = await resolveDeployAuth({
-    team: options.team,
-    apiKey: options.apiKey,
-    fetchImpl: options.fetchImpl,
-    err,
-  });
-  if (typeof auth === "number") {
-    throw new Error(
-      `Could not resolve Cursor credentials/team for the hosted deployment (see above).`,
-    );
-  }
-  const architecture = await deploymentArchitecture({
-    client: auth.client,
-    teamId: auth.teamId,
-    slug,
-  });
-  if (architecture === "v2") {
-    const playgroundUrl = new URL(
-      `/dashboard/deployed-agents/${encodeURIComponent(slug)}/playground`,
-      cursorWebsiteUrl(),
-    );
-    const sessionId = options.sessionId?.trim();
-    if (sessionId !== undefined && sessionId !== "") {
-      playgroundUrl.searchParams.set("sessionId", sessionId);
-    }
-    err(`${stderrPalette().dim(`Using hosted deployment "${slug}".`)}\n`);
-    return {
-      playgroundUrl: playgroundUrl.toString(),
-      slug,
-      architecture,
-    };
-  }
-
-  const resolved = await resolveProdAliasPlaygroundUrlWithAuth(options, auth, slug, err);
-  return { ...resolved, architecture };
-}
-
-/**
- * Look up a running deployment and return its stable alias playground URL.
- * Does not mint `engineAccess` — the browser signs in with the alias token.
- * Throws {@link Error} with a CLI-ready message on failure.
- */
-export async function resolveProdAliasPlaygroundUrl(
-  options: ResolveProdTargetOptions & { sessionId?: string },
-): Promise<ResolvedProdAliasPlayground> {
-  const err = options.err ?? ((text: string) => void process.stderr.write(text));
-  const slug = resolveProdSlug(options);
-  const auth = await resolveDeployAuth({
-    team: options.team,
-    apiKey: options.apiKey,
-    fetchImpl: options.fetchImpl,
-    err,
-  });
-  if (typeof auth === "number") {
-    throw new Error(
-      `Could not resolve Cursor credentials/team for the hosted deployment (see above).`,
-    );
-  }
-  await rejectV2ForLegacyCommand({
-    client: auth.client,
-    teamId: auth.teamId,
-    slug,
-  });
-  return resolveProdAliasPlaygroundUrlWithAuth(options, auth, slug, err);
-}
-
-async function resolveProdAliasPlaygroundUrlWithAuth(
-  options: ResolveProdTargetOptions & { sessionId?: string },
-  auth: ResolvedDeployAuth,
-  slug: string,
-  err: (text: string) => void,
-): Promise<ResolvedProdAliasPlayground> {
-  let detail: DeploymentDetail;
-  try {
-    detail = await auth.client.getDeployment({
-      teamId: auth.teamId,
-      slug,
-    });
-  } catch (error) {
-    if (error instanceof DeployApiError) {
-      throw new Error(`Deployment "${slug}" (team ${auth.teamId}): ${error.message}`);
-    }
-    throw error;
-  }
-
-  const statusOk = detail.status === "running" || detail.status === "degraded";
-  if (!statusOk) {
-    const lastError =
-      detail.lastError === null || detail.lastError === undefined
-        ? ""
-        : ` ${sanitizeCustomerFacingDetail(detail.lastError)}`;
-    throw new Error(
-      `Deployment "${slug}" is ${detail.status}, not running.${lastError}\n` +
-        `Deploy or wait: \`${CLI} deploy --slug ${slug}\` / \`${CLI} deployment ${slug}\``,
-    );
-  }
-
-  const aliasBase = auth.client.aliasUrl(detail.engineAlias).replace(/\/$/, "");
-  const base = `${aliasBase}/playground`;
-  const sessionId =
-    options.sessionId !== undefined && options.sessionId.trim() !== ""
-      ? options.sessionId.trim()
-      : undefined;
-  const playgroundUrl =
-    sessionId === undefined ? base : `${base}?sessionId=${encodeURIComponent(sessionId)}`;
-
-  err(`${stderrPalette().dim(`Using hosted deployment "${slug}".`)}\n`);
-
-  return { playgroundUrl, slug };
-}
-
-/** Strip obvious hosting internals from customer-facing error fragments. */
-function sanitizeCustomerFacingDetail(message: string): string {
-  return message
-    .replace(/https?:\/\/\S+/gi, "[url]")
-    .replace(/\bpod-[a-z0-9]+\b/gi, "[runtime]")
-    .replace(/\banyrun\b/gi, "runtime")
-    .replace(/\bcursorvm\.com\b/gi, "host");
-}
-
-/** Resolve the deployment slug the same way `deploy` does for a single dir. */
-export function resolveProdSlug(options: { dir: string; cwd?: string; slug?: string }): string {
-  if (options.slug !== undefined && options.slug !== "") {
-    const slugError = validateDeploymentSlug(options.slug);
-    if (slugError !== undefined) {
-      throw new Error(slugError);
-    }
-    return options.slug;
-  }
-  const dir = resolve(options.cwd ?? process.cwd(), options.dir);
-  const derived = slugFromDirectoryName(basename(dir));
-  if (derived === undefined) {
-    throw new Error(
-      `Could not derive a deployment slug from the directory name ${JSON.stringify(basename(dir))}; pass --slug.`,
-    );
-  }
-  return derived;
-}

package/src/internal/resolved-connections.ts

@@ -1,190 +0,0 @@
-/**
- * Serve-time connection resolution for one mounted agent: once the host is
- * listening (port known), symbolic transports — peers and the Cursor
- * account bridge — resolve to concrete URLs and join the engine's
- * resolved-connection set. Local turns call both over loopback; cloud
- * turns use the serve `publicUrl` for peers and the account's native
- * connectors instead of the bridge.
- */
-
-import { type AgentProject, isHostOauthConnectionTransport } from "../types.js";
-import {
-  type CursorAccountConnectionRef,
-  type CursorAccountMcpBridge,
-  resolveCursorAccountConnections,
-} from "./cursor/account-mcp.js";
-import { type PeerConnectionRef, resolvePeerConnections } from "./peer-connections.js";
-import type { EngineResolvedConnection } from "./session-engine.js";
-
-/** Fail fast before listen when static cloud config cannot honor `servers`. */
-export function validateMountConnectionsConfig(args: {
-  slug: string;
-  project: AgentProject;
-  accountRefs?: CursorAccountConnectionRef[];
-  publicUrl?: string;
-  /**
-   * True when serve has a cloud tools URL (`--cloud-tools-url`, always set on
-   * managed hosting): cloud turns then reach filtered account connections
-   * through the host connection bridge on the tool MCP endpoint, so the
-   * filter is honored host-side and no `--public-url` is needed.
-   */
-  cloudToolsBridge?: boolean;
-}): void {
-  if (args.accountRefs === undefined || args.accountRefs.length === 0) {
-    return;
-  }
-  const agent = args.project.agent;
-  const cloudCapable = agent.runtime === "cloud" || agent.cloud !== undefined;
-  if (!cloudCapable || args.publicUrl !== undefined || args.cloudToolsBridge === true) {
-    return;
-  }
-  const label = args.slug === "" ? args.project.name : args.slug;
-  const hostConnectionNames = new Set(
-    (args.project.agent.hostConnections ?? []).map(connection => connection.name),
-  );
-  const filteredRefs = args.accountRefs.filter(
-    ref => ref.servers !== undefined && !hostConnectionNames.has(ref.name),
-  );
-  if (filteredRefs.length === 0) {
-    return;
-  }
-  throw new Error(
-    `[agent-sdk] agent "${label}" has Cursor account MCP connections with \`servers\` filters (${filteredRefs
-      .map(ref => ref.name)
-      .join(
-        ", ",
-      )}) but no --public-url; cloud-runtime turns cannot honor those filters without a public bridge URL. Set --public-url or remove the \`servers\` filter.`,
-  );
-}
-
-/** Fail closed when a cloud turn cannot honor a `servers` filter. */
-export function assertCloudCanHonorAccountServersFilters(args: {
-  runtime: "local" | "cloud";
-  resolvedConnections: readonly EngineResolvedConnection[];
-  /**
-   * Connection names this cloud turn reaches through the host connection
-   * bridge (tool MCP endpoint). The filter is honored on the serve host
-   * there, so a missing `cloudUrl` is not a fail-open.
-   */
-  bridgedNames?: ReadonlySet<string>;
-}): void {
-  if (args.runtime !== "cloud") {
-    return;
-  }
-  const blocked = args.resolvedConnections.filter(
-    connection =>
-      connection.accountServersFilter !== undefined &&
-      connection.cloudUrl === undefined &&
-      args.bridgedNames?.has(connection.name) !== true,
-  );
-  if (blocked.length === 0) {
-    return;
-  }
-  throw new Error(
-    `[agent-sdk] cloud turn cannot honor Cursor account \`servers\` filters (${blocked
-      .map(connection => connection.name)
-      .join(
-        ", ",
-      )}) without --public-url; set --public-url so cloud turns reach the filtered account bridge instead of falling back to native connectors.`,
-  );
-}
-
-/** Fail closed when anonymous HTTP admission would expose account connectors. */
-export function assertAccountConnectionsNotAnonymous(args: {
-  allowAnonymous?: boolean;
-  /**
-   * Opt in when every admitted caller is already trusted (e.g. behind an
-   * authenticating proxy / hosted alias token). Same trust model as
-   * `--allow-anonymous-cursor-github`.
-   */
-  allowAnonymousCursorAccountMcp?: boolean;
-  hasAccountConnections: boolean;
-}): void {
-  if (args.allowAnonymous !== true || !args.hasAccountConnections) {
-    return;
-  }
-  if (args.allowAnonymousCursorAccountMcp === true) {
-    return;
-  }
-  throw new Error(
-    "[agent-sdk] --allow-anonymous cannot be used with Cursor account MCP connections (defineConnection({ cursorAccount: true })); use --bearer-token, or opt in with --allow-anonymous-cursor-account-mcp behind a trusted boundary.",
-  );
-}
-
-export function resolveMountConnections(args: {
-  slug: string;
-  project: AgentProject;
-  serverUrl: string;
-  peerRefs?: PeerConnectionRef[];
-  accountRefs?: CursorAccountConnectionRef[];
-  accountBridge?: CursorAccountMcpBridge;
-  publicUrl?: string;
-  authToken?: string;
-  /** See {@link validateMountConnectionsConfig}. */
-  cloudToolsBridge?: boolean;
-  logger: (line: string) => void;
-}): EngineResolvedConnection[] {
-  const agent = args.project.agent;
-  const cloudCapable = agent.runtime === "cloud" || agent.cloud !== undefined;
-  const label = args.slug === "" ? args.project.name : args.slug;
-  const resolved: EngineResolvedConnection[] = [];
-
-  if (cloudCapable) {
-    const hostOauthNames = agent.connections
-      .filter(connection => isHostOauthConnectionTransport(connection.transport))
-      .map(connection => connection.name);
-    if (hostOauthNames.length > 0) {
-      args.logger(
-        args.cloudToolsBridge === true
-          ? `[agent-sdk] agent "${label}": host-OAuth MCP connections (${hostOauthNames.join(
-              ", ",
-            )}) reach cloud turns through the host connection bridge; their tokens stay on this serve host.`
-          : `[agent-sdk] warning: agent "${label}" has host-OAuth MCP connections (${hostOauthNames.join(
-              ", ",
-            )}) whose tokens live on this serve host; cloud-runtime turns omit them. Serve with a cloud tools URL so they reach turns through the host connection bridge, or drop \`oauth\` and authorize the server another way.`,
-      );
-    }
-  }
-
-  if (args.peerRefs !== undefined && args.peerRefs.length > 0) {
-    const peers = resolvePeerConnections({
-      refs: args.peerRefs,
-      serverUrl: args.serverUrl,
-      ...(args.publicUrl === undefined ? {} : { publicUrl: args.publicUrl }),
-      ...(args.authToken === undefined ? {} : { authToken: args.authToken }),
-    });
-    resolved.push(...peers);
-    if (cloudCapable && args.publicUrl === undefined) {
-      args.logger(
-        `[agent-sdk] warning: agent "${label}" has peer MCP connections (${peers
-          .map(peer => peer.name)
-          .join(
-            ", ",
-          )}) but no --public-url; cloud-runtime turns cannot reach this host's loopback address, so peers are omitted from cloud turns.`,
-      );
-    }
-  }
-
-  if (args.accountRefs !== undefined && args.accountBridge !== undefined) {
-    resolved.push(
-      ...resolveCursorAccountConnections({
-        refs: args.accountRefs,
-        serverUrl: args.serverUrl,
-        basePath: args.slug === "" ? "" : `/${args.slug}`,
-        bridgeSecret: args.accountBridge.secret,
-        ...(args.publicUrl === undefined ? {} : { publicUrl: args.publicUrl }),
-      }),
-    );
-    // Non-blocking startup DX: connector statuses land in the serve log.
-    args.accountBridge.logPreflight(args.accountRefs);
-    if (cloudCapable && args.publicUrl === undefined) {
-      args.logger(
-        args.cloudToolsBridge === true
-          ? `[agent-sdk] agent "${label}": cloud-runtime turns reach filtered account connections through the host connection bridge (unfiltered ones fall back to the account's native connectors).`
-          : `[agent-sdk] agent "${label}": cloud-runtime turns omit the account bridge without --public-url (cloud agents fall back to the account's native connectors).`,
-      );
-    }
-  }
-
-  return resolved;
-}

package/src/internal/router.ts

@@ -1,143 +0,0 @@
-/**
- * Tiny path router: literal segments, `:param` captures, and a trailing
- * `*param` catch-all, compiled once at server startup.
- */
-
-import type { AuthContext, AuthPolicy, RouteMethod } from "../types.js";
-
-export interface ServerRouteContext {
-  params: Record<string, string>;
-  requestIp: string | null;
-  /** Resolved by the route's auth chain ("none" routes see null). */
-  auth: AuthContext | null;
-}
-
-export type ServerRouteHandler = (
-  request: Request,
-  ctx: ServerRouteContext,
-) => Response | Promise<Response>;
-
-export interface ServerRoute {
-  method: RouteMethod;
-  /** Path pattern, e.g. `/v1/session/:sessionId/stream`. */
-  pattern: string;
-  /** Auth chain for the route; "none" mounts the route unauthenticated. */
-  auth: AuthPolicy[] | "none";
-  handler: ServerRouteHandler;
-}
-
-type Segment =
-  | { kind: "literal"; value: string }
-  | { kind: "param"; name: string }
-  /** Trailing catch-all (`*name`): matches zero or more remaining segments. */
-  | { kind: "rest"; name: string };
-
-interface CompiledRoute {
-  route: ServerRoute;
-  segments: Segment[];
-}
-
-export interface RouteMatch {
-  route: ServerRoute;
-  params: Record<string, string>;
-}
-
-export class Router {
-  private readonly routes: CompiledRoute[] = [];
-
-  add(route: ServerRoute): void {
-    this.routes.push({ route, segments: compilePattern(route.pattern) });
-  }
-
-  match(method: string, pathname: string): RouteMatch | undefined {
-    const direct = this.matchExact(method, pathname);
-    if (direct !== undefined) {
-      return direct;
-    }
-    // HTTP: HEAD may be served by the corresponding GET handler (wget --spider,
-    // some load-balancer probes). Without this, GET-only routes return 405.
-    if (method === "HEAD") {
-      return this.matchExact("GET", pathname);
-    }
-    return undefined;
-  }
-
-  private matchExact(method: string, pathname: string): RouteMatch | undefined {
-    const pathSegments = splitPath(pathname);
-    for (const { route, segments } of this.routes) {
-      if (route.method !== method) {
-        continue;
-      }
-      const params = matchSegments(segments, pathSegments);
-      if (params !== undefined) {
-        return { route, params };
-      }
-    }
-    return undefined;
-  }
-
-  /** True when the path matches some route with a different method. */
-  hasPath(pathname: string): boolean {
-    const pathSegments = splitPath(pathname);
-    return this.routes.some(({ segments }) => matchSegments(segments, pathSegments) !== undefined);
-  }
-}
-
-function compilePattern(pattern: string): Segment[] {
-  const segments: Segment[] = splitPath(pattern).map(part =>
-    part.startsWith(":")
-      ? { kind: "param", name: part.slice(1) }
-      : part.startsWith("*")
-        ? { kind: "rest", name: part.slice(1) }
-        : { kind: "literal", value: part },
-  );
-  const restIndex = segments.findIndex(segment => segment.kind === "rest");
-  if (restIndex !== -1 && restIndex !== segments.length - 1) {
-    throw new Error(
-      `Route pattern "${pattern}" may only use a catch-all (*name) as the last segment.`,
-    );
-  }
-  return segments;
-}
-
-function splitPath(path: string): string[] {
-  return path.split("/").filter(part => part !== "");
-}
-
-function matchSegments(
-  segments: Segment[],
-  pathSegments: string[],
-): Record<string, string> | undefined {
-  const last = segments[segments.length - 1];
-  const hasRest = last !== undefined && last.kind === "rest";
-  if (hasRest) {
-    if (pathSegments.length < segments.length - 1) {
-      return undefined;
-    }
-  } else if (segments.length !== pathSegments.length) {
-    return undefined;
-  }
-  const params: Record<string, string> = {};
-  const fixedCount = hasRest ? segments.length - 1 : segments.length;
-  for (let i = 0; i < fixedCount; i++) {
-    const segment = segments[i];
-    const value = pathSegments[i];
-    if (segment === undefined || value === undefined) {
-      return undefined;
-    }
-    if (segment.kind === "literal") {
-      if (segment.value !== value) {
-        return undefined;
-      }
-    } else if (segment.kind === "param") {
-      params[segment.name] = decodeURIComponent(value);
-    }
-  }
-  if (hasRest) {
-    params[last.name] = pathSegments
-      .slice(fixedCount)
-      .map(value => decodeURIComponent(value))
-      .join("/");
-  }
-  return params;
-}