@lizard-build/cli 4.0.67 → 4.0.68

package/src/lib/lizard-git.ts

@@ -1,5 +1,5 @@
-import { execFileSync } from "node:child_process";
-import { realpathSync } from "node:fs";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { apiErrorFrom, clientHeaders, getRequestToken, APIError } from "./api.js";
 
 /**
@@ -38,6 +38,11 @@ export function gitToken(): string | null {
   return process.env.LIZARD_GIT_TOKEN || getRequestToken();
 }
 
+/** One request with the Lizard Git sign-in; non-2xx answers throw. */
+export function sendRaw(method: string, path: string, body?: Buffer, headers: Record<string, string> = {}): Promise<Response> {
+  return send(method, path, body === undefined ? undefined : new Uint8Array(body), headers);
+}
+
 async function send(method: string, path: string, body?: BodyInit, headers: Record<string, string> = {}): Promise<Response> {
   const token = gitToken();
   const h: Record<string, string> = { ...clientHeaders(), ...headers };
@@ -93,35 +98,21 @@ export async function myLogin(): Promise<string> {
   return me.login;
 }
 
-/** owner/name from a Lizard Git remote URL (https or ssh-style), or null. */
-/** Every address a Lizard Git remote may use: LIZARD_GIT_URL, or lizard.build/git and the old one. */
+/** Every address Lizard Git has had: LIZARD_GIT_URL, or lizard.build/git and the old one. */
 export function gitURLs(): string[] {
   const u = gitURL();
   return u === DEFAULT_GIT_URL ? [u, OLD_GIT_URL] : [u];
 }
 
-export function repoFromRemote(url: string, bases = gitURLs()): string | null {
-  const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  for (const base of bases) {
-    const b = new URL(base);
-    const re = new RegExp(`^https?://(?:[^@/]+@)?${esc(b.host)}${esc(b.pathname.replace(/\/+$/, ""))}/([^/]+)/([^/]+?)(?:\\.git)?/?$`);
-    const m = url.trim().match(re);
-    if (m && ![m[1], m[2]].some((x) => x === "." || x === "..")) return `${m[1]}/${m[2]}`;
+/** owner/name of the Lizard Git checkout this directory is in (.lizard-git/checkout.json), or null. */
+function checkoutRepo(): string | null {
+  for (let d = process.cwd(); ; d = dirname(d)) {
+    try {
+      const c = JSON.parse(readFileSync(join(d, ".lizard-git", "checkout.json"), "utf8"));
+      if (typeof c.repo === "string" && /^[^/\s]+\/[^/\s]+$/.test(c.repo)) return c.repo;
+    } catch {}
+    if (dirname(d) === d) return null;
   }
-  return null;
-}
-
-function originRepo(): string | null {
-  try {
-    const remotes = execFileSync("git", ["remote", "-v"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-    const lines = remotes.split("\n").filter((l) => l.includes("(fetch)"));
-    const ordered = [...lines.filter((l) => l.startsWith("origin\t")), ...lines];
-    for (const l of ordered) {
-      const r = repoFromRemote(l.split(/\s+/)[1] ?? "");
-      if (r) return r;
-    }
-  } catch {}
-  return null;
 }
 
 /**
@@ -136,9 +127,9 @@ export async function resolveRepo(flag?: string): Promise<string> {
     if (ok(f)) return `${await myLogin()}/${f}`;
     throw new APIError(400, `--repo is owner/name or name, got "${flag}"`);
   }
-  const r = originRepo();
+  const r = checkoutRepo();
   if (r) return r;
-  throw new APIError(400, `Which repository? Pass --repo owner/name, or run this inside a clone of a Lizard Git repository (${gitURL()}).`);
+  throw new APIError(400, `Which repository? Pass --repo owner/name, or run this inside a checkout (lizard git clone owner/name).`);
 }
 
 export function repoPath(repo: string): string {
@@ -146,22 +137,6 @@ export function repoPath(repo: string): string {
   return `/api/repos/${seg(owner)}/${seg(name)}`;
 }
 
-export function cloneURL(repo: string): string {
-  return `${gitURL()}/${repo}.git`;
-}
-
-/** How git should run this CLI as its credential helper. */
-export function helperCommand(): string {
-  // `npm i -g` runs us through a bin symlink with no .js name (/usr/local/bin/lizard): resolve it,
-  // or the helper would be `node git credential`, which can't start.
-  let script = process.argv[1] ?? "";
-  try { script = realpathSync(script); } catch { /* keep argv[1] */ }
-  const q = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`;
-  // npm install: node + the script. Standalone binary: the binary itself.
-  if (/\.(c|m)?js$/.test(script)) return `!${q(process.execPath)} ${q(script)} git credential`;
-  return `!${q(process.execPath)} git credential`;
-}
-
 /** Seconds (Lizard Git) to "3m ago". */
 export function ago(sec: number | null | undefined): string {
   if (!sec) return "";

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.67";
+export const CURRENT_VERSION = "4.0.68";
 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/lizard-git.test.ts

@@ -1,5 +1,9 @@
 import { describe, it, expect, afterEach, vi } from "vitest";
-import { repoFromRemote, qs, gitURL, helperCommand, resolveRepo, lg, segs } from "../../src/lib/lizard-git.js";
+import { mkdtempSync, mkdirSync, writeFileSync, symlinkSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { qs, gitURL, resolveRepo, lg, segs } from "../../src/lib/lizard-git.js";
+import { changesOf, scanWorking, saveCheckout, findCheckout, sha256, unifiedDiff, type Checkout } from "../../src/lib/checkout.js";
 
 afterEach(() => {
   vi.unstubAllGlobals();
@@ -7,18 +11,6 @@ afterEach(() => {
 });
 
 describe("lizard git helpers", () => {
-  it("reads owner/name from Lizard Git remotes only", () => {
-    expect(repoFromRemote("https://lizard.build/git/alice/app.git")).toBe("alice/app");
-    expect(repoFromRemote("https://lizard:liz_x@lizard.build/git/alice/app")).toBe("alice/app");
-    expect(repoFromRemote("https://git.lizard.build/alice/app.git")).toBe("alice/app"); // older clones
-    expect(repoFromRemote("https://lizard:liz_x@git.lizard.build/alice/app")).toBe("alice/app");
-    expect(repoFromRemote("https://github.com/alice/app.git")).toBeNull();
-    expect(repoFromRemote("git@github.com:alice/app.git")).toBeNull();
-    expect(repoFromRemote("https://lizard.build/alice/app.git")).toBeNull();
-    expect(repoFromRemote("https://lizard.build/gitx/alice/app.git")).toBeNull();
-    expect(repoFromRemote("https://lizard.build/git/alice/app/extra.git")).toBeNull();
-  });
-
   it("drops empty query values", () => {
     expect(qs("/x", { a: "1", b: undefined, c: "", d: false, e: 2 })).toBe("/x?a=1&e=2");
   });
@@ -26,12 +18,6 @@ describe("lizard git helpers", () => {
   it("honours LIZARD_GIT_URL", () => {
     vi.stubEnv("LIZARD_GIT_URL", "http://localhost:8080/");
     expect(gitURL()).toBe("http://localhost:8080");
-    expect(repoFromRemote("http://localhost:8080/a/b.git")).toBe("a/b");
-    expect(repoFromRemote("https://git.lizard.build/a/b.git")).toBeNull(); // another server: only it
-  });
-
-  it("runs itself as git's credential helper", () => {
-    expect(helperCommand()).toMatch(/^!'.+' .*git credential$/);
   });
 
   it("takes owner/name or a bare name (yours) for --repo", async () => {
@@ -66,8 +52,63 @@ describe("lizard git safety", () => {
     await expect(resolveRepo("a/..")).rejects.toThrow();
     expect(() => segs("../../api/user/tokens")).toThrow(/bad path/);
     expect(segs("src/a b.js")).toBe("src/a%20b.js");
-    expect(repoFromRemote("https://git.lizard.build/../x.git")).toBeNull();
-    expect(repoFromRemote("https://lizard.build/git/../x.git")).toBeNull();
-    expect(repoFromRemote("https://lizard.build/git/a/...git")).toBeNull();
+  });
+});
+
+describe("lizard git checkouts", () => {
+  const make = (files: Record<string, string>, state: Partial<Checkout> = {}) => {
+    const root = mkdtempSync(join(tmpdir(), "lzg-"));
+    const c: Checkout = { version: 1, url: "x", repo: "alice/app", branch: "main", base: "b".repeat(64), root: "r".repeat(64), sparse: null, files: {}, ...state };
+    for (const [p, body] of Object.entries(files)) {
+      mkdirSync(join(root, p, ".."), { recursive: true });
+      writeFileSync(join(root, p), body);
+      c.files[p] = { h: sha256(body), m: "100644" };
+    }
+    saveCheckout(root, c);
+    return { root, c };
+  };
+
+  it("finds its checkout from a subdirectory and the repository from it", async () => {
+    const { root } = make({ "src/a.ts": "a" });
+    expect(findCheckout(join(root, "src"))).toBe(root);
+    const cwd = process.cwd();
+    process.chdir(join(root, "src"));
+    try {
+      expect(await resolveRepo()).toBe("alice/app");
+    } finally {
+      process.chdir(cwd);
+    }
+  });
+
+  it("sees added, modified and deleted files, and nothing it shouldn't", () => {
+    const { root, c } = make({ "a.txt": "a", "src/b.txt": "b", "gone.txt": "g" });
+    writeFileSync(join(root, "a.txt"), "a2");
+    writeFileSync(join(root, "new.txt"), "n");
+    mkdirSync(join(root, ".lizard/workflows"), { recursive: true }); // a repository's CI: content like any other
+    writeFileSync(join(root, ".lizard/workflows/ci.yml"), "on: push\n");
+    writeFileSync(join(root, ".gitignore"), "*.log\nbuild/\n");
+    writeFileSync(join(root, "debug.log"), "x");
+    mkdirSync(join(root, "build"));
+    writeFileSync(join(root, "build/out.js"), "x");
+    mkdirSync(join(root, "node_modules/x"), { recursive: true });
+    writeFileSync(join(root, "node_modules/x/i.js"), "x");
+    symlinkSync("a.txt", join(root, "link"));
+    unlinkSync(join(root, "gone.txt"));
+    const ch = changesOf(c, scanWorking(root, c));
+    expect(ch).toEqual({ added: [".gitignore", ".lizard/workflows/ci.yml", "link", "new.txt"], modified: ["a.txt"], deleted: ["gone.txt"] });
+  });
+
+  it("a sparse checkout only looks inside its folders", () => {
+    const { root, c } = make({ "src/a.txt": "a" }, { sparse: ["src"] });
+    writeFileSync(join(root, "outside.txt"), "o");
+    writeFileSync(join(root, "src/b.txt"), "b");
+    expect(changesOf(c, scanWorking(root, c)).added).toEqual(["src/b.txt"]);
+  });
+
+  it("diffs lines", () => {
+    const d = unifiedDiff("a\nb\nc\n", "a\nB\nc\n", "f");
+    expect(d).toContain("@@ -1,4 +1,4 @@");
+    expect(d).toContain("-b");
+    expect(d).toContain("+B");
   });
 });