@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/sync/workspace.ts

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+
+const globs = z.array(z.string());
+const versions = z.record(z.string(), z.string({ error: "must be a version string" }), {
+  error: "must be an object of package versions",
+});
+
+const packageJsonSchema: z.ZodObject<
+  {
+    name: z.ZodOptional<z.ZodString>;
+    private: z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodOptional<z.ZodUnknown>;
+    sideEffects: z.ZodOptional<z.ZodUnknown>;
+    packageManager: z.ZodOptional<z.ZodUnknown>;
+    bin: z.ZodOptional<z.ZodUnknown>;
+    exports: z.ZodOptional<z.ZodUnknown>;
+    scripts: z.ZodOptional<z.ZodUnknown>;
+    workspaces: z.ZodOptional<
+      z.ZodUnion<
+        readonly [
+          z.ZodArray<z.ZodString>,
+          z.ZodObject<
+            {
+              packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            },
+            z.core.$strip
+          >,
+        ]
+      >
+    >;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    optionalDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  },
+  z.core.$strip
+> = z.object(
+  {
+    name: z.string({ error: "must be a string" }).optional(),
+    private: z.boolean({ error: "must be true or false" }).optional(),
+    // Kept as written: sync accepts any value and only `repo check` judges these.
+    version: z.unknown().optional(),
+    sideEffects: z.unknown().optional(),
+    packageManager: z.unknown().optional(),
+    // Kept for the lint config, which narrows them where it reads them.
+    bin: z.unknown().optional(),
+    exports: z.unknown().optional(),
+    // Kept as written; `repo check` narrows the root's scripts where it reads them.
+    scripts: z.unknown().optional(),
+    workspaces: z
+      .union([globs, z.object({ packages: globs.optional() })], {
+        error: 'must be a list of globs or { "packages": [...] }',
+      })
+      .optional(),
+    dependencies: versions.optional(),
+    devDependencies: versions.optional(),
+    peerDependencies: versions.optional(),
+    optionalDependencies: versions.optional(),
+  },
+  { error: "must be a JSON object" },
+);
+
+/** The package.json fields repo sync reads; `version`, `sideEffects`, `packageManager`, `bin` and `exports` stay unjudged `unknown`s; every other field is dropped at parse. */
+export type PackageJson = z.output<typeof packageJsonSchema>;
+export type WorkspacePackage = { dir: string; manifest: PackageJson };
+/** A repo root and its workspace packages; `dir` is root-relative with POSIX separators. */
+export type Workspace = { root: string; manifest: PackageJson; packages: WorkspacePackage[] };
+export type WorkspaceResult = { ok: true; workspace: Workspace } | { ok: false; errors: string[] };
+/** Expands one glob under `cwd` into the matching paths, relative to `cwd`. */
+export type Glob = (pattern: string, cwd: string) => string[];
+
+const globSync: Glob = (pattern, cwd) => fs.globSync(pattern, { cwd });
+
+/** Reads the root package.json and every workspace package it declares, sorted by dir. */
+export function readWorkspace(root: string, glob: Glob = globSync): WorkspaceResult {
+  const rootFile = path.join(root, "package.json");
+  // A root without package.json has no workspaces and no dependencies, as loadConfig reads it.
+  const rootManifest: ManifestResult = fs.existsSync(rootFile)
+    ? parseManifest("package.json", rootFile)
+    : { ok: true, manifest: {} };
+  if (!rootManifest.ok) return { ok: false, errors: rootManifest.errors };
+
+  const errors: string[] = [];
+  const packages: WorkspacePackage[] = [];
+  for (const dir of expandWorkspaces(root, rootManifest.manifest, glob)) {
+    const rel = `${dir}/package.json`;
+    const manifest = parseManifest(rel, path.join(root, rel));
+    if (manifest.ok) packages.push({ dir, manifest: manifest.manifest });
+    else errors.push(...manifest.errors);
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, workspace: { root, manifest: rootManifest.manifest, packages } };
+}
+
+/** Workspace dirs that hold a package.json, outside node_modules, deduped and sorted. */
+function expandWorkspaces(root: string, manifest: PackageJson, glob: Glob): string[] {
+  const workspaces = manifest.workspaces;
+  const patterns = (Array.isArray(workspaces) ? workspaces : workspaces?.packages) ?? [];
+  const included = new Set<string>();
+  const excluded = new Set<string>();
+  for (const pattern of patterns) {
+    const negated = pattern.startsWith("!");
+    const target = negated ? excluded : included;
+    for (const match of glob(negated ? pattern.slice(1) : pattern, root)) target.add(toPosixDir(match));
+  }
+  return [...included]
+    .filter((dir) => !excluded.has(dir))
+    .filter((dir) => !dir.split("/").includes("node_modules"))
+    .filter((dir) => fs.existsSync(path.join(root, dir, "package.json")))
+    .sort();
+}
+
+/** `packages\api\` and `./packages/api/` both read `packages/api`. */
+function toPosixDir(match: string): string {
+  return path.posix.normalize(match.replaceAll("\\", "/")).replace(/\/+$/, "");
+}
+
+type ManifestResult = { ok: true; manifest: PackageJson } | { ok: false; errors: string[] };
+
+function parseManifest(rel: string, file: string): ManifestResult {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (error) {
+    return { ok: false, errors: [`${rel}: not valid JSON: ${(error as Error).message}`] };
+  }
+  const parsed = packageJsonSchema.safeParse(raw);
+  if (parsed.success) return { ok: true, manifest: parsed.data };
+  return {
+    ok: false,
+    errors: parsed.error.issues.map((issue) => {
+      const at = issue.path.join(".");
+      return `${rel}: ${at ? `${at}: ` : ""}${issue.message}`;
+    }),
+  };
+}

package/cli/sync/write.test.ts

@@ -0,0 +1,341 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { linkText } from "../../dev/test-paths.ts";
+import { MANIFEST_REL, renderManifest } from "./manifest.ts";
+import type { Output } from "./outputs.ts";
+import { writeAll, writeOutput } from "./write.ts";
+
+const temps: string[] = [];
+afterEach(() => {
+  vi.restoreAllMocks();
+  for (const dir of temps.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+function tempRoot(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "workerstack-write-"));
+  temps.push(dir);
+  return dir;
+}
+
+function put(root: string, rel: string, text: string): void {
+  fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+  fs.writeFileSync(path.join(root, rel), text);
+}
+
+/** Every path under `root` with its kind, bytes, link text and file mode, so a restore can be compared byte for byte. */
+function tree(root: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const rel of fs.readdirSync(root, { recursive: true, encoding: "utf8" }).sort()) {
+    const abs = path.join(root, rel);
+    const stat = fs.lstatSync(abs);
+    if (stat.isSymbolicLink()) out[rel] = `link ${linkText(abs)}`;
+    else if (stat.isDirectory()) out[rel] = "dir";
+    else out[rel] = `file ${(stat.mode & 0o777).toString(8)} ${fs.readFileSync(abs, "latin1")}`;
+  }
+  return out;
+}
+
+const file = (p: string, content = `${p}\n`): Output => ({
+  kind: "file",
+  path: p,
+  content,
+  tracked: true,
+  managed: "whole",
+});
+const link = (p: string, target: string): Output => ({
+  kind: "link",
+  path: p,
+  target,
+  tracked: true,
+  managed: "whole",
+});
+const deps = { platform: process.platform, writeOutput };
+const MANIFEST = renderManifest(["a.txt"]);
+
+/** A tree with an old file, an old link and a prunable file that is the only thing in its dirs. */
+function seeded(): string {
+  const root = tempRoot();
+  put(root, "a.txt", "old a\n");
+  fs.chmodSync(path.join(root, "a.txt"), 0o750);
+  fs.mkdirSync(path.join(root, "s1"));
+  fs.mkdirSync(path.join(root, "s2"));
+  fs.mkdirSync(path.join(root, "tree"));
+  fs.symlinkSync("../s1", path.join(root, "tree/lnk"), "dir");
+  put(root, "gone/deep/x.txt", "x\n");
+  put(root, MANIFEST_REL, renderManifest(["gone/deep/x.txt"]));
+  return root;
+}
+
+/** Fails the output at `path` with `message` and writes every other one for real. */
+const failing = (target: string, message = "EACCES: permission denied") => ({
+  platform: process.platform,
+  writeOutput: (root: string, output: Output, platform: NodeJS.Platform) =>
+    output.path === target ? message : writeOutput(root, output, platform),
+});
+
+describe("writeAll", () => {
+  it("writes the changed outputs, removes the pruned paths and writes the manifest", () => {
+    const root = seeded();
+    const changed = [
+      file("a.txt", "new a\n"),
+      file("n/ew/b.txt"),
+      link("tree/lnk", "../s2"),
+      link("fresh/lnk", "../s2"),
+    ];
+    expect(writeAll(root, changed, ["gone/deep/x.txt"], MANIFEST, deps)).toEqual({ ok: true });
+    expect(linkText(path.join(root, "fresh/lnk"))).toBe("../s2");
+    expect(fs.readFileSync(path.join(root, "a.txt"), "utf8")).toBe("new a\n");
+    expect(fs.readFileSync(path.join(root, "n/ew/b.txt"), "utf8")).toBe("n/ew/b.txt\n");
+    expect(linkText(path.join(root, "tree/lnk"))).toBe("../s2");
+    expect(fs.existsSync(path.join(root, "gone"))).toBe(false);
+    expect(fs.readFileSync(path.join(root, MANIFEST_REL), "utf8")).toBe(MANIFEST);
+  });
+
+  it("leaves a manifest that is already current alone", () => {
+    const root = tempRoot();
+    put(root, MANIFEST_REL, MANIFEST);
+    const rename = vi.spyOn(fs, "renameSync");
+    expect(writeAll(root, [], [], MANIFEST, deps)).toEqual({ ok: true });
+    expect(rename).not.toHaveBeenCalled();
+  });
+
+  it("restores earlier files, links and created dirs byte for byte when a later output fails", () => {
+    const root = seeded();
+    const before = tree(root);
+    const changed = [file("a.txt", "new a\n"), file("n/ew/b.txt"), link("tree/lnk", "../s2"), file("c.txt")];
+    const result = writeAll(root, changed, ["gone/deep/x.txt"], MANIFEST, failing("c.txt"));
+    expect(result).toEqual({
+      ok: false,
+      errors: ["c.txt: cannot write: EACCES: permission denied; restored 3 outputs, nothing changed"],
+      refused: false,
+    });
+    expect(tree(root)).toEqual(before);
+    expect(fs.existsSync(path.join(root, "n"))).toBe(false);
+  });
+
+  it("says restored 1 output in the singular", () => {
+    const root = seeded();
+    const result = writeAll(root, [file("a.txt", "new\n"), file("c.txt")], [], MANIFEST, failing("c.txt", "boom"));
+    expect(result).toMatchObject({ errors: ["c.txt: cannot write: boom; restored 1 output, nothing changed"] });
+  });
+
+  it("restores outputs, removals and the dirs a removal emptied when a removal fails", () => {
+    const root = seeded();
+    put(root, "gone/other.txt", "other\n");
+    const before = tree(root);
+    const real = fs.rmSync;
+    let failed = false;
+    vi.spyOn(fs, "rmSync").mockImplementation((target, options) => {
+      if (String(target).endsWith("other.txt") && !failed) {
+        failed = true;
+        throw new Error("EBUSY: resource busy");
+      }
+      return real(target, options);
+    });
+    const result = writeAll(root, [file("a.txt", "new\n")], ["gone/deep/x.txt", "gone/other.txt"], MANIFEST, deps);
+    expect(result).toEqual({
+      ok: false,
+      errors: ["gone/other.txt: cannot remove: EBUSY: resource busy; restored 2 outputs, nothing changed"],
+      refused: false,
+    });
+    vi.restoreAllMocks();
+    expect(tree(root)).toEqual(before);
+  });
+
+  it("rolls every output and removal back when the manifest write fails", () => {
+    const root = seeded();
+    fs.rmSync(path.join(root, MANIFEST_REL));
+    fs.rmdirSync(path.join(root, ".repo/tmp"));
+    fs.rmdirSync(path.join(root, ".repo"));
+    const before = tree(root);
+    const real = fs.renameSync;
+    vi.spyOn(fs, "renameSync").mockImplementation((from, to) => {
+      if (String(to).endsWith("sync.json")) throw new Error("EACCES: permission denied, rename");
+      return real(from, to);
+    });
+    const changed = [file("a.txt", "new a\n"), file("n/ew/b.txt"), link("tree/lnk", "../s2")];
+    const result = writeAll(root, changed, ["gone/deep/x.txt"], MANIFEST, deps);
+    expect(result).toEqual({
+      ok: false,
+      errors: [`${MANIFEST_REL}: cannot write: EACCES: permission denied, rename; restored 4 outputs, nothing changed`],
+      refused: false,
+    });
+    vi.restoreAllMocks();
+    expect(tree(root)).toEqual(before);
+  });
+
+  it("does not try to remove a dir that is already gone when it undoes a failed manifest write", () => {
+    const root = tempRoot();
+    put(root, ".repo", "a file where the manifest dir belongs\n");
+    const result = writeAll(root, [], [], MANIFEST, deps);
+    expect(result).toMatchObject({ ok: false, refused: false });
+    expect(result).toMatchObject({
+      errors: [
+        expect.stringMatching(/^\.repo\/tmp\/sync\.json: cannot write: .*; restored 0 outputs, nothing changed$/),
+      ],
+    });
+    expect(fs.readFileSync(path.join(root, ".repo"), "utf8")).toBe("a file where the manifest dir belongs\n");
+  });
+
+  it("refuses a real dir at a skill link path before any write, naming the folder to move", () => {
+    const root = seeded();
+    put(root, ".claude/skills/ask/SKILL.md", "mine\n");
+    const before = tree(root);
+    const changed = [file("a.txt", "new\n"), link(".claude/skills/ask", "../../.agents/skills/ask")];
+    expect(writeAll(root, changed, ["gone/deep/x.txt"], MANIFEST, deps)).toEqual({
+      ok: false,
+      errors: [".claude/skills/ask is a folder where sync puts a link; move it to .repo/skills/ask"],
+      refused: true,
+    });
+    expect(tree(root)).toEqual(before);
+  });
+
+  it("refuses a real dir at any other link path with one fix", () => {
+    const root = seeded();
+    put(root, "tree/real/file.txt", "mine\n");
+    put(root, ".agents/skills/b/SKILL.md", "mine\n");
+    const before = tree(root);
+    const result = writeAll(
+      root,
+      [link("tree/real", "../s1"), link(".agents/skills/b", "../../s1")],
+      [],
+      MANIFEST,
+      deps,
+    );
+    expect(result).toEqual({
+      ok: false,
+      errors: [
+        "tree/real is a folder where sync puts a link; move or delete it",
+        ".agents/skills/b is a folder where sync puts a link; move it to .repo/skills/b",
+      ],
+      refused: true,
+    });
+    expect(tree(root)).toEqual(before);
+  });
+
+  it("converges on a rerun after a restore", () => {
+    const root = seeded();
+    const changed = [file("a.txt", "new a\n"), file("n/ew/b.txt"), link("tree/lnk", "../s2"), file("c.txt")];
+    expect(writeAll(root, changed, ["gone/deep/x.txt"], MANIFEST, failing("c.txt")).ok).toBe(false);
+    expect(writeAll(root, changed, ["gone/deep/x.txt"], MANIFEST, deps)).toEqual({ ok: true });
+
+    const clean = seeded();
+    expect(writeAll(clean, changed, ["gone/deep/x.txt"], MANIFEST, deps)).toEqual({ ok: true });
+    const strip = (t: Record<string, string>) =>
+      Object.fromEntries(Object.entries(t).filter(([rel]) => !rel.startsWith("..")));
+    expect(strip(tree(root))).toEqual(strip(tree(clean)));
+  });
+
+  it("leaves a real dir that stands where a file belongs and reports the failed write", () => {
+    const root = seeded();
+    put(root, "d/keep.txt", "mine\n");
+    const before = tree(root);
+    const result = writeAll(root, [file("a.txt", "new\n"), file("d")], [], MANIFEST, deps);
+    expect(result).toMatchObject({ ok: false, refused: false });
+    expect(result).toMatchObject({
+      errors: [expect.stringMatching(/^d: cannot write: .*; restored 1 output, nothing changed$/)],
+    });
+    expect(tree(root)).toEqual(before);
+  });
+
+  it("reports a file it cannot read before touching it", () => {
+    const root = seeded();
+    const real = fs.readFileSync;
+    vi.spyOn(fs, "readFileSync").mockImplementation(((target: fs.PathOrFileDescriptor, options?: unknown) => {
+      if (String(target).endsWith("a.txt")) throw new Error("EACCES: permission denied, open");
+      return (real as (t: unknown, o?: unknown) => unknown)(target, options);
+    }) as typeof fs.readFileSync);
+    const result = writeAll(root, [file("a.txt", "new\n")], [], MANIFEST, deps);
+    expect(result).toEqual({
+      ok: false,
+      errors: ["a.txt: cannot write: EACCES: permission denied, open; restored 0 outputs, nothing changed"],
+      refused: false,
+    });
+    vi.restoreAllMocks();
+    expect(fs.readFileSync(path.join(root, "a.txt"), "utf8")).toBe("old a\n");
+  });
+
+  it("names what it could not restore and says to rerun", () => {
+    const root = seeded();
+    const real = fs.writeFileSync;
+    vi.spyOn(fs, "writeFileSync").mockImplementation(((
+      target: fs.PathOrFileDescriptor,
+      data: unknown,
+      options?: unknown,
+    ) => {
+      if (String(target) === path.join(root, "a.txt") && data instanceof Buffer) throw new Error("EIO: i/o error");
+      return (real as (t: unknown, d: unknown, o?: unknown) => void)(target, data, options);
+    }) as typeof fs.writeFileSync);
+    const result = writeAll(root, [file("a.txt", "new a\n"), file("c.txt")], [], MANIFEST, failing("c.txt", "boom"));
+    expect(result).toEqual({
+      ok: false,
+      errors: ["c.txt: cannot write: boom; could not restore a.txt; run `bun repo sync` again"],
+      refused: false,
+    });
+  });
+
+  it("restores a replaced link with a symlink call that works on every platform", () => {
+    const root = seeded();
+    const symlink = vi.spyOn(fs, "symlinkSync");
+    const result = writeAll(root, [link("tree/lnk", "../s2"), file("c.txt")], [], MANIFEST, failing("c.txt"));
+    expect(result).toMatchObject({ ok: false });
+    expect(symlink).toHaveBeenLastCalledWith(path.normalize("../s1"), path.join(root, "tree/lnk"), "junction");
+  });
+
+  it("reports a link it cannot make and restores the old one", () => {
+    const root = seeded();
+    const before = tree(root);
+    vi.spyOn(fs, "symlinkSync").mockImplementationOnce(() => {
+      throw new Error("EPERM: operation not permitted, symlink");
+    });
+    const result = writeAll(root, [link("tree/lnk", "../s2")], [], MANIFEST, deps);
+    expect(result).toMatchObject({
+      errors: ["tree/lnk: cannot write: EPERM: operation not permitted, symlink; restored 0 outputs, nothing changed"],
+    });
+    expect(tree(root)).toEqual(before);
+  });
+
+  it("writes the default way, and a link as a junction with an absolute target on win32", () => {
+    const root = seeded();
+    expect(
+      writeAll(root, [file("a.txt", "new\n"), link("tree/lnk", "../s2")], [], MANIFEST, { platform: "win32" }),
+    ).toEqual({ ok: true });
+    expect(fs.readFileSync(path.join(root, "a.txt"), "utf8")).toBe("new\n");
+    expect(fs.readlinkSync(path.join(root, "tree/lnk"))).toBe(path.join(root, "s2"));
+  });
+});
+
+describe("writeOutput modes", () => {
+  const hook = (content: string): Output => ({
+    kind: "file",
+    path: ".githooks/pre-commit",
+    content,
+    tracked: true,
+    managed: "whole",
+    executable: true,
+  });
+  const mode = (root: string, rel: string) => fs.statSync(path.join(root, rel)).mode & 0o777;
+
+  // Windows has no execute bits; sync marks a hook in the index there instead.
+  it.skipIf(process.platform === "win32")(
+    "makes an executable output 0755 on POSIX, a new file and a rewritten one alike",
+    () => {
+      const root = tempRoot();
+      expect(writeOutput(root, hook("#!/bin/sh\n"), "linux")).toBeNull();
+      expect(mode(root, ".githooks/pre-commit")).toBe(0o755);
+      fs.chmodSync(path.join(root, ".githooks/pre-commit"), 0o644);
+      expect(writeOutput(root, hook("#!/bin/sh\nnew\n"), "darwin")).toBeNull();
+      expect(mode(root, ".githooks/pre-commit")).toBe(0o755);
+    },
+  );
+
+  it("leaves a plain output, and any output written for win32, which has no modes, without the execute bits", () => {
+    const root = tempRoot();
+    expect(writeOutput(root, file("a.txt"), "linux")).toBeNull();
+    expect(mode(root, "a.txt") & 0o111).toBe(0);
+    expect(writeOutput(root, hook("#!/bin/sh\n"), "win32")).toBeNull();
+    expect(mode(root, ".githooks/pre-commit") & 0o111).toBe(0);
+  });
+});