@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/init/monorepo.js

@@ -0,0 +1,185 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+async function fileExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJsonFile(path) {
+    try {
+        const raw = await readFile(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function packageHasRnDeps(pkg) {
+    if (!pkg)
+        return { expo: false, rn: false };
+    const dep = pkg.dependencies ?? {};
+    const dev = pkg.devDependencies ?? {};
+    const all = { ...dep, ...dev };
+    return {
+        expo: Boolean(all["expo"] || all["expo-router"]),
+        rn: Boolean(all["react-native"]),
+    };
+}
+async function readPnpmWorkspaceGlobs(projectDir) {
+    const file = join(projectDir, "pnpm-workspace.yaml");
+    let raw;
+    try {
+        raw = await readFile(file, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const globs = [];
+    let inPackages = false;
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.replace(/#.*$/, "").trimEnd();
+        if (trimmed.length === 0)
+            continue;
+        if (/^packages\s*:\s*$/.test(trimmed)) {
+            inPackages = true;
+            continue;
+        }
+        if (!line.startsWith(" ") && !line.startsWith("-") && trimmed.endsWith(":")) {
+            inPackages = false;
+            continue;
+        }
+        if (!inPackages)
+            continue;
+        const m = trimmed.match(/^\s*-\s*['"]?([^'"]+?)['"]?\s*$/);
+        if (m && m[1])
+            globs.push(m[1]);
+    }
+    return globs;
+}
+async function expandGlob(projectDir, pattern) {
+    const cleaned = pattern.replace(/^\.\//, "").replace(/\/+$/, "");
+    if (cleaned.length === 0)
+        return [];
+    if (!cleaned.includes("*")) {
+        const abs = join(projectDir, cleaned);
+        const ok = await fileExists(abs);
+        return ok ? [abs] : [];
+    }
+    const m = cleaned.match(/^([^*]+)\/\*$/);
+    if (!m || !m[1])
+        return [];
+    const parentRel = m[1].replace(/\/+$/, "");
+    const parentAbs = join(projectDir, parentRel);
+    let entries;
+    try {
+        entries = await readdir(parentAbs, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith("."))
+            continue;
+        out.push(join(parentAbs, entry.name));
+    }
+    return out;
+}
+export async function readWorkspaceGlobs(projectDir) {
+    const globs = new Set();
+    let foundManifest = false;
+    const rootPkg = await readJsonFile(join(projectDir, "package.json"));
+    if (rootPkg?.workspaces) {
+        foundManifest = true;
+        if (Array.isArray(rootPkg.workspaces)) {
+            for (const g of rootPkg.workspaces)
+                globs.add(g);
+        }
+        else if (rootPkg.workspaces &&
+            typeof rootPkg.workspaces === "object" &&
+            Array.isArray(rootPkg.workspaces.packages)) {
+            for (const g of rootPkg.workspaces.packages) {
+                globs.add(g);
+            }
+        }
+    }
+    const pnpmGlobs = await readPnpmWorkspaceGlobs(projectDir);
+    if (pnpmGlobs != null) {
+        foundManifest = true;
+        for (const g of pnpmGlobs)
+            globs.add(g);
+    }
+    const lernaJson = await readJsonFile(join(projectDir, "lerna.json"));
+    if (lernaJson) {
+        const lernaPkgs = lernaJson.packages;
+        if (Array.isArray(lernaPkgs)) {
+            foundManifest = true;
+            for (const g of lernaPkgs) {
+                if (typeof g === "string")
+                    globs.add(g);
+            }
+        }
+        else if (await fileExists(join(projectDir, "lerna.json"))) {
+            foundManifest = true;
+        }
+    }
+    if (!foundManifest)
+        return null;
+    return Array.from(globs);
+}
+export async function detectMonorepoSubpackages(projectDir) {
+    const cwdPkg = await readJsonFile(join(projectDir, "package.json"));
+    const cwdHas = packageHasRnDeps(cwdPkg);
+    if (cwdHas.expo || cwdHas.rn) {
+        return {
+            kind: "none",
+            matches: [],
+            rootIsRnApp: true,
+            isMonorepo: (await readWorkspaceGlobs(projectDir)) != null,
+        };
+    }
+    const globs = await readWorkspaceGlobs(projectDir);
+    if (globs == null) {
+        return { kind: "none", matches: [], rootIsRnApp: false, isMonorepo: false };
+    }
+    const candidates = new Set();
+    for (const pattern of globs) {
+        for (const dir of await expandGlob(projectDir, pattern)) {
+            candidates.add(dir);
+        }
+    }
+    const matches = [];
+    for (const absPath of candidates) {
+        const pkgPath = join(absPath, "package.json");
+        const pkg = await readJsonFile(pkgPath);
+        const has = packageHasRnDeps(pkg);
+        const hasAppJson = await fileExists(join(absPath, "app.json"));
+        const signals = [];
+        if (has.expo)
+            signals.push("expo");
+        if (has.rn)
+            signals.push("react-native");
+        if (hasAppJson)
+            signals.push("app.json");
+        if (signals.length === 0)
+            continue;
+        const rel = relative(projectDir, absPath).split(sep).join("/");
+        matches.push({
+            absPath,
+            relPath: rel.length > 0 ? rel : ".",
+            signals,
+        });
+    }
+    matches.sort((a, b) => (a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0));
+    const kind = matches.length === 0 ? "none" : matches.length === 1 ? "single" : "multi";
+    return { kind, matches, rootIsRnApp: false, isMonorepo: true };
+}

package/dist/init/oauth.d.ts

@@ -0,0 +1,52 @@
+export interface StoredAuth {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt: number;
+    githubUser: {
+        login: string;
+        id: number;
+    };
+    probeSecretHash?: string;
+    storedAt: string;
+}
+export interface DeviceFlowStart {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    expiresIn: number;
+    intervalSeconds: number;
+    startedAt: number;
+}
+export type DeviceFlowPollResult = {
+    kind: "pending";
+} | {
+    kind: "slow_down";
+    intervalSeconds: number;
+} | {
+    kind: "expired";
+} | {
+    kind: "denied";
+} | {
+    kind: "success";
+    accessToken: string;
+};
+export interface OAuthDeps {
+    fetchFn?: typeof fetch;
+    clientId?: string;
+}
+export declare function hashToken(token: string): string;
+export declare function startDeviceFlow(deps?: OAuthDeps): Promise<DeviceFlowStart>;
+export declare function pollDeviceFlow(deviceCode: string, deps?: OAuthDeps): Promise<DeviceFlowPollResult>;
+export declare function finalizeAndPersist(accessToken: string, deps?: OAuthDeps): Promise<StoredAuth>;
+export declare function readExistingAuth(): Promise<StoredAuth | null>;
+export interface PollUntilTokenOptions extends OAuthDeps {
+    nowFn?: () => number;
+    delayFn?: (ms: number) => Promise<void>;
+    onPrompt?: (codes: {
+        verificationUri: string;
+        userCode: string;
+    }) => void;
+    onTick?: (remainingSeconds: number) => void;
+    noBrowser?: boolean;
+}
+export declare function pollUntilToken(opts?: PollUntilTokenOptions): Promise<StoredAuth>;

package/dist/init/oauth.js

@@ -0,0 +1,220 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { platform } from "node:os";
+const DEFAULT_CLIENT_ID = "Ov23lix6jqKVuLz3ydM4";
+const GITHUB_API = "https://github.com";
+const GITHUB_USER_API = "https://api.github.com/user";
+const OAUTH_SCOPES = "read:user read:org repo";
+function getClientId() {
+    return process.env.CERAPH_GITHUB_CLIENT_ID ?? DEFAULT_CLIENT_ID;
+}
+function getAuthFilePath() {
+    return join(homedir(), ".ceraph", "auth.json");
+}
+export function hashToken(token) {
+    return createHash("sha256").update(token, "utf8").digest("hex");
+}
+export async function startDeviceFlow(deps = {}) {
+    const fetchFn = deps.fetchFn ?? fetch;
+    const clientId = deps.clientId ?? getClientId();
+    const res = await fetchFn(`${GITHUB_API}/login/device/code`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/x-www-form-urlencoded",
+            accept: "application/json",
+        },
+        body: `client_id=${encodeURIComponent(clientId)}&scope=${encodeURIComponent(OAUTH_SCOPES)}`,
+    });
+    if (!res.ok) {
+        throw new Error(`GitHub device code request failed: HTTP ${res.status}`);
+    }
+    const body = (await res.json());
+    return {
+        deviceCode: body.device_code,
+        userCode: body.user_code,
+        verificationUri: body.verification_uri,
+        expiresIn: body.expires_in,
+        intervalSeconds: Math.max(1, body.interval),
+        startedAt: Date.now(),
+    };
+}
+export async function pollDeviceFlow(deviceCode, deps = {}) {
+    const fetchFn = deps.fetchFn ?? fetch;
+    const clientId = deps.clientId ?? getClientId();
+    const res = await fetchFn(`${GITHUB_API}/login/oauth/access_token`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/x-www-form-urlencoded",
+            accept: "application/json",
+        },
+        body: `client_id=${encodeURIComponent(clientId)}` +
+            `&device_code=${encodeURIComponent(deviceCode)}` +
+            `&grant_type=urn:ietf:params:oauth:grant-type:device_code`,
+    });
+    const body = (await res.json());
+    if (body.access_token) {
+        return { kind: "success", accessToken: body.access_token };
+    }
+    switch (body.error) {
+        case "authorization_pending":
+            return { kind: "pending" };
+        case "slow_down":
+            return { kind: "slow_down", intervalSeconds: 5 };
+        case "expired_token":
+            return { kind: "expired" };
+        case "access_denied":
+            return { kind: "denied" };
+        default:
+            return { kind: "expired" };
+    }
+}
+export async function finalizeAndPersist(accessToken, deps = {}) {
+    const fetchFn = deps.fetchFn ?? fetch;
+    const res = await fetchFn(GITHUB_USER_API, {
+        headers: {
+            authorization: `Bearer ${accessToken}`,
+            accept: "application/vnd.github+json",
+            "user-agent": "ceraph-react-native-mcp",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`GitHub /user returned HTTP ${res.status}`);
+    }
+    const user = (await res.json());
+    const stored = {
+        accessToken,
+        expiresAt: 0,
+        githubUser: { login: user.login, id: user.id },
+        probeSecretHash: hashToken(accessToken),
+        storedAt: new Date().toISOString(),
+    };
+    await writeAuthFile(stored);
+    return stored;
+}
+async function writeAuthFile(stored) {
+    const filePath = getAuthFilePath();
+    await fs.mkdir(dirname(filePath), { recursive: true });
+    const data = JSON.stringify(stored, null, 2) + "\n";
+    const tmpPath = `${filePath}.tmp.${process.pid}.${Math.random()
+        .toString(36)
+        .slice(2)}`;
+    try {
+        await fs.writeFile(tmpPath, data, { mode: 0o600 });
+        await fs.chmod(tmpPath, 0o600);
+        await fs.rename(tmpPath, filePath);
+    }
+    catch (err) {
+        try {
+            await fs.unlink(tmpPath);
+        }
+        catch {
+        }
+        throw err;
+    }
+    try {
+        await fs.chmod(dirname(filePath), 0o700);
+    }
+    catch {
+    }
+}
+export async function readExistingAuth() {
+    let raw;
+    try {
+        raw = await fs.readFile(getAuthFilePath(), "utf-8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!isValidStoredAuth(parsed))
+        return null;
+    if (parsed.accessToken === "__keychain__")
+        return null;
+    if (parsed.expiresAt !== 0 && Date.now() >= parsed.expiresAt)
+        return null;
+    return parsed;
+}
+function isValidStoredAuth(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    if (typeof v.accessToken !== "string" || v.accessToken.length === 0) {
+        return false;
+    }
+    if (typeof v.expiresAt !== "number")
+        return false;
+    if (!v.githubUser || typeof v.githubUser !== "object")
+        return false;
+    const user = v.githubUser;
+    if (typeof user.login !== "string" || typeof user.id !== "number")
+        return false;
+    if (typeof v.storedAt !== "string")
+        return false;
+    return true;
+}
+export async function pollUntilToken(opts = {}) {
+    const nowFn = opts.nowFn ?? (() => Date.now());
+    const delayFn = opts.delayFn ?? defaultDelay;
+    while (true) {
+        const start = await startDeviceFlow(opts);
+        opts.onPrompt?.({
+            verificationUri: start.verificationUri,
+            userCode: start.userCode,
+        });
+        if (!opts.noBrowser)
+            openBrowser(start.verificationUri);
+        const startedAt = nowFn();
+        const expiresAt = startedAt + start.expiresIn * 1000;
+        let intervalMs = start.intervalSeconds * 1000;
+        let restart = false;
+        while (nowFn() < expiresAt) {
+            const remaining = Math.max(0, Math.round((expiresAt - nowFn()) / 1000));
+            opts.onTick?.(remaining);
+            await delayFn(intervalMs);
+            const result = await pollDeviceFlow(start.deviceCode, opts);
+            if (result.kind === "success") {
+                return await finalizeAndPersist(result.accessToken, opts);
+            }
+            if (result.kind === "pending")
+                continue;
+            if (result.kind === "slow_down") {
+                await delayFn(result.intervalSeconds * 1000);
+                intervalMs = Math.max(intervalMs, result.intervalSeconds * 1000);
+                continue;
+            }
+            if (result.kind === "denied") {
+                throw new Error("GitHub authorization denied");
+            }
+            restart = true;
+            break;
+        }
+        if (!restart) {
+            restart = true;
+        }
+    }
+}
+async function defaultDelay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function openBrowser(url) {
+    try {
+        const p = platform();
+        const cmd = p === "darwin" ? "open" : p === "win32" ? "cmd" : "xdg-open";
+        const args = p === "win32" ? ["/c", "start", "", url] : [url];
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+        child.on("error", () => {
+        });
+        child.unref();
+    }
+    catch {
+    }
+}

package/dist/init/package-manager.d.ts

@@ -0,0 +1,11 @@
+export type PackageManager = "pnpm" | "yarn" | "bun" | "npm";
+export declare const LOCKFILES: ReadonlyArray<{
+    file: string;
+    pm: PackageManager;
+}>;
+export declare function detectPackageManager(projectDir: string): Promise<PackageManager>;
+export declare function installArgv(pm: PackageManager, pkg?: string): {
+    bin: string;
+    args: string[];
+};
+export declare function isPackageInstalled(projectDir: string, pkg?: string): Promise<boolean>;

package/dist/init/package-manager.js

@@ -0,0 +1,60 @@
+import { readFile, access } from "node:fs/promises";
+import { join } from "node:path";
+export const LOCKFILES = [
+    { file: "pnpm-lock.yaml", pm: "pnpm" },
+    { file: "yarn.lock", pm: "yarn" },
+    { file: "bun.lockb", pm: "bun" },
+    { file: "bun.lock", pm: "bun" },
+    { file: "package-lock.json", pm: "npm" },
+];
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectPackageManager(projectDir) {
+    for (const { file, pm } of LOCKFILES) {
+        if (await fileExists(join(projectDir, file))) {
+            return pm;
+        }
+    }
+    return "npm";
+}
+export function installArgv(pm, pkg = "@ceraph/react-native-mcp") {
+    switch (pm) {
+        case "pnpm":
+            return { bin: "pnpm", args: ["add", pkg] };
+        case "yarn":
+            return { bin: "yarn", args: ["add", pkg] };
+        case "bun":
+            return { bin: "bun", args: ["add", pkg] };
+        case "npm":
+            return { bin: "npm", args: ["install", pkg] };
+    }
+}
+export async function isPackageInstalled(projectDir, pkg = "@ceraph/react-native-mcp") {
+    let raw;
+    try {
+        raw = await readFile(join(projectDir, "package.json"), "utf-8");
+    }
+    catch {
+        return false;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return false;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return false;
+    const pj = parsed;
+    const dep = pj.dependencies;
+    const dev = pj.devDependencies;
+    return Boolean(dep?.[pkg] || dev?.[pkg]);
+}

package/dist/init/prompt.d.ts

@@ -0,0 +1,12 @@
+export interface PromptDeps {
+    write?: (msg: string) => void;
+    ask?: (question: string) => Promise<string>;
+    nonInteractive?: boolean;
+}
+export declare function confirm(question: string, options?: {
+    defaultYes?: boolean;
+} & PromptDeps): Promise<boolean>;
+export type ReplaceChoice = "yes" | "no" | "show";
+export declare function chooseReplaceAction(question: string, options?: PromptDeps): Promise<ReplaceChoice>;
+export declare function print(msg: string, deps?: PromptDeps): void;
+export declare function chooseFromList(question: string, options: ReadonlyArray<string>, deps?: PromptDeps): Promise<number | null>;

package/dist/init/prompt.js

@@ -0,0 +1,68 @@
+import { createInterface } from "node:readline";
+function isNonInteractive(deps) {
+    if (deps.nonInteractive !== undefined)
+        return deps.nonInteractive;
+    if (process.env.CERAPH_NON_INTERACTIVE === "1")
+        return true;
+    return !process.stdin.isTTY;
+}
+function defaultAsk(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+export async function confirm(question, options = {}) {
+    const defaultYes = options.defaultYes ?? true;
+    if (isNonInteractive(options))
+        return defaultYes;
+    const ask = options.ask ?? defaultAsk;
+    const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
+    const answer = (await ask(question + suffix)).trim().toLowerCase();
+    if (answer.length === 0)
+        return defaultYes;
+    return answer === "y" || answer === "yes";
+}
+export async function chooseReplaceAction(question, options = {}) {
+    if (isNonInteractive(options))
+        return "yes";
+    const ask = options.ask ?? defaultAsk;
+    const answer = (await ask(question + " [Y/n/show diff] ")).trim().toLowerCase();
+    if (answer.length === 0)
+        return "yes";
+    if (answer.startsWith("s"))
+        return "show";
+    if (answer.startsWith("n"))
+        return "no";
+    return "yes";
+}
+export function print(msg, deps = {}) {
+    const write = deps.write ?? ((m) => process.stdout.write(m));
+    write(msg);
+}
+export async function chooseFromList(question, options, deps = {}) {
+    if (options.length === 0)
+        return null;
+    if (isNonInteractive(deps))
+        return 0;
+    const ask = deps.ask ?? defaultAsk;
+    const lines = [question, ""];
+    options.forEach((opt, i) => {
+        lines.push(`  ${i + 1}. ${opt}`);
+    });
+    lines.push("");
+    const prompt = lines.join("\n") + `Select [1-${options.length}]: `;
+    const answer = (await ask(prompt)).trim();
+    if (answer.length === 0)
+        return 0;
+    const idx = Number.parseInt(answer, 10) - 1;
+    if (Number.isNaN(idx) || idx < 0 || idx >= options.length)
+        return null;
+    return idx;
+}

package/dist/init/shell-profile.d.ts

@@ -0,0 +1,22 @@
+export interface ShellProfileTarget {
+    path: string;
+    shell: "zsh" | "bash";
+}
+export declare function pickShellProfile(deps?: {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+}): ShellProfileTarget;
+export interface WriteSignalHostEnvResult {
+    path: string;
+    shell: "zsh" | "bash";
+    state: "added" | "updated" | "unchanged";
+}
+export interface WriteSignalHostEnvDeps {
+    readFile?: (path: string) => Promise<string>;
+    writeFile?: (path: string, content: string) => Promise<void>;
+    mkdir?: (path: string, opts: {
+        recursive: true;
+    }) => Promise<unknown>;
+    target?: ShellProfileTarget;
+}
+export declare function writeSignalHostEnv(ip: string, deps?: WriteSignalHostEnvDeps): Promise<WriteSignalHostEnvResult>;