@coderook/cli 0.31.12 → 0.32.0

package/dist/cbx/src/local/store.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectStore = exports.PACKED_OBJECT_LIMIT = exports.DIGEST = void 0;
+exports.digestOf = digestOf;
+/**
+ * The object store under `.cbx/objects`: everything a local history holds.
+ *
+ * Every object is named by the SHA-256 of its original bytes and kept as a
+ * chunk frame (see `core/cbx.ts`), so it is compressed when that saves at
+ * least two percent and verified whenever it is read. Pieces of files, the
+ * trees that list them and the saves that name a tree are all objects; an
+ * object never changes once written, which is what makes writing one safe to
+ * repeat and a store safe to copy while nothing is saving.
+ *
+ *   .cbx/objects/ab/cdef…        one object on its own ("loose")
+ *   .cbx/objects/packs/<id>.pack  many small objects, frame after frame
+ *   .cbx/objects/packs/<id>.idx   where each of them starts, as JSON
+ *
+ * Small objects go into packs because a file per object is what made the
+ * first save of twenty thousand small files take thirty-six seconds on
+ * Windows, nearly all of it creating files. A pack is written whole and
+ * renamed into place before its index is, so an index on disk always
+ * describes a finished pack; a pack with no index is an interrupted write
+ * and is never read.
+ */
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const cbx_js_1 = require("../core/cbx.js");
+exports.DIGEST = /^[0-9a-f]{64}$/;
+/** Objects at most this big are packed rather than written on their own. */
+exports.PACKED_OBJECT_LIMIT = 256 * 1024;
+/** A pack is written out once it holds this much. */
+const PACK_BYTES = 32 * 1024 * 1024;
+function digestOf(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+}
+class ObjectStore {
+    directory;
+    /* Fan-out folders already known to exist, so each is made once, not per object. */
+    made = new Set();
+    /* Every packed object, once the indexes have been read. */
+    packed = null;
+    /* Small objects waiting to be written as one pack. */
+    pending = new Map();
+    /* The batch being written right now, still readable while it is. */
+    writing = new Map();
+    pendingBytes = 0;
+    flushing = null;
+    /*
+      Packs held open while an operation reads from them. Opening a pack for
+      each object made restoring twenty thousand small files take three
+      minutes. Closed by `release`, which every operation calls when it ends,
+      because Windows will not delete a folder holding an open file.
+    */
+    handles = new Map();
+    constructor(directory) {
+        this.directory = directory;
+    }
+    get packDirectory() {
+        return node_path_1.default.join(this.directory, "packs");
+    }
+    where(digest) {
+        if (!exports.DIGEST.test(digest))
+            throw new Error(`Not an object name: ${digest}`);
+        return node_path_1.default.join(this.directory, digest.slice(0, 2), digest.slice(2));
+    }
+    async packs() {
+        if (this.packed)
+            return this.packed;
+        const found = new Map();
+        let names = [];
+        try {
+            names = await (0, promises_1.readdir)(this.packDirectory);
+        }
+        catch {
+            /* No packs yet. */
+        }
+        for (const name of names.filter((one) => one.endsWith(".idx")).sort()) {
+            const pack = node_path_1.default.join(this.packDirectory, name.replace(/\.idx$/, ".pack"));
+            const index = JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(this.packDirectory, name), "utf8"));
+            for (const [digest, [offset, length]] of Object.entries(index)) {
+                found.set(digest, { pack, offset, length });
+            }
+        }
+        this.packed = found;
+        return found;
+    }
+    async loose(digest) {
+        try {
+            await (0, promises_1.stat)(this.where(digest));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async has(digest) {
+        if (this.pending.has(digest) || this.writing.has(digest))
+            return true;
+        if ((await this.packs()).has(digest))
+            return true;
+        return this.loose(digest);
+    }
+    /**
+     * Keep `raw`, returning its name.
+     *
+     * A small object is held until there is a pack's worth, then written with
+     * the others; call `flush` before anything else needs to read it from disk.
+     * A large one is written beside its final name and renamed into place, so
+     * an interrupted save never leaves half an object under a real name. An
+     * object already present is not written again: same name, same bytes.
+     */
+    async put(raw, options = {}) {
+        const digest = digestOf(raw);
+        if (await this.has(digest))
+            return digest;
+        const { frame } = (0, cbx_js_1.chunkFrame)(raw);
+        if (!options.loose && raw.length <= exports.PACKED_OBJECT_LIMIT) {
+            this.pending.set(digest, frame);
+            this.pendingBytes += frame.length;
+            if (this.pendingBytes >= PACK_BYTES)
+                await this.flush();
+            return digest;
+        }
+        const target = this.where(digest);
+        const folder = node_path_1.default.dirname(target);
+        if (!this.made.has(folder)) {
+            await (0, promises_1.mkdir)(folder, { recursive: true });
+            this.made.add(folder);
+        }
+        const partial = `${target}.${(0, node_crypto_1.randomBytes)(6).toString("hex")}.partial`;
+        await (0, promises_1.writeFile)(partial, frame);
+        try {
+            await (0, promises_1.rename)(partial, target);
+        }
+        catch (error) {
+            await (0, promises_1.rm)(partial, { force: true });
+            /* Another writer got there first with the same bytes. */
+            if (!(await this.loose(digest)))
+                throw error;
+        }
+        return digest;
+    }
+    /** Write whatever small objects are waiting as one pack. */
+    async flush() {
+        /* One pack at a time; a second caller waits for the first and goes again. */
+        while (this.flushing)
+            await this.flushing;
+        if (!this.pending.size)
+            return;
+        const taken = this.pending;
+        this.pending = new Map();
+        this.pendingBytes = 0;
+        this.writing = taken;
+        this.flushing = this.writePack(taken).finally(() => {
+            this.writing = new Map();
+            this.flushing = null;
+        });
+        await this.flushing;
+    }
+    async writePack(objects) {
+        await (0, promises_1.mkdir)(this.packDirectory, { recursive: true });
+        const index = {};
+        const frames = [];
+        let offset = 0;
+        for (const [digest, frame] of [...objects].sort(([left], [right]) => (left < right ? -1 : 1))) {
+            index[digest] = [offset, frame.length];
+            frames.push(frame);
+            offset += frame.length;
+        }
+        const body = Buffer.concat(frames);
+        const id = digestOf(body);
+        const pack = node_path_1.default.join(this.packDirectory, `${id}.pack`);
+        const idx = node_path_1.default.join(this.packDirectory, `${id}.idx`);
+        await (0, promises_1.writeFile)(`${pack}.partial`, body);
+        await (0, promises_1.rename)(`${pack}.partial`, pack);
+        await (0, promises_1.writeFile)(`${idx}.partial`, JSON.stringify(index));
+        await (0, promises_1.rename)(`${idx}.partial`, idx);
+        const known = await this.packs();
+        for (const [digest, [at, length]] of Object.entries(index)) {
+            known.set(digest, { pack, offset: at, length });
+        }
+    }
+    async get(digest) {
+        const waiting = this.pending.get(digest) ?? this.writing.get(digest);
+        if (waiting)
+            return (0, cbx_js_1.openChunkFrame)(waiting, digest);
+        const located = (await this.packs()).get(digest);
+        if (located) {
+            let opening = this.handles.get(located.pack);
+            if (!opening) {
+                opening = (0, promises_1.open)(located.pack, "r");
+                this.handles.set(located.pack, opening);
+            }
+            const handle = await opening;
+            const frame = Buffer.alloc(located.length);
+            const { bytesRead } = await handle.read(frame, 0, located.length, located.offset);
+            if (bytesRead !== located.length) {
+                throw new Error(`Object ${digest.slice(0, 12)} runs past the end of its pack`);
+            }
+            return (0, cbx_js_1.openChunkFrame)(frame, digest);
+        }
+        let frame;
+        try {
+            frame = await (0, promises_1.readFile)(this.where(digest));
+        }
+        catch {
+            throw new Error(`The history is missing object ${digest.slice(0, 12)}`);
+        }
+        return (0, cbx_js_1.openChunkFrame)(frame, digest);
+    }
+    /** Close any packs held open for reading. Safe to call at any time. */
+    async release() {
+        const open = [...this.handles.values()];
+        this.handles.clear();
+        for (const opening of open) {
+            try {
+                await (await opening).close();
+            }
+            catch {
+                /* Never opened, or already closed. */
+            }
+        }
+    }
+    /** Stored on its own, so a save or tree is one file a person can find. */
+    async putJson(value) {
+        return this.put(Buffer.from(JSON.stringify(value), "utf8"), { loose: true });
+    }
+    async getJson(digest) {
+        return JSON.parse((await this.get(digest)).toString("utf8"));
+    }
+    /** Every object whose name starts with `prefix` (at least four characters). */
+    async matching(prefix) {
+        if (!/^[0-9a-f]{4,64}$/.test(prefix))
+            return [];
+        const found = new Set();
+        try {
+            const rest = prefix.slice(2);
+            for (const name of await (0, promises_1.readdir)(node_path_1.default.join(this.directory, prefix.slice(0, 2)))) {
+                if (name.length === 62 && name.startsWith(rest))
+                    found.add(prefix.slice(0, 2) + name);
+            }
+        }
+        catch {
+            /* No loose objects under that prefix. */
+        }
+        for (const digest of (await this.packs()).keys()) {
+            if (digest.startsWith(prefix))
+                found.add(digest);
+        }
+        return [...found];
+    }
+}
+exports.ObjectStore = ObjectStore;

package/dist/{desktop-app → cbx}/src/shared/safe_path.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isGitDirectoryName = isGitDirectoryName;
+exports.isCbxDirectoryName = isCbxDirectoryName;
 exports.whyUnsafe = whyUnsafe;
 exports.safeParts = safeParts;
 exports.inside = inside;
@@ -38,6 +39,15 @@ function isGitDirectoryName(part) {
     const name = part.split(":")[0].replace(/[. ]+$/, "").toLowerCase();
     return name === ".git" || /^git~\d+$/.test(name);
 }
+/**
+ * A name CBX keeps its local history under, compared the way git's is.
+ *
+ * A version holding `.cbx/lines/main` would otherwise move somebody's line to
+ * a save of the version's choosing the moment it was fetched.
+ */
+function isCbxDirectoryName(part) {
+    return part.split(":")[0].replace(/[. ]+$/, "").toLowerCase() === ".cbx";
+}
 /** Why this path must not be written, or null when it may. */
 function whyUnsafe(relative) {
     if (!relative)
@@ -52,6 +62,8 @@ function whyUnsafe(relative) {
             return "it climbs out of the folder";
         if (isGitDirectoryName(part))
             return "it writes into git's own directory";
+        if (isCbxDirectoryName(part))
+            return "it writes into CBX's own history";
         /* A stream or a drive-relative name on Windows; refused by the service too. */
         if (process.platform === "win32" && part.includes(":")) {
             return "it names a Windows data stream";

package/dist/cli/src/api.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceError = void 0;
 exports.putObject = putObject;
 exports.beginUpload = beginUpload;
 exports.uploadPart = uploadPart;
@@ -22,6 +23,10 @@ exports.cancelMerge = cancelMerge;
 exports.aiAccess = aiAccess;
 exports.setAiAccess = setAiAccess;
 exports.updateProject = updateProject;
+exports.pages = pages;
+exports.setPages = setPages;
+exports.detectPages = detectPages;
+exports.autoPages = autoPages;
 exports.compareVersions = compareVersions;
 exports.fileTextAt = fileTextAt;
 exports.versions = versions;
@@ -53,7 +58,7 @@ exports.addWebhook = addWebhook;
 exports.removeWebhook = removeWebhook;
 exports.collisionCheck = collisionCheck;
 /** The small part of the API the command-line tool needs directly. */
-const identify_js_1 = require("../../desktop-app/src/main/identify.js");
+const identify_js_1 = require("../../cbx/src/core/identify.js");
 const config_js_1 = require("./config.js");
 /**
  * How long one request may go unanswered before it is treated as lost.
@@ -70,6 +75,25 @@ const config_js_1 = require("./config.js");
  * than ending the run.
  */
 const REQUEST_DEADLINE_MS = 180_000;
+/**
+ * A refusal from the service, with what it said and why.
+ *
+ * Still an Error carrying the service's own sentence, so every caller that
+ * prints `error.message` goes on printing the same words. The status and the
+ * code are there for the few commands that answer a particular refusal
+ * differently — "not available here yet" is not the same as "not allowed".
+ */
+class ServiceError extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "ServiceError";
+    }
+}
+exports.ServiceError = ServiceError;
 async function call(route, options = {}) {
     const token = await (0, config_js_1.loadToken)();
     if (!token) {
@@ -93,7 +117,7 @@ async function call(route, options = {}) {
         if (response.status === 401) {
             throw new Error("That token was not accepted. Run: cbx sign-in");
         }
-        throw new Error(body?.error?.message ?? `${route} failed (${response.status})`);
+        throw new ServiceError(body?.error?.message ?? `${route} failed (${response.status})`, response.status, typeof body?.error?.code === "string" ? body.error.code : null);
     }
     return body;
 }
@@ -388,6 +412,94 @@ async function updateProject(repositoryId, change) {
         body: change,
     });
 }
+function pagesSettings(row) {
+    const live = row.live;
+    const entry = row.entry;
+    return {
+        enabled: row.enabled === true,
+        folder: String(row.folder ?? ""),
+        versionId: row.versionId == null ? null : String(row.versionId),
+        spa: row.spa === true,
+        isolation: row.isolation === true,
+        address: row.address == null ? null : String(row.address),
+        domainReady: row.domainReady === true,
+        live: live
+            ? {
+                id: String(live.id ?? ""),
+                sequence: Number(live.sequence ?? 0),
+                name: live.name == null ? null : String(live.name),
+            }
+            : null,
+        entry: entry
+            ? { path: String(entry.path ?? ""), found: entry.found === true }
+            : null,
+        blocked: row.blocked == null ? null : String(row.blocked),
+    };
+}
+const pagesRoute = (repositoryId) => `/v1/repositories/${encodeURIComponent(repositoryId)}/pages`;
+/** What a project's site is set to, and what it is serving. */
+async function pages(repositoryId) {
+    return pagesSettings(await call(pagesRoute(repositoryId)));
+}
+/** Change a project's site. Only what is given is sent. */
+async function setPages(repositoryId, change) {
+    return pagesSettings(await call(pagesRoute(repositoryId), {
+        method: "PUT",
+        body: change,
+    }));
+}
+/** What the newest published version looks like it could serve. */
+async function detectPages(repositoryId) {
+    const body = await call(`${pagesRoute(repositoryId)}/detect`);
+    const version = body.version;
+    const suggestion = body.suggestion;
+    return {
+        version: version
+            ? {
+                id: String(version.id ?? ""),
+                sequence: Number(version.sequence ?? 0),
+                name: version.name == null ? null : String(version.name),
+            }
+            : null,
+        suggestion: suggestion
+            ? {
+                folder: String(suggestion.folder ?? ""),
+                kind: String(suggestion.kind ?? "static"),
+                spa: suggestion.spa === true,
+                isolation: suggestion.isolation === true,
+                why: String(suggestion.why ?? ""),
+            }
+            : null,
+        candidates: Array.isArray(body.candidates)
+            ? body.candidates.map((one) => ({
+                folder: String(one.folder ?? ""),
+                kind: String(one.kind ?? "static"),
+                why: String(one.why ?? ""),
+            }))
+            : [],
+        problem: body.problem == null ? null : String(body.problem),
+    };
+}
+/**
+ * Detect and apply in one request, so what is switched on is what the
+ * service found rather than what this client last saw.
+ */
+async function autoPages(repositoryId) {
+    const body = await call(`${pagesRoute(repositoryId)}/auto`, { method: "POST" });
+    const applied = body.applied;
+    return {
+        ...pagesSettings(body),
+        applied: applied
+            ? {
+                folder: String(applied.folder ?? ""),
+                kind: String(applied.kind ?? "static"),
+                spa: applied.spa === true,
+                isolation: applied.isolation === true,
+                why: String(applied.why ?? ""),
+            }
+            : null,
+    };
+}
 /**
  * What changed between two saved versions.
  *