@tinyrack/devsync 1.1.0 → 1.2.2

package/src/lib/string.ts

@@ -1,3 +0,0 @@
-export const ensureTrailingNewline = (value: string) => {
-  return value.endsWith("\n") ? value : `${value}\n`;
-};

package/src/lib/validation.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { ZodIssue } from "zod";
-
-import { formatInputIssues } from "#app/lib/validation.ts";
-
-describe("validation helpers", () => {
-  it("formats root-level issues as input", () => {
-    const issues = [
-      {
-        code: "custom",
-        message: "Invalid request.",
-        path: [],
-      },
-    ] satisfies ZodIssue[];
-
-    expect(formatInputIssues(issues)).toBe("- input: Invalid request.");
-  });
-
-  it("formats nested issue paths with dot notation", () => {
-    const issues = [
-      {
-        code: "custom",
-        message: "Value must not be empty.",
-        path: ["entries", 0, "repoPath"],
-      },
-    ] satisfies ZodIssue[];
-
-    expect(formatInputIssues(issues)).toBe(
-      "- entries.0.repoPath: Value must not be empty.",
-    );
-  });
-});

package/src/lib/validation.ts

@@ -1,11 +0,0 @@
-import type { z } from "zod";
-
-export const formatInputIssues = (issues: z.ZodIssue[]): string => {
-  return issues
-    .map((issue) => {
-      const path = issue.path.length === 0 ? "input" : issue.path.join(".");
-
-      return `- ${path}: ${issue.message}`;
-    })
-    .join("\n");
-};

package/src/services/add.ts

@@ -1,178 +0,0 @@
-import {
-  type ResolvedSyncConfig,
-  type ResolvedSyncConfigEntry,
-  readSyncConfig,
-  type SyncConfigEntryKind,
-  type SyncMode,
-} from "#app/config/sync.ts";
-
-import {
-  createSyncConfigDocument,
-  createSyncConfigDocumentEntry,
-  sortSyncConfigEntries,
-  writeValidatedSyncConfig,
-} from "./config-file.ts";
-import { DevsyncError } from "./error.ts";
-import { getPathStats } from "./filesystem.ts";
-import {
-  buildConfiguredHomeLocalPath,
-  buildRepoPathWithinRoot,
-  doPathsOverlap,
-  resolveCommandTargetPath,
-} from "./paths.ts";
-import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
-
-export type SyncAddRequest = Readonly<{
-  secret: boolean;
-  target: string;
-}>;
-
-export type SyncAddResult = Readonly<{
-  alreadyTracked: boolean;
-  configPath: string;
-  kind: SyncConfigEntryKind;
-  localPath: string;
-  mode: SyncMode;
-  repoPath: string;
-  syncDirectory: string;
-}>;
-
-const buildAddEntryCandidate = async (
-  targetPath: string,
-  config: ResolvedSyncConfig,
-  context: Pick<SyncContext, "paths">,
-) => {
-  const targetStats = await getPathStats(targetPath);
-
-  if (targetStats === undefined) {
-    throw new DevsyncError(`Sync target does not exist: ${targetPath}`);
-  }
-
-  const kind = (() => {
-    if (targetStats.isDirectory()) {
-      return "directory" as const;
-    }
-
-    if (targetStats.isFile() || targetStats.isSymbolicLink()) {
-      return "file" as const;
-    }
-
-    throw new DevsyncError(`Unsupported sync target type: ${targetPath}`);
-  })();
-
-  if (doPathsOverlap(targetPath, context.paths.syncDirectory)) {
-    throw new DevsyncError(
-      `Sync target must not overlap the sync directory: ${targetPath}`,
-    );
-  }
-
-  if (doPathsOverlap(targetPath, config.age.identityFile)) {
-    throw new DevsyncError(
-      `Sync target must not contain the age identity file: ${targetPath}`,
-    );
-  }
-
-  const repoPath = buildRepoPathWithinRoot(
-    targetPath,
-    context.paths.homeDirectory,
-    "Sync target",
-  );
-
-  return {
-    configuredLocalPath: buildConfiguredHomeLocalPath(repoPath),
-    kind,
-    localPath: targetPath,
-    mode: "normal",
-    name: repoPath,
-    overrides: [],
-    repoPath,
-  } satisfies ResolvedSyncConfigEntry;
-};
-
-export const addSyncTarget = async (
-  request: SyncAddRequest,
-  context: SyncContext,
-): Promise<SyncAddResult> => {
-  const target = request.target.trim();
-
-  if (target.length === 0) {
-    throw new DevsyncError("Target path is required.");
-  }
-
-  await ensureSyncRepository(context);
-
-  const config = await readSyncConfig(
-    context.paths.syncDirectory,
-    context.environment,
-  );
-  const candidate = await buildAddEntryCandidate(
-    resolveCommandTargetPath(target, context.environment, context.cwd),
-    config,
-    context,
-  );
-  const existingEntry = config.entries.find((entry) => {
-    return (
-      entry.localPath === candidate.localPath ||
-      entry.repoPath === candidate.repoPath
-    );
-  });
-  let alreadyTracked = false;
-
-  if (existingEntry !== undefined) {
-    if (
-      existingEntry.localPath === candidate.localPath &&
-      existingEntry.repoPath === candidate.repoPath &&
-      existingEntry.kind === candidate.kind
-    ) {
-      alreadyTracked = true;
-    } else {
-      throw new DevsyncError(
-        `Sync target conflicts with an existing entry: ${existingEntry.repoPath}`,
-      );
-    }
-  }
-
-  const nextConfig = createSyncConfigDocument(config);
-  const desiredMode: SyncMode = request.secret ? "secret" : "normal";
-  let mode = existingEntry?.mode ?? (request.secret ? "secret" : "normal");
-
-  if (!alreadyTracked) {
-    nextConfig.entries = sortSyncConfigEntries([
-      ...nextConfig.entries,
-      createSyncConfigDocumentEntry({
-        ...candidate,
-        mode: desiredMode,
-      }),
-    ]);
-    mode = desiredMode;
-  } else if (request.secret && existingEntry?.mode !== "secret") {
-    nextConfig.entries = nextConfig.entries.map((entry) => {
-      if (entry.repoPath !== candidate.repoPath) {
-        return entry;
-      }
-
-      return {
-        ...entry,
-        mode: "secret",
-      };
-    });
-
-    mode = "secret";
-  }
-
-  if (!alreadyTracked || (request.secret && existingEntry?.mode !== "secret")) {
-    await writeValidatedSyncConfig(context.paths.syncDirectory, nextConfig, {
-      environment: context.environment,
-    });
-  }
-
-  return {
-    alreadyTracked,
-    configPath: context.paths.configPath,
-    kind: candidate.kind,
-    localPath: candidate.localPath,
-    mode,
-    repoPath: candidate.repoPath,
-    syncDirectory: context.paths.syncDirectory,
-  };
-};

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

@@ -1,161 +0,0 @@
-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/config-file.ts

@@ -1,101 +0,0 @@
-import {
-  formatSyncConfig,
-  formatSyncOverrideSelector,
-  parseSyncConfig,
-  type ResolvedSyncConfig,
-  type ResolvedSyncConfigEntry,
-  type ResolvedSyncOverride,
-  resolveSyncConfigFilePath,
-  type SyncConfig,
-} from "#app/config/sync.ts";
-
-import { writeTextFileAtomically } from "./filesystem.ts";
-
-type SyncConfigDocumentEntry = SyncConfig["entries"][number];
-
-export const sortSyncOverrides = (
-  overrides: readonly Pick<ResolvedSyncOverride, "match" | "mode" | "path">[],
-) => {
-  return [...overrides].sort((left, right) => {
-    return formatSyncOverrideSelector(left).localeCompare(
-      formatSyncOverrideSelector(right),
-    );
-  });
-};
-
-export const createSyncConfigDocumentEntry = (
-  entry: Pick<
-    ResolvedSyncConfigEntry,
-    "configuredLocalPath" | "kind" | "name" | "mode" | "overrides" | "repoPath"
-  >,
-): SyncConfigDocumentEntry => {
-  return {
-    kind: entry.kind,
-    localPath: entry.configuredLocalPath,
-    mode: entry.mode,
-    name: entry.name,
-    ...(entry.overrides.length === 0
-      ? {}
-      : {
-          overrides: Object.fromEntries(
-            sortSyncOverrides(entry.overrides).map((override) => {
-              return [formatSyncOverrideSelector(override), override.mode];
-            }),
-          ),
-        }),
-    repoPath: entry.repoPath,
-  };
-};
-
-export const createSyncConfigDocument = (
-  config: ResolvedSyncConfig,
-): SyncConfig => {
-  return {
-    version: 1,
-    age: {
-      identityFile: config.age.configuredIdentityFile,
-      recipients: [...config.age.recipients],
-    },
-    entries: config.entries.map((entry) => {
-      return createSyncConfigDocumentEntry(entry);
-    }),
-  };
-};
-
-export const sortSyncConfigEntries = (
-  entries: readonly SyncConfigDocumentEntry[],
-) => {
-  return [...entries].sort((left, right) => {
-    return left.repoPath.localeCompare(right.repoPath);
-  });
-};
-
-export const countConfiguredRules = (config: ResolvedSyncConfig) => {
-  return config.entries.reduce((total, entry) => {
-    return total + entry.overrides.length;
-  }, 0);
-};
-
-export const writeValidatedSyncConfig = async (
-  syncDirectory: string,
-  config: SyncConfig,
-  dependencies: Readonly<{
-    environment: NodeJS.ProcessEnv;
-  }>,
-) => {
-  const resolvedConfig = parseSyncConfig(
-    {
-      ...config,
-      entries: sortSyncConfigEntries(config.entries),
-    },
-    dependencies.environment,
-  );
-  const nextConfig = createSyncConfigDocument(resolvedConfig);
-
-  await writeTextFileAtomically(
-    resolveSyncConfigFilePath(syncDirectory),
-    formatSyncConfig(nextConfig),
-  );
-
-  return nextConfig;
-};

package/src/services/crypto.test.ts

@@ -1,132 +0,0 @@
-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/crypto.ts

@@ -1,83 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-
-import {
-  armor,
-  Decrypter,
-  Encrypter,
-  generateIdentity,
-  identityToRecipient,
-} from "age-encryption";
-
-import { ensureTrailingNewline } from "#app/lib/string.ts";
-
-export const readAgeIdentityLines = async (identityFile: string) => {
-  const contents = await readFile(identityFile, "utf8");
-  const identities = contents
-    .split(/\r?\n/u)
-    .map((line) => line.trim())
-    .filter((line) => {
-      return line !== "" && !line.startsWith("#");
-    });
-
-  if (identities.length === 0) {
-    throw new Error(`No age identities found in ${identityFile}`);
-  }
-
-  return identities;
-};
-
-export const readAgeRecipientsFromIdentityFile = async (
-  identityFile: string,
-) => {
-  const identities = await readAgeIdentityLines(identityFile);
-  const recipients = await Promise.all(
-    identities.map(async (identity) => {
-      return await identityToRecipient(identity);
-    }),
-  );
-
-  return [...new Set(recipients)];
-};
-
-export const createAgeIdentityFile = async (identityFile: string) => {
-  const identity = await generateIdentity();
-  const recipient = await identityToRecipient(identity);
-
-  await mkdir(dirname(identityFile), { recursive: true });
-  await writeFile(identityFile, ensureTrailingNewline(identity), "utf8");
-
-  return {
-    identity,
-    recipient,
-  };
-};
-
-export const encryptSecretFile = async (
-  contents: Uint8Array,
-  recipients: readonly string[],
-) => {
-  const encrypter = new Encrypter();
-
-  for (const recipient of recipients) {
-    encrypter.addRecipient(recipient);
-  }
-
-  const ciphertext = await encrypter.encrypt(contents);
-
-  return armor.encode(ciphertext);
-};
-
-export const decryptSecretFile = async (
-  armoredCiphertext: string,
-  identityFile: string,
-) => {
-  const decrypter = new Decrypter();
-  const identities = await readAgeIdentityLines(identityFile);
-
-  for (const identity of identities) {
-    decrypter.addIdentity(identity);
-  }
-
-  return await decrypter.decrypt(armor.decode(armoredCiphertext));
-};