@tinyrack/devsync 1.1.0 → 1.3.0

package/src/services/doctor.ts

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

@@ -1,6 +0,0 @@
-export class DevsyncError extends Error {
-  public constructor(message: string) {
-    super(message);
-    this.name = "DevsyncError";
-  }
-}

package/src/services/filesystem.test.ts

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

@@ -1,183 +0,0 @@
-import { randomUUID } from "node:crypto";
-import {
-  access,
-  chmod,
-  lstat,
-  mkdir,
-  mkdtemp,
-  readdir,
-  readFile,
-  readlink,
-  rename,
-  rm,
-  symlink,
-  writeFile,
-} from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-
-import { DevsyncError } from "./error.ts";
-
-export const pathExists = async (path: string) => {
-  try {
-    await access(path);
-
-    return true;
-  } catch (error: unknown) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return false;
-    }
-
-    throw error;
-  }
-};
-
-export const getPathStats = async (path: string) => {
-  try {
-    return await lstat(path);
-  } catch (error: unknown) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return undefined;
-    }
-
-    throw error;
-  }
-};
-
-export const listDirectoryEntries = async (path: string) => {
-  const entries = await readdir(path, { withFileTypes: true });
-
-  return entries.sort((left, right) => {
-    return left.name.localeCompare(right.name);
-  });
-};
-
-export const buildExecutableMode = (executable: boolean) => {
-  return executable ? 0o755 : 0o644;
-};
-
-export const isExecutableMode = (mode: number | bigint) => {
-  return (Number(mode) & 0o111) !== 0;
-};
-
-export const writeFileNode = async (
-  path: string,
-  node: Readonly<{
-    contents: string | Uint8Array;
-    executable: boolean;
-  }>,
-) => {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, node.contents);
-  await chmod(path, buildExecutableMode(node.executable));
-};
-
-export const writeSymlinkNode = async (path: string, linkTarget: string) => {
-  await mkdir(dirname(path), { recursive: true });
-  await rm(path, { force: true, recursive: true });
-  await symlink(linkTarget, path);
-};
-
-export const copyFilesystemNode = async (
-  sourcePath: string,
-  targetPath: string,
-  stats?: Awaited<ReturnType<typeof lstat>>,
-) => {
-  const sourceStats = stats ?? (await lstat(sourcePath));
-
-  if (sourceStats.isDirectory()) {
-    await mkdir(targetPath, { recursive: true });
-
-    const entries = await listDirectoryEntries(sourcePath);
-
-    for (const entry of entries) {
-      await copyFilesystemNode(
-        join(sourcePath, entry.name),
-        join(targetPath, entry.name),
-      );
-    }
-
-    return;
-  }
-
-  if (sourceStats.isSymbolicLink()) {
-    await writeSymlinkNode(targetPath, await readlink(sourcePath));
-
-    return;
-  }
-
-  if (!sourceStats.isFile()) {
-    throw new DevsyncError(`Unsupported filesystem entry: ${sourcePath}`);
-  }
-
-  await writeFileNode(targetPath, {
-    contents: await readFile(sourcePath),
-    executable: isExecutableMode(sourceStats.mode),
-  });
-};
-
-export const replacePathAtomically = async (
-  targetPath: string,
-  nextPath: string,
-) => {
-  const backupPath = join(
-    dirname(targetPath),
-    `.${basename(targetPath)}.devsync-sync-backup-${randomUUID()}`,
-  );
-  const existingStats = await getPathStats(targetPath);
-  let targetMoved = false;
-
-  try {
-    if (existingStats !== undefined) {
-      await rename(targetPath, backupPath);
-      targetMoved = true;
-    }
-
-    await rename(nextPath, targetPath);
-
-    if (targetMoved) {
-      await rm(backupPath, { force: true, recursive: true });
-    }
-  } catch (error: unknown) {
-    if (targetMoved && !(await pathExists(targetPath))) {
-      await rename(backupPath, targetPath).catch(() => {});
-    }
-
-    throw error;
-  } finally {
-    await rm(backupPath, { force: true, recursive: true }).catch(() => {});
-  }
-};
-
-export const removePathAtomically = async (targetPath: string) => {
-  const stats = await getPathStats(targetPath);
-
-  if (stats === undefined) {
-    return;
-  }
-
-  const backupPath = join(
-    dirname(targetPath),
-    `.${basename(targetPath)}.devsync-sync-remove-${randomUUID()}`,
-  );
-
-  await rename(targetPath, backupPath);
-  await rm(backupPath, { force: true, recursive: true });
-};
-
-export const writeTextFileAtomically = async (
-  targetPath: string,
-  contents: string,
-) => {
-  await mkdir(dirname(targetPath), { recursive: true });
-  const stagingDirectory = await mkdtemp(
-    join(dirname(targetPath), `.${basename(targetPath)}.devsync-sync-`),
-  );
-  const stagedPath = join(stagingDirectory, basename(targetPath));
-
-  try {
-    await writeFile(stagedPath, contents, "utf8");
-    await replacePathAtomically(targetPath, stagedPath);
-  } finally {
-    await rm(stagingDirectory, { force: true, recursive: true });
-  }
-};