ubriot 1.0.0 → 1.1.0

package/dist/api.js

@@ -7,14 +7,17 @@ exports.makeClient = makeClient;
 exports.handleError = handleError;
 const axios_1 = __importDefault(require("axios"));
 const config_1 = require("./config");
+function normalizeApiBase(apiBase) {
+    return apiBase.replace(/\/+$/, "");
+}
 async function refreshAccessToken() {
     const cfg = (0, config_1.readConfig)();
     if (!cfg.refreshToken)
         return null;
     try {
-        const { data } = await axios_1.default.post(`${cfg.apiBase}/auth/refresh`, {
+        const { data } = await axios_1.default.post(`${normalizeApiBase(cfg.apiBase)}/auth/refresh`, {
             refreshToken: cfg.refreshToken,
-        });
+        }, { timeout: 120000 });
         const token = data?.user?.token;
         if (!token)
             return null;
@@ -28,7 +31,7 @@ async function refreshAccessToken() {
 function makeClient() {
     const cfg = (0, config_1.readConfig)();
     const client = axios_1.default.create({
-        baseURL: cfg.apiBase,
+        baseURL: normalizeApiBase(cfg.apiBase),
         headers: cfg.token ? { Authorization: `Bearer ${cfg.token}` } : {},
         timeout: 120000,
     });

package/dist/index.js

@@ -38,11 +38,12 @@ const commander_1 = require("commander");
 const readline_1 = require("./readline");
 const config_1 = require("./config");
 const api_1 = require("./api");
+const migrate_1 = require("./migrate");
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const crypto_1 = require("crypto");
-commander_1.program.name("ubriot").description("Ubriot, self-hosted Expo release infrastructure").version("0.1.0");
+commander_1.program.name("ubriot").description("Ubriot, self-hosted Expo release infrastructure").version("1.1.0");
 const MIME = {
     ".avif": "image/avif",
     ".bundle": "application/javascript",
@@ -1872,4 +1873,42 @@ updates
         (0, api_1.handleError)(err);
     }
 });
+// ─── Migrate ─────────────────────────────────────────────────────────────────
+const migrate = commander_1.program.command("migrate").description("Migrate onto Ubriot from other services");
+migrate
+    .command("codepush")
+    .description("Migrate a React Native app from App Center CodePush to Ubriot OTA")
+    .option("--project-dir <dir>", "App directory to scan", ".")
+    .option("--expo-config <path>", "Path to app.json", "app.json")
+    .option("--app <slug>", "Ubriot app slug for the update URL; defaults to expo.slug from app.json")
+    .option("--channel <channel>", "OTA channel", "production")
+    .option("--runtime-version <version>", "Runtime version to write into app.json")
+    .option("--apply", "Apply the changes (default is a dry run)", false)
+    .option("--yes", "Skip the clean-git-tree safety check", false)
+    .action((opts) => {
+    try {
+        const plan = (0, migrate_1.planCodePushMigration)({
+            projectDir: opts.projectDir,
+            expoConfigPath: opts.expoConfig,
+            app: opts.app,
+        });
+        (0, migrate_1.renderPlan)(plan);
+        if (!plan.found)
+            return;
+        if (!opts.apply) {
+            console.log("\nDry run. Re-run with --apply to make these changes.");
+            return;
+        }
+        (0, migrate_1.applyCodePushMigration)({
+            plan,
+            apiBase: (0, config_1.readConfig)().apiBase,
+            channel: opts.channel,
+            runtimeVersion: opts.runtimeVersion,
+            requireCleanGit: !opts.yes,
+        });
+    }
+    catch (err) {
+        (0, api_1.handleError)(err);
+    }
+});
 commander_1.program.parse(process.argv);

package/dist/migrate.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCodePushMigration = planCodePushMigration;
+exports.renderPlan = renderPlan;
+exports.applyCodePushMigration = applyCodePushMigration;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "Pods", ".expo", ".next", "coverage"]);
+const SOURCE_EXT = new Set([".js", ".jsx", ".ts", ".tsx"]);
+const CODE_PUSH_PKG = "react-native-code-push";
+function walk(dir, out, depth = 0) {
+    if (depth > 8)
+        return;
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (SKIP_DIRS.has(name))
+            continue;
+        const full = (0, path_1.join)(dir, name);
+        let st;
+        try {
+            st = (0, fs_1.statSync)(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory())
+            walk(full, out, depth + 1);
+        else
+            out.push(full);
+    }
+}
+function readJson(path) {
+    return JSON.parse((0, fs_1.readFileSync)(path, "utf8"));
+}
+function expoBlock(json) {
+    return json.expo ?? json;
+}
+function planCodePushMigration(input) {
+    const projectDir = (0, path_1.resolve)(input.projectDir);
+    const appJsonPath = (0, path_1.resolve)(projectDir, input.expoConfigPath);
+    const findings = [];
+    const warnings = [];
+    const sourceFiles = [];
+    const iosKeyFiles = [];
+    const androidKeyFiles = [];
+    let slug = input.app;
+    let runtimeVersion;
+    if ((0, fs_1.existsSync)(appJsonPath)) {
+        try {
+            const expo = expoBlock(readJson(appJsonPath));
+            slug = slug ?? expo.slug;
+            if (typeof expo.runtimeVersion === "string")
+                runtimeVersion = expo.runtimeVersion;
+        }
+        catch {
+            warnings.push(`Could not parse ${(0, path_1.relative)(projectDir, appJsonPath)} as JSON.`);
+        }
+    }
+    else {
+        warnings.push(`No app.json found at ${(0, path_1.relative)(projectDir, appJsonPath)}. Ubriot OTA needs an Expo config; create one before applying.`);
+    }
+    let packageJsonPath;
+    const pkgPath = (0, path_1.join)(projectDir, "package.json");
+    if ((0, fs_1.existsSync)(pkgPath)) {
+        try {
+            const pkg = readJson(pkgPath);
+            const inDeps = pkg.dependencies?.[CODE_PUSH_PKG];
+            const inDev = pkg.devDependencies?.[CODE_PUSH_PKG];
+            if (inDeps || inDev) {
+                packageJsonPath = pkgPath;
+                findings.push({ file: (0, path_1.relative)(projectDir, pkgPath), kind: "package", detail: `${CODE_PUSH_PKG}@${inDeps ?? inDev}` });
+            }
+        }
+        catch {
+            warnings.push("Could not parse package.json.");
+        }
+    }
+    const all = [];
+    walk(projectDir, all);
+    for (const file of all) {
+        const ext = (0, path_1.extname)(file);
+        const name = (0, path_1.basename)(file);
+        const rel = (0, path_1.relative)(projectDir, file);
+        let content = "";
+        try {
+            content = (0, fs_1.readFileSync)(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (SOURCE_EXT.has(ext)) {
+            const hasImport = content.includes(CODE_PUSH_PKG);
+            const hasWrapper = /(^|[^.\w])codePush\s*\(/.test(content) || /@codePush\b/.test(content);
+            if (hasImport)
+                findings.push({ file: rel, kind: "source-import", detail: `imports ${CODE_PUSH_PKG}` });
+            if (hasWrapper) {
+                findings.push({ file: rel, kind: "source-wrapper", detail: "uses codePush() wrapper or decorator" });
+                sourceFiles.push(file);
+            }
+            else if (hasImport) {
+                sourceFiles.push(file);
+            }
+            continue;
+        }
+        if (name === "Info.plist" && content.includes("CodePushDeploymentKey")) {
+            iosKeyFiles.push(file);
+            findings.push({ file: rel, kind: "ios-key", detail: "CodePushDeploymentKey in Info.plist" });
+        }
+        if (name === "strings.xml" && content.includes("CodePushDeploymentKey")) {
+            androidKeyFiles.push(file);
+            findings.push({ file: rel, kind: "android-key", detail: "CodePushDeploymentKey in strings.xml" });
+        }
+        if ((name.startsWith("AppDelegate") || name.startsWith("MainApplication")) && content.includes("CodePush")) {
+            findings.push({ file: rel, kind: "native-bundle", detail: `${name} references CodePush for the JS bundle URL` });
+        }
+    }
+    return {
+        found: findings.length > 0,
+        projectDir,
+        appJsonPath,
+        slug,
+        runtimeVersion,
+        packageJsonPath,
+        sourceFiles: [...new Set(sourceFiles)],
+        iosKeyFiles,
+        androidKeyFiles,
+        findings,
+        warnings,
+    };
+}
+function renderPlan(plan) {
+    if (!plan.found) {
+        console.log("No react-native-code-push usage found. Nothing to migrate.");
+        for (const w of plan.warnings)
+            console.log(`  note: ${w}`);
+        return;
+    }
+    console.log(`Found ${plan.findings.length} CodePush reference(s) in ${plan.projectDir}:\n`);
+    for (const f of plan.findings) {
+        console.log(`  [${f.kind}] ${f.file}  ${f.detail}`);
+    }
+    console.log("\nPlan on --apply:");
+    console.log(`  1. Back up every edited file to <file>.codepush.bak`);
+    if (plan.packageJsonPath)
+        console.log(`  2. Remove ${CODE_PUSH_PKG} from package.json`);
+    console.log(`  3. Write expo.updates (url, channel, runtimeVersion) into ${(0, path_1.relative)(plan.projectDir, plan.appJsonPath)}`);
+    if (plan.sourceFiles.length)
+        console.log(`  4. Remove CodePush imports and unwrap codePush() in ${plan.sourceFiles.length} source file(s), best-effort`);
+    if (plan.iosKeyFiles.length || plan.androidKeyFiles.length)
+        console.log(`  5. Strip CodePushDeploymentKey from ${plan.iosKeyFiles.length + plan.androidKeyFiles.length} native file(s)`);
+    if (plan.warnings.length) {
+        console.log("\nWarnings:");
+        for (const w of plan.warnings)
+            console.log(`  ! ${w}`);
+    }
+}
+function backup(file) {
+    const bak = `${file}.codepush.bak`;
+    if (!(0, fs_1.existsSync)(bak))
+        (0, fs_1.copyFileSync)(file, bak);
+}
+function unwrapCodePush(content) {
+    let next = content;
+    next = next.replace(/^.*(?:from|require\s*\()\s*["']react-native-code-push["'].*$\r?\n?/gm, "");
+    next = next.replace(/@codePush\s*\([^)]*\)\s*/g, "");
+    next = next.replace(/codePush\s*\([^()]*\)\s*\(\s*([A-Za-z0-9_$]+)\s*\)/g, "$1");
+    next = next.replace(/codePush\s*\(\s*([A-Za-z0-9_$]+)\s*\)/g, "$1");
+    const residual = /code[Pp]ush\s*[.(]/.test(next) ||
+        /\bCodePush\b/.test(next) ||
+        next.includes("react-native-code-push");
+    return { next, changed: next !== content, residual };
+}
+function applyCodePushMigration(input) {
+    const { plan, apiBase, channel } = input;
+    if (input.requireCleanGit) {
+        const res = (0, child_process_1.spawnSync)("git", ["status", "--porcelain"], { cwd: plan.projectDir, encoding: "utf8" });
+        if (res.status === 0 && res.stdout.trim().length > 0) {
+            throw new Error("Working tree is not clean. Commit or stash first, or re-run with --yes to override.");
+        }
+    }
+    const changed = [];
+    const manual = [];
+    let sourceChanged = false;
+    if (plan.packageJsonPath) {
+        backup(plan.packageJsonPath);
+        const pkg = readJson(plan.packageJsonPath);
+        if (pkg.dependencies)
+            delete pkg.dependencies[CODE_PUSH_PKG];
+        if (pkg.devDependencies)
+            delete pkg.devDependencies[CODE_PUSH_PKG];
+        (0, fs_1.writeFileSync)(plan.packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`);
+        changed.push((0, path_1.relative)(plan.projectDir, plan.packageJsonPath));
+    }
+    if ((0, fs_1.existsSync)(plan.appJsonPath)) {
+        backup(plan.appJsonPath);
+        const json = readJson(plan.appJsonPath);
+        const hasExpoKey = Boolean(json.expo);
+        const expo = hasExpoKey ? json.expo : json;
+        const slug = plan.slug ?? expo.slug;
+        if (!slug)
+            throw new Error("No app slug. Pass --app <slug> or set expo.slug in app.json.");
+        expo.updates = {
+            ...(expo.updates ?? {}),
+            enabled: true,
+            url: `${apiBase.replace(/\/$/, "")}/ubriot/updates/manifest?appId=${encodeURIComponent(slug)}`,
+            requestHeaders: { ...(expo.updates?.requestHeaders ?? {}), "expo-channel-name": channel },
+        };
+        const rv = input.runtimeVersion ?? plan.runtimeVersion;
+        if (rv)
+            expo.runtimeVersion = rv;
+        else if (!expo.runtimeVersion)
+            manual.push("Set expo.runtimeVersion in app.json (pass --runtime-version to do it automatically).");
+        if (hasExpoKey)
+            json.expo = expo;
+        (0, fs_1.writeFileSync)(plan.appJsonPath, `${JSON.stringify(json, null, 2)}\n`);
+        changed.push((0, path_1.relative)(plan.projectDir, plan.appJsonPath));
+    }
+    for (const file of plan.sourceFiles) {
+        let content;
+        try {
+            content = (0, fs_1.readFileSync)(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const { next, changed: didChange, residual } = unwrapCodePush(content);
+        if (didChange) {
+            backup(file);
+            (0, fs_1.writeFileSync)(file, next);
+            changed.push((0, path_1.relative)(plan.projectDir, file));
+            sourceChanged = true;
+        }
+        if (residual)
+            manual.push(`Review ${(0, path_1.relative)(plan.projectDir, file)}: a CodePush reference could not be rewritten automatically.`);
+    }
+    if (sourceChanged) {
+        manual.push("Verify the app still compiles. If you used the imperative CodePush API (CodePush.sync / checkForUpdate), migrate those calls to expo-updates (Updates.checkForUpdateAsync / fetchUpdateAsync / reloadAsync) by hand.");
+    }
+    for (const file of [...plan.iosKeyFiles, ...plan.androidKeyFiles]) {
+        let content;
+        try {
+            content = (0, fs_1.readFileSync)(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        let next = content;
+        next = next.replace(/^\s*<key>CodePushDeploymentKey<\/key>\s*\n\s*<string>[^<]*<\/string>\s*\n/gm, "");
+        next = next.replace(/^\s*<string\b[^>]*\bname="CodePushDeploymentKey"[^>]*>[^<]*<\/string>\s*\n/gm, "");
+        if (next !== content) {
+            backup(file);
+            (0, fs_1.writeFileSync)(file, next);
+            changed.push((0, path_1.relative)(plan.projectDir, file));
+        }
+        else {
+            manual.push(`Remove the CodePushDeploymentKey entry from ${(0, path_1.relative)(plan.projectDir, file)} by hand.`);
+        }
+    }
+    console.log(`\nApplied. Edited ${changed.length} file(s):`);
+    for (const c of changed)
+        console.log(`  ~ ${c}`);
+    console.log("\nFinish the migration with:");
+    console.log("  1. npx expo install expo-updates");
+    if (!plan.slug)
+        console.log("  2. Create or link a Ubriot app, then set --app <slug>");
+    else
+        console.log(`  2. ubriot apps create --name "<App Name>" --slug ${plan.slug}   (skip if it already exists)`);
+    console.log(`  3. ubriot update --app ${plan.slug ?? "<slug>"} --channel ${channel}`);
+    if (manual.length) {
+        console.log("\nManual steps still required:");
+        for (const m of manual)
+            console.log(`  ! ${m}`);
+    }
+    console.log("\nBackups written as <file>.codepush.bak next to each edited file.");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ubriot",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "CI/CD CLI for Expo and React Native, ship iOS, Android, and OTA updates from your terminal.",
   "license": "MIT",
   "homepage": "https://ubriot.dev",