@tinyrack/devsync 1.0.0 → 1.1.0

package/src/services/config-file.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it } from "vitest";
+
+import type {
+  ResolvedSyncConfig,
+  ResolvedSyncConfigEntry,
+  ResolvedSyncOverride,
+  SyncConfig,
+} from "#app/config/sync.ts";
+import {
+  countConfiguredRules,
+  createSyncConfigDocument,
+  createSyncConfigDocumentEntry,
+  sortSyncConfigEntries,
+  sortSyncOverrides,
+} from "#app/services/config-file.ts";
+
+const baseOverride = (
+  value: Pick<ResolvedSyncOverride, "match" | "mode" | "path">,
+): ResolvedSyncOverride => {
+  return value;
+};
+
+const baseEntry = (
+  value: Pick<
+    ResolvedSyncConfigEntry,
+    | "configuredLocalPath"
+    | "kind"
+    | "localPath"
+    | "mode"
+    | "name"
+    | "overrides"
+    | "repoPath"
+  >,
+): ResolvedSyncConfigEntry => {
+  return value;
+};
+
+describe("config file helpers", () => {
+  it("sorts overrides by their formatted selector", () => {
+    const overrides = sortSyncOverrides([
+      baseOverride({ match: "exact", mode: "secret", path: "z.txt" }),
+      baseOverride({ match: "subtree", mode: "ignore", path: "cache" }),
+      baseOverride({ match: "exact", mode: "normal", path: "a.txt" }),
+    ]);
+
+    expect(overrides).toEqual([
+      { match: "exact", mode: "normal", path: "a.txt" },
+      { match: "subtree", mode: "ignore", path: "cache" },
+      { match: "exact", mode: "secret", path: "z.txt" },
+    ]);
+  });
+
+  it("creates config document entries without empty overrides", () => {
+    expect(
+      createSyncConfigDocumentEntry(
+        baseEntry({
+          configuredLocalPath: "~/.zshrc",
+          kind: "file",
+          localPath: "/tmp/home/.zshrc",
+          mode: "normal",
+          name: ".zshrc",
+          overrides: [],
+          repoPath: ".zshrc",
+        }),
+      ),
+    ).toEqual({
+      kind: "file",
+      localPath: "~/.zshrc",
+      mode: "normal",
+      name: ".zshrc",
+      repoPath: ".zshrc",
+    });
+  });
+
+  it("creates sorted override maps for config document entries", () => {
+    expect(
+      createSyncConfigDocumentEntry(
+        baseEntry({
+          configuredLocalPath: "~/bundle",
+          kind: "directory",
+          localPath: "/tmp/home/bundle",
+          mode: "normal",
+          name: "bundle",
+          overrides: [
+            baseOverride({ match: "exact", mode: "secret", path: "z.txt" }),
+            baseOverride({ match: "subtree", mode: "ignore", path: "cache" }),
+            baseOverride({ match: "exact", mode: "normal", path: "a.txt" }),
+          ],
+          repoPath: "bundle",
+        }),
+      ),
+    ).toEqual({
+      kind: "directory",
+      localPath: "~/bundle",
+      mode: "normal",
+      name: "bundle",
+      overrides: {
+        "a.txt": "normal",
+        "cache/": "ignore",
+        "z.txt": "secret",
+      },
+      repoPath: "bundle",
+    });
+  });
+
+  it("creates and sorts config documents from resolved config", () => {
+    const config: ResolvedSyncConfig = {
+      version: 1,
+      age: {
+        configuredIdentityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
+        identityFile: "/tmp/xdg/devsync/age/keys.txt",
+        recipients: ["age1a", "age1b"],
+      },
+      entries: [
+        baseEntry({
+          configuredLocalPath: "~/bundle",
+          kind: "directory",
+          localPath: "/tmp/home/bundle",
+          mode: "secret",
+          name: "bundle",
+          overrides: [
+            baseOverride({ match: "subtree", mode: "ignore", path: "cache" }),
+          ],
+          repoPath: "bundle",
+        }),
+        baseEntry({
+          configuredLocalPath: "~/.zshrc",
+          kind: "file",
+          localPath: "/tmp/home/.zshrc",
+          mode: "normal",
+          name: ".zshrc",
+          overrides: [],
+          repoPath: ".zshrc",
+        }),
+      ],
+    };
+
+    expect(
+      sortSyncConfigEntries(createSyncConfigDocument(config).entries),
+    ).toEqual([
+      {
+        kind: "file",
+        localPath: "~/.zshrc",
+        mode: "normal",
+        name: ".zshrc",
+        repoPath: ".zshrc",
+      },
+      {
+        kind: "directory",
+        localPath: "~/bundle",
+        mode: "secret",
+        name: "bundle",
+        overrides: {
+          "cache/": "ignore",
+        },
+        repoPath: "bundle",
+      },
+    ] satisfies SyncConfig["entries"]);
+    expect(countConfiguredRules(config)).toBe(1);
+  });
+});

package/src/services/crypto.test.ts

@@ -0,0 +1,132 @@
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  createAgeIdentityFile,
+  decryptSecretFile,
+  encryptSecretFile,
+  readAgeIdentityLines,
+  readAgeRecipientsFromIdentityFile,
+} from "#app/services/crypto.ts";
+import {
+  createAgeKeyPair,
+  createTemporaryDirectory,
+} from "../test/helpers/sync-fixture.ts";
+
+const temporaryDirectories: string[] = [];
+
+const createWorkspace = async () => {
+  const directory = await createTemporaryDirectory("devsync-sync-crypto-");
+
+  temporaryDirectories.push(directory);
+
+  return directory;
+};
+
+afterEach(async () => {
+  while (temporaryDirectories.length > 0) {
+    const directory = temporaryDirectories.pop();
+
+    if (directory !== undefined) {
+      await rm(directory, { force: true, recursive: true });
+    }
+  }
+});
+
+describe("sync crypto helpers", () => {
+  it("reads identities while ignoring blank lines and comments", async () => {
+    const workspace = await createWorkspace();
+    const keyPair = await createAgeKeyPair();
+    const identityFile = join(workspace, "keys.txt");
+
+    await writeFile(
+      identityFile,
+      `\n# first\n${keyPair.identity}\n\n# second\n${keyPair.identity}\n`,
+      "utf8",
+    );
+
+    expect(await readAgeIdentityLines(identityFile)).toEqual([
+      keyPair.identity,
+      keyPair.identity,
+    ]);
+  });
+
+  it("fails when no usable identities are present", async () => {
+    const workspace = await createWorkspace();
+    const identityFile = join(workspace, "keys.txt");
+
+    await writeFile(identityFile, "\n# comment only\n\n", "utf8");
+
+    await expect(readAgeIdentityLines(identityFile)).rejects.toThrowError(
+      /No age identities found/u,
+    );
+  });
+
+  it("deduplicates recipients derived from repeated identities", async () => {
+    const workspace = await createWorkspace();
+    const keyPair = await createAgeKeyPair();
+    const identityFile = join(workspace, "keys.txt");
+
+    await writeFile(
+      identityFile,
+      `${keyPair.identity}\n${keyPair.identity}\n`,
+      "utf8",
+    );
+
+    expect(await readAgeRecipientsFromIdentityFile(identityFile)).toEqual([
+      keyPair.recipient,
+    ]);
+  });
+
+  it("creates a new identity file with a trailing newline", async () => {
+    const workspace = await createWorkspace();
+    const identityFile = join(workspace, "nested", "keys.txt");
+
+    const result = await createAgeIdentityFile(identityFile);
+    const contents = await readFile(identityFile, "utf8");
+
+    expect(contents.endsWith("\n")).toBe(true);
+    expect(await readAgeRecipientsFromIdentityFile(identityFile)).toEqual([
+      result.recipient,
+    ]);
+  });
+
+  it("round-trips secret payloads through age encryption", async () => {
+    const workspace = await createWorkspace();
+    const keyPair = await createAgeKeyPair();
+    const identityFile = join(workspace, "keys.txt");
+    const payload = new TextEncoder().encode("super secret payload");
+
+    await writeFile(identityFile, `${keyPair.identity}\n`, "utf8");
+
+    const ciphertext = await encryptSecretFile(payload, [keyPair.recipient]);
+    const plaintext = await decryptSecretFile(ciphertext, identityFile);
+
+    expect(new TextDecoder().decode(plaintext)).toBe("super secret payload");
+  });
+
+  it("fails to decrypt with the wrong identity or malformed ciphertext", async () => {
+    const workspace = await createWorkspace();
+    const sender = await createAgeKeyPair();
+    const wrongIdentity = await createAgeKeyPair();
+    const senderIdentityFile = join(workspace, "sender.txt");
+    const wrongIdentityFile = join(workspace, "wrong.txt");
+
+    await writeFile(senderIdentityFile, `${sender.identity}\n`, "utf8");
+    await writeFile(wrongIdentityFile, `${wrongIdentity.identity}\n`, "utf8");
+
+    const ciphertext = await encryptSecretFile(
+      new TextEncoder().encode("secret"),
+      [sender.recipient],
+    );
+
+    await expect(
+      decryptSecretFile(ciphertext, wrongIdentityFile),
+    ).rejects.toThrowError();
+    await expect(
+      decryptSecretFile("not a valid age payload", senderIdentityFile),
+    ).rejects.toThrowError();
+  });
+});

package/src/services/doctor.ts

@@ -0,0 +1,142 @@
+import { readSyncConfig } from "#app/config/sync.ts";
+
+import { countConfiguredRules } from "./config-file.ts";
+import { pathExists } from "./filesystem.ts";
+import { ensureRepository } from "./git.ts";
+import type { SyncContext } from "./runtime.ts";
+
+export type DoctorCheckLevel = "fail" | "ok" | "warn";
+
+export type DoctorCheck = Readonly<{
+  detail: string;
+  level: DoctorCheckLevel;
+  name: string;
+}>;
+
+export type SyncDoctorResult = Readonly<{
+  checks: readonly DoctorCheck[];
+  configPath: string;
+  hasFailures: boolean;
+  hasWarnings: boolean;
+  syncDirectory: string;
+}>;
+
+const ok = (name: string, detail: string): DoctorCheck => ({
+  detail,
+  level: "ok",
+  name,
+});
+
+const warn = (name: string, detail: string): DoctorCheck => ({
+  detail,
+  level: "warn",
+  name,
+});
+
+const fail = (name: string, detail: string): DoctorCheck => ({
+  detail,
+  level: "fail",
+  name,
+});
+
+export const runSyncDoctor = async (
+  context: SyncContext,
+): Promise<SyncDoctorResult> => {
+  const checks: DoctorCheck[] = [];
+
+  try {
+    await ensureRepository(context.paths.syncDirectory);
+    checks.push(ok("git", "Sync directory is a git repository."));
+  } catch (error: unknown) {
+    checks.push(
+      fail(
+        "git",
+        error instanceof Error ? error.message : "Git repository check failed.",
+      ),
+    );
+
+    return {
+      checks,
+      configPath: context.paths.configPath,
+      hasFailures: true,
+      hasWarnings: false,
+      syncDirectory: context.paths.syncDirectory,
+    };
+  }
+
+  let config: Awaited<ReturnType<typeof readSyncConfig>>;
+
+  try {
+    config = await readSyncConfig(
+      context.paths.syncDirectory,
+      context.environment,
+    );
+    checks.push(
+      ok(
+        "config",
+        `Loaded config with ${config.entries.length} entries, ${countConfiguredRules(config)} rules, and ${config.age.recipients.length} recipients.`,
+      ),
+    );
+  } catch (error: unknown) {
+    checks.push(
+      fail(
+        "config",
+        error instanceof Error
+          ? error.message
+          : "Sync configuration could not be read.",
+      ),
+    );
+
+    return {
+      checks,
+      configPath: context.paths.configPath,
+      hasFailures: true,
+      hasWarnings: false,
+      syncDirectory: context.paths.syncDirectory,
+    };
+  }
+
+  checks.push(
+    (await pathExists(config.age.identityFile))
+      ? ok("age", `Age identity file exists at ${config.age.identityFile}.`)
+      : fail("age", `Age identity file is missing: ${config.age.identityFile}`),
+  );
+
+  checks.push(
+    config.entries.length === 0
+      ? warn("entries", "No sync entries are configured yet.")
+      : ok("entries", `Tracked ${config.entries.length} sync entries.`),
+  );
+
+  const missingEntries = config.entries.filter((entry) => {
+    return !context.environment || entry.localPath.length > 0;
+  });
+
+  let missingCount = 0;
+
+  for (const entry of missingEntries) {
+    if (!(await pathExists(entry.localPath))) {
+      missingCount += 1;
+    }
+  }
+
+  checks.push(
+    missingCount === 0
+      ? ok("local-paths", "All tracked local paths currently exist.")
+      : warn(
+          "local-paths",
+          `${missingCount} tracked local path${missingCount === 1 ? " is" : "s are"} missing.`,
+        ),
+  );
+
+  const hasFailures = checks.some((check) => check.level === "fail");
+  const hasWarnings = checks.some((check) => check.level === "warn");
+
+  return {
+    checks,
+    configPath: context.paths.configPath,
+    hasFailures,
+    hasWarnings,
+    syncDirectory: context.paths.syncDirectory,
+  };
+};

package/src/services/filesystem.test.ts

@@ -0,0 +1,171 @@
+import {
+  chmod,
+  lstat,
+  mkdir,
+  readFile,
+  readlink,
+  rm,
+  symlink,
+  writeFile,
+} from "node:fs/promises";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  buildExecutableMode,
+  copyFilesystemNode,
+  getPathStats,
+  isExecutableMode,
+  listDirectoryEntries,
+  pathExists,
+  removePathAtomically,
+  replacePathAtomically,
+  writeFileNode,
+  writeSymlinkNode,
+  writeTextFileAtomically,
+} from "#app/services/filesystem.ts";
+import { createTemporaryDirectory } from "../test/helpers/sync-fixture.ts";
+
+const temporaryDirectories: string[] = [];
+
+const createWorkspace = async () => {
+  const directory = await createTemporaryDirectory("devsync-filesystem-");
+
+  temporaryDirectories.push(directory);
+
+  return directory;
+};
+
+afterEach(async () => {
+  while (temporaryDirectories.length > 0) {
+    const directory = temporaryDirectories.pop();
+
+    if (directory !== undefined) {
+      await rm(directory, { force: true, recursive: true });
+    }
+  }
+});
+
+describe("filesystem helpers", () => {
+  it("checks path existence and missing stats", async () => {
+    const workspace = await createWorkspace();
+    const filePath = join(workspace, "value.txt");
+
+    expect(await pathExists(filePath)).toBe(false);
+    expect(await getPathStats(filePath)).toBeUndefined();
+
+    await writeFile(filePath, "value\n", "utf8");
+
+    expect(await pathExists(filePath)).toBe(true);
+    expect((await getPathStats(filePath))?.isFile()).toBe(true);
+  });
+
+  it("lists directory entries in sorted order", async () => {
+    const workspace = await createWorkspace();
+
+    await mkdir(join(workspace, "b"), { recursive: true });
+    await writeFile(join(workspace, "c.txt"), "c\n", "utf8");
+    await writeFile(join(workspace, "a.txt"), "a\n", "utf8");
+
+    const entries = await listDirectoryEntries(workspace);
+
+    expect(entries.map((entry) => entry.name)).toEqual(["a.txt", "b", "c.txt"]);
+  });
+
+  it("builds and detects executable modes", async () => {
+    expect(buildExecutableMode(true)).toBe(0o755);
+    expect(buildExecutableMode(false)).toBe(0o644);
+    expect(isExecutableMode(0o100755)).toBe(true);
+    expect(isExecutableMode(0o100644)).toBe(false);
+  });
+
+  it("writes regular files and preserves executable bits", async () => {
+    if (process.platform === "win32") {
+      return;
+    }
+
+    const workspace = await createWorkspace();
+    const filePath = join(workspace, "bin", "tool.sh");
+
+    await writeFileNode(filePath, {
+      contents: "#!/bin/sh\nexit 0\n",
+      executable: true,
+    });
+
+    expect(await readFile(filePath, "utf8")).toContain("#!/bin/sh");
+    expect(isExecutableMode((await lstat(filePath)).mode)).toBe(true);
+  });
+
+  it("writes symlinks after removing existing content", async () => {
+    if (process.platform === "win32") {
+      return;
+    }
+
+    const workspace = await createWorkspace();
+    const linkPath = join(workspace, "links", "current");
+
+    await mkdir(join(workspace, "links"), { recursive: true });
+    await writeFile(linkPath, "old\n", "utf8");
+    await writeSymlinkNode(linkPath, "../target.txt");
+
+    expect(await readlink(linkPath)).toBe("../target.txt");
+  });
+
+  it("copies regular files and symlinks", async () => {
+    if (process.platform === "win32") {
+      return;
+    }
+
+    const workspace = await createWorkspace();
+    const sourceDirectory = join(workspace, "source");
+    const targetDirectory = join(workspace, "target");
+    const filePath = join(sourceDirectory, "nested", "value.txt");
+    const linkPath = join(sourceDirectory, "nested", "value-link");
+
+    await mkdir(join(sourceDirectory, "nested"), { recursive: true });
+    await writeFile(filePath, "payload\n", "utf8");
+    await chmod(filePath, 0o755);
+    await symlink("value.txt", linkPath);
+
+    await copyFilesystemNode(sourceDirectory, targetDirectory);
+
+    expect(
+      await readFile(join(targetDirectory, "nested", "value.txt"), "utf8"),
+    ).toBe("payload\n");
+    expect(await readlink(join(targetDirectory, "nested", "value-link"))).toBe(
+      "value.txt",
+    );
+  });
+
+  it("replaces and removes paths atomically", async () => {
+    const workspace = await createWorkspace();
+    const targetPath = join(workspace, "config.json");
+    const stagedPath = join(workspace, "next.json");
+
+    await writeFile(targetPath, "old\n", "utf8");
+    await writeFile(stagedPath, "new\n", "utf8");
+
+    await replacePathAtomically(targetPath, stagedPath);
+
+    expect(await readFile(targetPath, "utf8")).toBe("new\n");
+    expect(await pathExists(stagedPath)).toBe(false);
+
+    await removePathAtomically(targetPath);
+
+    expect(await pathExists(targetPath)).toBe(false);
+    await removePathAtomically(targetPath);
+    expect(await pathExists(targetPath)).toBe(false);
+  });
+
+  it("writes text files atomically for create and overwrite flows", async () => {
+    const workspace = await createWorkspace();
+    const targetPath = join(workspace, "nested", "config.json");
+
+    await writeTextFileAtomically(targetPath, "first\n");
+    expect(await readFile(targetPath, "utf8")).toBe("first\n");
+
+    await writeTextFileAtomically(targetPath, "second\n");
+    expect(await readFile(targetPath, "utf8")).toBe("second\n");
+  });
+});

package/src/services/git.test.ts

@@ -0,0 +1,83 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { DevsyncError } from "#app/services/error.ts";
+import {
+  ensureGitRepository,
+  ensureRepository,
+  initializeRepository,
+} from "#app/services/git.ts";
+import {
+  createTemporaryDirectory,
+  runGit,
+} from "../test/helpers/sync-fixture.ts";
+
+const temporaryDirectories: string[] = [];
+
+const createWorkspace = async () => {
+  const directory = await createTemporaryDirectory("devsync-git-");
+
+  temporaryDirectories.push(directory);
+
+  return directory;
+};
+
+afterEach(async () => {
+  while (temporaryDirectories.length > 0) {
+    const directory = temporaryDirectories.pop();
+
+    if (directory !== undefined) {
+      await rm(directory, { force: true, recursive: true });
+    }
+  }
+});
+
+describe("git helpers", () => {
+  it("initializes a repository with a main branch", async () => {
+    const workspace = await createWorkspace();
+    const repositoryPath = join(workspace, "sync");
+
+    await expect(initializeRepository(repositoryPath)).resolves.toEqual({
+      action: "initialized",
+    });
+    await expect(ensureRepository(repositoryPath)).resolves.toBeUndefined();
+    await expect(
+      runGit(["-C", repositoryPath, "symbolic-ref", "--short", "HEAD"]),
+    ).resolves.toMatchObject({
+      stdout: "main\n",
+    });
+  });
+
+  it("clones an existing repository and reports the source", async () => {
+    const workspace = await createWorkspace();
+    const sourcePath = join(workspace, "source");
+    const targetPath = join(workspace, "clone");
+
+    await runGit(["init", "-b", "main", sourcePath], workspace);
+
+    await expect(initializeRepository(targetPath, sourcePath)).resolves.toEqual(
+      {
+        action: "cloned",
+        source: sourcePath,
+      },
+    );
+    await expect(ensureRepository(targetPath)).resolves.toBeUndefined();
+  });
+
+  it("wraps missing git repositories in a DevsyncError", async () => {
+    const workspace = await createWorkspace();
+    const missingRepositoryPath = join(workspace, "not-a-repo");
+
+    await expect(
+      ensureRepository(missingRepositoryPath),
+    ).rejects.toThrowError();
+    await expect(
+      ensureGitRepository(missingRepositoryPath),
+    ).rejects.toThrowError(DevsyncError);
+    await expect(
+      ensureGitRepository(missingRepositoryPath),
+    ).rejects.toThrowError(/Sync directory is not a git repository/u);
+  });
+});