@lizard-build/cli 4.0.72 → 4.0.73

package/src/lib/checkout.ts

@@ -16,10 +16,11 @@ import { gitURL, lg, repoPath, sendRaw } from "./lizard-git.js";
  * checkout on this machine (~/.cache/lizard/git; immutable, so it never needs invalidating),
  * and a sparse checkout only ever fetches the folders it covers.
  *
- * `commit` sends what changed: the server is asked which contents it lacks, those are
- * uploaded, then one request makes the commit on the branch. If the branch moved since base,
- * the server places the change on the new tip (merging the same files line by line); only a
- * real conflict comes back.
+ * `commit` records a commit here (pending, with copies of its contents under
+ * .lizard-git/objects/); `push` sends every pending commit: the server is asked which contents
+ * it lacks, those are uploaded, then one request makes the commits on the branch and moves it
+ * once (one CI run, one deploy). If the branch moved since they were made, the server places
+ * them on the new tip (merging the same files line by line); only a real conflict comes back.
  */
 
 export const STATE_DIR = ".lizard-git";
@@ -32,6 +33,21 @@ export interface FileState {
   t?: number;
 }
 
+/** A commit made here and not pushed yet: its files' states (full contents, by hash). */
+export interface PendingCommit {
+  message: string;
+  time: number; // unix seconds
+  files: ({ path: string; hash: string; mode: string } | { path: string; delete: true })[];
+}
+
+export interface Pending {
+  base: string; // the commit the first one was made on ("" in an empty repository)
+  newBranch?: boolean; // the branch doesn't exist on the server yet (commit -b): push creates it at base
+  fromBranch?: string; // with newBranch: the branch the checkout was on
+  commits: PendingCommit[];
+  orig: Record<string, FileState | null>; // the touched files' states at base (null: not there), for uncommit
+}
+
 export interface Checkout {
   version: 1;
   url: string;
@@ -41,6 +57,7 @@ export interface Checkout {
   root: string; // its root tree
   sparse: string[] | null; // folders (or files) checked out; null: everything
   files: Record<string, FileState>;
+  pending?: Pending; // commits made here, not pushed
 }
 
 interface WireEntry {
@@ -393,6 +410,7 @@ export interface SyncResult {
  * first, and the server merges.
  */
 export async function sync(root: string, c: Checkout, toBranch?: string): Promise<SyncResult> {
+  needNoPending(c);
   const branch = toBranch ?? c.branch;
   const r = await lg.get<{ id: string; root: string }>(`${repoPath(c.repo)}/resolve?rev=${encodeURIComponent(branch)}`);
   const res: SyncResult = { from: c.base, to: r.id, updated: [], removed: [] };
@@ -415,7 +433,7 @@ export async function sync(root: string, c: Checkout, toBranch?: string): Promis
     return !(l && w && l.h === w.h && l.m === w.m); // the same change on both sides is fine
   });
   if (clash.length) {
-    throw new APIError(409, `${branch} changed files you changed too: ${clash.slice(0, 10).join(", ")}${clash.length > 10 ? ", ..." : ""}. Commit first (lizard git commit): the server merges them line by line.`);
+    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 blobs = await getBlobs(c.repo, toWrite.filter(([p]) => !dirty.has(p)).map(([, f]) => f.h));
   for (const [p, f] of toWrite) {
@@ -438,6 +456,124 @@ export async function sync(root: string, c: Checkout, toBranch?: string): Promis
   return res;
 }
 
+/** Refuse what would move this checkout's base while commits wait to be pushed. */
+export function needNoPending(c: Checkout): void {
+  const n = c.pending?.commits.length ?? 0;
+  if (n) throw new APIError(409, `${n} commit${n === 1 ? "" : "s"} not pushed yet: lizard git push first (the server puts them on top of others' commits), or lizard git uncommit`);
+}
+
+function objectPath(root: string, h: string): string {
+  return join(root, STATE_DIR, "objects", h.slice(0, 2), h);
+}
+
+export interface LocalCommitResult {
+  branch: string;
+  files: number;
+  pending: number; // commits waiting to be pushed, this one included
+}
+
+/** 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 {
+  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(/\/+$/, "") + "/"));
+  const changed = [...ch.added, ...ch.modified].filter(pick);
+  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)");
+  // Keep the contents as they are now: later edits don't change a commit.
+  for (const p of changed) {
+    const f = local.get(p)!;
+    const dst = objectPath(root, f.h);
+    if (existsSync(dst)) continue;
+    const full = safeJoin(root, p);
+    const content = f.m === "120000" ? Buffer.from(readlinkSync(full)) : readFileSync(full);
+    if (sha256(content) !== f.h) throw new APIError(409, `${p} changed while committing; try again`);
+    mkdirSync(dirname(dst), { recursive: true });
+    writeFileSync(dst + ".tmp", content);
+    renameSync(dst + ".tmp", dst);
+  }
+  if (!c.pending) c.pending = { base: c.base, commits: [], orig: {}, ...(newBranch ? { newBranch: true, fromBranch: c.branch } : {}) };
+  for (const p of [...changed, ...deleted]) if (!(p in c.pending.orig)) c.pending.orig[p] = c.files[p] ?? null;
+  c.pending.commits.push({
+    message,
+    time: Math.floor(Date.now() / 1000),
+    files: [
+      ...changed.map((p) => ({ path: p, hash: local.get(p)!.h, mode: local.get(p)!.m })),
+      ...deleted.map((p) => ({ path: p, delete: true as const })),
+    ],
+  });
+  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;
+  saveCheckout(root, c);
+  return { branch: c.branch, files: changed.length + deleted.length, pending: c.pending.commits.length };
+}
+
+/** Turn the commits not pushed back into changes in the files (their messages are dropped). */
+export function uncommit(root: string, c: Checkout): number {
+  const n = c.pending?.commits.length ?? 0;
+  if (!c.pending) return 0;
+  for (const [p, f] of Object.entries(c.pending.orig)) {
+    if (f) c.files[p] = f;
+    else delete c.files[p];
+  }
+  // A branch that never reached the server: back on the one it started from.
+  if (c.pending.newBranch && c.pending.fromBranch) c.branch = c.pending.fromBranch;
+  c.pending = undefined;
+  rmSync(join(root, STATE_DIR, "objects"), { recursive: true, force: true });
+  saveCheckout(root, c);
+  return n;
+}
+
+export interface PushResult {
+  shas: string[];
+  sha: string;
+  branch: string;
+  uploaded: number;
+  sync: SyncResult;
+}
+
+/** Send the commits not pushed: one branch move; then bring in others' commits if there were any. */
+export async function push(root: string, c: Checkout): Promise<PushResult> {
+  const pend = c.pending;
+  if (!pend?.commits.length) throw new APIError(400, "nothing to push: no commits waiting (lizard git commit -m \"...\")");
+  const hashes = [...new Set(pend.commits.flatMap((x) => x.files.flatMap((f) => ("hash" in f ? [f.hash] : []))))];
+  const missing = new Set<string>();
+  for (let i = 0; i < hashes.length; i += 5000) {
+    const r = await lg.post<{ missing: string[] }>(`${repoPath(c.repo)}/blobs/missing`, { hashes: hashes.slice(i, i + 5000) });
+    for (const h of r.missing) missing.add(h);
+  }
+  const list = [...missing];
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(6, list.length) }, async () => {
+    while (next < list.length) {
+      const h = list[next++];
+      const content = readFileSync(objectPath(root, h));
+      if (sha256(content) !== h) throw new APIError(409, `.lizard-git/objects/${h.slice(0, 12)} is damaged`);
+      await sendRaw("PUT", `${repoPath(c.repo)}/blobs/${h}`, content, { "Content-Type": "application/octet-stream" });
+      cachePut("b", h, content);
+    }
+  }));
+  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);
+  const from = pend.base;
+  c.pending = undefined;
+  rmSync(join(root, STATE_DIR, "objects"), { recursive: true, force: true });
+  // Nobody else committed meanwhile: the files here are exactly the last commit's.
+  if (r.root && (r.parent ?? "") === from) {
+    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: [] } };
+  }
+  saveCheckout(root, c);
+  const s = await sync(root, c);
+  return { shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: s };
+}
+
 export interface CommitResult {
   sha: string;
   branch: string;

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.72";
+export const CURRENT_VERSION = "4.0.73";
 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";