@magland/mochi 0.3.1

package/dist/import-cli.js

@@ -0,0 +1,316 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importCmd = importCmd;
+exports.collectionAddCmd = collectionAddCmd;
+exports.collectionListCmd = collectionListCmd;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const cli_api_1 = require("./cli-api");
+const scan_1 = require("./scan");
+const source_1 = require("./source");
+function parseImportArgs(args, usage) {
+    const out = {
+        src: null,
+        collection: null,
+        name: null,
+        host: null,
+        token: null,
+        lfs: false,
+        description: null,
+        noDescription: false,
+    };
+    let positional = 0;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '-h' || a === '--help')
+            usage();
+        else if (a === '--host')
+            out.host = args[++i];
+        else if (a === '--token')
+            out.token = args[++i];
+        else if (a === '--collection')
+            out.collection = args[++i];
+        else if (a === '--name')
+            out.name = args[++i];
+        else if (a === '--lfs')
+            out.lfs = true;
+        else if (a === '--description')
+            out.description = args[++i];
+        else if (a === '--no-description')
+            out.noDescription = true;
+        else if (a.startsWith('-')) {
+            console.error(`Unknown option: ${a}`);
+            process.exit(1);
+        }
+        else if (positional === 0) {
+            out.src = a;
+            positional++;
+        }
+        else if (positional === 1) {
+            // The destination is written the way a repository is addressed
+            // everywhere else in mochi: `collection` or `collection/repo`.
+            const slash = a.indexOf('/');
+            if (slash === -1)
+                out.collection = a;
+            else {
+                out.collection = a.slice(0, slash);
+                out.name = a.slice(slash + 1);
+            }
+            positional++;
+        }
+        else {
+            console.error(`Unexpected argument: ${a}`);
+            process.exit(1);
+        }
+    }
+    return out;
+}
+/** Run git with its output going straight to the terminal, so a long clone shows progress. */
+function git(args, env) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)('git', args, { stdio: 'inherit', env: env ?? process.env });
+        child.on('error', (e) => reject(new Error(e.code === 'ENOENT' ? 'git is not on PATH' : String(e.message))));
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+// The token is handed to the push through a helper that reads it from the
+// environment rather than through the command line, where every process on the
+// machine could read it. The empty helper first clears the list, so the answer
+// comes from here and nowhere else, and no prompt can appear.
+function pushEnv(username, token) {
+    return { ...process.env, MOCHI_USER: username, MOCHI_TOKEN: token, GIT_TERMINAL_PROMPT: '0' };
+}
+const CREDENTIAL_HELPER = `!f() { test "$1" = get && printf 'username=%s\\npassword=%s\\n' "$MOCHI_USER" "$MOCHI_TOKEN"; }; f`;
+function pushArgs(dir) {
+    return ['-C', dir, '-c', 'credential.helper=', '-c', `credential.helper=${CREDENTIAL_HELPER}`];
+}
+/**
+ * A repository's one-line description is not part of its git data, so a clone
+ * and a mirror push carry everything except that. For a GitHub source we can
+ * ask for it: one unauthenticated call to the REST API, which answers for a
+ * public repository and declines for a private one. Nothing here is worth
+ * failing an import that has already arrived, so every failure is a null and
+ * the caller says so in one line.
+ */
+async function githubDescription(gh) {
+    const url = `https://api.github.com/repos/${encodeURIComponent(gh.owner)}/${encodeURIComponent(gh.repo)}`;
+    try {
+        const resp = await fetch(url, {
+            headers: { accept: 'application/vnd.github+json', 'user-agent': 'mochi-import' },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!resp.ok)
+            return null;
+        const data = (await resp.json());
+        const description = typeof data.description === 'string' ? data.description.trim() : '';
+        return description === '' ? null : description;
+    }
+    catch {
+        return null;
+    }
+}
+async function importCmd(args, usage) {
+    const a = parseImportArgs(args, usage);
+    if (!a.src) {
+        console.error('Usage: mochi import <source> <collection>[/<name>]');
+        console.error("  e.g. mochi import https://github.com/octocat/Hello-World mycollection");
+        process.exit(1);
+    }
+    const source = (0, source_1.parseSource)(a.src);
+    if (!source) {
+        console.error(`Not a source we can clone: ${a.src}`);
+        console.error('Give an https or ssh git URL, owner/repo for GitHub, or the path to a repository here.');
+        process.exit(1);
+    }
+    const collection = a.collection ?? '';
+    const name = a.name ?? source.name;
+    if (!collection) {
+        console.error(`Which collection should ${name} go into?`);
+        console.error(`  mochi import ${a.src} mycollection`);
+        process.exit(1);
+    }
+    if (!(0, scan_1.isValidName)(collection) || !(0, scan_1.isValidName)(name)) {
+        console.error('Collection and repository names may use letters, digits, dot, underscore, and dash,');
+        console.error('and must not be reserved words.');
+        process.exit(1);
+    }
+    const target = await (0, cli_api_1.remoteTarget)(a);
+    // Who the push will be as, and whether the token still works: worth knowing
+    // before a clone that may take minutes.
+    const who = await (0, cli_api_1.api)(target, 'GET', '/api/whoami');
+    const username = String(who.username ?? '');
+    if (!username) {
+        console.error(`${target.host} did not say who this token belongs to.`);
+        process.exit(1);
+    }
+    // A mirror push at an existing repository would replace its refs, so an
+    // existing name stops the import here rather than after the clone.
+    const listing = `/api/collections/${encodeURIComponent(collection)}`;
+    const existing = await (0, cli_api_1.apiTry)(target, 'GET', listing);
+    if (existing.ok && (existing.data.repos ?? []).includes(name)) {
+        console.error(`${collection}/${name} already exists on ${target.host}.`);
+        console.error('A mirror push would replace its branches and tags, so this stops here. Import');
+        console.error('under another name,');
+        console.error(`  mochi import ${a.src} ${collection}/another-name`);
+        console.error('or delete the existing repository first, from its settings page.');
+        process.exit(1);
+    }
+    if (!existing.ok && existing.status !== 404)
+        (0, cli_api_1.apiFailed)(target, listing, existing);
+    const dest = `${target.host}/${encodeURIComponent(collection)}/${encodeURIComponent(name)}`;
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mochi-import-'));
+    const cleanup = () => {
+        try {
+            fs.rmSync(tmp, { recursive: true, force: true });
+        }
+        catch {
+            // A leftover temporary directory is not worth failing the import over.
+        }
+    };
+    try {
+        // --bare rather than --mirror: mirroring a GitHub repository drags in
+        // refs/pull/*, thousands of refs the vault has no use for. A bare clone
+        // carries branches and tags, which is what the push then mirrors.
+        console.log(`Cloning ${source.url}`);
+        if ((await git(['clone', '--bare', '--', source.url, tmp])) !== 0) {
+            throw new Error(`Could not clone ${source.url}.`);
+        }
+        if (a.lfs) {
+            console.log('Fetching Git LFS objects');
+            if ((await git(['-C', tmp, 'lfs', 'fetch', '--all'])) !== 0) {
+                throw new Error('Could not fetch the LFS objects. Is git-lfs installed?');
+            }
+        }
+        console.log(`Pushing to ${dest} as ${username}`);
+        const env = pushEnv(username, target.token);
+        if ((await git([...pushArgs(tmp), 'push', '--mirror', dest], env)) !== 0) {
+            throw new Error(`Could not push to ${dest}.\nIf it refused the token, check that you may create in ${collection}.`);
+        }
+        if (a.lfs) {
+            console.log('Pushing Git LFS objects');
+            if ((await git([...pushArgs(tmp), 'lfs', 'push', '--all', dest], env)) !== 0) {
+                throw new Error('The repository arrived, but its LFS objects did not.');
+            }
+        }
+    }
+    finally {
+        // Reported through an exception rather than process.exit, since exiting
+        // here would skip this and leave the bare clone behind.
+        cleanup();
+    }
+    // The description is set after the push rather than before it, since the
+    // repository does not exist until the push creates it.
+    let described = a.description?.trim() || null;
+    if (!described && !a.noDescription && source.github)
+        described = await githubDescription(source.github);
+    if (described) {
+        const patch = await (0, cli_api_1.apiTry)(target, 'PATCH', `/api/repos/${encodeURIComponent(collection)}/${encodeURIComponent(name)}`, {
+            description: described,
+        });
+        if (!patch.ok) {
+            console.error(`The repository arrived, but its description could not be set: ${patch.data.error ?? `HTTP ${patch.status}`}`);
+            described = null;
+        }
+    }
+    console.log('');
+    console.log(`Imported ${collection}/${name}`);
+    console.log(`  ${dest}`);
+    // Worth saying rather than leaving to be discovered: a mirror push carries
+    // LFS pointer files, so the files look present and read as missing.
+    if (described)
+        console.log(`  ${described}`);
+    else if (source.github && !a.noDescription)
+        console.log('  (no description came across; set one in repository settings)');
+    if (!a.lfs)
+        console.log('  (Git LFS objects, if it has any, were not carried over; import again with --lfs)');
+}
+function parseCollectionArgs(args, usage) {
+    const out = { name: null, host: null, token: null };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '-h' || a === '--help')
+            usage();
+        else if (a === '--host')
+            out.host = args[++i];
+        else if (a === '--token')
+            out.token = args[++i];
+        else if (a.startsWith('-')) {
+            console.error(`Unknown option: ${a}`);
+            process.exit(1);
+        }
+        else if (!out.name)
+            out.name = a;
+        else {
+            console.error(`Unexpected argument: ${a}`);
+            process.exit(1);
+        }
+    }
+    return out;
+}
+async function collectionAddCmd(args, usage) {
+    const a = parseCollectionArgs(args, usage);
+    if (!a.name) {
+        console.error('Usage: mochi collection add <name>');
+        process.exit(1);
+    }
+    const target = await (0, cli_api_1.remoteTarget)(a);
+    const data = await (0, cli_api_1.api)(target, 'POST', '/api/collections', { name: a.name });
+    console.log(`Created collection '${data.name}' on ${target.host}`);
+    console.log(`  ${target.host}/${encodeURIComponent(String(data.name))}`);
+    console.log('');
+    console.log('It has no repositories yet. Put one in it with');
+    console.log(`  mochi import https://github.com/owner/repo ${data.name}`);
+}
+async function collectionListCmd(args, usage) {
+    const a = parseCollectionArgs(args, usage);
+    if (a.name) {
+        console.error(`Unexpected argument: ${a.name}`);
+        process.exit(1);
+    }
+    const target = await (0, cli_api_1.remoteTarget)(a);
+    const data = await (0, cli_api_1.api)(target, 'GET', '/api/collections');
+    const collections = (data.collections ?? []);
+    if (collections.length === 0) {
+        console.log(`No collections on ${target.host}`);
+        return;
+    }
+    const width = Math.max(...collections.map((c) => c.name.length));
+    for (const c of collections) {
+        console.log(`${c.name.padEnd(width)}  ${c.repoCount} ${c.repoCount === 1 ? 'repository' : 'repositories'}`);
+    }
+}