@illuminis/comprism 0.1.3 → 0.1.4

package/out/commands/skills.js

@@ -0,0 +1,207 @@
+"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.SKILLS_HELP = void 0;
+exports.skillRows = skillRows;
+exports.cmdSkills = cmdSkills;
+/**
+ * `comprism skills` (manual 9.1 to 9.4): the skills here, where each came
+ * from, and which one a closer skill hides; `skills add --personal <folder>`
+ * keeps a skill folder on your account.
+ *
+ * The service decides what counts as a skill, which one wins a name, and
+ * every word shown. This reads the files it names, inside the project and
+ * through the executor's own checks, lines up the columns, and for `add`
+ * reads the folder and sends it. Nothing in a skill folder is ever run.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const commandlist_1 = require("../lib/commandlist");
+const gateway_1 = require("../lib/gateway");
+const project_1 = require("../lib/project");
+const ui = __importStar(require("../lib/ui"));
+const ROUNDS = 6;
+/** What a folder sent with `add` may hold, beside its SKILL.md. The service
+ *  sets the same ceilings and says so when one is met. */
+const MAX_FILES = 20;
+const MAX_FILE_BYTES = 50_000;
+async function skillRows(folder, op = "list") {
+    const root = (0, project_1.resolveProject)(folder).root;
+    const files = {};
+    const listings = {};
+    for (let round = 0; round < ROUNDS; round += 1) {
+        const reply = await (0, gateway_1.ask)({ intent: "skills", prompt: "", skillsPayload: { op, round, files, listings, project: root } });
+        const body = reply.skills;
+        if (!reply.ok || reply.served === false || !body) {
+            return { rows: [], error: reply.message || "The skill list could not be read from your workspace." };
+        }
+        if (!body.wants) {
+            return op === "check"
+                ? { rows: [], checked: (body.rows ?? []) }
+                : { rows: body.rows ?? [], empty: body.empty };
+        }
+        for (const p of body.wants.read ?? [])
+            files[p] = (0, commandlist_1.readOne)(root, p);
+        for (const f of body.wants.list ?? [])
+            listings[f] = (0, commandlist_1.listOne)(root, f);
+    }
+    return { rows: [], error: "The skill list could not be completed." };
+}
+function draw(rows) {
+    const nameW = Math.min(24, Math.max(...rows.map((r) => r.name.length))) + 2;
+    const descW = Math.max(...rows.map((r) => r.description.length)) + 2;
+    return rows.map((r) => {
+        const line = `${r.name.padEnd(nameW)}${r.description.padEnd(descW)}${r.where}`;
+        const note = r.note ? `   ${r.note}` : "";
+        return r.active ? `${line}${ui.c.dim(note)}` : ui.c.dim(`${line}${note}`);
+    });
+}
+/** Every text file in a skill folder, by path relative to it, one level of
+ *  subfolder deep (a `references/` folder), within the ceilings. */
+function folderFiles(dir) {
+    const found = {};
+    const walk = (at, rel, depth) => {
+        for (const entry of fs.readdirSync(at, { withFileTypes: true })) {
+            if (Object.keys(found).length >= MAX_FILES)
+                return;
+            if (entry.name.startsWith("."))
+                continue;
+            const full = path.join(at, entry.name);
+            const inside = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (depth < 1)
+                    walk(full, inside, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || inside === "SKILL.md")
+                continue;
+            const stat = fs.statSync(full);
+            if (stat.size > MAX_FILE_BYTES)
+                continue;
+            const text = fs.readFileSync(full, "utf8");
+            if (text.includes("\u0000"))
+                continue;
+            found[inside] = text;
+        }
+    };
+    walk(dir, "", 0);
+    return found;
+}
+async function addPersonal(folder) {
+    const dir = path.resolve(folder);
+    const md = path.join(dir, "SKILL.md");
+    if (!fs.existsSync(md)) {
+        process.stdout.write(`  ${ui.fail(`${folder} has no SKILL.md directly inside it, so it is not a skill folder. Nothing was saved.`)}\n`);
+        return 2;
+    }
+    const reply = await (0, gateway_1.ask)({
+        intent: "skills", prompt: "",
+        skillsPayload: {
+            op: "add_personal", folder_name: path.basename(dir),
+            skill_md: fs.readFileSync(md, "utf8"), files: folderFiles(dir),
+        },
+    });
+    const body = reply.skills;
+    if (!reply.ok || reply.served === false || !body) {
+        process.stdout.write(`  ${ui.fail(reply.message || "The skill could not be saved to your account.")}\n`);
+        return 1;
+    }
+    if (body.error) {
+        process.stdout.write(`  ${ui.fail(body.error)}\n`);
+        return 1;
+    }
+    process.stdout.write(`  ${body.line ?? ""}\n`);
+    return 0;
+}
+async function removePersonal(name) {
+    const reply = await (0, gateway_1.ask)({ intent: "skills", prompt: "", skillsPayload: { op: "remove_personal", name } });
+    const body = reply.skills;
+    if (!reply.ok || reply.served === false || !body || body.error) {
+        process.stdout.write(`  ${ui.fail(body?.error || reply.message || "The skill could not be removed.")}\n`);
+        return 1;
+    }
+    process.stdout.write(`  ${body.line ?? ""}\n`);
+    return 0;
+}
+exports.SKILLS_HELP = `  comprism skills                          the skills here and where each came from
+  comprism skills add --personal <folder>  keep a skill folder on your account
+  comprism skills remove --personal <name> remove one of your own skills
+  comprism skills check                    what will not load, and how to fix it
+  In a session, /name followed by anything runs that skill with it.`;
+async function cmdSkills(args) {
+    const at = args.indexOf("--cwd");
+    const cwd = at >= 0 && args[at + 1] ? String(args[at + 1]) : process.cwd();
+    const [sub] = args.filter((a, i) => !a.startsWith("--") && args[i - 1] !== "--cwd" && args[i - 1] !== "--personal");
+    const personal = args.indexOf("--personal");
+    const target = personal >= 0 ? args[personal + 1] : undefined;
+    if (args.includes("--help") || args.includes("-h")) {
+        process.stdout.write(`${exports.SKILLS_HELP}\n`);
+        return 0;
+    }
+    if (sub === "add" || sub === "remove") {
+        if (!target) {
+            process.stdout.write(`  ${ui.fail(`comprism skills ${sub} takes --personal ${sub === "add" ? "<folder>" : "<name>"}. Nothing was changed.`)}\n`);
+            return 2;
+        }
+        return sub === "add" ? addPersonal(target) : removePersonal(target);
+    }
+    if (sub === "check") {
+        const found = await skillRows(cwd, "check");
+        if (found.error) {
+            process.stdout.write(`  ${ui.fail(found.error)}\n`);
+            return 1;
+        }
+        const tone = (level) => (level === "error" ? ui.c.red : level === "warn" ? ui.c.amber : ui.c.dim);
+        for (const r of found.checked ?? [])
+            process.stdout.write(`  ${tone(r.level)(r.level.padEnd(7))}${r.line}\n`);
+        return (found.checked ?? []).some((r) => r.level === "error") ? 1 : 0;
+    }
+    if (sub) {
+        process.stdout.write(`  ${ui.fail(`\`skills ${sub}\` is not a skills command.`)}\n${exports.SKILLS_HELP}\n`);
+        return 2;
+    }
+    const found = await skillRows(cwd);
+    if (found.error) {
+        process.stdout.write(`  ${ui.fail(found.error)}\n`);
+        return 1;
+    }
+    if (!found.rows.length) {
+        process.stdout.write(`  ${found.empty ?? ""}\n`);
+        return 0;
+    }
+    for (const line of draw(found.rows))
+        process.stdout.write(`  ${line}\n`);
+    return 0;
+}

package/out/commands/unattended.d.ts

@@ -0,0 +1,7 @@
+export declare function cmdSchedule(args: string[]): Promise<number>;
+export declare function cmdTriggers(args: string[]): Promise<number>;
+/** `comprism worker [--cloud] [--once]`: take and run what the service offers. */
+export declare function cmdWorker(args: string[]): Promise<number>;
+export declare function submitCloud(request: string, cwd: string, args: string[]): Promise<number>;
+/** Before resuming a session: apply what its cloud job changed, once (10.18). */
+export declare function handBack(sessionId: string, cwd: string): Promise<void>;

package/out/commands/unattended.js

@@ -0,0 +1,351 @@
+"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.cmdSchedule = cmdSchedule;
+exports.cmdTriggers = cmdTriggers;
+exports.cmdWorker = cmdWorker;
+exports.submitCloud = submitCloud;
+exports.handBack = handBack;
+/**
+ * `comprism schedule`, `comprism triggers`, `comprism worker`, `work --cloud`
+ * and bringing a cloud job back (manual 10.17 to 10.19).
+ *
+ * The service decides what runs, when, where and with which limits. This file
+ * sends what was typed, keeps a runner going, and does the physical part: a
+ * copy of the repository for a cloud job, the unattended job itself, and
+ * applying a cloud job's changes here when it is brought back.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const ui = __importStar(require("../lib/ui"));
+const queue_1 = require("../lib/queue");
+const project_1 = require("../lib/project");
+const self_1 = require("../lib/self");
+const out = (s = "") => process.stdout.write(`${s}\n`);
+const err = (s = "") => process.stderr.write(`${s}\n`);
+/** Values typed after flags, so they are never read as the request. */
+const VALUE_FLAGS = ["--mode", "--max-spend", "--max-steps", "--max-minutes", "--name"];
+function words(args) {
+    return args.filter((a, i) => !a.startsWith("--") && !VALUE_FLAGS.includes(String(args[i - 1])));
+}
+function failed(reply) {
+    if (!reply.ok)
+        return reply.message || "Your workspace could not be reached.";
+    if (reply.served === false)
+        return "Your workspace is running an older build that does not answer this yet.";
+    if (reply.granted === false)
+        return reply.message || "Refused.";
+    return null;
+}
+function printLines(lines) {
+    for (const line of lines ?? [])
+        out(`  ${line}`);
+}
+function startRunner() {
+    const w = (0, queue_1.ensureWorker)();
+    out(ui.c.dim(w.started
+        ? `  Started this machine's runner (process ${w.pid}); its log is ${(0, queue_1.workerLog)()}.`
+        : `  This machine's runner is going (process ${w.pid}).`));
+}
+// ── schedule (10.17) ─────────────────────────────────────────────────────────
+async function cmdSchedule(args) {
+    const [verb, ...rest] = args;
+    if (!verb || verb === "list") {
+        const reply = await (0, queue_1.queue)("schedule_list");
+        const why = failed(reply);
+        if (why) {
+            err(ui.fail(why));
+            return 1;
+        }
+        out();
+        printLines(reply.lines);
+        const running = (0, queue_1.workerRunning)();
+        out(ui.c.dim(running ? `  This machine's runner is going (process ${running}).`
+            : "  This machine's runner is not going; schedules here wait until it is: comprism worker"));
+        out();
+        return 0;
+    }
+    if (verb === "add") {
+        const [rule, request] = words(rest);
+        if (!rule || !request) {
+            err(ui.fail("Say when and what: comprism schedule add \"every weekday 08:00\" \"summarize failing tests\""));
+            return 2;
+        }
+        const reply = await (0, queue_1.queue)("schedule_add", {
+            rule, request, project_root: (0, project_1.resolveProject)(process.cwd()).root, options: (0, queue_1.limitsFrom)(rest),
+        });
+        const why = failed(reply);
+        if (why) {
+            err(ui.fail(why));
+            return reply.granted === false ? 2 : 1;
+        }
+        out();
+        printLines(reply.lines);
+        startRunner();
+        out();
+        return 0;
+    }
+    if (verb === "remove") {
+        const reply = await (0, queue_1.queue)("schedule_remove", { key: rest[0] ?? "" });
+        const why = failed(reply);
+        if (why) {
+            err(ui.fail(why));
+            return 1;
+        }
+        printLines(reply.lines);
+        return 0;
+    }
+    err(ui.fail(`\`schedule ${verb}\` is not a command. Use schedule, schedule add or schedule remove.`));
+    return 2;
+}
+// ── triggers (10.19) ─────────────────────────────────────────────────────────
+async function cmdTriggers(args) {
+    const [verb, ...rest] = args;
+    if (!verb || verb === "list") {
+        const reply = await (0, queue_1.queue)("trigger_list");
+        const why = failed(reply);
+        if (why) {
+            err(ui.fail(why));
+            return 1;
+        }
+        out();
+        printLines(reply.lines);
+        out();
+        return 0;
+    }
+    if (verb === "add") {
+        const [request] = words(rest);
+        if (!request) {
+            err(ui.fail("Say what each job should do: comprism triggers add \"investigate the failed CI run\""));
+            return 2;
+        }
+        const at = rest.indexOf("--name");
+        const reply = await (0, queue_1.queue)("trigger_add", {
+            request, target: "machine", name: at === -1 ? "" : rest[at + 1],
+            project_root: (0, project_1.resolveProject)(process.cwd()).root, options: (0, queue_1.limitsFrom)(rest),
+        });
+        const why = failed(reply);
+        if (why) {
+            err(ui.fail(why));
+            return reply.granted === false ? 2 : 1;
+        }
+        out();
+        printLines(reply.lines);
+        startRunner();
+        out();
+        return 0;
+    }
+    if (verb === "remove") {
+        const reply = await (0, queue_1.queue)("trigger_remove", { key: rest[0] ?? "" });
+        const why = failed(reply);
+        if (why) {
+            err(ui.fail(why));
+            return 1;
+        }
+        printLines(reply.lines);
+        return 0;
+    }
+    err(ui.fail(`\`triggers ${verb}\` is not a command. Use triggers, triggers add or triggers remove.`));
+    return 2;
+}
+function git(cwd, args, env) {
+    const r = (0, child_process_1.spawnSync)("git", args, { cwd, encoding: "utf8", env: { ...process.env, ...(env ?? {}) },
+        maxBuffer: 64 * 1024 * 1024 });
+    return { ok: r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}` };
+}
+/** Run one claimed job as an unattended `comprism work`, in `cwd`. */
+function runJob(job, cwd, extra = []) {
+    return new Promise((resolve) => {
+        // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process -- starts this same program again, every value a separate argument, no shell
+        const child = (0, child_process_1.spawn)(...(0, self_1.selfLaunch)(["work", "--yes", "--queued", job.id,
+            "--cwd", cwd, ...extra, job.request.slice(0, 2000)]), {
+            stdio: ["ignore", "inherit", "inherit"], env: { ...process.env, NO_COLOR: "1" },
+        });
+        child.on("exit", (code) => resolve(code ?? 1));
+        child.on("error", () => resolve(1));
+    });
+}
+async function runCloud(job) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "comprism-cloud-"));
+    const bundle = path.join(dir, "repo.bundle");
+    const work = path.join(dir, "repo");
+    try {
+        fs.writeFileSync(bundle, Buffer.from(job.bundle ?? "", "base64"));
+        fs.mkdirSync(work);
+        const steps = [["init", "-q"], ["fetch", "-q", bundle, "refs/comprism/cloud:refs/heads/work"],
+            ["checkout", "-q", "work"]];
+        for (const s of steps) {
+            const r = git(work, s);
+            if (!r.ok) {
+                await (0, queue_1.queue)("failed", { id: job.id, why: `the repository copy could not be opened: ${r.out.slice(0, 300)}` });
+                return;
+            }
+        }
+        const base = git(work, ["rev-parse", "HEAD"]).out.trim();
+        const { availability } = await Promise.resolve().then(() => __importStar(require("../executor/sandbox")));
+        const code = await runJob(job, work, availability().system ? ["--sandbox"] : []);
+        git(work, ["add", "-A"]);
+        const patch = git(work, ["diff", "--cached", "--binary", base]).out;
+        await (0, queue_1.queue)("result", { id: job.id, patch, result: { exit: code } });
+        out(`  cloud job ${job.id.slice(0, 8)} finished with exit ${code}; ${patch ? "changes" : "no changes"} sent back`);
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** `comprism worker [--cloud] [--once]`: take and run what the service offers. */
+async function cmdWorker(args) {
+    const cloud = args.includes("--cloud");
+    const once = args.includes("--once");
+    if (!cloud) {
+        const running = (0, queue_1.workerRunning)();
+        if (running && running !== process.pid) {
+            out(`  This machine's runner is already going (process ${running}).`);
+            return 0;
+        }
+        (0, queue_1.notePid)();
+    }
+    out(`  ${new Date().toISOString()}  runner started${cloud ? " for cloud jobs" : " for this machine"}`);
+    let stop = false;
+    process.on("SIGTERM", () => { stop = true; });
+    process.on("SIGINT", () => { stop = true; });
+    while (!stop) {
+        const reply = await (0, queue_1.queue)("claim", { cloud });
+        const why = failed(reply);
+        const job = reply.data?.job ?? null;
+        if (why) {
+            out(`  ${new Date().toISOString()}  ${why}`);
+        }
+        else if (job) {
+            out(`  ${new Date().toISOString()}  running ${job.source} job ${job.id.slice(0, 8)}: ${(job.request.split("\n")[0] ?? "").slice(0, 80)}`);
+            if (cloud) {
+                await runCloud(job);
+            }
+            else {
+                const folder = job.project_root && fs.existsSync(job.project_root) ? job.project_root : null;
+                if (!folder) {
+                    await (0, queue_1.queue)("failed", { id: job.id, why: `the project folder ${job.project_root} is not on this machine` });
+                }
+                else {
+                    const code = await runJob(job, folder);
+                    out(`  ${new Date().toISOString()}  job ${job.id.slice(0, 8)} ended with exit ${code}`);
+                    if (code === 1 || code === 6)
+                        await (0, queue_1.queue)("failed", { id: job.id, why: `ended with exit ${code}` });
+                }
+            }
+            if (once)
+                break;
+            continue;
+        }
+        if (once)
+            break;
+        await new Promise((r) => setTimeout(r, 15_000));
+    }
+    return 0;
+}
+// ── a cloud job (10.18) ──────────────────────────────────────────────────────
+/** The repository as it is now, working changes and new files included. */
+function repositoryCopy(root) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "comprism-copy-"));
+    const index = path.join(dir, "index");
+    const env = { GIT_INDEX_FILE: index };
+    const head = git(root, ["rev-parse", "HEAD"]);
+    if (!head.ok)
+        return { why: "this folder is not a Git repository with a commit, so it cannot be copied" };
+    git(root, ["read-tree", "HEAD"], env);
+    git(root, ["add", "-A"], env);
+    const tree = git(root, ["write-tree"], env);
+    const commit = git(root, ["commit-tree", tree.out.trim(), "-p", head.out.trim(), "-m", "comprism cloud copy"], { ...env, GIT_AUTHOR_NAME: "comprism", GIT_AUTHOR_EMAIL: "cloud@comprism",
+        GIT_COMMITTER_NAME: "comprism", GIT_COMMITTER_EMAIL: "cloud@comprism" });
+    if (!commit.ok)
+        return { why: `the working changes could not be copied: ${commit.out.slice(0, 200)}` };
+    const ref = "refs/comprism/cloud";
+    git(root, ["update-ref", ref, commit.out.trim()]);
+    const file = path.join(dir, "repo.bundle");
+    const made = git(root, ["bundle", "create", file, ref]);
+    git(root, ["update-ref", "-d", ref]);
+    return made.ok ? { file } : { why: `the copy could not be made: ${made.out.slice(0, 200)}` };
+}
+async function submitCloud(request, cwd, args) {
+    const root = (0, project_1.resolveProject)(cwd).root;
+    const copy = repositoryCopy(root);
+    if ("why" in copy) {
+        err(ui.fail(copy.why));
+        return 1;
+    }
+    const bundle = fs.readFileSync(copy.file).toString("base64");
+    fs.rmSync(path.dirname(copy.file), { recursive: true, force: true });
+    const reply = await (0, queue_1.queue)("submit_cloud", { request, bundle, options: (0, queue_1.limitsFrom)(args) });
+    const why = failed(reply);
+    if (why) {
+        err(ui.fail(why));
+        return reply.ok ? 1 : 6;
+    }
+    out();
+    printLines(reply.lines);
+    out();
+    return 0;
+}
+/** Before resuming a session: apply what its cloud job changed, once (10.18). */
+async function handBack(sessionId, cwd) {
+    const reply = await (0, queue_1.queue)("handback", { session_id: sessionId });
+    const data = (reply.data ?? {});
+    if (!reply.ok || !data.cloud)
+        return;
+    if (!data.ready) {
+        printLines(reply.lines);
+        return;
+    }
+    if (data.applied)
+        return;
+    const root = (0, project_1.resolveProject)(cwd).root;
+    if (!data.patch) {
+        out(ui.c.dim("  The cloud job changed no files."));
+    }
+    else {
+        const file = path.join(os.tmpdir(), `comprism-handback-${Date.now()}.patch`);
+        fs.writeFileSync(file, data.patch);
+        const applied = git(root, ["apply", "--3way", "--binary", file]);
+        fs.rmSync(file, { force: true });
+        if (!applied.ok) {
+            err(ui.fail(`The cloud job's changes could not be applied here: ${applied.out.slice(0, 300)}`));
+            return;
+        }
+        out(ui.ok("Applied the cloud job's changes to this folder."));
+    }
+    await (0, queue_1.queue)("handed_back", { id: data.id });
+}

package/out/commands/update.d.ts

@@ -0,0 +1 @@
+export declare function cmdUpdate(args: string[]): Promise<number>;