#!/usr/bin/env node // github-to-rithub — mirror GitHub repos to Rithub (or any Gitea-API // compatible server) using your own tokens. Zero dependencies. // See README.md for full usage. import { writeFile } from "node:fs/promises"; import { listGithubRepos, getGithubRepo } from "../src/github.js"; import { getRithubAuthedUser, rithubRepoIsFree, migrateRepo } from "../src/rithub.js"; import { resolveStatePath, loadState, saveState, markCompleted, markFailed, isAlreadyDone } from "../src/state.js"; import { buildReport, formatReportMarkdown } from "../src/report.js"; function parseArgs(argv) { const args = { _: [] }; for (let i = 0; i < argv.length; i += 1) { const token = argv[i]; if (token.startsWith("--")) { const key = token.slice(2); const next = argv[i + 1]; if (next === undefined || next.startsWith("--")) { args[key] = true; } else if (key in args) { args[key] = [...(Array.isArray(args[key]) ? args[key] : [args[key]]), next]; i += 1; } else { args[key] = next; i += 1; } } else { args._.push(token); } } return args; } function requireEnv(name) { const value = process.env[name]; if (!value) { console.error(`Missing required environment variable: ${name}`); process.exit(1); } return value; } function printUsage() { console.log(`github-to-rithub — move your repos from GitHub to Rithub Usage: github-to-rithub list --github-user github-to-rithub migrate --github-user --rithub-owner [--repo ...] [--all] [--rithub-url https://rithub.dev] [--dry-run] [--resume] [--state ] [--report ] [--report-md ] Environment: GITHUB_TOKEN GitHub personal access token (read scope is enough: repo, read:org) RITHUB_TOKEN Rithub personal access token for the target account/org Commands: list List the repos your GitHub token can see (no writes anywhere). migrate Migrate selected repos to Rithub via Rithub's own /repos/migrate API. `); } async function cmdList(args) { const githubToken = requireEnv("GITHUB_TOKEN"); const repos = await listGithubRepos(githubToken); for (const repo of repos) { console.log(`${repo.full_name}\t${repo.private ? "private" : "public"}\t${repo.html_url}`); } console.log(`\n${repos.length} repo(s) visible to this token.`); } function selectRepos(allRepos, args) { if (args.all) return allRepos; const requested = Array.isArray(args.repo) ? args.repo : args.repo ? [args.repo] : []; if (requested.length === 0) { console.error("Pass --repo one or more times, or --all. Refusing to migrate nothing/everything by accident."); process.exit(1); } return allRepos.filter((repo) => requested.includes(repo.name) || requested.includes(repo.full_name)); } async function migrateOne({ repo, args, githubToken, rithubToken, rithubUrl, rithubOwner, state }) { const fullName = repo.full_name; if (args.resume && isAlreadyDone(state, fullName)) { return { repo: fullName, status: "skipped-already-done" }; } const targetName = repo.name; const free = await rithubRepoIsFree(rithubUrl, rithubToken, rithubOwner, targetName); if (!free) { return { repo: fullName, status: "skipped-existing", rithubUrl: `${rithubUrl}/${rithubOwner}/${targetName}` }; } if (args["dry-run"]) { return { repo: fullName, status: "dry-run", rithubUrl: `${rithubUrl}/${rithubOwner}/${targetName} (not created)` }; } try { const detail = await getGithubRepo(repo.owner.login, repo.name, githubToken); await migrateRepo(rithubUrl, rithubToken, { cloneUrl: detail.clone_url, githubToken, repoOwner: rithubOwner, repoName: targetName, isPrivate: detail.private, description: detail.description, }); return { repo: fullName, status: "migrated", rithubUrl: `${rithubUrl}/${rithubOwner}/${targetName}` }; } catch (error) { return { repo: fullName, status: "failed", error: error instanceof Error ? error.message : String(error) }; } } async function cmdMigrate(args) { const githubToken = requireEnv("GITHUB_TOKEN"); const rithubToken = requireEnv("RITHUB_TOKEN"); const rithubUrl = String(args["rithub-url"] || "https://rithub.dev").replace(/\/$/, ""); const rithubOwner = args["rithub-owner"]; if (!rithubOwner) { console.error("Pass --rithub-owner "); process.exit(1); } const authedUser = await getRithubAuthedUser(rithubUrl, rithubToken); console.log(`Authenticated to ${rithubUrl} as ${authedUser.login}. Target namespace: ${rithubOwner}.`); const githubUser = args["github-user"]; const allRepos = await listGithubRepos(githubToken); const scoped = githubUser ? allRepos.filter((r) => r.owner.login === githubUser) : allRepos; const selected = selectRepos(scoped, args); const statePath = resolveStatePath(args.state); let state = await loadState(statePath); console.log(`\nMigrating ${selected.length} repo(s) from GitHub to ${rithubUrl}/${rithubOwner} ${args["dry-run"] ? "(DRY RUN)" : ""}`); const startedAt = new Date().toISOString(); const results = []; for (const repo of selected) { console.log(`-> ${repo.full_name}`); const result = await migrateOne({ repo, args, githubToken, rithubToken, rithubUrl, rithubOwner, state }); results.push(result); console.log(` ${result.status}${result.rithubUrl ? " " + result.rithubUrl : ""}${result.error ? " " + result.error : ""}`); if (result.status === "migrated") state = markCompleted(state, repo.full_name, { rithubUrl: result.rithubUrl }); if (result.status === "failed") state = markFailed(state, repo.full_name, result.error); if (!args["dry-run"]) await saveState(statePath, state); } const finishedAt = new Date().toISOString(); const report = buildReport({ startedAt, finishedAt, baseUrl: rithubUrl, rithubOwner, results }); console.log(`\n${JSON.stringify(report.totals, null, 2)}`); if (args.report) await writeFile(args.report, JSON.stringify(report, null, 2)); if (args["report-md"]) await writeFile(args["report-md"], formatReportMarkdown(report)); } async function main() { const args = parseArgs(process.argv.slice(2)); const command = args._[0]; if (command === "list") return cmdList(args); if (command === "migrate") return cmdMigrate(args); printUsage(); process.exit(command ? 1 : 0); } main().catch((error) => { console.error(error instanceof Error ? error.message : error); process.exit(1); });