@mkterswingman/5mghost-yonder 0.0.27 → 0.0.29

package/dist/cli/runtime.js

@@ -0,0 +1,35 @@
+import { checkAll, installAll, updateAll } from "../runtime/installers.js";
+export function formatRuntimeSummary(summary) {
+    const lines = [`Runtime ${summary.action} completed`];
+    for (const component of summary.components) {
+        const base = `${component.name}: ${component.status} (${component.source}`;
+        if (component.version) {
+            lines.push(`${base}, ${component.version})`);
+        }
+        else if (component.message) {
+            lines.push(`${base}) — ${component.message}`);
+        }
+        else {
+            lines.push(`${base})`);
+        }
+    }
+    return lines.join("\n");
+}
+export async function runRuntimeCommand(action, deps = {
+    installAll,
+    updateAll,
+    checkAll,
+}) {
+    const summary = action === "install"
+        ? await deps.installAll()
+        : action === "update"
+            ? await deps.updateAll()
+            : await deps.checkAll();
+    return formatRuntimeSummary(summary);
+}
+export async function runRuntimeCli(action = "check") {
+    const normalized = action === "install" || action === "update" || action === "check"
+        ? action
+        : "check";
+    console.log(await runRuntimeCommand(normalized));
+}

package/dist/cli/serve.d.ts

@@ -0,0 +1 @@
+export declare function runServe(): Promise<void>;

package/dist/cli/serve.js

@@ -0,0 +1,26 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "../utils/config.js";
+import { TokenManager } from "../auth/tokenManager.js";
+import { DownloadJobManager } from "../download/jobManager.js";
+import { createServer } from "../server.js";
+export async function runServe() {
+    const config = loadConfig();
+    const tokenManager = new TokenManager(config.auth_url);
+    const downloadJobManager = new DownloadJobManager();
+    // PAT mode via env var (don't persist — just keep in memory for this session)
+    const pat = process.env.YT_MCP_TOKEN;
+    if (pat) {
+        await tokenManager.savePAT(pat);
+    }
+    const server = await createServer(config, tokenManager, downloadJobManager);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.on("SIGINT", async () => {
+        await server.close();
+        process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+        await server.close();
+        process.exit(0);
+    });
+}

package/dist/cli/setup.d.ts

@@ -0,0 +1,33 @@
+interface CliCommand {
+    file: string;
+    args: string[];
+}
+interface SetupCliCandidate {
+    bin: string;
+    label: string;
+    command: CliCommand;
+}
+export declare function buildSetupCliCandidates(launcherCommand: CliCommand): SetupCliCandidate[];
+export declare function canOpenBrowserForEnv(input: {
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    stdinIsTTY: boolean;
+}): boolean;
+type PromptQuestionFn = (question: string, signal: AbortSignal) => Promise<string>;
+export interface PromptWithDefaultOptions {
+    defaultValue: string;
+    defaultLabel?: string;
+    timeoutMs?: number;
+    stdinIsTTY?: boolean;
+    log?: (message: string) => void;
+    questionFn?: PromptQuestionFn;
+}
+export declare const INSTALLER_OAUTH_TIMEOUT_MS = 180000;
+export declare function getOAuthRecoveryHint(authUrl: string): string[];
+export declare function getCookieSetupRecoveryHint(): string[];
+export declare function promptWithDefault(question: string, options: PromptWithDefaultOptions): Promise<string>;
+export declare function getNoBrowserSessionNotice(): string;
+export declare function getNoBrowserPatHint(authUrl: string): string[];
+export declare function getCookieSetupDeferredHint(): string[];
+export declare function runSetup(): Promise<void>;
+export {};

package/dist/cli/setup.js

@@ -0,0 +1,450 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { loadConfig, saveConfig, PATHS, ensureConfigDir } from "../utils/config.js";
+import { TokenManager } from "../auth/tokenManager.js";
+import { runOAuthFlow } from "../auth/oauthFlow.js";
+import { hasSIDCookies } from "../utils/cookies.js";
+import { buildLauncherCommand, writeLauncherFile } from "../utils/launcher.js";
+import { buildBrowserOpenCommand } from "../utils/browserLaunch.js";
+import { checkAll } from "../runtime/installers.js";
+import { runInstallSkills } from "./installSkills.js";
+import { getOpenClawConfigPath, isOpenClawInstallLikelyInstalled, writeOpenClawConfig, } from "../utils/openClaw.js";
+import { getCodexInternalConfigPath, writeCodexInternalConfig, } from "../utils/codexInternal.js";
+import { MCP_REGISTER_TIMEOUT_MS, classifyRegistrationFailure, } from "../utils/mcpRegistration.js";
+function detectCli(name) {
+    try {
+        execFileSync(name, ["--version"], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function tryRegisterMcp(cmd, label) {
+    try {
+        execFileSync(cmd.file, cmd.args, { stdio: "pipe", timeout: MCP_REGISTER_TIMEOUT_MS });
+        console.log(`  ✅ MCP registered in ${label}`);
+        return true;
+    }
+    catch (err) {
+        const failure = classifyRegistrationFailure(err);
+        if (failure.kind === "already_exists") {
+            console.log(`  ✅ MCP already registered in ${label}`);
+            return true;
+        }
+        if (failure.kind === "authentication") {
+            console.log(`  ⚠️  ${label} is waiting for authentication — skipped auto-register.`);
+            return false;
+        }
+        if (failure.kind === "timeout") {
+            console.log(`  ⚠️  ${label} registration timed out after ${MCP_REGISTER_TIMEOUT_MS}ms — skipped auto-register.`);
+            return false;
+        }
+        const summary = failure.output.replace(/\s+/g, " ").trim().slice(0, 240);
+        if (summary) {
+            console.log(`  ⚠️  ${label} auto-register failed: ${summary}`);
+        }
+        else {
+            console.log(`  ⚠️  ${label} auto-register failed with no diagnostic output.`);
+        }
+        return false;
+    }
+}
+export function buildSetupCliCandidates(launcherCommand) {
+    return [
+        { bin: "claude-internal", label: "Claude Code (internal)", command: { file: "claude-internal", args: ["mcp", "add", "-s", "user", "yt-mcp", "--", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "claude", label: "Claude Code", command: { file: "claude", args: ["mcp", "add", "-s", "user", "yt-mcp", "--", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "codex", label: "Codex CLI / Codex App", command: { file: "codex", args: ["mcp", "add", "yt-mcp", "--", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "gemini-internal", label: "Gemini CLI (internal)", command: { file: "gemini-internal", args: ["mcp", "add", "-s", "user", "yt-mcp", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "gemini", label: "Gemini CLI", command: { file: "gemini", args: ["mcp", "add", "-s", "user", "yt-mcp", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "opencode", label: "OpenCode", command: { file: "opencode", args: ["mcp", "add", "yt-mcp", "--", launcherCommand.file, ...launcherCommand.args] } },
+    ];
+}
+export function canOpenBrowserForEnv(input) {
+    if (input.env.YT_MCP_NO_BROWSER === "1") {
+        return false;
+    }
+    if (input.env.CODESPACES || input.env.GITPOD_WORKSPACE_ID || input.env.CLOUD_SHELL) {
+        return false;
+    }
+    if (input.platform === "linux") {
+        return Boolean(input.env.DISPLAY || input.env.WAYLAND_DISPLAY);
+    }
+    // Why: desktop Windows/macOS sessions can launch browsers even when the host app pipes stdio.
+    if (input.platform === "win32" || input.platform === "darwin") {
+        return true;
+    }
+    return input.stdinIsTTY;
+}
+function canOpenBrowser() {
+    return canOpenBrowserForEnv({
+        platform: process.platform,
+        env: process.env,
+        stdinIsTTY: Boolean(process.stdin.isTTY),
+    });
+}
+function openUrl(url) {
+    try {
+        const command = buildBrowserOpenCommand(url);
+        execFileSync(command.file, command.args, { stdio: "ignore" });
+    }
+    catch {
+        // Can't open — user will see the URL in console
+    }
+}
+export const INSTALLER_OAUTH_TIMEOUT_MS = 180_000;
+export function getOAuthRecoveryHint(authUrl) {
+    return [
+        "  如果浏览器没有出现，或你之后想改用 PAT，可直接继续：",
+        `  PAT 登录页：${authUrl}/pat/login`,
+        "  macOS / Linux: YT_MCP_TOKEN='pat_xxx' yt-mcp setup",
+        "  Windows: $env:YT_MCP_TOKEN='pat_xxx'; yt-mcp setup",
+    ];
+}
+export function getCookieSetupRecoveryHint() {
+    return [
+        "  如果浏览器没有出现，或这次没完成 YouTube 登录，可稍后继续：",
+        "  重新执行：yt-mcp setup-cookies",
+        "  验证字幕：yt-mcp smoke --subtitles",
+    ];
+}
+function createPromptQuestionFn() {
+    return async (question, signal) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            return (await rl.question(question, { signal })).trim();
+        }
+        finally {
+            rl.close();
+        }
+    };
+}
+export async function promptWithDefault(question, options) {
+    const stdinIsTTY = options.stdinIsTTY ?? Boolean(process.stdin.isTTY);
+    const defaultLabel = options.defaultLabel ?? options.defaultValue;
+    const log = options.log ?? console.log;
+    if (!stdinIsTTY) {
+        log(`  ℹ️  No interactive terminal detected; defaulting to ${defaultLabel}.`);
+        return options.defaultValue;
+    }
+    const questionFn = options.questionFn ?? createPromptQuestionFn();
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const answer = await questionFn(question, controller.signal);
+        return answer || options.defaultValue;
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+            log(`  ℹ️  No input received within ${Math.round(timeoutMs / 1000)}s; defaulting to ${defaultLabel}.`);
+            return options.defaultValue;
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function getRequestedAuthModeFromEnv(env) {
+    const value = env.YT_MCP_AUTH_MODE?.trim().toLowerCase();
+    if (value === "oauth" || value === "1") {
+        return "oauth";
+    }
+    if (value === "pat" || value === "2") {
+        return "pat";
+    }
+    return null;
+}
+export function getNoBrowserSessionNotice() {
+    return "  ℹ️  当前安装会话无法自动拉起浏览器 — 使用 PAT 模式\n";
+}
+export function getNoBrowserPatHint(authUrl) {
+    return [
+        "  🔗 请在当前这台运行安装器的桌面环境浏览器中打开此链接获取 PAT token：",
+        `     ${authUrl}/pat/login`,
+        "",
+        "  ⚠️  如果你在云桌面上运行，请在云桌面的浏览器中完成登录，不要在本地电脑打开。"
+    ];
+}
+export function getCookieSetupDeferredHint() {
+    return [
+        "  ⏭️  Skipped (current session can't open a browser automatically — subtitle verification deferred)",
+        "  💡 在当前这台机器或云桌面的交互终端里运行：npx @mkterswingman/5mghost-yonder setup-cookies"
+    ];
+}
+export async function runSetup() {
+    const installerMode = process.env.YT_MCP_INSTALLER_MODE === "1";
+    const skipCookieStep = installerMode || process.env.YT_MCP_SETUP_SKIP_COOKIES === "1";
+    const quietSummary = installerMode || process.env.YT_MCP_SETUP_QUIET_SUMMARY === "1";
+    console.log("\n🚀 yt-mcp setup\n");
+    ensureConfigDir();
+    const hasBrowser = canOpenBrowser();
+    if (!hasBrowser) {
+        console.log(getNoBrowserSessionNotice());
+    }
+    // ── Step 1: Runtime check ──
+    console.log("Step 1/5: Checking required runtimes...");
+    const runtimeSummary = await checkAll();
+    for (const component of runtimeSummary.components) {
+        if (component.status === "installed") {
+            console.log(`  ✅ ${component.name}: ${component.source}${component.version ? ` (${component.version})` : ""}`);
+        }
+        else {
+            console.log(`  ⚠️  ${component.name}: missing${component.message ? ` — ${component.message}` : ""}`);
+        }
+    }
+    if (runtimeSummary.components.some((component) => component.status !== "installed")) {
+        console.log("  💡 Install missing runtimes with: yt-mcp runtime install");
+    }
+    // ── Step 2: Config ──
+    console.log("Step 2/5: Initializing config...");
+    const config = loadConfig();
+    saveConfig(config);
+    writeLauncherFile();
+    console.log(`  ✅ Config: ${PATHS.configJson}`);
+    console.log(`  ✅ Launcher: ${PATHS.launcherJs}`);
+    console.log(`  ✅ Shared auth: ${PATHS.sharedAuthJson}`);
+    // ── Step 3: Authentication ──
+    console.log("Step 3/5: Authentication...");
+    const tokenManager = new TokenManager(config.auth_url);
+    const pat = process.env.YT_MCP_TOKEN;
+    if (pat) {
+        // Explicit PAT provided via env var
+        await tokenManager.savePAT(pat);
+        console.log(`  ✅ PAT saved from YT_MCP_TOKEN to shared auth`);
+    }
+    else if (hasBrowser) {
+        // Local or cloud desktop — let user choose auth method
+        console.log("  请选择登录方式：");
+        console.log("  [1] OAuth 自动登录（推荐 — 自动弹出浏览器完成登录）");
+        console.log("  [2] PAT Token 登录（手动 — 在浏览器中生成 token 后粘贴）");
+        console.log("");
+        const forcedAuthMode = getRequestedAuthModeFromEnv(process.env);
+        const usePAT = forcedAuthMode
+            ? forcedAuthMode === "pat"
+            : (await promptWithDefault("  请输入 1 或 2 (默认 1): ", {
+                defaultValue: "1",
+                defaultLabel: "1",
+            })) === "2";
+        if (usePAT) {
+            // User chose PAT
+            const patUrl = `${config.auth_url}/pat/login`;
+            console.log("");
+            console.log(`  🔗 Opening PAT login page: ${patUrl}`);
+            openUrl(patUrl);
+            console.log("");
+            console.log("  请在浏览器中登录并生成 PAT token。");
+            const patInput = process.stdin.isTTY
+                ? await promptWithDefault("  粘贴你的 PAT token (pat_xxx): ", {
+                    defaultValue: "",
+                    defaultLabel: "skip",
+                })
+                : "";
+            if (patInput) {
+                await tokenManager.savePAT(patInput);
+                console.log("  ✅ PAT saved to shared auth");
+            }
+            else {
+                console.log("  ⚠️  未输入 token，稍后可通过环境变量配置：");
+                console.log('     "env": { "YT_MCP_TOKEN": "pat_xxx" }');
+            }
+        }
+        else {
+            // User chose OAuth (default)
+            const oauthTimeoutMs = installerMode ? INSTALLER_OAUTH_TIMEOUT_MS : 5 * 60 * 1000;
+            console.log("");
+            console.log("  🌐 Opening browser for OAuth login...");
+            console.log("  ⚠️  如果你在云桌面上运行，请在云桌面的浏览器中完成登录！");
+            console.log("     在本地电脑打开链接将无法完成回调。");
+            for (const line of getOAuthRecoveryHint(config.auth_url)) {
+                console.log(line);
+            }
+            console.log(`  OAuth 等待上限：${Math.round(oauthTimeoutMs / 1000)}s`);
+            try {
+                const tokens = await runOAuthFlow(config.auth_url, { timeoutMs: oauthTimeoutMs });
+                await tokenManager.saveTokens(tokens.accessToken, tokens.refreshToken, tokens.expiresIn, tokens.clientId);
+                console.log("  ✅ OAuth login successful");
+                console.log("  ℹ️  Other first-party local MCPs on this machine can reuse this login.");
+            }
+            catch (err) {
+                // OAuth failed — auto fallback to PAT
+                console.log(`  ⚠️  OAuth failed: ${err instanceof Error ? err.message : String(err)}`);
+                for (const line of getOAuthRecoveryHint(config.auth_url)) {
+                    console.log(line);
+                }
+                if (process.stdin.isTTY) {
+                    console.log("");
+                    console.log("  📋 Falling back to PAT login...");
+                    const patUrl = `${config.auth_url}/pat/login`;
+                    console.log(`  🔗 Opening PAT login page: ${patUrl}`);
+                    openUrl(patUrl);
+                    console.log("");
+                }
+                else {
+                    console.log("  ℹ️  当前安装会话无交互输入，请拿到 PAT 后直接带 YT_MCP_TOKEN 重跑。");
+                }
+                const patInput = process.stdin.isTTY
+                    ? await promptWithDefault("  粘贴你的 PAT token (pat_xxx), 或直接回车跳过: ", {
+                        defaultValue: "",
+                        defaultLabel: "skip",
+                    })
+                    : "";
+                if (patInput) {
+                    await tokenManager.savePAT(patInput);
+                    console.log("  ✅ PAT saved to shared auth");
+                }
+                else {
+                    console.log("  ⚠️  稍后可通过环境变量配置：");
+                    console.log('     "env": { "YT_MCP_TOKEN": "pat_xxx" }');
+                }
+            }
+        }
+    }
+    else {
+        // Cloud/headless — can't open browser, PAT only
+        for (const line of getNoBrowserPatHint(config.auth_url)) {
+            console.log(line);
+        }
+        const patInput = process.stdin.isTTY
+            ? await promptWithDefault("  粘贴你的 PAT token (pat_xxx), 或直接回车跳过: ", {
+                defaultValue: "",
+                defaultLabel: "skip",
+            })
+            : "";
+        if (patInput) {
+            await tokenManager.savePAT(patInput);
+            console.log("  ✅ PAT saved to shared auth");
+        }
+        else {
+            console.log("  ⚠️  稍后可通过环境变量配置：");
+            console.log('     "env": { "YT_MCP_TOKEN": "pat_xxx" }');
+        }
+    }
+    const hasSharedAuth = Boolean(pat) || existsSync(PATHS.sharedAuthJson);
+    // ── Step 4: YouTube Cookies ──
+    console.log("Step 4/5: YouTube cookies...");
+    if (!hasSharedAuth) {
+        console.log("  ℹ️  Deferred because authentication is not complete yet");
+    }
+    else if (skipCookieStep) {
+        console.log("  ℹ️  Deferred to installer cookie flow");
+    }
+    else if (!hasBrowser) {
+        for (const line of getCookieSetupDeferredHint()) {
+            console.log(line);
+        }
+    }
+    else if (hasSIDCookies(PATHS.cookiesTxt)) {
+        console.log("  ✅ Cookies already present");
+    }
+    else {
+        console.log("  🌐 Opening browser for YouTube login...");
+        console.log("  ⚠️  如果你在云桌面上运行，请在云桌面的浏览器窗口中登录 YouTube！");
+        console.log("  (Please log in to YouTube in the browser window)");
+        try {
+            const { runSetupCookies } = await import("./setupCookies.js");
+            await runSetupCookies();
+            console.log("  ✅ YouTube cookies saved");
+        }
+        catch (err) {
+            console.log(`  ⚠️  Cookie setup skipped: ${err instanceof Error ? err.message : String(err)}`);
+            console.log("  💡 Run later: npx @mkterswingman/5mghost-yonder setup-cookies");
+        }
+    }
+    // ── Step 5: MCP Registration ──
+    console.log("Step 5/5: Registering MCP in AI clients...");
+    const launcherCommand = buildLauncherCommand();
+    let registered = false;
+    let skillsInstalled = false;
+    for (const { bin, label, command } of buildSetupCliCandidates({
+        file: launcherCommand.command,
+        args: launcherCommand.args,
+    })) {
+        if (!detectCli(bin))
+            continue;
+        if (tryRegisterMcp(command, label)) {
+            registered = true;
+        }
+    }
+    if (isOpenClawInstallLikelyInstalled(detectCli)) {
+        try {
+            const status = writeOpenClawConfig("yt-mcp", launcherCommand);
+            const suffix = status === "created" ? "created" : "updated";
+            console.log(`  ✅ MCP registered in OpenClaw (${suffix} mcporter.json)`);
+            registered = true;
+        }
+        catch (err) {
+            console.log(`  ⚠️  OpenClaw auto-register failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (detectCli("codex-internal")) {
+        try {
+            const status = writeCodexInternalConfig("yt-mcp", launcherCommand);
+            const suffix = status === "created" ? "created" : "updated";
+            console.log(`  ✅ MCP registered in Codex CLI (internal) (${suffix} ${getCodexInternalConfigPath()})`);
+            registered = true;
+        }
+        catch (err) {
+            console.log(`  ⚠️  Codex CLI (internal) auto-register failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    try {
+        process.env.YT_MCP_INSTALL_OPENCLAW_SKILL = isOpenClawInstallLikelyInstalled(detectCli) ? "1" : "0";
+        await runInstallSkills();
+        skillsInstalled = true;
+    }
+    catch (err) {
+        console.log(`  ⚠️  Bundled skill install failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!registered) {
+        console.log("  ℹ️  No supported CLI found. Add manually to your AI client:");
+    }
+    // Always print manual config
+    console.log("");
+    console.log("  MCP config (for manual setup / other clients):");
+    console.log(`
+  {
+    "mcpServers": {
+      "yt-mcp": {
+        "command": "node",
+        "args": [${JSON.stringify(PATHS.launcherJs)}, "serve"]
+      }
+    }
+  }
+`);
+    console.log(`  OpenClaw mcporter config: ${getOpenClawConfigPath()}`);
+    console.log("  OpenClaw manual config:");
+    console.log(`
+  {
+    "servers": {
+      "yt-mcp": {
+        "transport": "stdio",
+        "command": "node",
+        "args": [${JSON.stringify(PATHS.launcherJs)}, "serve"]
+      }
+    }
+  }
+`);
+    console.log(`  OpenClaw uses ${PATHS.sharedAuthJson} for PAT/JWT, so env.YT_MCP_TOKEN is optional after setup.`);
+    if (skillsInstalled) {
+        console.log("  ✅ Installed bundled yt-mcp analysis skill for detected AI clients");
+    }
+    console.log("  Media downloads:");
+    console.log("  - `start_download_job` / `poll_download_job` are job-based local tools");
+    console.log("  - Batch limit: 5 YouTube videos per job");
+    console.log("  - Output path: ~/Downloads/yt-mcp/YYYY-MM-DD_<video_id>");
+    console.log("  - `ffmpeg` is required for video download modes");
+    console.log("");
+    if (!quietSummary) {
+        console.log("✅ Setup complete!");
+        if (hasBrowser) {
+            console.log('   Open your AI client and try: "搜索 Python 教程"');
+        }
+        else {
+            console.log("   Set YT_MCP_TOKEN in your MCP env config, then restart your AI client.");
+        }
+        console.log("");
+    }
+}

package/dist/cli/setupCookies.d.ts

@@ -0,0 +1,88 @@
+import { ensureConfigDir } from "../utils/config.js";
+import { cleanupImportedBrowserWorkspace, findImportableBrowserProfileCandidates, prepareImportedBrowserWorkspace, type BrowserProfileCandidate } from "../utils/browserProfileImport.js";
+export type PlaywrightCookie = {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    secure: boolean;
+    httpOnly: boolean;
+    expires: number;
+};
+/**
+ * Detect which browser channel is available on the system.
+ * Prefers Chrome → Edge → falls back to bundled Chromium.
+ */
+export declare function detectBrowserChannel(chromium: typeof import("playwright").chromium): Promise<string>;
+export declare const CHANNEL_LABELS: Record<string, string>;
+/** Check if YouTube SID cookies are present — the real signal of a logged-in session. */
+export declare function hasYouTubeSession(cookies: Array<{
+    name: string;
+    domain: string;
+}>): boolean;
+/**
+ * Save cookies to Netscape format file and close the browser context.
+ */
+export declare function saveCookiesAndClose(context: {
+    close(): Promise<void>;
+}, rawCookies: PlaywrightCookie[], silent?: boolean): Promise<void>;
+/**
+ * Save cookies to disk WITHOUT closing the context (caller manages lifecycle).
+ */
+export declare function saveCookiesToDisk(rawCookies: PlaywrightCookie[]): void;
+/**
+ * Poll cookies at intervals until YouTube session cookies appear or timeout.
+ * Returns the full cookie list on success, or null on timeout / browser closed.
+ */
+declare function waitForLogin(context: Awaited<ReturnType<typeof import("playwright").chromium.launchPersistentContext>>, isClosed: () => boolean, timeoutMs: number, pollIntervalMs?: number): Promise<PlaywrightCookie[] | null>;
+declare function loadPlaywrightChromium(): Promise<typeof import("playwright").chromium>;
+export interface SetupCookiesDeps {
+    ensureConfigDir: typeof ensureConfigDir;
+    loadChromium: typeof loadPlaywrightChromium;
+    detectBrowserChannel: typeof detectBrowserChannel;
+    hasYouTubeSession: typeof hasYouTubeSession;
+    saveCookiesAndClose: typeof saveCookiesAndClose;
+    waitForLogin: typeof waitForLogin;
+    findImportableBrowserProfileCandidates: typeof findImportableBrowserProfileCandidates;
+    prepareImportedBrowserWorkspace: typeof prepareImportedBrowserWorkspace;
+    cleanupImportedBrowserWorkspace: typeof cleanupImportedBrowserWorkspace;
+    readImportedBrowserCookies: typeof readImportedBrowserCookies;
+    tryImportBrowserCookies: typeof tryImportBrowserCookies;
+    runManualCookieSetup: typeof runManualCookieSetup;
+    log: (message: string) => void;
+}
+export interface SetupCookiesOptions {
+    importOnly?: boolean;
+    headed?: boolean;
+}
+export declare class BrowserProfileLockedError extends Error {
+    constructor(message?: string);
+}
+type SetupCookiesChromium = Awaited<ReturnType<SetupCookiesDeps["loadChromium"]>>;
+interface CdpCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    expires?: number;
+}
+interface CdpCookieClient {
+    send(method: "Network.getAllCookies"): Promise<{
+        cookies?: CdpCookie[];
+    }>;
+}
+export declare function readCdpCookiesUntilSession(client: CdpCookieClient, deps: Pick<SetupCookiesDeps, "hasYouTubeSession">, options?: {
+    attempts?: number;
+    delayMs?: number;
+}): Promise<PlaywrightCookie[] | null>;
+export declare function tryImportBrowserCookies(chromium: SetupCookiesChromium, deps: SetupCookiesDeps): Promise<boolean>;
+export declare function readImportedBrowserCookies(candidate: BrowserProfileCandidate, chromium: SetupCookiesChromium, deps: SetupCookiesDeps): Promise<PlaywrightCookie[] | null>;
+export declare function runManualCookieSetup(chromium: SetupCookiesChromium, deps: SetupCookiesDeps): Promise<void>;
+/**
+ * Interactive cookie setup — opens a visible browser for user to log in.
+ */
+export declare function parseSetupCookiesArgs(argv: string[]): SetupCookiesOptions;
+export declare function runSetupCookies(overrides?: Partial<SetupCookiesDeps>, options?: SetupCookiesOptions): Promise<void>;
+export {};