@lizard-build/cli 4.0.74 → 4.0.76

package/src/commands/sandbox.ts

@@ -58,6 +58,32 @@ function parseIntOption(v: string): number {
   return n;
 }
 
+const MAX_FORK_COUNT = 100;
+
+/** One entry per requested copy, in order: the new sandbox, or why it could not start. */
+interface ForkResult {
+  sandbox?: SandboxRecord & { forkedFrom?: string };
+  error?: string;
+}
+
+function parseForkCount(value: string): number {
+  const count = Number(value);
+  if (!/^\d+$/.test(value) || count < 1 || count > MAX_FORK_COUNT) {
+    throw new Error(`Count must be an integer from 1 to ${MAX_FORK_COUNT}`);
+  }
+  return count;
+}
+
+// The platform reads 0 (or nothing) as "the source's lifetime", so 0 can't mean "no limit" here
+// the way it does at create: refuse it rather than quietly give the copies something else.
+function parseForkTimeout(value: string): number {
+  const timeout = Number(value);
+  if (!/^\d+$/.test(value) || !Number.isSafeInteger(timeout) || timeout < 1000 || timeout > 2_147_483_647) {
+    throw new Error("Timeout must be an integer from 1000 to 2147483647 milliseconds; leave it out to keep the source's lifetime");
+  }
+  return timeout;
+}
+
 function parseTimeoutOption(value: string): number {
   const timeout = Number(value);
   if (!/^\d+$/.test(value) || !Number.isSafeInteger(timeout) || timeout > 2_147_483_647) {
@@ -266,8 +292,10 @@ export function registerSandbox(program: Command) {
       printSandboxList(sandboxes);
     });
 
+  // `kill` is what the SDK calls it (`sandbox.kill()`), so agents that know the SDK reach for
+  // it first; an unknown-command error there once left 20 sandboxes running.
   sb.command("rm")
-    .alias("delete")
+    .aliases(["delete", "kill"])
     .argument("<id>", "Sandbox ID")
     .description("Delete a sandbox")
     .option("-y, --yes", "Skip confirmation")
@@ -553,6 +581,40 @@ Examples:
       else success(`Sandbox ${chalk.bold(sandbox.id)} created from ${snapshot.name}`);
     });
 
+  sb.command("fork")
+    .argument("<id>", "Running sandbox ID")
+    .option("-n, --count <n>", `Copies to start (1-${MAX_FORK_COUNT})`, parseForkCount, 1)
+    .option("--timeout <ms>", "Lifetime of each copy in milliseconds; default: the source's", parseForkTimeout)
+    .description("Start live copies of a running sandbox: memory, processes and files")
+    .action(async (id: string, opts) => {
+      // The platform pauses the source for a moment, captures it and boots every copy from that
+      // one capture. Each copy is a sandbox start and counts toward the account's limits, so a
+      // partial result is normal near a limit: one entry per copy, `sandbox` or `error`.
+      const spinner = isJSONMode() ? null : ora(`Forking ${id}...`).start();
+      let results: ForkResult[];
+      try {
+        results = await api.post<ForkResult[]>(`/api/sandboxes/${id}/fork`, { count: opts.count, timeoutMs: opts.timeout });
+      } finally {
+        spinner?.stop();
+      }
+      if (!Array.isArray(results)) results = [];
+      const started = results.flatMap((r) => (r.sandbox ? [r.sandbox] : []));
+      const failed = results.length - started.length;
+      // Copies that did start are running and billed: print them, but don't exit 0 on a short count.
+      if (failed > 0 || started.length === 0) process.exitCode = 1;
+      if (isJSONMode()) {
+        printJSON(results);
+        return;
+      }
+      if (started.length) {
+        const copies = (n: number) => `${n} ${n === 1 ? "copy" : "copies"}`;
+        success(`Forked ${chalk.bold(id)}: ${failed ? `${started.length} of ${copies(results.length)}` : copies(started.length)} running`);
+        printSandboxList(started);
+        info(chalk.dim(lifetimeLine(started[0].expiresAt ?? started[0].endAt)));
+      }
+      results.forEach((r, i) => { if (!r.sandbox) error(`Copy ${i + 1}: ${r.error ?? "fork failed"}`); });
+    });
+
   // Warm pools exist only for CRIU snapshots of runc pod sandboxes, which are no longer
   // created. These stay, out of the help, for the few such snapshots still around.
   for (const operation of ["pause", "resume"] as const) {

package/src/lib/checkout.ts

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
 import { APIError } from "./api.js";
 import { gitURL, lg, repoPath, sendRaw } from "./lizard-git.js";
+import { hasConflictMarkers, merge3 } from "./merge3.js";
 
 /**
  * A Lizard Git working copy (after Scion: lizard.build/git keeps no repositories as files and
@@ -58,6 +59,12 @@ export interface Checkout {
   sparse: string[] | null; // folders (or files) checked out; null: everything
   files: Record<string, FileState>;
   pending?: Pending; // commits made here, not pushed
+  conflicts?: Conflict[]; // left by the last sync for a person to fix (cleared by a commit)
+}
+
+export interface Conflict {
+  path: string;
+  reason: string;
 }
 
 interface WireEntry {
@@ -402,12 +409,17 @@ export interface SyncResult {
   to: string;
   updated: string[];
   removed: string[];
+  merged?: string[]; // changed here and on the branch: merged line by line
+  conflicts?: Conflict[]; // changed here and on the branch the same lines: marked in the file
 }
 
+const isBinaryBuf = (b: Buffer) => b.subarray(0, 8000).includes(0);
+
 /**
- * Bring the files to the branch's tip (or another branch: switching). Local changes are kept;
- * if the tip changed the same files, nothing is touched and the conflict comes back: commit
- * first, and the server merges.
+ * Bring the files to the branch's tip (or another branch: switching). Local changes are kept.
+ * A file changed here and on the branch is merged here line by line, as the server merges:
+ * what both changed differently is written between conflict markers for a person to choose,
+ * and listed in the result (and in status until the next commit).
  */
 export async function sync(root: string, c: Checkout, toBranch?: string): Promise<SyncResult> {
   needNoPending(c);
@@ -432,11 +444,57 @@ export async function sync(root: string, c: Checkout, toBranch?: string): Promis
     const w = want.get(p);
     return !(l && w && l.h === w.h && l.m === w.m); // the same change on both sides is fine
   });
+  const clashSet = new Set(clash);
+  const merged: string[] = [];
+  const conflicts: Conflict[] = [];
   if (clash.length) {
-    throw new APIError(409, `${branch} changed files you changed too: ${clash.slice(0, 10).join(", ")}${clash.length > 10 ? ", ..." : ""}. Commit and push them (lizard git commit --push -m "..."): the server merges them line by line.`);
+    const need = new Set<string>();
+    for (const p of clash) {
+      if (c.files[p]) need.add(c.files[p].h);
+      const w = want.get(p);
+      if (w) need.add(w.h);
+    }
+    const got = await getBlobs(c.repo, [...need]);
+    for (const p of clash) {
+      const baseF = c.files[p];
+      const w = want.get(p);
+      const l = local.get(p);
+      if (!l && !w) {
+        delete c.files[p]; // deleted on both sides
+        continue;
+      }
+      if (!l) {
+        // Deleted here, changed on the branch: theirs comes back; deleting it again is one rm away.
+        c.files[p] = writeFile(root, p, got.get(w!.h)!, w!.m);
+        conflicts.push({ path: p, reason: `you deleted it, ${branch} changed it: their version is back (delete it again if you meant to)` });
+        continue;
+      }
+      if (!w) {
+        // Deleted on the branch, changed here: yours stays (it is new to the branch now).
+        delete c.files[p];
+        conflicts.push({ path: p, reason: `${branch} deleted it, you changed it: your version is kept` });
+        continue;
+      }
+      const full = safeJoin(root, p);
+      const ours = l.m === "120000" ? Buffer.from(readlinkSync(full)) : readFileSync(full);
+      const base = baseF ? got.get(baseF.h)! : Buffer.alloc(0);
+      const theirs = got.get(w.h)!;
+      c.files[p] = { h: w.h, m: w.m }; // the branch's version is what yours now differs from
+      if (l.m === "120000" || w.m === "120000" || isBinaryBuf(base) || isBinaryBuf(ours) || isBinaryBuf(theirs)) {
+        writeFileSync(full + ".theirs", theirs);
+        conflicts.push({ path: p, reason: `binary, changed on both sides: yours kept, theirs saved as ${p}.theirs` });
+        continue;
+      }
+      const r = merge3(base.toString("utf8"), ours.toString("utf8"), theirs.toString("utf8"), branch);
+      // Yours kept its mode unless only the branch changed it.
+      writeFile(root, p, Buffer.from(r.text, "utf8"), baseF && l.m === baseF.m ? w.m : l.m);
+      if (r.conflicts) conflicts.push({ path: p, reason: `${r.conflicts} place${r.conflicts === 1 ? "" : "s"} both changed: marked <<<<<<< yours / ======= / >>>>>>> ${branch}` });
+      else merged.push(p);
+    }
   }
   const blobs = await getBlobs(c.repo, toWrite.filter(([p]) => !dirty.has(p)).map(([, f]) => f.h));
   for (const [p, f] of toWrite) {
+    if (clashSet.has(p)) continue;
     if (dirty.has(p)) {
       c.files[p] = { ...local.get(p)!, h: f.h, m: f.m }; // already identical locally
       continue;
@@ -445,6 +503,7 @@ export async function sync(root: string, c: Checkout, toBranch?: string): Promis
     res.updated.push(p);
   }
   for (const p of toRemove) {
+    if (clashSet.has(p)) continue;
     if (!dirty.has(p)) removeFile(root, p);
     delete c.files[p];
     res.removed.push(p);
@@ -452,7 +511,10 @@ export async function sync(root: string, c: Checkout, toBranch?: string): Promis
   c.base = r.id;
   c.root = r.root;
   c.branch = branch;
+  if (conflicts.length) c.conflicts = [...(c.conflicts ?? []).filter((x) => !conflicts.some((y) => y.path === x.path)), ...conflicts];
   saveCheckout(root, c);
+  if (merged.length) res.merged = merged;
+  if (conflicts.length) res.conflicts = conflicts;
   return res;
 }
 
@@ -473,7 +535,7 @@ export interface LocalCommitResult {
 }
 
 /** Record a commit of the changed files (all, or those under paths) here; push sends it. */
-export function commitLocal(root: string, c: Checkout, message: string, paths: string[], newBranch?: string): LocalCommitResult {
+export function commitLocal(root: string, c: Checkout, message: string, paths: string[], newBranch?: string, force = false): LocalCommitResult {
   const local = scanWorking(root, c);
   const ch = changesOf(c, local);
   const pick = (p: string) => !paths.length || paths.some((x) => p === x || p.startsWith(x.replace(/\/+$/, "") + "/"));
@@ -481,6 +543,15 @@ export function commitLocal(root: string, c: Checkout, message: string, paths: s
   const deleted = ch.deleted.filter(pick);
   if (!changed.length && !deleted.length) throw new APIError(400, "nothing to commit: no changes");
   if (newBranch && c.pending?.commits.length) throw new APIError(409, "push the commits on this branch before starting another (lizard git push)");
+  if (!force) {
+    const marked = changed.filter((p) => {
+      const f = local.get(p)!;
+      if (f.m === "120000" || f.s > 8 << 20) return false;
+      const b = readFileSync(safeJoin(root, p));
+      return !isBinaryBuf(b) && hasConflictMarkers(b.toString("utf8"));
+    });
+    if (marked.length) throw new APIError(409, `conflict markers left in ${marked.join(", ")}: choose between yours and theirs there first (or commit --force)`);
+  }
   // Keep the contents as they are now: later edits don't change a commit.
   for (const p of changed) {
     const f = local.get(p)!;
@@ -506,6 +577,10 @@ export function commitLocal(root: string, c: Checkout, message: string, paths: s
   for (const p of changed) c.files[p] = { ...local.get(p)! };
   for (const p of deleted) delete c.files[p];
   if (newBranch) c.branch = newBranch;
+  if (c.conflicts) {
+    c.conflicts = c.conflicts.filter((x) => !changed.includes(x.path) && !deleted.includes(x.path));
+    if (!c.conflicts.length) delete c.conflicts;
+  }
   saveCheckout(root, c);
   return { branch: c.branch, files: changed.length + deleted.length, pending: c.pending.commits.length };
 }
@@ -527,11 +602,13 @@ export function uncommit(root: string, c: Checkout): number {
 }
 
 export interface PushResult {
+  pushed: boolean; // false: conflicts; the commits are changes in the files again, merged with the branch
   shas: string[];
   sha: string;
   branch: string;
   uploaded: number;
   sync: SyncResult;
+  messages?: string[]; // when not pushed: the commits' messages, to commit again
 }
 
 /** Send the commits not pushed: one branch move; then bring in others' commits if there were any. */
@@ -558,7 +635,19 @@ export async function push(root: string, c: Checkout): Promise<PushResult> {
   const body: Record<string, unknown> = { branch: c.branch, commits: pend.commits };
   if (pend.newBranch && pend.base) body.createFrom = pend.base;
   else if (pend.base) body.expect = pend.base;
-  const r = await lg.post<{ shas: string[]; sha: string; parent?: string; root?: string }>(`${repoPath(c.repo)}/push`, body);
+  let r: { shas: string[]; sha: string; parent?: string; root?: string };
+  try {
+    r = await lg.post<{ shas: string[]; sha: string; parent?: string; root?: string }>(`${repoPath(c.repo)}/push`, body);
+  } catch (e) {
+    const conflicts = e instanceof APIError && e.status === 409 ? (e.body as { conflicts?: string[] } | null)?.conflicts : undefined;
+    if (!conflicts?.length) throw e;
+    // Someone changed the same lines: bring their commits here and merge in the files, so the
+    // person sees exactly what to choose; then commit and push again.
+    const messages = pend.commits.map((x) => x.message.trim());
+    uncommit(root, c);
+    const s = await sync(root, c);
+    return { pushed: false, shas: [], sha: "", branch: c.branch, uploaded: missing.size, sync: s, messages };
+  }
   const from = pend.base;
   c.pending = undefined;
   rmSync(join(root, STATE_DIR, "objects"), { recursive: true, force: true });
@@ -567,11 +656,11 @@ export async function push(root: string, c: Checkout): Promise<PushResult> {
     c.base = r.sha;
     c.root = r.root;
     saveCheckout(root, c);
-    return { shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: { from, to: r.sha, updated: [], removed: [] } };
+    return { pushed: true, shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: { from, to: r.sha, updated: [], removed: [] } };
   }
   saveCheckout(root, c);
   const s = await sync(root, c);
-  return { shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: s };
+  return { pushed: true, shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: s };
 }
 
 export interface CommitResult {

package/src/lib/merge3.ts

@@ -0,0 +1,179 @@
+/**
+ * Three-way line merge, as Lizard Git's server merges (lizard-git-server internal/store/merge.go,
+ * merge3): the changes each side made to base are combined; changes to different lines (even
+ * neighbouring ones) merge, the same change on both sides is taken once, and only lines both
+ * sides changed differently conflict. Where the server refuses, this writes both versions
+ * between conflict markers, for a person to choose, as git does.
+ */
+
+export const MARK_OURS = "<<<<<<< yours";
+export const MARK_SEP = "=======";
+export const MARK_THEIRS = ">>>>>>>";
+
+/** Lines with their line endings kept (the last one may have none). */
+export function splitLines(s: string): string[] {
+  const out: string[] = [];
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\n") {
+      out.push(s.slice(start, i + 1));
+      start = i + 1;
+    }
+  }
+  if (start < s.length) out.push(s.slice(start));
+  return out;
+}
+
+interface Op {
+  k: " " | "-" | "+";
+  a: number; // index in base
+  b: number; // index in side
+}
+
+/** Myers' diff of two line lists. */
+export function diffLines(A: string[], B: string[]): Op[] {
+  const n = A.length;
+  const m = B.length;
+  const max = n + m;
+  const v: number[] = new Array(2 * max + 2).fill(0);
+  const trace: number[][] = [];
+  outer: for (let d = 0; d <= max; d++) {
+    trace.push(v.slice());
+    for (let k = -d; k <= d; k += 2) {
+      let x = k === -d || (k !== d && v[max + k - 1] < v[max + k + 1]) ? v[max + k + 1] : v[max + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && A[x] === B[y]) {
+        x++;
+        y++;
+      }
+      v[max + k] = x;
+      if (x >= n && y >= m) break outer;
+    }
+  }
+  const ops: Op[] = [];
+  let x = n;
+  let y = m;
+  for (let d = trace.length - 1; d >= 0; d--) {
+    const vd = trace[d];
+    const k = x - y;
+    const pk = k === -d || (k !== d && vd[max + k - 1] < vd[max + k + 1]) ? k + 1 : k - 1;
+    const px = vd[max + pk];
+    const py = px - pk;
+    while (x > px && y > py) ops.unshift({ k: " ", a: --x, b: --y });
+    if (d > 0) {
+      if (x === px) ops.unshift({ k: "+", a: x, b: --y });
+      else ops.unshift({ k: "-", a: --x, b: y });
+    }
+  }
+  return ops;
+}
+
+/** Base lines [start, end) replaced by lines. */
+interface Region {
+  start: number;
+  end: number;
+  lines: string[];
+}
+
+function changeRegions(base: string[], side: string[]): Region[] {
+  const out: Region[] = [];
+  let cur: Region | null = null;
+  for (const o of diffLines(base, side)) {
+    if (o.k === " ") {
+      if (cur) out.push(cur);
+      cur = null;
+      continue;
+    }
+    if (!cur) cur = { start: o.a, end: o.a, lines: [] };
+    if (o.k === "-") cur.end = o.a + 1;
+    else cur.lines.push(side[o.b]);
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+function overlaps(a: Region, b: Region): boolean {
+  // Touching insertions at the same point conflict too, as in git (and the server).
+  return (a.start < b.end && b.start < a.end) || a.start === b.start || (a.start === a.end && a.start === b.end) || (b.start === b.end && b.start === a.end);
+}
+
+function apply(base: string[], r: { start: number; end: number }, rs: Region[]): string {
+  let s = "";
+  let pos = r.start;
+  for (const x of rs) {
+    for (; pos < x.start; pos++) s += base[pos];
+    s += x.lines.join("");
+    pos = x.end;
+  }
+  for (; pos < r.end; pos++) s += base[pos];
+  return s;
+}
+
+const withEOL = (s: string) => (s === "" || s.endsWith("\n") ? s : s + "\n");
+
+export interface MergeResult {
+  text: string;
+  conflicts: number; // regions between markers
+}
+
+/** Merge ours and theirs over base; conflicting regions are written with markers. */
+export function merge3(base: string, ours: string, theirs: string, theirsLabel = "theirs"): MergeResult {
+  const b = splitLines(base);
+  const co = changeRegions(b, splitLines(ours));
+  const ct = changeRegions(b, splitLines(theirs));
+  let out = "";
+  let conflicts = 0;
+  let pos = 0;
+  let i = 0;
+  let j = 0;
+  while (i < co.length || j < ct.length) {
+    let r: { start: number; end: number };
+    const fromO: Region[] = [];
+    const fromT: Region[] = [];
+    if (j >= ct.length || (i < co.length && co[i].start <= ct[j].start)) {
+      r = { start: co[i].start, end: co[i].end };
+      fromO.push(co[i++]);
+    } else {
+      r = { start: ct[j].start, end: ct[j].end };
+      fromT.push(ct[j++]);
+    }
+    for (let grew = true; grew; ) {
+      grew = false;
+      while (i < co.length && overlaps(co[i], { ...r, lines: [] })) {
+        r = { start: Math.min(r.start, co[i].start), end: Math.max(r.end, co[i].end) };
+        fromO.push(co[i++]);
+        grew = true;
+      }
+      while (j < ct.length && overlaps(ct[j], { ...r, lines: [] })) {
+        r = { start: Math.min(r.start, ct[j].start), end: Math.max(r.end, ct[j].end) };
+        fromT.push(ct[j++]);
+        grew = true;
+      }
+    }
+    for (; pos < r.start; pos++) out += b[pos];
+    if (!fromT.length) out += apply(b, r, fromO);
+    else if (!fromO.length) out += apply(b, r, fromT);
+    else {
+      const mo = apply(b, r, fromO);
+      const mt = apply(b, r, fromT);
+      if (mo === mt) out += mo;
+      else {
+        conflicts++;
+        out += `${MARK_OURS}\n${withEOL(mo)}${MARK_SEP}\n${withEOL(mt)}${MARK_THEIRS} ${theirsLabel}\n`;
+      }
+    }
+    pos = r.end;
+  }
+  for (; pos < b.length; pos++) out += b[pos];
+  return { text: out, conflicts };
+}
+
+/** Whether text still holds conflict markers (a whole marker line from merge3). */
+export function hasConflictMarkers(text: string): boolean {
+  let ours = false;
+  for (const l of text.split("\n")) {
+    if (l === MARK_OURS) ours = true;
+    else if (ours && l.startsWith(MARK_THEIRS + " ")) return true;
+  }
+  return false;
+}

package/src/lib/updater.ts

@@ -5,7 +5,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
 
-export const CURRENT_VERSION = "4.0.74";
+export const CURRENT_VERSION = "4.0.76";
 const RELEASES_API = "https://api.github.com/repos/lizard-build/lizard-cli/releases/latest";
 const RELEASE_BASE = "https://github.com/lizard-build/lizard-cli/releases/latest/download";
 

package/test/unit/merge3.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { hasConflictMarkers, merge3 } from "../../src/lib/merge3.js";
+
+const L = (...xs: string[]) => xs.map((x) => x + "\n").join("");
+const ten = Array.from({ length: 10 }, (_, i) => `line ${i + 1}`);
+
+describe("merge3 (as the server merges)", () => {
+  it("merges changes to different lines, even neighbouring ones", () => {
+    const base = L(...ten);
+    expect(merge3(base, L("LINE 1", ...ten.slice(1)), L(...ten.slice(0, 9), "LINE 10"))).toEqual({ text: L("LINE 1", ...ten.slice(1, 9), "LINE 10"), conflicts: 0 });
+    expect(merge3(base, L(...ten.slice(0, 4), "LINE 5", ...ten.slice(5)), L(...ten.slice(0, 5), "LINE 6", ...ten.slice(6))).text)
+      .toBe(L(...ten.slice(0, 4), "LINE 5", "LINE 6", ...ten.slice(6)));
+  });
+  it("takes the same change once", () => {
+    const x = L(...ten.slice(0, 4), "SAME", ...ten.slice(5));
+    expect(merge3(L(...ten), x, x)).toEqual({ text: x, conflicts: 0 });
+  });
+  it("marks lines both changed differently, and merges the rest", () => {
+    const base = L(...ten);
+    const r = merge3(base, L("TOP", ...ten.slice(1, 4), "OURS", ...ten.slice(5)), L(...ten.slice(0, 4), "THEIRS", ...ten.slice(5, 9), "BOTTOM"), "main");
+    expect(r.conflicts).toBe(1);
+    expect(r.text).toBe(L("TOP", ...ten.slice(1, 4), "<<<<<<< yours", "OURS", "=======", "THEIRS", ">>>>>>> main", ...ten.slice(5, 9), "BOTTOM"));
+    expect(hasConflictMarkers(r.text)).toBe(true);
+  });
+  it("both appending at the end conflicts (as in git)", () => {
+    const r = merge3(L("a"), L("a", "ours"), L("a", "theirs"));
+    expect(r.conflicts).toBe(1);
+  });
+  it("keeps CRLF and a missing final newline", () => {
+    expect(merge3("a\r\nb\r\nc\r\nd\r\n", "A\r\nb\r\nc\r\nd\r\n", "a\r\nb\r\nc\r\nD\r\n").text).toBe("A\r\nb\r\nc\r\nD\r\n");
+    expect(merge3("a\nb\nc\nd", "A\nb\nc\nd", "a\nb\nc\nD").text).toBe("A\nb\nc\nD");
+  });
+  it("a file both added differently: everything is one marked region", () => {
+    const r = merge3("", "ours\n", "theirs\n");
+    expect(r.text).toBe("<<<<<<< yours\nours\n=======\ntheirs\n>>>>>>> theirs\n");
+  });
+  it("marker detection needs whole marker lines", () => {
+    expect(hasConflictMarkers("x <<<<<<< yours\n")).toBe(false);
+    expect(hasConflictMarkers("a\n=======\nb\n")).toBe(false);
+  });
+});

package/test/unit/sandbox.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { Command } from "commander";
 import { registerSandbox, lifetimeLine, sandboxNextSteps } from "../../src/commands/sandbox.js";
 import { api, APIError } from "../../src/lib/api.js";
@@ -84,7 +84,7 @@ describe("sandbox create without a project", () => {
 });
 
 describe("unsupported sandbox commands", () => {
-  it.each(["fork", "snapshot-fork", "logs"])(
+  it.each(["snapshot-fork", "logs"])(
     "rejects %s without making an API request", async (name) => {
       vi.clearAllMocks();
       const program = new Command().exitOverride().configureOutput({ writeErr: () => {} });
@@ -98,6 +98,61 @@ describe("unsupported sandbox commands", () => {
   );
 });
 
+function sandboxCmd(args: string[]) {
+  const program = new Command().exitOverride().configureOutput({ writeErr: () => {} });
+  registerSandbox(program);
+  return program.parseAsync(["sandbox", ...args], { from: "user" });
+}
+
+describe("sandbox rm aliases", () => {
+  beforeEach(() => { vi.clearAllMocks(); vi.mocked(api.delete).mockResolvedValue(undefined); });
+
+  it.each(["rm", "delete", "kill"])("%s deletes the sandbox", async (name) => {
+    await sandboxCmd([name, "brave-otter-1234", "-y"]);
+    expect(api.delete).toHaveBeenCalledWith("/api/sandboxes/brave-otter-1234");
+    expect(printJSON).toHaveBeenCalledWith({ id: "brave-otter-1234", status: "deleted" });
+  });
+});
+
+describe("sandbox fork", () => {
+  const copy = (id: string) => ({ sandbox: { sandboxId: id, id, status: "running", forkedFrom: "src-1234" } });
+  beforeEach(() => { vi.clearAllMocks(); process.exitCode = undefined; });
+  afterEach(() => { process.exitCode = undefined; });
+
+  it("asks for one copy with the source's lifetime by default", async () => {
+    vi.mocked(api.post).mockResolvedValue([copy("a-1")]);
+    await sandboxCmd(["fork", "src-1234"]);
+    expect(api.post).toHaveBeenCalledWith("/api/sandboxes/src-1234/fork", { count: 1, timeoutMs: undefined });
+    expect(printJSON).toHaveBeenCalledWith([copy("a-1")]);
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it("sends --count and --timeout", async () => {
+    vi.mocked(api.post).mockResolvedValue([copy("a-1"), copy("a-2"), copy("a-3")]);
+    await sandboxCmd(["fork", "src-1234", "-n", "3", "--timeout", "900000"]);
+    expect(api.post).toHaveBeenCalledWith("/api/sandboxes/src-1234/fork", { count: 3, timeoutMs: 900_000 });
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it("prints a partial result and exits 1 when some copies could not start", async () => {
+    const results = [copy("a-1"), { error: "Sandbox limit reached" }];
+    vi.mocked(api.post).mockResolvedValue(results);
+    await sandboxCmd(["fork", "src-1234", "--count", "2"]);
+    expect(printJSON).toHaveBeenCalledWith(results);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it.each(["0", "101", "1.5", "two"])("rejects --count %s before making a request", async (n) => {
+    await expect(sandboxCmd(["fork", "src-1234", "--count", n])).rejects.toThrow(/Count must be/);
+    expect(api.post).not.toHaveBeenCalled();
+  });
+
+  it.each(["0", "999", "2147483648", "1h"])("rejects --timeout %s, since 0 would mean the source's lifetime", async (ms) => {
+    await expect(sandboxCmd(["fork", "src-1234", "--timeout", ms])).rejects.toThrow(/Timeout must be/);
+    expect(api.post).not.toHaveBeenCalled();
+  });
+});
+
 describe("private sandbox snapshots", () => {
   beforeEach(() => { vi.clearAllMocks(); vi.mocked(api.post).mockResolvedValue({ id: 'snap-test', status: 'building' }); });
   it("creates a snapshot without a pool size", async () => {