@introspection-ai/recipes 0.18.0 → 0.19.0

package/dist/mcp-chunks/chunk-YHQUTU6L.js

@@ -1,571 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  clearVaultEntry,
-  getOAuthVaultPath,
-  loadVaultEntry,
-  saveVaultEntry
-} from "./chunk-TATVT5IT.js";
-import {
-  checkResourceAllowed,
-  discoverOAuthServerInfo,
-  refreshAuthorization,
-  resourceUrlFromServerUrl
-} from "./chunk-P3PSC54P.js";
-import {
-  readJsonFile,
-  writeJsonFile,
-  writeTextFileAtomic
-} from "./chunk-2XL7MG7R.js";
-import {
-  legacyMcporterDir
-} from "./chunk-ECIVB7P4.js";
-
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/oauth-persistence.js
-import fs from "node:fs/promises";
-import { Buffer } from "node:buffer";
-import os from "node:os";
-import path from "node:path";
-
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/oauth-client-info.js
-function buildStaticClientInformation(definition, options = {}) {
-  if (!definition.oauthClientId) {
-    return void 0;
-  }
-  const clientSecret = resolveOAuthClientSecret(definition);
-  return {
-    client_id: definition.oauthClientId,
-    ...clientSecret ? { client_secret: clientSecret } : {},
-    ...options.redirectUrl ? { redirect_uris: [options.redirectUrl.toString()] } : {},
-    grant_types: ["authorization_code", "refresh_token"],
-    response_types: ["code"],
-    ...definition.oauthTokenEndpointAuthMethod ? { token_endpoint_auth_method: definition.oauthTokenEndpointAuthMethod } : {}
-  };
-}
-function resolveOAuthClientSecret(definition) {
-  if (definition.oauthClientSecretEnv) {
-    const value = process.env[definition.oauthClientSecretEnv];
-    if (!value) {
-      throw new Error(`Environment variable '${definition.oauthClientSecretEnv}' is required for OAuth client secret.`);
-    }
-    return value;
-  }
-  return definition.oauthClientSecret;
-}
-
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/oauth-persistence.js
-var TOKEN_EXPIRY_SKEW_SECONDS = 60;
-function withStoredExpiry(tokens) {
-  const stored = tokens;
-  if (typeof stored.expires_at === "number" || typeof stored.expiresAt === "number") {
-    return tokens;
-  }
-  if (typeof tokens.expires_in === "number" && Number.isFinite(tokens.expires_in)) {
-    return {
-      ...tokens,
-      expires_at: Math.floor(Date.now() / 1e3) + tokens.expires_in
-    };
-  }
-  return tokens;
-}
-function tokenExpirySeconds(tokens) {
-  const stored = tokens;
-  for (const candidate of [stored.expires_at, stored.expiresAt]) {
-    if (typeof candidate === "number" && Number.isFinite(candidate)) {
-      return candidate;
-    }
-  }
-  return void 0;
-}
-function cachedTokensChanged(original, current) {
-  if (!current || typeof current.access_token !== "string" || current.access_token.trim().length === 0) {
-    return false;
-  }
-  if (typeof original.refresh_token === "string" && typeof current.refresh_token === "string") {
-    return current.refresh_token !== original.refresh_token || current.access_token !== original.access_token;
-  }
-  return current.access_token !== original.access_token;
-}
-function shouldRefreshCachedToken(tokens, skewSeconds = TOKEN_EXPIRY_SKEW_SECONDS) {
-  const expiresAt = tokenExpirySeconds(tokens);
-  if (expiresAt !== void 0) {
-    return expiresAt <= Math.floor(Date.now() / 1e3) + skewSeconds;
-  }
-  return typeof tokens.expires_in === "number" && typeof tokens.refresh_token === "string";
-}
-function resourceForRefresh(serverUrl, resourceMetadata) {
-  if (!resourceMetadata) {
-    return void 0;
-  }
-  const defaultResource = resourceUrlFromServerUrl(serverUrl);
-  if (!checkResourceAllowed({ requestedResource: defaultResource, configuredResource: resourceMetadata.resource })) {
-    throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
-  }
-  return new URL(resourceMetadata.resource);
-}
-function unrecoverableOAuthRefreshCode(error) {
-  const errorCode = oauthErrorCode(error);
-  if (errorCode && ["invalid_client", "invalid_grant", "unauthorized_client"].includes(errorCode)) {
-    return errorCode;
-  }
-  return void 0;
-}
-function oauthErrorCode(error) {
-  if (!error || typeof error !== "object") {
-    return void 0;
-  }
-  const { errorCode, name } = error;
-  if (typeof errorCode === "string" && errorCode.length > 0) {
-    return errorCode.toLowerCase();
-  }
-  if (typeof name === "string") {
-    const normalized = name.toLowerCase();
-    if (normalized === "invalidclienterror") {
-      return "invalid_client";
-    }
-    if (normalized === "invalidgranterror") {
-      return "invalid_grant";
-    }
-    if (normalized === "unauthorizedclienterror") {
-      return "unauthorized_client";
-    }
-  }
-  return void 0;
-}
-var DirectoryPersistence = class {
-  root;
-  logger;
-  tokenPath;
-  clientInfoPath;
-  codeVerifierPath;
-  statePath;
-  constructor(root, logger) {
-    this.root = root;
-    this.logger = logger;
-    this.tokenPath = path.join(root, "tokens.json");
-    this.clientInfoPath = path.join(root, "client.json");
-    this.codeVerifierPath = path.join(root, "code_verifier.txt");
-    this.statePath = path.join(root, "state.txt");
-  }
-  describe() {
-    return this.root;
-  }
-  async ensureDir() {
-    await fs.mkdir(this.root, { recursive: true });
-  }
-  async readTokens() {
-    return this.readJsonOrUndefined(this.tokenPath);
-  }
-  async saveTokens(tokens) {
-    await this.ensureDir();
-    await writeJsonFile(this.tokenPath, withStoredExpiry(tokens));
-    this.logger?.debug?.(`Saved tokens to ${this.tokenPath}`);
-  }
-  async readClientInfo() {
-    return this.readJsonOrUndefined(this.clientInfoPath);
-  }
-  async saveClientInfo(info) {
-    await this.ensureDir();
-    await writeJsonFile(this.clientInfoPath, info);
-  }
-  async readCodeVerifier() {
-    try {
-      return (await fs.readFile(this.codeVerifierPath, "utf8")).trim();
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return void 0;
-      }
-      throw error;
-    }
-  }
-  async saveCodeVerifier(value) {
-    await this.ensureDir();
-    await writeTextFileAtomic(this.codeVerifierPath, value);
-  }
-  async readState() {
-    return readJsonFile(this.statePath);
-  }
-  // A present-but-corrupt credential cache (tokens/client) means "no usable
-  // credentials": degrade to re-auth instead of crashing the connection,
-  // mirroring VaultPersistence and the daemon/server-proxy readers. Genuine I/O
-  // faults still propagate (readJsonFile re-throws everything except ENOENT).
-  // OAuth state is intentionally excluded (see readState) so its CSRF check
-  // still fails closed on a corrupt state file.
-  async readJsonOrUndefined(filePath) {
-    try {
-      return await readJsonFile(filePath);
-    } catch (error) {
-      if (!(error instanceof SyntaxError)) {
-        throw error;
-      }
-      this.logger?.debug?.(`Ignoring corrupt OAuth cache file ${filePath}: ${error.message}`);
-      return void 0;
-    }
-  }
-  async saveState(value) {
-    await this.ensureDir();
-    await writeJsonFile(this.statePath, value);
-  }
-  async clear(scope) {
-    const files = [];
-    if (scope === "all" || scope === "tokens") {
-      files.push(this.tokenPath);
-    }
-    if (scope === "all" || scope === "client") {
-      files.push(this.clientInfoPath);
-    }
-    if (scope === "all" || scope === "verifier") {
-      files.push(this.codeVerifierPath);
-    }
-    if (scope === "all" || scope === "state") {
-      files.push(this.statePath);
-    }
-    await Promise.all(files.map(async (file) => {
-      try {
-        await fs.unlink(file);
-      } catch (error) {
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-      }
-    }));
-  }
-};
-var VaultPersistence = class {
-  definition;
-  constructor(definition) {
-    this.definition = definition;
-  }
-  describe() {
-    return `${getOAuthVaultPath()} (vault)`;
-  }
-  async readTokens() {
-    return (await loadVaultEntry(this.definition))?.tokens;
-  }
-  async saveTokens(tokens) {
-    await saveVaultEntry(this.definition, { tokens: withStoredExpiry(tokens) });
-  }
-  async readClientInfo() {
-    return (await loadVaultEntry(this.definition))?.clientInfo;
-  }
-  async saveClientInfo(info) {
-    await saveVaultEntry(this.definition, { clientInfo: info });
-  }
-  async readCodeVerifier() {
-    return (await loadVaultEntry(this.definition))?.codeVerifier;
-  }
-  async saveCodeVerifier(value) {
-    await saveVaultEntry(this.definition, { codeVerifier: value });
-  }
-  async readState() {
-    return (await loadVaultEntry(this.definition))?.state;
-  }
-  async saveState(value) {
-    await saveVaultEntry(this.definition, { state: value });
-  }
-  async clear(scope) {
-    await clearVaultEntry(this.definition, scope);
-  }
-};
-var CompositePersistence = class {
-  stores;
-  constructor(stores) {
-    this.stores = stores;
-  }
-  describe() {
-    return this.stores.map((store) => store.describe()).join(" + ");
-  }
-  async readTokens() {
-    for (const store of this.stores) {
-      const result = await store.readTokens();
-      if (result) {
-        return result;
-      }
-    }
-    return void 0;
-  }
-  async saveTokens(tokens) {
-    await Promise.all(this.stores.map((store) => store.saveTokens(tokens)));
-  }
-  async readClientInfo() {
-    for (const store of this.stores) {
-      const result = await store.readClientInfo();
-      if (result) {
-        return result;
-      }
-    }
-    return void 0;
-  }
-  async saveClientInfo(info) {
-    await Promise.all(this.stores.map((store) => store.saveClientInfo(info)));
-  }
-  async readCodeVerifier() {
-    for (const store of this.stores) {
-      const result = await store.readCodeVerifier();
-      if (result) {
-        return result;
-      }
-    }
-    return void 0;
-  }
-  async saveCodeVerifier(value) {
-    await Promise.all(this.stores.map((store) => store.saveCodeVerifier(value)));
-  }
-  async readState() {
-    for (const store of this.stores) {
-      const result = await store.readState();
-      if (result) {
-        return result;
-      }
-    }
-    return void 0;
-  }
-  async saveState(value) {
-    await Promise.all(this.stores.map((store) => store.saveState(value)));
-  }
-  async clear(scope) {
-    await Promise.all(this.stores.map((store) => store.clear(scope)));
-  }
-};
-async function buildOAuthPersistence(definition, logger) {
-  const vault = new VaultPersistence(definition);
-  const stores = [vault];
-  if (definition.tokenCacheDir) {
-    stores.unshift(new DirectoryPersistence(definition.tokenCacheDir, logger));
-  }
-  const legacyDir = path.join(legacyMcporterDir(), definition.name);
-  if (!definition.tokenCacheDir && legacyDir) {
-    const legacy = new DirectoryPersistence(legacyDir, logger);
-    const legacyTokens = await legacy.readTokens();
-    const legacyClient = await legacy.readClientInfo();
-    const legacyVerifier = await legacy.readCodeVerifier();
-    const legacyState = await legacy.readState();
-    if (legacyTokens || legacyClient || legacyVerifier || legacyState) {
-      if (legacyTokens) {
-        await vault.saveTokens(legacyTokens);
-      }
-      if (legacyClient) {
-        await vault.saveClientInfo(legacyClient);
-      }
-      if (legacyVerifier) {
-        await vault.saveCodeVerifier(legacyVerifier);
-      }
-      if (legacyState) {
-        await vault.saveState(legacyState);
-      }
-      logger?.info?.(`Migrated legacy OAuth cache for '${definition.name}' into vault.`);
-    }
-  }
-  return stores.length === 1 ? vault : new CompositePersistence(stores);
-}
-async function clearOAuthCaches(definition, logger, scope = "all") {
-  const persistence = await buildOAuthPersistence(definition, logger);
-  await persistence.clear(scope);
-  const legacyDir = path.join(legacyMcporterDir(), definition.name);
-  if (legacyDir && (!definition.tokenCacheDir || legacyDir !== definition.tokenCacheDir)) {
-    const legacy = new DirectoryPersistence(legacyDir, logger);
-    await legacy.clear(scope);
-  }
-  if (definition.tokenCacheDir && scope === "all") {
-    await fs.rm(definition.tokenCacheDir, { recursive: true, force: true });
-  }
-  const legacyFiles = [];
-  if (definition.name.toLowerCase() === "gmail") {
-    legacyFiles.push(path.join(os.homedir(), ".gmail-mcp", "credentials.json"));
-  }
-  await Promise.all(legacyFiles.map(async (file) => {
-    try {
-      await fs.unlink(file);
-      logger?.info?.(`Cleared legacy OAuth cache file ${file}`);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }));
-}
-async function readCachedAccessToken(definition, logger) {
-  const persistence = await buildOAuthPersistence(definition, logger);
-  const tokens = await persistence.readTokens();
-  if (!tokens || typeof tokens.access_token !== "string" || tokens.access_token.trim().length === 0) {
-    return void 0;
-  }
-  if (definition.auth === "refreshable_bearer") {
-    return await readExplicitRefreshableBearerToken(definition, persistence, tokens, logger);
-  }
-  if (!shouldRefreshCachedToken(tokens)) {
-    return tokens.access_token;
-  }
-  if (typeof tokens.refresh_token !== "string" || tokens.refresh_token.trim().length === 0) {
-    return tokens.access_token;
-  }
-  try {
-    const clientInformation = buildStaticClientInformation(definition) ?? await persistence.readClientInfo();
-    if (!clientInformation) {
-      logger?.debug?.(`Cached OAuth token for '${definition.name}' is expired, but no client information is available.`);
-      return tokens.access_token;
-    }
-    if (definition.command.kind !== "http") {
-      return tokens.access_token;
-    }
-    const serverInfo = await discoverOAuthServerInfo(definition.command.url);
-    const resource = resourceForRefresh(definition.command.url, serverInfo.resourceMetadata);
-    const refreshed = await refreshAuthorization(serverInfo.authorizationServerUrl, {
-      metadata: serverInfo.authorizationServerMetadata,
-      clientInformation,
-      refreshToken: tokens.refresh_token,
-      ...resource ? { resource } : {}
-    });
-    await persistence.saveTokens(refreshed);
-    logger?.debug?.(`Refreshed cached OAuth access token for '${definition.name}' (non-interactive).`);
-    return refreshed.access_token;
-  } catch (error) {
-    logger?.debug?.(`Failed to refresh cached OAuth token for '${definition.name}' non-interactively: ${error instanceof Error ? error.message : String(error)}`);
-    const unrecoverableCode = unrecoverableOAuthRefreshCode(error);
-    if (unrecoverableCode) {
-      const latestTokens = await persistence.readTokens();
-      if (cachedTokensChanged(tokens, latestTokens)) {
-        logger?.debug?.(`Kept cached OAuth token for '${definition.name}' because another refresh updated it first.`);
-        return latestTokens?.access_token;
-      }
-      const scope = unrecoverableCode === "invalid_grant" ? "tokens" : "all";
-      await clearOAuthCaches(definition, logger, scope);
-      logger?.debug?.(`Cleared cached OAuth ${scope === "all" ? "credentials" : "token"} for '${definition.name}' after unrecoverable refresh failure.`);
-      return void 0;
-    }
-    return tokens.access_token;
-  }
-}
-async function readExplicitRefreshableBearerToken(definition, persistence, tokens, logger) {
-  const refresh = definition.refresh;
-  const skewSeconds = refresh?.refreshSkewSeconds ?? TOKEN_EXPIRY_SKEW_SECONDS;
-  if (!shouldRefreshCachedToken(tokens, skewSeconds)) {
-    return tokens.access_token;
-  }
-  if (!refresh) {
-    throw new Error(`Cached bearer token for '${definition.name}' is expired, but refresh is not configured.`);
-  }
-  if (typeof tokens.refresh_token !== "string" || tokens.refresh_token.trim().length === 0) {
-    throw new Error(`Cached bearer token for '${definition.name}' is expired, but no refresh_token is available.`);
-  }
-  try {
-    const refreshed = await refreshBearerToken(definition, tokens.refresh_token);
-    await persistence.saveTokens(refreshed);
-    logger?.debug?.(`Refreshed bearer access token for '${definition.name}' (non-interactive).`);
-    return refreshed.access_token;
-  } catch (error) {
-    logger?.debug?.(`Failed to refresh bearer token for '${definition.name}' non-interactively: ${error instanceof Error ? error.message : String(error)}`);
-    throw new Error(`Failed to refresh cached bearer token for '${definition.name}': ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-  }
-}
-async function refreshBearerToken(definition, refreshToken) {
-  const refresh = definition.refresh;
-  if (!refresh) {
-    throw new Error("Missing refresh configuration.");
-  }
-  const clientId = readEnvOrConfig(refresh.clientIdEnv, definition.oauthClientId);
-  const method = refresh.clientAuthMethod ?? definition.oauthTokenEndpointAuthMethod ?? "client_secret_basic";
-  const clientSecret = method === "none" ? void 0 : readClientSecret(definition, refresh.clientSecretEnv);
-  const body = new URLSearchParams({
-    grant_type: "refresh_token",
-    refresh_token: refreshToken
-  });
-  const headers = {
-    accept: "application/json",
-    "content-type": "application/x-www-form-urlencoded"
-  };
-  if (method === "client_secret_post") {
-    if (clientId) {
-      body.set("client_id", clientId);
-    }
-    if (clientSecret) {
-      body.set("client_secret", clientSecret);
-    }
-  } else if (method === "none") {
-    if (clientId) {
-      body.set("client_id", clientId);
-    }
-  } else {
-    if (!clientId || !clientSecret) {
-      throw new Error(`Refresh client credentials are required for '${method}'.`);
-    }
-    headers.authorization = `Basic ${Buffer.from(`${formEncodeCredential(clientId)}:${formEncodeCredential(clientSecret)}`).toString("base64")}`;
-  }
-  const response = await fetch(refresh.tokenEndpoint, {
-    method: "POST",
-    headers,
-    body
-  });
-  if (!response.ok) {
-    throw new Error(`Token endpoint returned HTTP ${response.status}.`);
-  }
-  const payload = normalizeBearerTokenResponse(await response.json());
-  return {
-    ...payload,
-    ...payload.refresh_token ? {} : { refresh_token: refreshToken }
-  };
-}
-function normalizeBearerTokenResponse(value) {
-  if (!value || typeof value !== "object") {
-    throw new Error("Token endpoint did not return a JSON object.");
-  }
-  const payload = value;
-  if (typeof payload.access_token !== "string" || payload.access_token.trim().length === 0) {
-    throw new Error("Token endpoint did not return an access_token.");
-  }
-  return {
-    access_token: payload.access_token,
-    token_type: typeof payload.token_type === "string" && payload.token_type ? payload.token_type : "Bearer",
-    ...typeof payload.id_token === "string" ? { id_token: payload.id_token } : {},
-    ...typeof payload.scope === "string" ? { scope: payload.scope } : {},
-    ...typeof payload.refresh_token === "string" && payload.refresh_token ? { refresh_token: payload.refresh_token } : {},
-    ...coerceExpiresIn(payload.expires_in)
-  };
-}
-function coerceExpiresIn(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return { expires_in: value };
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return { expires_in: parsed };
-    }
-  }
-  return {};
-}
-function readEnvOrConfig(envName, fallback) {
-  if (!envName) {
-    return fallback;
-  }
-  const value = process.env[envName];
-  if (value === void 0 || value.trim().length === 0) {
-    throw new Error(`Environment variable '${envName}' is required for bearer token refresh.`);
-  }
-  return value;
-}
-function formEncodeCredential(value) {
-  return new URLSearchParams([["", value]]).toString().slice(1);
-}
-function readClientSecret(definition, refreshClientSecretEnv) {
-  if (refreshClientSecretEnv) {
-    return readEnvOrConfig(refreshClientSecretEnv, void 0);
-  }
-  return resolveOAuthClientSecret2(definition);
-}
-function resolveOAuthClientSecret2(definition) {
-  if (definition.oauthClientSecretEnv) {
-    const value = process.env[definition.oauthClientSecretEnv];
-    if (value === void 0 || value.trim().length === 0) {
-      throw new Error(`Environment variable '${definition.oauthClientSecretEnv}' is required for OAuth client secret.`);
-    }
-    return value;
-  }
-  return definition.oauthClientSecret;
-}
-
-export {
-  buildStaticClientInformation,
-  buildOAuthPersistence,
-  clearOAuthCaches,
-  readCachedAccessToken
-};

package/dist/mcp-chunks/client-S7RQUG5U.js

@@ -1,13 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  DaemonClient,
-  resolveDaemonPaths
-} from "./chunk-PWYFKGKG.js";
-import "./chunk-2XL7MG7R.js";
-import "./chunk-WQJZMCJN.js";
-import "./chunk-ECIVB7P4.js";
-import "./chunk-LRKZP7DJ.js";
-export {
-  DaemonClient,
-  resolveDaemonPaths
-};

package/dist/mcp-chunks/daemon-command-U242Z6VY.js

@@ -1,26 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  handleDaemonCli
-} from "./chunk-6XCZGU3G.js";
-import "./chunk-NNOEGEUZ.js";
-import "./chunk-7FHEBT5G.js";
-import "./chunk-BZIQOWE6.js";
-import "./chunk-YHQUTU6L.js";
-import "./chunk-TATVT5IT.js";
-import "./chunk-HKRJ6O36.js";
-import "./chunk-4SQKWYFF.js";
-import "./chunk-6W5QFASN.js";
-import "./chunk-2U4BSDC4.js";
-import "./chunk-UKYNQGNE.js";
-import "./chunk-P3PSC54P.js";
-import "./chunk-NRAJX5E4.js";
-import "./chunk-PWYFKGKG.js";
-import "./chunk-2XL7MG7R.js";
-import "./chunk-WQJZMCJN.js";
-import "./chunk-ECIVB7P4.js";
-import "./chunk-LS7PMWSR.js";
-import "./chunk-D3MRAZ6H.js";
-import "./chunk-LRKZP7DJ.js";
-export {
-  handleDaemonCli
-};

package/dist/mcp-chunks/replay-command-25HJ6AQU.js

@@ -1,85 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  parseReplayArgs
-} from "./chunk-7UDVSOOF.js";
-import {
-  buildReplayCommandEnv
-} from "./chunk-J6LYIZXN.js";
-import {
-  PRIVATE_RECORDING_FILE_MODE,
-  ensurePrivateRecordingDir,
-  resolveRecordingConfigPath,
-  resolveRecordingPath
-} from "./chunk-7FHEBT5G.js";
-import "./chunk-ECIVB7P4.js";
-import "./chunk-LRKZP7DJ.js";
-
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/replay-command.js
-import { spawn } from "node:child_process";
-import fs from "node:fs/promises";
-async function handleReplayCli(args) {
-  const parsed = parseReplayArgs(args);
-  const replayPath = resolveRecordingPath(parsed.sessionName);
-  if (parsed.command.length > 0) {
-    await runWithReplayEnv(parsed.command, buildReplayCommandEnv(parsed.sessionName, parsed.server));
-    return;
-  }
-  const configPath = resolveRecordingConfigPath(parsed.sessionName);
-  await ensurePrivateRecordingDir(configPath);
-  await fs.writeFile(configPath, `${JSON.stringify({
-    session: parsed.sessionName,
-    server: parsed.server,
-    mode: "replay",
-    replayPath,
-    env: {
-      MCPORTER_REPLAY: parsed.sessionName,
-      ...parsed.server ? { MCPORTER_REPLAY_SERVER: parsed.server } : {},
-      MCPORTER_DISABLE_KEEPALIVE: "*"
-    }
-  }, null, 2)}
-`, {
-    encoding: "utf8",
-    mode: PRIVATE_RECORDING_FILE_MODE
-  });
-  await fs.chmod(configPath, PRIVATE_RECORDING_FILE_MODE);
-  console.log(`Replay configuration written to ${configPath}`);
-  const envInstructions = [
-    `MCPORTER_REPLAY=${parsed.sessionName}`,
-    ...parsed.server ? [`MCPORTER_REPLAY_SERVER=${parsed.server}`] : [],
-    "MCPORTER_DISABLE_KEEPALIVE=*"
-  ];
-  console.log(`Set ${envInstructions.join(" and ")} before the next mcporter call to replay ${replayPath}.`);
-}
-function printReplayHelp() {
-  console.log(`Usage: mcporter replay <session-name> [--server <name>] [-- <command-to-run>]
-
-Replay MCP JSON-RPC traffic from ~/.mcporter/recordings/<session-name>.ndjson.
-
-Flags:
-  --server <name>  Restrict replay to one configured server.`);
-}
-async function runWithReplayEnv(commandAndArgs, env) {
-  const [command, ...args] = commandAndArgs;
-  if (!command) {
-    return;
-  }
-  await new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      stdio: "inherit",
-      env
-    });
-    child.once("error", reject);
-    child.once("exit", (code, signal) => {
-      if (signal) {
-        reject(new Error(`Command '${command}' exited from signal ${signal}.`));
-        return;
-      }
-      process.exitCode = code ?? 0;
-      resolve();
-    });
-  });
-}
-export {
-  handleReplayCli,
-  printReplayHelp
-};