@mkterswingman/5mghost-yonder 0.0.37 → 0.0.39

package/dist/utils/launcher.js

@@ -1,90 +1,19 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
 import { PATHS } from "./config.js";
+import { buildLauncherCommand as _buildLauncherCommand, buildLauncherSource as _buildLauncherSource, writeLauncherFile as _writeLauncherFile, isRepairableNpxFailure, } from "@mkterswingman/5mghost-shared-client/launcher";
+export { isRepairableNpxFailure };
 const DEFAULT_PACKAGE_SPEC = "@mkterswingman/5mghost-yonder@latest";
 export function buildLauncherCommand(launcherPath = PATHS.launcherJs) {
-    return {
-        command: "node",
-        args: [launcherPath, "serve"],
-    };
-}
-export function isRepairableNpxFailure(stderr) {
-    const lower = stderr.toLowerCase();
-    const referencesNpxDir = lower.includes("_npx/") || lower.includes("_npx\\");
-    return referencesNpxDir && (lower.includes("enotempty") || lower.includes("rename"));
+    return _buildLauncherCommand(launcherPath);
 }
 export function buildLauncherSource(options = {}) {
-    const packageSpec = options.packageSpec ?? DEFAULT_PACKAGE_SPEC;
-    const npmCacheDir = options.npmCacheDir ?? PATHS.npmCacheDir;
-    return `#!/usr/bin/env node
-import { existsSync, mkdirSync, renameSync } from "node:fs";
-import { join } from "node:path";
-import { spawnSync } from "node:child_process";
-
-const packageSpec = ${JSON.stringify(packageSpec)};
-const npmCacheDir = ${JSON.stringify(npmCacheDir)};
-const args = process.argv.slice(2);
-const targetArgs = args.length > 0 ? args : ["serve"];
-
-function isSkillInstallerMode(subArgs) {
-  return subArgs[0] === "install-skills";
-}
-
-function isRepairableNpxFailure(stderr) {
-  const lower = stderr.toLowerCase();
-  return (lower.includes("_npx/") || lower.includes("_npx\\\\"))
-    && (lower.includes("enotempty") || lower.includes("rename"));
-}
-
-function runNpx(subArgs, captureStdErrOnly = false) {
-  mkdirSync(npmCacheDir, { recursive: true });
-  const npxBin = process.platform === "win32" ? "npx.cmd" : "npx";
-  return spawnSync(npxBin, ["--yes", packageSpec, ...subArgs], {
-    env: { ...process.env, npm_config_cache: npmCacheDir },
-    // Why: probe runs before MCP starts; stdout must stay silent or it will corrupt stdio transport.
-    // The skill installer is an explicit one-shot CLI path, so it can inherit stdio safely.
-    stdio: captureStdErrOnly ? ["ignore", "ignore", "pipe"] : "inherit",
-  });
-}
-
-function rotateNpxDir() {
-  const npxDir = join(npmCacheDir, "_npx");
-  if (!existsSync(npxDir)) return false;
-  const backup = \`\${npxDir}.bad.\${new Date().toISOString().replace(/[^0-9]/g, "").slice(0, 14)}\`;
-  renameSync(npxDir, backup);
-  process.stderr.write(\`[yt-mcp launcher] repaired corrupted npx cache: \${backup}\\n\`);
-  return true;
-}
-
-function ensurePackageReady() {
-  const first = runNpx(["version"], true);
-  if ((first.status ?? 1) === 0) return;
-
-  const stderr = first.stderr ? String(first.stderr) : "";
-  if (!isRepairableNpxFailure(stderr) || !rotateNpxDir()) {
-    if (stderr) process.stderr.write(stderr);
-    process.exit(first.status ?? 1);
-  }
-
-  const second = runNpx(["version"], true);
-  const secondStderr = second.stderr ? String(second.stderr) : "";
-  if ((second.status ?? 1) !== 0) {
-    if (secondStderr) process.stderr.write(secondStderr);
-    process.exit(second.status ?? 1);
-  }
-}
-
-ensurePackageReady();
-if (isSkillInstallerMode(targetArgs)) {
-  process.env.YT_MCP_INSTALL_SKILLS = "1";
-}
-const finalRun = runNpx(targetArgs, false);
-process.exit(finalRun.status ?? 0);
-`;
+    return _buildLauncherSource({
+        packageSpec: options.packageSpec ?? DEFAULT_PACKAGE_SPEC,
+        npmCacheDir: options.npmCacheDir ?? PATHS.npmCacheDir,
+    });
 }
 export function writeLauncherFile(options = {}) {
-    mkdirSync(dirname(PATHS.launcherJs), { recursive: true });
-    const source = buildLauncherSource(options);
-    writeFileSync(PATHS.launcherJs, source, { encoding: "utf8", mode: 0o755 });
-    return PATHS.launcherJs;
+    return _writeLauncherFile({
+        packageSpec: options.packageSpec ?? DEFAULT_PACKAGE_SPEC,
+        npmCacheDir: options.npmCacheDir ?? PATHS.npmCacheDir,
+    }, PATHS.launcherJs);
 }

package/dist/utils/workBuddy.d.ts

@@ -0,0 +1,8 @@
+export declare function getWorkBuddyConfigPath(homeDir?: string): string;
+export declare function getWorkBuddySkillsDir(homeDir?: string): string;
+export declare function isWorkBuddyInstallLikelyInstalled(configPath?: string): boolean;
+export declare function writeWorkBuddyConfig(serverName: string, launcherCommand: {
+    command: string;
+    args: string[];
+}, configPath?: string): "created" | "updated";
+export declare function removeWorkBuddyConfig(serverName: string, configPath?: string): "removed" | "missing";

package/dist/utils/workBuddy.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 getWorkBuddyConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".workbuddy", "mcp.json");
+}
+export function getWorkBuddySkillsDir(homeDir = homedir()) {
+    return join(homeDir, ".workbuddy", "skills");
+}
+function parseConfig(raw) {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+    }
+    throw new Error("WorkBuddy config must be a JSON object");
+}
+export function isWorkBuddyInstallLikelyInstalled(configPath = getWorkBuddyConfigPath()) {
+    return existsSync(configPath) || existsSync(dirname(configPath));
+}
+export function writeWorkBuddyConfig(serverName, launcherCommand, configPath = getWorkBuddyConfigPath()) {
+    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 removeWorkBuddyConfig(serverName, configPath = getWorkBuddyConfigPath()) {
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mkterswingman/5mghost-yonder",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "description": "Internal MCP client with local data tools and remote API proxy",
   "type": "module",
   "bin": {
@@ -12,11 +12,16 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "npm run build && node --test tests/*.test.mjs",
+    "test:unit": "npm test",
+    "test:tool": "npm run build && node --test tests/smoke.test.mjs tests/subtitleTools.test.mjs tests/downloadTools.test.mjs",
+    "test:smoke": "npm run build && node dist/cli/index.js --help && node dist/cli/index.js doctor",
+    "test:clean-install": "npm run build && node scripts/clean-install-smoke.mjs",
     "prepublishOnly": "npm run build",
     "dev": "tsx src/cli/index.ts",
     "start": "node dist/cli/index.js"
   },
   "dependencies": {
+    "@mkterswingman/5mghost-shared-client": "^0.0.2",
     "@modelcontextprotocol/sdk": "^1.28.0",
     "playwright": "^1.58.0",
     "zod": "^4.3.6"

package/dist/auth/oauthFlow.d.ts

@@ -1,9 +0,0 @@
-export interface OAuthFlowOptions {
-    timeoutMs?: number;
-}
-export declare function runOAuthFlow(authUrl: string, options?: OAuthFlowOptions): Promise<{
-    accessToken: string;
-    refreshToken: string;
-    expiresIn: number;
-    clientId: string;
-}>;

package/dist/auth/oauthFlow.js

@@ -1,151 +0,0 @@
-import { createServer } from "node:http";
-import { randomBytes, createHash } from "node:crypto";
-import { URL } from "node:url";
-import { buildBrowserOpenCommand } from "../utils/browserLaunch.js";
-function base64url(buf) {
-    return buf
-        .toString("base64")
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=+$/, "");
-}
-export async function runOAuthFlow(authUrl, options = {}) {
-    // 1. Generate PKCE + state
-    const codeVerifier = base64url(randomBytes(32));
-    const codeChallenge = base64url(createHash("sha256").update(codeVerifier).digest());
-    const state = base64url(randomBytes(32));
-    // 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 timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
-        const timeout = setTimeout(() => {
-            httpServer.close();
-            reject(new Error(`OAuth flow timed out after ${Math.round(timeoutMs / 1000)}s`));
-        }, timeoutMs);
-        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");
-                const returnedState = url.searchParams.get("state");
-                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;
-                }
-                // Verify state to prevent CSRF
-                if (returnedState !== state) {
-                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-                    res.end("<h1>Authorization failed</h1><p>State mismatch — possible CSRF attack.</p>");
-                    cleanup();
-                    reject(new Error("OAuth state mismatch"));
-                    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&state=${encodeURIComponent(state)}`;
-        console.log("\n\x1b[1mOpen this URL in your browser to authorize:\x1b[0m");
-        console.log(`\n  ${authorizeUrl}\n`);
-        import("node:child_process").then(({ execFile }) => {
-            const command = buildBrowserOpenCommand(authorizeUrl);
-            execFile(command.file, command.args);
-        }).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/sharedAuth.d.ts

@@ -1,10 +0,0 @@
-export interface SharedAuthData {
-    type: "jwt" | "pat";
-    access_token?: string;
-    refresh_token?: string;
-    expires_at?: number;
-    client_id?: string;
-    pat?: string;
-}
-export declare function readSharedAuth(authPath: string): SharedAuthData | null;
-export declare function writeSharedAuth(authPath: string, data: SharedAuthData): void;

package/dist/auth/sharedAuth.js

@@ -1,31 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-export function readSharedAuth(authPath) {
-    if (!existsSync(authPath))
-        return null;
-    try {
-        return JSON.parse(readFileSync(authPath, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-export function writeSharedAuth(authPath, data) {
-    const authDir = dirname(authPath);
-    mkdirSync(authDir, { recursive: true });
-    try {
-        chmodSync(authDir, 0o700);
-    }
-    catch {
-        // Why: best-effort hardening; Windows may ignore POSIX-style directory modes.
-    }
-    const tempPath = `${authPath}.tmp`;
-    writeFileSync(tempPath, JSON.stringify(data, null, 2), { encoding: "utf8", mode: 0o600 });
-    renameSync(tempPath, authPath);
-    try {
-        chmodSync(authPath, 0o600);
-    }
-    catch {
-        // Why: chmod is best-effort on Windows and should not block auth persistence.
-    }
-}

package/dist/auth/tokenManager.d.ts

@@ -1,18 +0,0 @@
-interface TokenManagerOptions {
-    authPath?: string;
-    env?: NodeJS.ProcessEnv;
-    fetchImpl?: typeof fetch;
-}
-export declare class TokenManager {
-    private authUrl;
-    private authPath;
-    private env;
-    private fetchImpl;
-    constructor(authUrl: string, options?: TokenManagerOptions);
-    getValidToken(): Promise<string | null>;
-    saveTokens(accessToken: string, refreshToken: string, expiresIn: number, clientId?: string): Promise<void>;
-    savePAT(pat: string): Promise<void>;
-    private readAuth;
-    private refreshTokens;
-}
-export {};

package/dist/auth/tokenManager.js

@@ -1,92 +0,0 @@
-import { PATHS } from "../utils/config.js";
-import { readSharedAuth, writeSharedAuth } from "./sharedAuth.js";
-export class TokenManager {
-    authUrl;
-    authPath;
-    env;
-    fetchImpl;
-    constructor(authUrl, options = {}) {
-        this.authUrl = authUrl;
-        this.authPath = options.authPath ?? PATHS.sharedAuthJson;
-        this.env = options.env ?? process.env;
-        this.fetchImpl = options.fetchImpl ?? fetch;
-    }
-    async getValidToken() {
-        // Check env var PAT first
-        const envPat = this.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) {
-        const data = {
-            type: "jwt",
-            access_token: accessToken,
-            refresh_token: refreshToken,
-            expires_at: Date.now() + expiresIn * 1000,
-            client_id: clientId,
-        };
-        writeSharedAuth(this.authPath, data);
-    }
-    async savePAT(pat) {
-        const data = {
-            type: "pat",
-            pat,
-        };
-        writeSharedAuth(this.authPath, data);
-    }
-    readAuth() {
-        return readSharedAuth(this.authPath);
-    }
-    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 this.fetchImpl(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/utils/codexInternal.d.ts

@@ -1,9 +0,0 @@
-import type { LauncherCommand } from "./launcher.js";
-export declare function getCodexInternalConfigPath(homeDir?: string): string;
-export declare function upsertCodexInternalConfigText(currentText: string | null, serverName: string, launcherCommand: LauncherCommand): string;
-export declare function removeCodexInternalConfigEntryText(currentText: string | null, serverName: string): {
-    changed: boolean;
-    nextText: string | null;
-};
-export declare function writeCodexInternalConfig(serverName: string, launcherCommand: LauncherCommand, configPath?: string): "created" | "updated";
-export declare function removeCodexInternalConfig(serverName: string, configPath?: string): "removed" | "missing";

package/dist/utils/codexInternal.js

@@ -1,60 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-export function getCodexInternalConfigPath(homeDir = homedir()) {
-    return join(homeDir, ".codex-internal", "config.toml");
-}
-function formatCodexInternalSection(serverName, launcherCommand) {
-    const escapedName = serverName.replace(/"/g, '\\"');
-    const args = launcherCommand.args.map((arg) => JSON.stringify(arg)).join(", ");
-    return `[mcp_servers.${JSON.stringify(escapedName)}]
-command = ${JSON.stringify(launcherCommand.command)}
-args = [${args}]
-`;
-}
-export function upsertCodexInternalConfigText(currentText, serverName, launcherCommand) {
-    const section = formatCodexInternalSection(serverName, launcherCommand).trimEnd();
-    const sectionPattern = new RegExp(String.raw `(?:^|\n)\[mcp_servers\.${JSON.stringify(serverName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n(?:.+\n?)*?(?=\n\[|$)`, "m");
-    if (!currentText || currentText.trim() === "") {
-        return `${section}\n`;
-    }
-    if (sectionPattern.test(currentText)) {
-        return `${currentText.replace(sectionPattern, `\n${section}\n`).trim()}\n`;
-    }
-    return `${currentText.trimEnd()}\n\n${section}\n`;
-}
-export function removeCodexInternalConfigEntryText(currentText, serverName) {
-    if (!currentText) {
-        return { changed: false, nextText: null };
-    }
-    const sectionPattern = new RegExp(String.raw `(?:^|\n)\[mcp_servers\.${JSON.stringify(serverName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n(?:.+\n?)*?(?=\n\[|$)`, "m");
-    if (!sectionPattern.test(currentText)) {
-        return { changed: false, nextText: currentText };
-    }
-    const nextText = currentText.replace(sectionPattern, "\n").replace(/\n{3,}/g, "\n\n").trim();
-    return {
-        changed: true,
-        nextText: nextText ? `${nextText}\n` : null,
-    };
-}
-export function writeCodexInternalConfig(serverName, launcherCommand, configPath = getCodexInternalConfigPath()) {
-    const existingText = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
-    const created = existingText === null;
-    const nextText = upsertCodexInternalConfigText(existingText, serverName, launcherCommand);
-    mkdirSync(dirname(configPath), { recursive: true });
-    writeFileSync(configPath, nextText, "utf8");
-    return created ? "created" : "updated";
-}
-export function removeCodexInternalConfig(serverName, configPath = getCodexInternalConfigPath()) {
-    const existingText = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
-    const result = removeCodexInternalConfigEntryText(existingText, serverName);
-    if (!result.changed) {
-        return "missing";
-    }
-    if (!result.nextText) {
-        rmSync(configPath, { force: true });
-        return "removed";
-    }
-    writeFileSync(configPath, result.nextText, "utf8");
-    return "removed";
-}

package/dist/utils/mcpRegistration.d.ts

@@ -1,7 +0,0 @@
-export declare const MCP_REGISTER_TIMEOUT_MS = 5000;
-export type RegistrationFailureKind = "already_exists" | "authentication" | "timeout" | "other";
-export interface RegistrationFailure {
-    kind: RegistrationFailureKind;
-    output: string;
-}
-export declare function classifyRegistrationFailure(err: unknown): RegistrationFailure;

package/dist/utils/mcpRegistration.js

@@ -1,23 +0,0 @@
-export const MCP_REGISTER_TIMEOUT_MS = 5000;
-function readOutput(err) {
-    if (!(err instanceof Error))
-        return "";
-    const stderr = "stderr" in err ? String(err.stderr ?? "") : "";
-    const stdout = "stdout" in err ? String(err.stdout ?? "") : "";
-    return `${stderr}${stdout}`;
-}
-export function classifyRegistrationFailure(err) {
-    const output = readOutput(err);
-    const lower = output.toLowerCase();
-    if (lower.includes("already exists")) {
-        return { kind: "already_exists", output };
-    }
-    if (lower.includes("waiting for authentication")) {
-        return { kind: "authentication", output };
-    }
-    if (err instanceof Error &&
-        ("code" in err && err.code === "ETIMEDOUT")) {
-        return { kind: "timeout", output };
-    }
-    return { kind: "other", output };
-}

package/dist/utils/openClaw.d.ts

@@ -1,18 +0,0 @@
-import type { LauncherCommand } from "./launcher.js";
-export interface OpenClawServerConfig {
-    transport: "stdio";
-    command: string;
-    args: string[];
-    env?: Record<string, string>;
-}
-export declare function getOpenClawConfigPath(homeDir?: string): string;
-export declare function getOpenClawSkillsDir(homeDir?: string): string;
-export declare function buildOpenClawServerConfig(launcherCommand: LauncherCommand): OpenClawServerConfig;
-export declare function upsertOpenClawConfigText(currentText: string | null, serverName: string, launcherCommand: LauncherCommand): string;
-export declare function removeOpenClawConfigEntryText(currentText: string | null, serverName: string): {
-    changed: boolean;
-    nextText: string | null;
-};
-export declare function isOpenClawInstallLikelyInstalled(detectBinary: (name: string) => boolean, configPath?: string): boolean;
-export declare function writeOpenClawConfig(serverName: string, launcherCommand: LauncherCommand, configPath?: string): "created" | "updated";
-export declare function removeOpenClawConfig(serverName: string, configPath?: string): "removed" | "missing";