@coderook/cli 0.38.2 → 0.40.0

package/dist/cli/src/workspace_machine.js

@@ -0,0 +1,322 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MACHINE_OPERATIONS = void 0;
+exports.commandWorkspaceMachine = commandWorkspaceMachine;
+exports.commandMachines = commandMachines;
+/**
+ * Working on a remote draft from a machine's own folder, and handing a draft
+ * to another machine (backend workspace_assignments.ts).
+ *
+ *   cbx workspace assign <project> <draft> [--name "Laptop"] [--days 14]
+ *       make a token that reaches that one draft; shown once
+ *   cbx workspace assignments <project> <draft>     the live ones
+ *   cbx workspace unassign <project> <draft> <id>   end one
+ *   cbx workspace checkout <project> <draft> [folder]
+ *       the draft as files: its base version, with the draft's edits on top
+ *   cbx workspace push [folder] [--save -m "…"] [--dry-run]
+ *       send this folder's text changes into the draft, and save it if asked
+ *
+ * A checked-out folder is not a linked folder: `cbx submit` does not apply to
+ * it, and its record lives in .coderook/workspace.json. Edits go in as the
+ * draft's own changes, each checked against the copy this folder last had,
+ * so somebody else's edit to the same file in the meantime is refused rather
+ * than overwritten. Text only, 256 KiB a file, as the draft itself allows.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const download_js_1 = require("../../cbx/src/core/download.js");
+const worktree_js_1 = require("../../cbx/src/core/worktree.js");
+const api_js_1 = require("./api.js");
+const config_js_1 = require("./config.js");
+const machine_js_1 = require("./machine.js");
+const colour_js_1 = require("./colour.js");
+const RECORD = node_path_1.default.join(".coderook", "workspace.json");
+const MAX_FILE = 256 * 1024;
+const MAX_BATCH = 900 * 1024;
+function flag(parsed, ...names) {
+    for (const name of names) {
+        const value = parsed.flags.get(name);
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+const sha = (bytes) => (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+const key = (what) => `${what}-${(0, node_crypto_1.randomBytes)(9).toString("base64url")}`;
+async function readRecord(folder) {
+    try {
+        return JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(folder, RECORD), "utf8"));
+    }
+    catch {
+        throw new Error(`${folder} is not a checked-out draft. Get one with: cbx workspace checkout <project> <draft> [folder]`);
+    }
+}
+async function writeRecord(folder, record) {
+    await (0, promises_1.mkdir)(node_path_1.default.join(folder, ".coderook"), { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(folder, RECORD), JSON.stringify(record, null, 2) + "\n");
+}
+async function project(reference) {
+    if (!reference)
+        throw new Error("Which project? Name it after the operation.");
+    const found = await (0, api_js_1.findProject)(reference);
+    if (!found)
+        throw new Error(`No accessible project ${reference}`);
+    return found;
+}
+/** The operations this file handles; anything else is the generic workspace command's. */
+exports.MACHINE_OPERATIONS = new Set(["assign", "assignments", "unassign", "checkout", "push"]);
+async function commandWorkspaceMachine(parsed) {
+    const [operation, first, second, third] = parsed.positional;
+    if (operation === "push")
+        return push(parsed, first ?? ".");
+    const found = await project(first);
+    const root = `/v1/repositories/${encodeURIComponent(found.id)}/workspaces`;
+    if (!second)
+        throw new Error("Name the draft (its ID) after the project. List them with: cbx workspace list <project>");
+    const draft = `${root}/${encodeURIComponent(second)}`;
+    if (operation === "assign") {
+        const days = flag(parsed, "days");
+        const made = await (0, api_js_1.callApi)(`${draft}/assignments`, {
+            method: "POST",
+            body: { name: flag(parsed, "name"), ...(days ? { days: Number(days) } : {}) },
+        });
+        console.log(`${(0, colour_js_1.green)("Handed over.")} This token reaches draft ${second} only, until ${made.assignment.expiresAt ? new Date(made.assignment.expiresAt).toLocaleDateString() : "it is revoked"}.`);
+        console.log((0, colour_js_1.dim)("It is shown once. Give it to the other machine privately."));
+        console.log(`\n  ${(0, colour_js_1.bold)(made.token)}\n`);
+        console.log("On that machine:");
+        console.log(`  ${(0, colour_js_1.accent)("npm install -g @coderook/cli")}`);
+        console.log(`  ${(0, colour_js_1.accent)("cbx sign-in")}                         ${(0, colour_js_1.dim)("paste the token when asked")}`);
+        console.log(`  ${(0, colour_js_1.accent)(`cbx workspace checkout ${found.slug} ${second}`)}`);
+        console.log(`  ${(0, colour_js_1.dim)("…work, then")} ${(0, colour_js_1.accent)('cbx workspace push --save -m "What changed"')}`);
+        console.log((0, colour_js_1.dim)(`\nEnd it early: cbx workspace unassign ${found.slug} ${second} ${made.assignment.id}`));
+        return 0;
+    }
+    if (operation === "assignments") {
+        const listed = await (0, api_js_1.callApi)(`${draft}/assignments`);
+        if (!listed.assignments.length)
+            console.log((0, colour_js_1.dim)("This draft is not handed to any machine."));
+        for (const one of listed.assignments) {
+            console.log(`${(0, colour_js_1.bold)(one.name)}  ${(0, colour_js_1.dim)(one.prefix + "…")}  ${(0, colour_js_1.dim)(`until ${one.expiresAt ? new Date(one.expiresAt).toLocaleDateString() : "revoked"}`)}  ` +
+                (0, colour_js_1.dim)(one.lastUsedAt ? `last used ${new Date(one.lastUsedAt).toLocaleString()}` : "not used yet") +
+                (0, colour_js_1.dim)(`  ${one.id}`));
+        }
+        return 0;
+    }
+    if (operation === "unassign") {
+        if (!third)
+            throw new Error("Name the assignment's ID after the draft. See them with: cbx workspace assignments <project> <draft>");
+        await (0, api_js_1.callApi)(`${draft}/assignments/${encodeURIComponent(third)}`, { method: "DELETE" });
+        console.log(`${(0, colour_js_1.green)("Ended.")} That machine can no longer reach the draft.`);
+        return 0;
+    }
+    return checkout(found, draft, second, third);
+}
+async function checkout(found, draft, workspaceId, into) {
+    const folder = node_path_1.default.resolve(into ?? `${found.slug}-draft`);
+    if ((0, node_fs_1.existsSync)(node_path_1.default.join(folder, RECORD))) {
+        console.error((0, colour_js_1.red)(`${folder} already holds a checked-out draft. Use cbx workspace push there, or choose another folder.`));
+        return 1;
+    }
+    const info = await (0, api_js_1.callApi)(draft);
+    const downloader = new download_js_1.Downloader(config_js_1.credentials);
+    let manifest;
+    try {
+        const result = await downloader.run(found.id, info.workspace.baseVersionId, folder, () => undefined, null, "replace");
+        manifest = { ...result.manifest };
+    }
+    catch (error) {
+        if (error instanceof download_js_1.DownloadFailed) {
+            console.error((0, colour_js_1.red)(error.message));
+            return 1;
+        }
+        throw error;
+    }
+    // The draft's own edits on top, each checked against the hash the draft gives for it.
+    let revision = info.workspace.revision;
+    let edited = 0;
+    for (let offset = 0; offset !== null;) {
+        const page = await (0, api_js_1.callApi)(`${draft}/diff?offset=${offset}`);
+        revision = page.revision;
+        for (const change of page.changes) {
+            const target = node_path_1.default.join(folder, ...change.path.split("/"));
+            if (change.removed || !change.after) {
+                await (0, promises_1.rm)(target, { force: true });
+                delete manifest[change.path];
+            }
+            else {
+                if (change.after.content === null) {
+                    throw new Error(`The draft's copy of ${change.path} could not be read as text (${change.after.reason ?? "unreadable"}).`);
+                }
+                if (sha(change.after.content) !== change.after.sha256) {
+                    throw new Error(`The draft's copy of ${change.path} did not arrive exactly; nothing was overwritten past it. Try again.`);
+                }
+                await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
+                await (0, promises_1.writeFile)(target, change.after.content);
+                manifest[change.path] = change.after.sha256;
+            }
+            edited += 1;
+        }
+        offset = page.nextOffset;
+    }
+    await writeRecord(folder, {
+        projectId: found.id,
+        projectSlug: found.slug,
+        workspaceId,
+        name: info.workspace.name,
+        revision,
+        baseVersionId: info.workspace.baseVersionId,
+        track: info.workspace.track,
+        files: manifest,
+    });
+    await (0, machine_js_1.checkIn)(found.id, { kind: "workspace", folder, workspaceId, track: info.workspace.track, baseVersionId: info.workspace.baseVersionId, changedFiles: 0 });
+    console.log(`${(0, colour_js_1.green)("Checked out")} ${(0, colour_js_1.bold)(info.workspace.name)} into ${folder}`);
+    console.log((0, colour_js_1.dim)(`  ${Object.keys(manifest).length} files · revision ${revision}${edited ? ` · ${edited} edited in the draft` : ""}`));
+    console.log((0, colour_js_1.dim)("  Send changes back with ") + (0, colour_js_1.accent)("cbx workspace push") + (0, colour_js_1.dim)(", and save with ") + (0, colour_js_1.accent)('cbx workspace push --save -m "…"'));
+    return 0;
+}
+async function push(parsed, where) {
+    const folder = node_path_1.default.resolve(where);
+    const record = await readRecord(folder);
+    const draft = `/v1/repositories/${encodeURIComponent(record.projectId)}/workspaces/${encodeURIComponent(record.workspaceId)}`;
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    const found = await (0, worktree_js_1.changedFiles)(folder, rules, new Map(Object.entries(record.files)), "synchronize");
+    const changes = [];
+    const refused = [];
+    for (const file of found) {
+        if (file.path === RECORD.replaceAll("\\", "/") || file.path.startsWith(".coderook/"))
+            continue;
+        if (file.deleted) {
+            changes.push({ path: file.path, remove: true, expectedSha256: record.files[file.path] ?? null });
+            continue;
+        }
+        const bytes = await (0, promises_1.readFile)(node_path_1.default.join(folder, ...file.path.split("/")));
+        if (bytes.length > MAX_FILE || bytes.includes(0)) {
+            refused.push(file.path);
+            continue;
+        }
+        changes.push({ path: file.path, content: bytes.toString("utf8"), expectedSha256: record.files[file.path] ?? null });
+    }
+    if (refused.length) {
+        console.error((0, colour_js_1.red)(`${refused.length} file${refused.length === 1 ? " is" : "s are"} binary or over 256 KiB, which a draft cannot take:`));
+        for (const one of refused.slice(0, 20))
+            console.error(`  ${one}`);
+        console.error((0, colour_js_1.dim)("Nothing was sent. Leave them out, or save them with a normal upload from a linked folder."));
+        return 1;
+    }
+    if (!changes.length && !parsed.flags.has("save")) {
+        console.log("Nothing changed since this folder's last push.");
+        return 0;
+    }
+    if (parsed.flags.has("dry-run")) {
+        for (const one of changes)
+            console.log(`  ${one.remove ? (0, colour_js_1.red)("removed") : record.files[one.path] ? "changed" : (0, colour_js_1.green)("new")}  ${one.path}`);
+        console.log((0, colour_js_1.dim)(`${changes.length} change${changes.length === 1 ? "" : "s"} would go to draft ${record.name}.`));
+        return 0;
+    }
+    // In batches the draft accepts, each against the revision the last one made.
+    let revision = record.revision;
+    for (let start = 0; start < changes.length;) {
+        const batch = [];
+        let bytes = 0;
+        while (start < changes.length) {
+            const next = changes[start];
+            const size = next.content ? Buffer.byteLength(next.content) : 0;
+            if (batch.length && bytes + size > MAX_BATCH)
+                break;
+            batch.push(next);
+            bytes += size;
+            start += 1;
+        }
+        const result = await (0, api_js_1.callApi)(`${draft}/changes`, {
+            method: "POST",
+            body: { expectedRevision: revision, operationKey: key("push"), changes: batch },
+        });
+        revision = result.workspace.revision;
+        for (const one of batch) {
+            if (one.remove)
+                delete record.files[one.path];
+            else
+                record.files[one.path] = sha(one.content);
+        }
+        record.revision = revision;
+        await writeRecord(folder, record);
+    }
+    if (changes.length)
+        console.log(`${(0, colour_js_1.green)("Sent")} ${changes.length} change${changes.length === 1 ? "" : "s"} to ${(0, colour_js_1.bold)(record.name)} · revision ${revision}`);
+    if (parsed.flags.has("save")) {
+        const message = flag(parsed, "m", "message");
+        if (!message) {
+            console.error((0, colour_js_1.red)('Say what changed: cbx workspace push --save -m "…"'));
+            return 1;
+        }
+        const saved = await (0, api_js_1.callApi)(`${draft}/save`, {
+            method: "POST",
+            body: { expectedRevision: revision, operationKey: key("save"), message },
+        });
+        if (saved.mergeTrack) {
+            console.log(`${(0, colour_js_1.accent)("Saved onto a merge track")} ${saved.mergeTrack.reference ?? ""}: somebody else changed the same lines, so it waits to be settled.`);
+        }
+        else if (saved.review) {
+            // A machine the draft was handed to saves to the draft's own line, for the owner to merge.
+            console.log(`${(0, colour_js_1.green)("Saved")} as v${saved.version?.sequence ?? "?"} on ${(0, colour_js_1.accent)(saved.review.line)}.`);
+            console.log(saved.review.pull
+                ? (0, colour_js_1.dim)(`  Pull request ${saved.review.pull.reference} carries it to ${saved.review.into}; it lands when the owner or a reviewer merges it.`)
+                : (0, colour_js_1.dim)(`  The owner merges it into ${saved.review.into} from that line.`));
+        }
+        else {
+            console.log(`${(0, colour_js_1.green)("Saved")} as v${saved.version?.sequence ?? "?"} on ${record.track}.`);
+        }
+    }
+    await (0, machine_js_1.checkIn)(record.projectId, { kind: "workspace", folder, workspaceId: record.workspaceId, track: record.track, baseVersionId: record.baseVersionId, changedFiles: 0 });
+    return 0;
+}
+function ago(when) {
+    const minutes = Math.round((Date.now() - Date.parse(when)) / 60000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    const hours = Math.round(minutes / 60);
+    return hours < 48 ? `${hours} h ago` : `${Math.round(hours / 24)} days ago`;
+}
+/** cbx machines [project]: the PCs working on a project, and its runners. */
+async function commandMachines(parsed, linkedProject) {
+    const reference = parsed.positional[0] ?? linkedProject;
+    if (!reference)
+        throw new Error("Which project? Try: cbx machines <project>, or run it in a linked folder.");
+    const found = await project(reference);
+    const root = `/v1/repositories/${encodeURIComponent(found.id)}`;
+    const [machines, runners] = await Promise.all([
+        (0, api_js_1.callApi)(`${root}/machines`),
+        (0, api_js_1.callApi)(`${root}/runners`).catch(() => ({ runners: [] })),
+    ]);
+    console.log((0, colour_js_1.bold)(found.slug));
+    console.log((0, colour_js_1.dim)("Linked folders and handed-over drafts"));
+    if (!machines.machines.length)
+        console.log((0, colour_js_1.dim)("  None in the last 30 days."));
+    for (const one of machines.machines) {
+        const behind = one.baseSequence !== null && one.lineSequence !== null
+            ? one.lineSequence > one.baseSequence
+                ? (0, colour_js_1.red)(`${one.lineSequence - one.baseSequence} behind`)
+                : (0, colour_js_1.green)("up to date")
+            : (0, colour_js_1.dim)("version unknown");
+        const what = one.kind === "workspace" ? `draft ${one.workspace?.name ?? "(private)"}` : `folder ${one.folderName ?? "?"}`;
+        console.log(`  ${(0, colour_js_1.bold)(one.name)}${one.mine ? (0, colour_js_1.dim)(" (you)") : ""}  ${(0, colour_js_1.dim)(one.person.displayName)}  ${what}` +
+            `  ${one.baseSequence !== null ? `v${one.baseSequence}` : ""} ${behind}` +
+            `  ${one.changedFiles === null ? "" : one.changedFiles ? `${one.changedFiles} unsaved` : (0, colour_js_1.dim)("nothing unsaved")}` +
+            `  ${(0, colour_js_1.dim)(ago(one.lastSeenAt))}`);
+    }
+    console.log((0, colour_js_1.dim)("Runners"));
+    if (!runners.runners.length)
+        console.log((0, colour_js_1.dim)("  None connected."));
+    for (const one of runners.runners) {
+        const online = Date.now() - Date.parse(one.lastSeenAt) < 120000;
+        console.log(`  ${(0, colour_js_1.bold)(one.name)}  ${(0, colour_js_1.dim)(one.platform ?? "")}  ${online ? (0, colour_js_1.green)("online") : (0, colour_js_1.dim)("offline")}  ${(0, colour_js_1.dim)(`${one.runsClaimed} runs · ${ago(one.lastSeenAt)}`)}`);
+    }
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.38.2",
+  "version": "0.40.0",
   "description": "The command line for CodeRook (coderook.com): version control and project hosting for projects of any size. Every save is a compressed snapshot, private or public, never used to train AI.",
   "license": "Apache-2.0",
   "homepage": "https://coderook.com",

package/skills/coderook/SKILL.md

@@ -25,6 +25,10 @@ Use `cbx workspace` when the person wants to continue a CodeRook project from a
 
 `cbx workspace show <project> <id>` includes the administrator-configured recipe commands and target information. Run a named recipe, inspect its job with `logs`, and use `cancel` if needed. Only deploy an explicitly requested target and a saved version with applicable checks. A missing recipe requires configuration; running a local terminal command does not change remote files.
 
+To hand a draft to a machine that is not signed in as the owner, run `cbx workspace assign <project> <draft> --name "Laptop"`. It prints a token that reaches that one draft (read the project, edit, save and run its checks; no deploys, settings, other drafts or more tokens). Tell the person to give it to the other machine privately; never repeat the token yourself. On that machine: `cbx sign-in` (paste the token), `cbx workspace checkout <project> <draft> [folder]`, edit the files, then `cbx workspace push` (add `--save -m "…"` to save, `--dry-run` to preview). A checked-out folder is not a linked folder, so `cbx submit` does not apply there. A handed-over machine's saves never land on the draft's line directly: they go to the draft's own line `drafts/<name>-<id>` and open a pull request into it, which the owner or a reviewer approves and merges (see it with `cbx pr list`). Saves made signed in as the owner go straight to the line. `cbx workspace assignments` lists live tokens and `cbx workspace unassign` ends one; archiving the draft ends them all.
+
+`cbx machines [project]` shows the PCs working on a project: linked folders and handed-over drafts, the version each holds, how far behind the line it is and its unsaved file count, then the runners. A machine appears when cbx status, get, submit or a workspace command runs there; `CODEROOK_NO_PRESENCE=1` keeps one off the list. Check it before assuming nobody else is mid-change.
+
 `cbx mcp --workspaces` opts into the remote workspace tools using this account's stored token. The original `cbx mcp` stays read-only. A token needs explicit workspace edit/run/deploy grants for those actions; never print its value. The remote plugin can connect directly without this CLI.
 
 Native jobs require CLI 0.38.0 or later on the selected Windows laptop and a matching `cbx runner --name` and label. The named recipe can select `includePaths` so only needed inputs download to a temporary job folder. Hosted jobs continue with the desktop PC off. Native execution, local GPU features, toolchains and signed-in services need their own suitable machine/setup. Remote task notes share project handover state, not proprietary chat history.