@mkterswingman/5mghost-yonder 0.0.37 → 0.0.39

package/dist/tools/subtitles.js

@@ -1,20 +1,14 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { z } from "zod";
 import { PATHS } from "../utils/config.js";
 import { runYtDlp } from "../utils/ytdlp.js";
-import { hasSIDCookies, areCookiesExpired } from "../utils/cookies.js";
-import { tryHeadlessRefresh } from "../utils/cookieRefresh.js";
-import { appendDiagnosticLog, classifyYtDlpFailure } from "../utils/ytdlpFailures.js";
+import { hasSIDCookies } from "../utils/cookies.js";
 import { resolveVideoInput, normalizeVideoInputs } from "../utils/videoInput.js";
+import { COOKIE_EXPIRED_MESSAGE, COOKIE_INVALID_MESSAGE, RATE_LIMITED_MESSAGE, SIGN_IN_REQUIRED_MESSAGE, ensureSubtitleCookiesReady, tryRefreshSubtitleCookies, toReadableSubtitleJobError } from "./subtitles/cookieSession.js";
+import { downloadSubtitle, downloadSubtitlesForLanguages } from "./subtitles/download.js";
+import { vttToCsv } from "./subtitles/parse.js";
 const AUTH_REQUIRED_MSG = "❌ 未认证。请先登录：\n• OAuth: npx @mkterswingman/5mghost-yonder setup\n• PAT: 设置环境变量 YT_MCP_TOKEN 或在 https://mkterswingman.com/pat/login 生成 token";
-const COOKIE_SETUP_COMMAND = "yt-mcp setup-cookies";
-const COOKIE_MISSING_MESSAGE = `No valid YouTube cookies found.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
-const COOKIE_EXPIRED_MESSAGE = `YouTube cookies have expired and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
-const COOKIE_INVALID_MESSAGE = `YouTube rejected the current cookies and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
-const SIGN_IN_REQUIRED_MESSAGE = `YouTube requested an additional sign-in confirmation and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
-const RATE_LIMITED_MESSAGE = "The current YouTube session has been rate-limited. Wait and retry later.";
-const COOKIE_JOB_MESSAGE = `YouTube cookies are missing, expired, or invalid.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
 function toolOk(payload) {
     return {
         structuredContent: payload,
@@ -40,382 +34,14 @@ function sleep(ms) {
 function randomSleep(min, max) {
     return sleep(Math.random() * (max - min) + min);
 }
-async function tryRefreshSubtitleCookies() {
-    try {
-        return await tryHeadlessRefresh();
-    }
-    catch {
-        return false;
-    }
-}
-function isCookieFailureText(error) {
-    if (!error) {
-        return false;
-    }
-    const normalized = error.toLowerCase();
-    return (normalized.includes("cookies_expired") ||
-        normalized.includes("cookie") ||
-        normalized.includes("sign in") ||
-        normalized.includes("login") ||
-        normalized.includes("not a bot"));
-}
-function classifyYtDlpCookieFailure(stderr) {
-    const kind = classifyYtDlpFailure(stderr);
-    switch (kind) {
-        case "COOKIES_EXPIRED":
-            return { code: kind, message: COOKIE_EXPIRED_MESSAGE };
-        case "COOKIES_INVALID":
-            return { code: kind, message: COOKIE_INVALID_MESSAGE };
-        case "SIGN_IN_REQUIRED":
-            return { code: kind, message: SIGN_IN_REQUIRED_MESSAGE };
-        case "RATE_LIMITED":
-            return { code: kind, message: RATE_LIMITED_MESSAGE };
-        default:
-            return null;
-    }
-}
-export function toReadableSubtitleJobError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return isCookieFailureText(message) ? COOKIE_JOB_MESSAGE : message;
-}
-async function ensureSubtitleCookiesReady() {
-    const hasSession = hasSIDCookies(PATHS.cookiesTxt);
-    const expired = areCookiesExpired(PATHS.cookiesTxt);
-    if (hasSession && !expired) {
-        return { ok: true };
-    }
-    const refreshed = await tryRefreshSubtitleCookies();
-    if (refreshed && hasSIDCookies(PATHS.cookiesTxt) && !areCookiesExpired(PATHS.cookiesTxt)) {
-        return { ok: true };
-    }
-    return {
-        ok: false,
-        code: hasSession && expired ? "COOKIES_EXPIRED" : "COOKIES_MISSING",
-        toolMessage: hasSession && expired ? COOKIE_EXPIRED_MESSAGE : COOKIE_MISSING_MESSAGE,
-        jobMessage: appendDiagnosticLog(COOKIE_JOB_MESSAGE, undefined),
-    };
-}
-/**
- * Decode common HTML entities found in YouTube auto-captions.
- */
-function decodeHtmlEntities(text) {
-    return text
-        .replace(/>/g, ">")
-        .replace(/&lt;/g, "<")
-        .replace(/&amp;/g, "&")
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&nbsp;/g, " ");
-}
-/**
- * Parse a VTT timestamp line into start/end seconds + clean time strings.
- * Input: "00:00:02.159 --> 00:00:03.590 align:start position:0%"
- * Returns: { startStr, endStr, startSec, endSec } or null if unparseable.
- */
-function parseTimestamp(line) {
-    // Strip positioning metadata (align:start position:0% etc.)
-    const match = line.match(/(\d{1,2}:\d{2}:\d{2}\.\d{3})\s*-->\s*(\d{1,2}:\d{2}:\d{2}\.\d{3})/);
-    if (!match)
-        return null;
-    const toSec = (t) => {
-        const parts = t.split(":");
-        return (Number(parts[0]) * 3600 + Number(parts[1]) * 60 + Number(parts[2]));
-    };
-    return {
-        startStr: match[1],
-        endStr: match[2],
-        startSec: toSec(match[1]),
-        endSec: toSec(match[2]),
-    };
-}
-/**
- * Escape a value for CSV (RFC 4180).
- */
-function csvEscapeField(value) {
-    if (/[",\n\r]/.test(value)) {
-        return `"${value.replace(/"/g, '""')}"`;
-    }
-    return value;
-}
-/**
- * Convert VTT subtitle content to clean, human-readable CSV.
- *
- * YouTube auto-captions use a "rolling" VTT format where each cue has two
- * lines: the first line repeats the previous cue's text, and the second line
- * contains new words (marked with <c> tags for word-level timing). This
- * function detects and handles this pattern:
- *
- * 1. Detects auto-caption format (presence of <c> word-timing tags)
- * 2. For auto-captions: extracts only the NEW text from each cue's second
- *    line, skips transition cues, and concatenates into clean sentences
- * 3. For manual subtitles: passes through cleanly with no data loss
- * 4. Outputs: start_time, end_time, text
- */
-export function vttToCsv(vtt) {
-    const lines = vtt.split("\n");
-    const isAutoCaption = /<\d{2}:\d{2}:\d{2}\.\d{3}><c>/.test(vtt);
-    const rawCues = [];
-    let currentTs = null;
-    let currentTextLines = [];
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.includes(" --> ")) {
-            // Flush previous cue
-            if (currentTs && currentTextLines.length > 0) {
-                let text;
-                if (isAutoCaption && currentTextLines.length >= 2) {
-                    // Auto-caption: line 1 = repeated text, line 2 = new text with <c> tags
-                    // Only take line 2 (new content)
-                    text = decodeHtmlEntities(currentTextLines[currentTextLines.length - 1]
-                        .replace(/<[^>]*>/g, "")
-                        .trim());
-                }
-                else {
-                    // Manual subtitle or single-line cue: take all lines
-                    text = decodeHtmlEntities(currentTextLines
-                        .map((l) => l.replace(/<[^>]*>/g, "").trim())
-                        .filter(Boolean)
-                        .join(" "));
-                }
-                if (text) {
-                    rawCues.push({ ...currentTs, text });
-                }
-            }
-            currentTs = parseTimestamp(trimmed);
-            currentTextLines = [];
-        }
-        else if (trimmed &&
-            !trimmed.startsWith("WEBVTT") &&
-            !trimmed.startsWith("Kind:") &&
-            !trimmed.startsWith("Language:") &&
-            !/^\d+$/.test(trimmed)) {
-            currentTextLines.push(trimmed);
-        }
-    }
-    // Flush last
-    if (currentTs && currentTextLines.length > 0) {
-        let text;
-        if (isAutoCaption && currentTextLines.length >= 2) {
-            text = decodeHtmlEntities(currentTextLines[currentTextLines.length - 1]
-                .replace(/<[^>]*>/g, "")
-                .trim());
-        }
-        else {
-            text = decodeHtmlEntities(currentTextLines
-                .map((l) => l.replace(/<[^>]*>/g, "").trim())
-                .filter(Boolean)
-                .join(" "));
-        }
-        if (text) {
-            rawCues.push({ ...currentTs, text });
-        }
-    }
-    if (rawCues.length === 0) {
-        return "start_time,end_time,text\n";
-    }
-    // ── Step 2: Deduplicate ───────────────────────────────────────
-    const deduped = [];
-    for (let i = 0; i < rawCues.length; i++) {
-        const cur = rawCues[i];
-        // Skip tiny transition cues (duration < 50ms)
-        const duration = cur.endSec - cur.startSec;
-        if (duration < 0.05)
-            continue;
-        // Merge with previous if same text
-        if (deduped.length > 0 && deduped[deduped.length - 1].text === cur.text) {
-            deduped[deduped.length - 1].endSec = cur.endSec;
-            deduped[deduped.length - 1].endStr = cur.endStr;
-            continue;
-        }
-        deduped.push({ ...cur });
-    }
-    // ── Step 3: Build CSV ─────────────────────────────────────────
-    const csvRows = ["start_time,end_time,text"];
-    for (const cue of deduped) {
-        csvRows.push(`${cue.startStr},${cue.endStr},${csvEscapeField(cue.text)}`);
-    }
-    return csvRows.join("\n") + "\n";
-}
-function todayDateStr() {
-    const d = new Date();
-    const yyyy = d.getFullYear();
-    const mm = String(d.getMonth() + 1).padStart(2, "0");
-    const dd = String(d.getDate()).padStart(2, "0");
-    return `${yyyy}-${mm}-${dd}`;
-}
-async function downloadSubtitle(videoId, lang, format, options = {}) {
-    const outputDir = options.outputDir ?? PATHS.subtitlesDir;
-    mkdirSync(outputDir, { recursive: true });
-    if (options.targetFile) {
-        mkdirSync(dirname(options.targetFile), { recursive: true });
-    }
-    const outTemplate = join(outputDir, options.outputStem ?? `${todayDateStr()}_${videoId}_${lang}`);
-    // CSV is not a yt-dlp native format — download as VTT then convert
-    const dlFormat = format === "csv" ? "vtt" : format;
-    const result = await runYtDlp([
-        "--skip-download",
-        "-f", "mhtml",
-        "--write-sub",
-        "--write-auto-sub",
-        "--sub-langs",
-        lang,
-        "--sub-format",
-        dlFormat,
-        "--output",
-        outTemplate,
-        options.sourceUrl ?? `https://www.youtube.com/watch?v=${videoId}`,
-    ]);
-    const cookieFailure = result.exitCode !== 0 ? classifyYtDlpCookieFailure(result.stderr) : null;
-    if (cookieFailure) {
-        return {
-            ok: false,
-            cookieFailureCode: cookieFailure.code,
-            diagnosticLogPath: result.failureLogPath,
-            error: appendDiagnosticLog(cookieFailure.message, result.failureLogPath),
-        };
-    }
-    if (result.exitCode !== 0) {
-        return {
-            ok: false,
-            diagnosticLogPath: result.failureLogPath,
-            error: appendDiagnosticLog(result.stderr.slice(0, 500) || `yt-dlp exited with ${result.exitCode}`, result.failureLogPath),
-        };
-    }
-    // Find the output file - yt-dlp appends lang and format extension.
-    // For CSV: yt-dlp downloads as VTT first, so only search for VTT (not stale .csv from previous runs).
-    const searchFormat = format === "csv" ? "vtt" : format;
-    const possibleExts = [`${lang}.${searchFormat}`, `${lang}.vtt`, `${lang}.srt`, `${lang}.ttml`, `${lang}.srv3`];
-    let foundFile;
-    for (const ext of possibleExts) {
-        const candidate = `${outTemplate}.${ext}`;
-        if (existsSync(candidate)) {
-            foundFile = candidate;
-            break;
-        }
-    }
-    if (!foundFile) {
-        // Try auto-generated subtitles which may have slightly different naming
-        const dir = outputDir;
-        try {
-            const files = readdirSync(dir);
-            const prefix = options.outputStem ?? `${todayDateStr()}_${videoId}_${lang}`;
-            const match = files.find((f) => f.startsWith(prefix));
-            if (match) {
-                foundFile = join(dir, match);
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    if (!foundFile) {
-        return {
-            ok: false,
-            error: `No subtitle file found for language '${lang}'`,
-        };
-    }
-    // If CSV format requested, convert VTT to CSV (timestamp, text)
-    if (format === "csv") {
-        const vttPath = foundFile;
-        const vttContent = readFileSync(foundFile, "utf8");
-        const csvContent = vttToCsv(vttContent);
-        const csvPath = foundFile.replace(/\.vtt$/, ".csv");
-        writeFileSync(csvPath, csvContent, "utf8");
-        foundFile = csvPath;
-        if (vttPath !== csvPath) {
-            try {
-                unlinkSync(vttPath);
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    if (options.targetFile && foundFile !== options.targetFile) {
-        renameSync(foundFile, options.targetFile);
-        foundFile = options.targetFile;
-    }
-    const stat = statSync(foundFile);
-    if (stat.size <= 100 * 1024) {
-        const text = readFileSync(foundFile, "utf8");
-        return { ok: true, text, filePath: foundFile };
-    }
-    return { ok: true, filePath: foundFile };
-}
-export async function downloadSubtitlesForLanguages(input) {
-    const cookieCheck = await ensureSubtitleCookiesReady();
-    if (!cookieCheck.ok) {
-        throw new Error(cookieCheck.jobMessage);
-    }
-    const filesByFormat = {};
-    const total = input.formats.length * input.languages.length;
-    let completed = 0;
-    for (const format of input.formats) {
-        filesByFormat[format] = [];
-        for (const lang of input.languages) {
-            const targetFile = join(input.subtitlesDir, `${lang}.${format}`);
-            let result = await downloadSubtitle(input.videoId, lang, format, {
-                sourceUrl: input.sourceUrl,
-                outputDir: input.subtitlesDir,
-                outputStem: `${lang}`,
-                targetFile,
-            });
-            if (result.cookieFailureCode && result.cookieFailureCode !== "RATE_LIMITED") {
-                const refreshed = await tryRefreshSubtitleCookies();
-                if (refreshed) {
-                    result = await downloadSubtitle(input.videoId, lang, format, {
-                        sourceUrl: input.sourceUrl,
-                        outputDir: input.subtitlesDir,
-                        outputStem: `${lang}`,
-                        targetFile,
-                    });
-                }
-            }
-            if (!result.ok || !result.filePath) {
-                if (isCookieFailureText(result.error)) {
-                    throw new Error(COOKIE_JOB_MESSAGE);
-                }
-                if (input.skipMissingLanguages && isUnavailableSubtitleError(result.error)) {
-                    completed += 1;
-                    input.onProgress?.(completed, total);
-                    continue;
-                }
-                throw new Error(result.error ?? `Failed to download ${format} subtitle for ${lang}`);
-            }
-            filesByFormat[format].push(result.filePath);
-            completed += 1;
-            input.onProgress?.(completed, total);
-        }
-    }
-    const hasAnySubtitleFiles = Object.values(filesByFormat).some((files) => files.length > 0);
-    if (!hasAnySubtitleFiles) {
-        throw new Error(`No subtitles found for requested languages: ${input.languages.join(", ")}`);
-    }
-    return filesByFormat;
-}
-function isUnavailableSubtitleError(error) {
-    if (!error) {
-        return false;
-    }
-    const normalized = error.toLowerCase();
-    return (normalized.includes("no subtitle file found") ||
-        normalized.includes("no subtitles") ||
-        normalized.includes("subtitle is not available") ||
-        normalized.includes("requested subtitles are not available"));
-}
+export { vttToCsv, downloadSubtitlesForLanguages, toReadableSubtitleJobError };
 export function registerSubtitleTools(server, config, tokenManager) {
-    /**
-     * Auth guard — every tool call must pass authentication.
-     * Both OAuth (JWT) and PAT modes are supported.
-     * Returns error message if not authenticated.
-     */
     async function requireAuth() {
         const token = await tokenManager.getValidToken();
         if (!token)
             return AUTH_REQUIRED_MSG;
         return null;
     }
-    // ── get_subtitles ──
     server.registerTool("get_subtitles", {
         description: "Download subtitles for a YouTube video. Accepts video ID or any YouTube URL (watch, shorts, youtu.be). Each language is fetched separately. Supports CSV output (timestamp + text columns). If languages is omitted, defaults to English + Simplified Chinese (unavailable languages are silently skipped).",
         inputSchema: {
@@ -447,7 +73,6 @@ export function registerSubtitleTools(server, config, tokenManager) {
             if (dl.cookieFailureCode) {
                 const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
-                    // Retry the download with fresh cookies
                     const retry = await downloadSubtitle(videoId, lang, fmt);
                     if (retry.ok) {
                         if (retry.text) {
@@ -458,7 +83,6 @@ export function registerSubtitleTools(server, config, tokenManager) {
                         }
                         continue;
                     }
-                    // Retry also failed with expired cookies — give up
                 }
                 return toolErr(dl.cookieFailureCode, dl.error ??
                     (dl.cookieFailureCode === "COOKIES_EXPIRED"
@@ -470,7 +94,6 @@ export function registerSubtitleTools(server, config, tokenManager) {
                                 : COOKIE_INVALID_MESSAGE));
             }
             if (!dl.ok) {
-                // When using default languages, silently skip unavailable ones
                 if (!usingDefaults) {
                     results.push({
                         language: lang,
@@ -505,7 +128,6 @@ export function registerSubtitleTools(server, config, tokenManager) {
             results,
         });
     });
-    // ── batch_get_subtitles ──
     server.registerTool("batch_get_subtitles", {
         description: "Download subtitles for multiple YouTube videos. Max 10 per batch. Accepts video IDs or URLs (can mix).",
         inputSchema: {
@@ -560,7 +182,6 @@ export function registerSubtitleTools(server, config, tokenManager) {
             if (cookieFailureCode) {
                 const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
-                    // Retry this video's subtitles
                     let retrySuccess = false;
                     for (const lang of langs) {
                         const retry = await downloadSubtitle(videoId, lang, fmt);
@@ -608,7 +229,6 @@ export function registerSubtitleTools(server, config, tokenManager) {
             results,
         });
     });
-    // ── list_available_subtitles ──
     server.registerTool("list_available_subtitles", {
         description: "List available subtitle tracks for a YouTube video. Accepts video ID or URL.",
         inputSchema: {
@@ -664,7 +284,6 @@ export function registerSubtitleTools(server, config, tokenManager) {
             translatable: automatic,
         });
     });
-    // ── validate_cookies ──
     server.registerTool("validate_cookies", {
         description: "Validate current YouTube cookies by testing a subtitle download.",
         inputSchema: {},
@@ -684,7 +303,6 @@ export function registerSubtitleTools(server, config, tokenManager) {
                 error: "cookies.txt does not contain YouTube SID cookies",
             });
         }
-        // Test with a known public video (Rick Astley - Never Gonna Give You Up)
         const result = await runYtDlp([
             "--skip-download",
             "-f", "mhtml",

package/dist/utils/codeBuddy.d.ts

@@ -0,0 +1,8 @@
+export declare function getCodeBuddyConfigPath(homeDir?: string): string;
+export declare function getCodeBuddySkillsDir(homeDir?: string): string;
+export declare function isCodeBuddyInstallLikelyInstalled(configPath?: string): boolean;
+export declare function writeCodeBuddyConfig(serverName: string, launcherCommand: {
+    command: string;
+    args: string[];
+}, configPath?: string): "created" | "updated";
+export declare function removeCodeBuddyConfig(serverName: string, configPath?: string): "removed" | "missing";

package/dist/utils/codeBuddy.js

@@ -0,0 +1,62 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function getCodeBuddyConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".codebuddy", ".mcp.json");
+}
+export function getCodeBuddySkillsDir(homeDir = homedir()) {
+    return join(homeDir, ".codebuddy", "skills");
+}
+function parseConfig(raw) {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+    }
+    throw new Error("CodeBuddy config must be a JSON object");
+}
+export function isCodeBuddyInstallLikelyInstalled(configPath = getCodeBuddyConfigPath()) {
+    return existsSync(configPath) || existsSync(dirname(configPath));
+}
+export function writeCodeBuddyConfig(serverName, launcherCommand, configPath = getCodeBuddyConfigPath()) {
+    const existingText = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const created = existingText === null;
+    const config = existingText ? parseConfig(existingText) : {};
+    const mcpServers = config.mcpServers && typeof config.mcpServers === "object"
+        ? { ...config.mcpServers }
+        : {};
+    mcpServers[serverName] = {
+        command: launcherCommand.command,
+        args: [...launcherCommand.args],
+    };
+    const nextConfig = {
+        ...config,
+        mcpServers,
+    };
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf8");
+    return created ? "created" : "updated";
+}
+export function removeCodeBuddyConfig(serverName, configPath = getCodeBuddyConfigPath()) {
+    if (!existsSync(configPath)) {
+        return "missing";
+    }
+    const config = parseConfig(readFileSync(configPath, "utf8"));
+    if (!config.mcpServers || typeof config.mcpServers !== "object" || !(serverName in config.mcpServers)) {
+        return "missing";
+    }
+    const nextMcpServers = { ...config.mcpServers };
+    delete nextMcpServers[serverName];
+    const nextConfig = { ...config };
+    if (Object.keys(nextMcpServers).length === 0) {
+        delete nextConfig.mcpServers;
+    }
+    else {
+        nextConfig.mcpServers = nextMcpServers;
+    }
+    if (Object.keys(nextConfig).length === 0) {
+        rmSync(configPath, { force: true });
+        return "removed";
+    }
+    writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf8");
+    return "removed";
+}

package/dist/utils/cookieRefresh.js

@@ -13,6 +13,9 @@ import { PATHS, ensureConfigDir } from "./config.js";
 import { detectBrowserChannel, hasYouTubeSession, saveCookiesToDisk, } from "../cli/setupCookies.js";
 import { hasSIDCookies } from "./cookies.js";
 const HEADLESS_TIMEOUT_MS = 30_000;
+function hasInteractiveTerminal() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
 /**
  * Attempt to refresh YouTube cookies through the dedicated two-tier fallback chain.
  *
@@ -26,6 +29,10 @@ export async function tryHeadlessRefresh() {
         if (tier1)
             return true;
     }
+    // Why: MCP stdio calls and tests run without a TTY; opening manual browser login would block until timeout.
+    if (!hasInteractiveTerminal()) {
+        return false;
+    }
     // Tier 2: Open headed browser for manual login
     return tryHeadedManualLogin();
 }

package/dist/utils/launcher.d.ts

@@ -1,12 +1,7 @@
-export interface LauncherSourceOptions {
-    packageSpec?: string;
-    npmCacheDir?: string;
-}
-export interface LauncherCommand {
-    command: string;
-    args: string[];
-}
+import { isRepairableNpxFailure } from "@mkterswingman/5mghost-shared-client/launcher";
+import type { LauncherCommand, LauncherSourceOptions } from "@mkterswingman/5mghost-shared-client/launcher";
+export type { LauncherCommand, LauncherSourceOptions };
+export { isRepairableNpxFailure };
 export declare function buildLauncherCommand(launcherPath?: string): LauncherCommand;
-export declare function isRepairableNpxFailure(stderr: string): boolean;
-export declare function buildLauncherSource(options?: LauncherSourceOptions): string;
-export declare function writeLauncherFile(options?: LauncherSourceOptions): string;
+export declare function buildLauncherSource(options?: Partial<LauncherSourceOptions>): string;
+export declare function writeLauncherFile(options?: Partial<LauncherSourceOptions>): string;