@mkterswingman/yt-mcp 0.1.0

package/dist/auth/oauthFlow.d.ts

@@ -0,0 +1,6 @@
+export declare function runOAuthFlow(authUrl: string): Promise<{
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    clientId: string;
+}>;

package/dist/auth/oauthFlow.js

@@ -0,0 +1,141 @@
+import { createServer } from "node:http";
+import { randomBytes, createHash } from "node:crypto";
+import { URL } from "node:url";
+function base64url(buf) {
+    return buf
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+export async function runOAuthFlow(authUrl) {
+    // 1. Generate PKCE
+    const codeVerifier = base64url(randomBytes(32));
+    const codeChallenge = base64url(createHash("sha256").update(codeVerifier).digest());
+    // 2. Start temp HTTP server to get the actual port for redirect_uri
+    const { server: httpServer, port } = await startCallbackServer();
+    const redirectUri = `http://127.0.0.1:${port}`;
+    // 3. DCR register client with actual redirect_uri (including port)
+    let clientId;
+    let clientSecret;
+    try {
+        const dcrRes = await fetch(`${authUrl}/oauth/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                client_name: "yt-mcp-cli",
+                redirect_uris: [redirectUri],
+            }),
+        });
+        if (!dcrRes.ok) {
+            const text = await dcrRes.text().catch(() => "");
+            httpServer.close();
+            throw new Error(`DCR registration failed: ${dcrRes.status} ${text}`);
+        }
+        const dcrBody = (await dcrRes.json());
+        clientId = dcrBody.client_id;
+        clientSecret = dcrBody.client_secret;
+    }
+    catch (err) {
+        httpServer.close();
+        throw err;
+    }
+    // 4. Wait for OAuth callback
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            httpServer.close();
+            reject(new Error("OAuth flow timed out after 5 minutes"));
+        }, 5 * 60 * 1000);
+        function cleanup() {
+            clearTimeout(timeout);
+            httpServer.close();
+        }
+        httpServer.on("request", async (req, res) => {
+            try {
+                const url = new URL(req.url ?? "/", `http://127.0.0.1`);
+                const code = url.searchParams.get("code");
+                const error = url.searchParams.get("error");
+                if (error) {
+                    const safeError = error.replace(/[<>&"']/g, (c) => `&#${c.charCodeAt(0)};`);
+                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                    res.end(`<h1>Authorization failed</h1><p>${safeError}</p>`);
+                    cleanup();
+                    reject(new Error(`OAuth error: ${error}`));
+                    return;
+                }
+                if (!code) {
+                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                    res.end("<h1>Waiting for authorization...</h1>");
+                    return;
+                }
+                // Exchange code for tokens
+                const tokenBody = {
+                    grant_type: "authorization_code",
+                    code,
+                    redirect_uri: redirectUri,
+                    client_id: clientId,
+                    code_verifier: codeVerifier,
+                };
+                if (clientSecret) {
+                    tokenBody.client_secret = clientSecret;
+                }
+                const tokenRes = await fetch(`${authUrl}/oauth/token`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(tokenBody),
+                });
+                if (!tokenRes.ok) {
+                    const text = await tokenRes.text().catch(() => "");
+                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                    res.end(`<h1>Token exchange failed</h1><p>${text}</p>`);
+                    cleanup();
+                    reject(new Error(`Token exchange failed: ${tokenRes.status} ${text}`));
+                    return;
+                }
+                const tokens = (await tokenRes.json());
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<h1>Authorization successful!</h1><p>You can close this window.</p>");
+                cleanup();
+                resolve({
+                    accessToken: tokens.access_token,
+                    refreshToken: tokens.refresh_token,
+                    expiresIn: tokens.expires_in,
+                    clientId,
+                });
+            }
+            catch (err) {
+                res.writeHead(500);
+                res.end("Internal error");
+                cleanup();
+                reject(err);
+            }
+        });
+        // Open browser
+        const authorizeUrl = `${authUrl}/oauth/authorize?response_type=code&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&code_challenge=${encodeURIComponent(codeChallenge)}&code_challenge_method=S256`;
+        console.log("\n\x1b[1mOpen this URL in your browser to authorize:\x1b[0m");
+        console.log(`\n  ${authorizeUrl}\n`);
+        import("node:child_process").then(({ exec }) => {
+            const cmd = process.platform === "darwin" ? "open" :
+                process.platform === "win32" ? "start" :
+                    "xdg-open";
+            exec(`${cmd} "${authorizeUrl}"`);
+        }).catch(() => {
+            // ignore — user can open manually
+        });
+    });
+}
+/** Start an HTTP server on a random port and return the server + port. */
+async function startCallbackServer() {
+    const server = createServer();
+    return new Promise((resolve, reject) => {
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                server.close();
+                reject(new Error("Failed to start callback server"));
+                return;
+            }
+            resolve({ server, port: addr.port });
+        });
+    });
+}

package/dist/auth/tokenManager.d.ts

@@ -0,0 +1,9 @@
+export declare class TokenManager {
+    private authUrl;
+    constructor(authUrl: string);
+    getValidToken(): Promise<string | null>;
+    saveTokens(accessToken: string, refreshToken: string, expiresIn: number, clientId?: string): Promise<void>;
+    savePAT(pat: string): Promise<void>;
+    private readAuth;
+    private refreshTokens;
+}

package/dist/auth/tokenManager.js

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { PATHS, ensureConfigDir } from "../utils/config.js";
+export class TokenManager {
+    authUrl;
+    constructor(authUrl) {
+        this.authUrl = authUrl;
+    }
+    async getValidToken() {
+        // Check env var PAT first
+        const envPat = process.env.YT_MCP_TOKEN;
+        if (envPat)
+            return envPat;
+        const auth = this.readAuth();
+        if (!auth)
+            return null;
+        if (auth.type === "pat" && auth.pat) {
+            return auth.pat;
+        }
+        if (auth.type === "jwt") {
+            if (auth.access_token && auth.expires_at && Date.now() < auth.expires_at) {
+                return auth.access_token;
+            }
+            // Try refresh
+            if (auth.refresh_token) {
+                try {
+                    const refreshed = await this.refreshTokens(auth.refresh_token, auth.client_id);
+                    if (refreshed) {
+                        await this.saveTokens(refreshed.access_token, refreshed.refresh_token, refreshed.expires_in, auth.client_id);
+                        return refreshed.access_token;
+                    }
+                }
+                catch {
+                    // refresh failed → AUTH_EXPIRED
+                }
+            }
+            return null;
+        }
+        return null;
+    }
+    async saveTokens(accessToken, refreshToken, expiresIn, clientId) {
+        ensureConfigDir();
+        const data = {
+            type: "jwt",
+            access_token: accessToken,
+            refresh_token: refreshToken,
+            expires_at: Date.now() + expiresIn * 1000,
+            client_id: clientId,
+        };
+        writeFileSync(PATHS.authJson, JSON.stringify(data, null, 2), {
+            mode: 0o600,
+        });
+    }
+    async savePAT(pat) {
+        ensureConfigDir();
+        const data = {
+            type: "pat",
+            pat,
+        };
+        writeFileSync(PATHS.authJson, JSON.stringify(data, null, 2), {
+            mode: 0o600,
+        });
+    }
+    readAuth() {
+        if (!existsSync(PATHS.authJson))
+            return null;
+        try {
+            const raw = readFileSync(PATHS.authJson, "utf8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async refreshTokens(refreshToken, clientId) {
+        const url = `${this.authUrl}/oauth/token`;
+        const body = {
+            grant_type: "refresh_token",
+            refresh_token: refreshToken,
+        };
+        if (clientId) {
+            body.client_id = clientId;
+        }
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            return null;
+        try {
+            const body = (await res.json());
+            if (!body.access_token)
+                return null;
+            return body;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+const command = process.argv[2];
+async function main() {
+    switch (command) {
+        case "setup": {
+            const { runSetup } = await import("./setup.js");
+            await runSetup();
+            break;
+        }
+        case "serve": {
+            const { runServe } = await import("./serve.js");
+            await runServe();
+            break;
+        }
+        case "setup-cookies": {
+            const { runSetupCookies } = await import("./setupCookies.js");
+            await runSetupCookies();
+            break;
+        }
+        default:
+            console.log(`
+Usage: yt-mcp <command>
+
+Commands:
+  setup          Run first-time setup (OAuth + cookies + MCP registration)
+  serve          Start the MCP server (stdio transport)
+  setup-cookies  Refresh YouTube cookies using browser login
+
+Environment variables:
+  YT_MCP_TOKEN   Personal Access Token (skips OAuth)
+`);
+            process.exit(command ? 1 : 0);
+    }
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+export {};

package/dist/cli/serve.d.ts

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

package/dist/cli/serve.js

@@ -0,0 +1,24 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "../utils/config.js";
+import { TokenManager } from "../auth/tokenManager.js";
+import { createServer } from "../server.js";
+export async function runServe() {
+    const config = loadConfig();
+    const tokenManager = new TokenManager(config.auth_url);
+    // 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);
+    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 @@
+export declare function runSetup(): Promise<void>;

package/dist/cli/setup.js

@@ -0,0 +1,246 @@
+import { execSync } from "node:child_process";
+import { createInterface } from "node:readline";
+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";
+function detectCli(name) {
+    try {
+        execSync(`${name} --version`, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function tryRegisterMcp(cmd, label) {
+    try {
+        execSync(cmd, { stdio: "pipe" });
+        console.log(`  ✅ MCP registered in ${label}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect if we can open a browser (local machine with display).
+ * Cloud environments (SSH, Docker, cloud IDE) typically can't.
+ */
+function canOpenBrowser() {
+    // Explicit override
+    if (process.env.YT_MCP_NO_BROWSER === "1")
+        return false;
+    // Check for display (Linux/macOS GUI)
+    if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+        return false;
+    }
+    // Check if running in common cloud/container environments
+    if (process.env.CODESPACES || process.env.GITPOD_WORKSPACE_ID || process.env.CLOUD_SHELL) {
+        return false;
+    }
+    // Check if we have a TTY (interactive terminal) — headless environments often don't
+    if (!process.stdin.isTTY) {
+        return false;
+    }
+    return true;
+}
+function openUrl(url) {
+    try {
+        const cmd = process.platform === "darwin" ? `open "${url}"` :
+            process.platform === "win32" ? `start "${url}"` :
+                `xdg-open "${url}"`;
+        execSync(cmd, { stdio: "ignore" });
+    }
+    catch {
+        // Can't open — user will see the URL in console
+    }
+}
+/**
+ * Prompt user for input in terminal.
+ */
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function runSetup() {
+    console.log("\n🚀 yt-mcp setup\n");
+    ensureConfigDir();
+    const hasBrowser = canOpenBrowser();
+    if (!hasBrowser) {
+        console.log("  ℹ️  Cloud/headless environment detected — using PAT mode\n");
+    }
+    // ── Step 1: Check yt-dlp ──
+    console.log("Step 1/5: Checking yt-dlp...");
+    try {
+        const ver = execSync("yt-dlp --version", { stdio: "pipe" }).toString().trim();
+        console.log(`  ✅ yt-dlp ${ver}`);
+    }
+    catch {
+        console.log("  ⚠️  yt-dlp not found (subtitle features will be unavailable)");
+        console.log("  💡 Install later: https://github.com/yt-dlp/yt-dlp#installation");
+    }
+    // ── Step 2: Config ──
+    console.log("Step 2/5: Initializing config...");
+    const config = loadConfig();
+    saveConfig(config);
+    console.log(`  ✅ Config: ${PATHS.configJson}`);
+    // ── 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");
+    }
+    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 choice = await prompt("  请输入 1 或 2 (默认 1): ");
+        const usePAT = choice === "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 = await prompt("  粘贴你的 PAT token (pat_xxx): ");
+            if (patInput) {
+                await tokenManager.savePAT(patInput);
+                console.log("  ✅ PAT saved");
+            }
+            else {
+                console.log("  ⚠️  未输入 token，稍后可通过环境变量配置：");
+                console.log('     "env": { "YT_MCP_TOKEN": "pat_xxx" }');
+            }
+        }
+        else {
+            // User chose OAuth (default)
+            console.log("");
+            console.log("  🌐 Opening browser for OAuth login...");
+            console.log("  ⚠️  如果你在云桌面上运行，请在云桌面的浏览器中完成登录！");
+            console.log("     在本地电脑打开链接将无法完成回调。");
+            try {
+                const tokens = await runOAuthFlow(config.auth_url);
+                await tokenManager.saveTokens(tokens.accessToken, tokens.refreshToken, tokens.expiresIn, tokens.clientId);
+                console.log("  ✅ OAuth login successful");
+            }
+            catch (err) {
+                // OAuth failed — auto fallback to PAT
+                console.log(`  ⚠️  OAuth failed: ${err instanceof Error ? err.message : String(err)}`);
+                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("");
+                const patInput = await prompt("  粘贴你的 PAT token (pat_xxx), 或直接回车跳过: ");
+                if (patInput) {
+                    await tokenManager.savePAT(patInput);
+                    console.log("  ✅ PAT saved");
+                }
+                else {
+                    console.log("  ⚠️  稍后可通过环境变量配置：");
+                    console.log('     "env": { "YT_MCP_TOKEN": "pat_xxx" }');
+                }
+            }
+        }
+    }
+    else {
+        // Cloud/headless — can't open browser, PAT only
+        const patUrl = `${config.auth_url}/pat/login`;
+        console.log(`  🔗 请在本地电脑浏览器中打开此链接获取 PAT token：`);
+        console.log(`     ${patUrl}`);
+        console.log("");
+        const patInput = await prompt("  粘贴你的 PAT token (pat_xxx), 或直接回车跳过: ");
+        if (patInput) {
+            await tokenManager.savePAT(patInput);
+            console.log("  ✅ PAT saved");
+        }
+        else {
+            console.log("  ⚠️  稍后可通过环境变量配置：");
+            console.log('     "env": { "YT_MCP_TOKEN": "pat_xxx" }');
+        }
+    }
+    // ── Step 4: YouTube Cookies ──
+    console.log("Step 4/5: YouTube cookies...");
+    if (!hasBrowser) {
+        console.log("  ⏭️  Skipped (no browser — subtitle features unavailable in cloud)");
+        console.log("  💡 Run on your local machine: npx @mkterswingman/yt-mcp setup-cookies");
+    }
+    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/yt-mcp setup-cookies");
+        }
+    }
+    // ── Step 5: MCP Registration ──
+    console.log("Step 5/5: Registering MCP in AI clients...");
+    const mcpCmd = "npx @mkterswingman/yt-mcp@latest serve";
+    let registered = false;
+    const cliCandidates = [
+        // Internal (company) variants
+        { bin: "claude-internal", label: "Claude Code (internal)" },
+        { bin: "codex-internal", label: "Codex CLI (internal)" },
+        { bin: "gemini-internal", label: "Gemini CLI (internal)" },
+        // Public versions
+        { bin: "claude", label: "Claude Code" },
+        { bin: "codex", label: "Codex CLI / Codex App" },
+        { bin: "gemini", label: "Gemini CLI" },
+        { bin: "opencode", label: "OpenCode" },
+        { bin: "openclaw", label: "OpenClaw" },
+    ];
+    for (const { bin, label } of cliCandidates) {
+        if (detectCli(bin)) {
+            if (tryRegisterMcp(`${bin} mcp add yt-mcp -- ${mcpCmd}`, label)) {
+                registered = true;
+            }
+        }
+    }
+    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": "npx",
+        "args": ["@mkterswingman/yt-mcp@latest", "serve"]
+      }
+    }
+  }
+`);
+    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 @@
+export declare function runSetupCookies(): Promise<void>;

package/dist/cli/setupCookies.js

@@ -0,0 +1,54 @@
+import { writeFileSync } from "node:fs";
+import { PATHS, ensureConfigDir } from "../utils/config.js";
+import { cookiesToNetscape } from "../utils/cookies.js";
+export async function runSetupCookies() {
+    console.log("\n🍪 YouTube Cookie Setup\n");
+    console.log("A browser window will open. Please log in to YouTube.\n");
+    ensureConfigDir();
+    // Dynamic import of playwright to avoid pulling it in at serve time
+    let chromium;
+    try {
+        const pw = await import("playwright");
+        chromium = pw.chromium;
+    }
+    catch {
+        throw new Error("Playwright is not installed. Run: npm install playwright && npx playwright install chromium");
+    }
+    const context = await chromium.launchPersistentContext(PATHS.browserProfile, {
+        headless: false,
+        channel: "chromium",
+        args: [
+            "--disable-blink-features=AutomationControlled",
+        ],
+    });
+    const page = context.pages()[0] ?? (await context.newPage());
+    await page.goto("https://accounts.google.com/ServiceLogin?continue=https://www.youtube.com");
+    console.log("Waiting for YouTube login (up to 5 minutes)...");
+    console.log("After logging in, the browser will close automatically.\n");
+    try {
+        await page.waitForURL("**/youtube.com/**", { timeout: 5 * 60 * 1000 });
+        // Wait a bit for cookies to settle
+        await page.waitForTimeout(3000);
+    }
+    catch {
+        console.error("Timed out waiting for YouTube login.");
+        await context.close();
+        throw new Error("Login timed out");
+    }
+    // Extract cookies
+    const rawCookies = await context.cookies("https://www.youtube.com");
+    await context.close();
+    const entries = rawCookies.map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        secure: c.secure,
+        httpOnly: c.httpOnly,
+        expires: c.expires,
+    }));
+    const netscape = cookiesToNetscape(entries);
+    writeFileSync(PATHS.cookiesTxt, netscape, { mode: 0o600 });
+    console.log(`✅ Cookies saved to ${PATHS.cookiesTxt}`);
+    console.log(`   ${entries.length} cookies extracted\n`);
+}

package/dist/server.d.ts

@@ -0,0 +1,21 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { YtMcpConfig } from "./utils/config.js";
+import type { TokenManager } from "./auth/tokenManager.js";
+/**
+ * Creates the MCP server.
+ *
+ * Authentication flow:
+ *
+ *   serve startup
+ *     │
+ *     ├─ YT_MCP_TOKEN env var? ──▶ PAT mode ──▶ full server (19 tools)
+ *     │
+ *     ├─ auth.json exists? ──▶ JWT mode ──▶ full server (19 tools)
+ *     │
+ *     └─ no token? ──▶ register "setup_required" tool only
+ *           │
+ *           └─ AI calls setup_required ──▶ returns:
+ *                ├─ PAT login URL (user clicks to get token)
+ *                └─ setup command (for full OAuth + cookies)
+ */
+export declare function createServer(config: YtMcpConfig, tokenManager: TokenManager): Promise<McpServer>;