@tinyrack/devsync 1.0.0

package/src/services/forget.ts

@@ -0,0 +1,261 @@
+import { readdir, rm } from "node:fs/promises";
+import { dirname, join, posix } from "node:path";
+
+import {
+  type ResolvedSyncConfig,
+  type ResolvedSyncConfigEntry,
+  readSyncConfig,
+  resolveSyncArtifactsDirectoryPath,
+} from "#app/config/sync.ts";
+
+import {
+  createSyncConfigDocument,
+  sortSyncConfigEntries,
+  writeValidatedSyncConfig,
+} from "./config-file.ts";
+import { DevsyncError } from "./error.ts";
+import {
+  getPathStats,
+  listDirectoryEntries,
+  removePathAtomically,
+} from "./filesystem.ts";
+import {
+  isExplicitLocalPath,
+  isPathEqualOrNested,
+  resolveCommandTargetPath,
+  tryNormalizeRepoPathInput,
+} from "./paths.ts";
+import {
+  isSecretArtifactPath,
+  resolveArtifactRelativePath,
+} from "./repo-artifacts.ts";
+import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
+
+export type SyncForgetRequest = Readonly<{
+  target: string;
+}>;
+
+export type SyncForgetResult = Readonly<{
+  configPath: string;
+  localPath: string;
+  plainArtifactCount: number;
+  repoPath: string;
+  secretArtifactCount: number;
+  syncDirectory: string;
+}>;
+
+const findMatchingTrackedEntry = (
+  config: ResolvedSyncConfig,
+  target: string,
+  context: Pick<SyncContext, "cwd" | "environment">,
+) => {
+  const trimmedTarget = target.trim();
+  const resolvedTargetPath = resolveCommandTargetPath(
+    trimmedTarget,
+    context.environment,
+    context.cwd,
+  );
+  const byLocalPath = config.entries.find((entry) => {
+    return entry.localPath === resolvedTargetPath;
+  });
+
+  if (byLocalPath !== undefined || isExplicitLocalPath(trimmedTarget)) {
+    return byLocalPath;
+  }
+
+  const normalizedRepoPath = tryNormalizeRepoPathInput(trimmedTarget);
+
+  if (normalizedRepoPath === undefined) {
+    return undefined;
+  }
+
+  return config.entries.find((entry) => {
+    return entry.repoPath === normalizedRepoPath;
+  });
+};
+
+const collectRepoArtifactCounts = async (
+  targetPath: string,
+  counts: {
+    plain: number;
+    secret: number;
+  },
+  relativePath: string,
+) => {
+  const stats = await getPathStats(targetPath);
+
+  if (stats === undefined) {
+    return;
+  }
+
+  if (stats.isDirectory()) {
+    counts.plain += 1;
+
+    const entries = await listDirectoryEntries(targetPath);
+
+    for (const entry of entries) {
+      await collectRepoArtifactCounts(
+        join(targetPath, entry.name),
+        counts,
+        posix.join(relativePath, entry.name),
+      );
+    }
+
+    return;
+  }
+
+  if (isSecretArtifactPath(relativePath)) {
+    counts.secret += 1;
+  } else {
+    counts.plain += 1;
+  }
+};
+
+const collectEntryArtifactCounts = async (
+  syncDirectory: string,
+  entry: ResolvedSyncConfigEntry,
+) => {
+  const artifactsRoot = resolveSyncArtifactsDirectoryPath(syncDirectory);
+  const counts = {
+    plain: 0,
+    secret: 0,
+  };
+
+  if (entry.kind === "directory") {
+    await collectRepoArtifactCounts(
+      join(artifactsRoot, ...entry.repoPath.split("/")),
+      counts,
+      entry.repoPath,
+    );
+  } else {
+    await collectRepoArtifactCounts(
+      join(artifactsRoot, ...entry.repoPath.split("/")),
+      counts,
+      entry.repoPath,
+    );
+    await collectRepoArtifactCounts(
+      join(
+        artifactsRoot,
+        ...resolveArtifactRelativePath({
+          category: "secret",
+          repoPath: entry.repoPath,
+        }).split("/"),
+      ),
+      counts,
+      resolveArtifactRelativePath({
+        category: "secret",
+        repoPath: entry.repoPath,
+      }),
+    );
+  }
+
+  return {
+    plainArtifactCount: counts.plain,
+    secretArtifactCount: counts.secret,
+  };
+};
+
+const pruneEmptyParentDirectories = async (
+  startPath: string,
+  rootPath: string,
+) => {
+  let currentPath = startPath;
+
+  while (
+    isPathEqualOrNested(currentPath, rootPath) &&
+    currentPath !== rootPath
+  ) {
+    const stats = await getPathStats(currentPath);
+
+    if (stats === undefined) {
+      currentPath = dirname(currentPath);
+      continue;
+    }
+
+    if (!stats.isDirectory()) {
+      break;
+    }
+
+    const entries = await readdir(currentPath);
+
+    if (entries.length > 0) {
+      break;
+    }
+
+    await rm(currentPath, { force: true, recursive: true });
+    currentPath = dirname(currentPath);
+  }
+};
+
+const removeTrackedEntryArtifacts = async (
+  syncDirectory: string,
+  entry: ResolvedSyncConfigEntry,
+) => {
+  const artifactsRoot = resolveSyncArtifactsDirectoryPath(syncDirectory);
+  const plainPath = join(artifactsRoot, ...entry.repoPath.split("/"));
+
+  await removePathAtomically(plainPath);
+  await pruneEmptyParentDirectories(dirname(plainPath), artifactsRoot);
+
+  if (entry.kind === "directory") {
+    return;
+  }
+
+  const secretPath = join(
+    artifactsRoot,
+    ...resolveArtifactRelativePath({
+      category: "secret",
+      repoPath: entry.repoPath,
+    }).split("/"),
+  );
+
+  await removePathAtomically(secretPath);
+  await pruneEmptyParentDirectories(dirname(secretPath), artifactsRoot);
+};
+
+export const forgetSyncTarget = async (
+  request: SyncForgetRequest,
+  context: SyncContext,
+): Promise<SyncForgetResult> => {
+  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 entry = findMatchingTrackedEntry(config, target, context);
+
+  if (entry === undefined) {
+    throw new DevsyncError(`No tracked sync entry matches: ${target}`);
+  }
+
+  const { plainArtifactCount, secretArtifactCount } =
+    await collectEntryArtifactCounts(context.paths.syncDirectory, entry);
+  const nextConfig = createSyncConfigDocument(config);
+
+  nextConfig.entries = sortSyncConfigEntries(
+    nextConfig.entries.filter((configEntry) => {
+      return configEntry.repoPath !== entry.repoPath;
+    }),
+  );
+
+  await writeValidatedSyncConfig(context.paths.syncDirectory, nextConfig, {
+    environment: context.environment,
+  });
+  await removeTrackedEntryArtifacts(context.paths.syncDirectory, entry);
+
+  return {
+    configPath: context.paths.configPath,
+    localPath: entry.localPath,
+    plainArtifactCount,
+    repoPath: entry.repoPath,
+    secretArtifactCount,
+    syncDirectory: context.paths.syncDirectory,
+  };
+};

package/src/services/git.ts

@@ -0,0 +1,74 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import { DevsyncError } from "./error.ts";
+
+const execFileAsync = promisify(execFile);
+
+const runGitCommand = async (
+  args: readonly string[],
+  options?: Readonly<{ cwd?: string }>,
+) => {
+  try {
+    const result = await execFileAsync("git", [...args], {
+      cwd: options?.cwd,
+      encoding: "utf8",
+      maxBuffer: 10_000_000,
+    });
+
+    return {
+      stderr: result.stderr,
+      stdout: result.stdout,
+    };
+  } catch (error: unknown) {
+    if (error instanceof Error && "stderr" in error) {
+      const stderr =
+        typeof error.stderr === "string" ? error.stderr.trim() : undefined;
+      const stdout =
+        "stdout" in error && typeof error.stdout === "string"
+          ? error.stdout.trim()
+          : undefined;
+      const message = stderr || stdout || error.message;
+
+      throw new Error(message);
+    }
+
+    throw new Error(error instanceof Error ? error.message : "git failed.");
+  }
+};
+
+export const ensureRepository = async (directory: string) => {
+  await runGitCommand(["-C", directory, "rev-parse", "--is-inside-work-tree"]);
+};
+
+export const initializeRepository = async (
+  directory: string,
+  source?: string,
+) => {
+  if (source === undefined) {
+    await runGitCommand(["init", "-b", "main", directory]);
+
+    return {
+      action: "initialized" as const,
+    };
+  }
+
+  await runGitCommand(["clone", source, directory]);
+
+  return {
+    action: "cloned" as const,
+    source,
+  };
+};
+
+export const ensureGitRepository = async (syncDirectory: string) => {
+  try {
+    await ensureRepository(syncDirectory);
+  } catch (error: unknown) {
+    throw new DevsyncError(
+      error instanceof Error
+        ? `Sync directory is not a git repository: ${error.message}`
+        : "Sync directory is not a git repository.",
+    );
+  }
+};

package/src/services/init.ts

@@ -0,0 +1,244 @@
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+import {
+  createInitialSyncConfig,
+  formatSyncConfig,
+  parseSyncConfig,
+  type ResolvedSyncConfig,
+  readSyncConfig,
+  resolveSyncArtifactsDirectoryPath,
+} from "#app/config/sync.ts";
+import { resolveConfiguredAbsolutePath } from "#app/config/xdg.ts";
+
+import { countConfiguredRules } from "./config-file.ts";
+import {
+  createAgeIdentityFile,
+  readAgeRecipientsFromIdentityFile,
+} from "./crypto.ts";
+import { DevsyncError } from "./error.ts";
+import { pathExists } from "./filesystem.ts";
+import { ensureRepository, initializeRepository } from "./git.ts";
+import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
+
+export type SyncInitRequest = Readonly<{
+  identityFile?: string;
+  recipients: readonly string[];
+  repository?: string;
+}>;
+
+export type SyncInitResult = Readonly<{
+  alreadyInitialized: boolean;
+  configPath: string;
+  entryCount: number;
+  gitAction: "cloned" | "existing" | "initialized";
+  gitSource?: string;
+  identityFile: string;
+  generatedIdentity: boolean;
+  recipientCount: number;
+  ruleCount: number;
+  syncDirectory: string;
+}>;
+
+const defaultSyncIdentityFile = "$XDG_CONFIG_HOME/devsync/age/keys.txt";
+
+const normalizeRecipients = (recipients: readonly string[]) => {
+  return [
+    ...new Set(recipients.map((recipient) => recipient.trim()).filter(Boolean)),
+  ].sort((left, right) => {
+    return left.localeCompare(right);
+  });
+};
+
+const resolveInitAgeBootstrap = async (
+  request: SyncInitRequest,
+  context: Pick<SyncContext, "environment">,
+) => {
+  const configuredIdentityFile =
+    request.identityFile?.trim() || defaultSyncIdentityFile;
+  const identityFile = resolveConfiguredAbsolutePath(
+    configuredIdentityFile,
+    context.environment,
+  );
+  const explicitRecipients = normalizeRecipients(request.recipients);
+
+  if (explicitRecipients.length === 0) {
+    if (await pathExists(identityFile)) {
+      return {
+        configuredIdentityFile,
+        generatedIdentity: false,
+        recipients: normalizeRecipients(
+          await readAgeRecipientsFromIdentityFile(identityFile),
+        ),
+      };
+    }
+
+    const { recipient } = await createAgeIdentityFile(identityFile);
+
+    return {
+      configuredIdentityFile,
+      generatedIdentity: true,
+      recipients: [recipient],
+    };
+  }
+
+  if (await pathExists(identityFile)) {
+    return {
+      configuredIdentityFile,
+      generatedIdentity: false,
+      recipients: explicitRecipients,
+    };
+  }
+
+  const { recipient } = await createAgeIdentityFile(identityFile);
+
+  return {
+    configuredIdentityFile,
+    generatedIdentity: true,
+    recipients: normalizeRecipients([...explicitRecipients, recipient]),
+  };
+};
+
+const assertInitRequestMatchesConfig = (
+  config: ResolvedSyncConfig,
+  request: SyncInitRequest,
+  environment: NodeJS.ProcessEnv,
+) => {
+  const recipients = normalizeRecipients(request.recipients);
+
+  if (
+    recipients.length > 0 &&
+    JSON.stringify(recipients) !==
+      JSON.stringify(normalizeRecipients(config.age.recipients))
+  ) {
+    throw new DevsyncError(
+      "Sync configuration already exists with different recipients.",
+    );
+  }
+
+  if (
+    request.identityFile === undefined ||
+    request.identityFile.trim() === ""
+  ) {
+    return;
+  }
+
+  const resolvedIdentity = resolveConfiguredAbsolutePath(
+    request.identityFile,
+    environment,
+  );
+
+  if (resolvedIdentity !== config.age.identityFile) {
+    throw new DevsyncError(
+      "Sync configuration already exists with a different identity file.",
+    );
+  }
+};
+
+export const initializeSync = async (
+  request: SyncInitRequest,
+  context: SyncContext,
+): Promise<SyncInitResult> => {
+  const syncDirectory = context.paths.syncDirectory;
+  const configPath = context.paths.configPath;
+  const configExists = await pathExists(configPath);
+
+  if (configExists) {
+    await ensureSyncRepository(context);
+
+    const config = await readSyncConfig(syncDirectory, context.environment);
+    assertInitRequestMatchesConfig(config, request, context.environment);
+
+    return {
+      alreadyInitialized: true,
+      configPath,
+      entryCount: config.entries.length,
+      gitAction: "existing",
+      generatedIdentity: false,
+      identityFile: config.age.identityFile,
+      recipientCount: config.age.recipients.length,
+      ruleCount: countConfiguredRules(config),
+      syncDirectory,
+    };
+  }
+
+  await mkdir(dirname(syncDirectory), {
+    recursive: true,
+  });
+
+  let gitAction: SyncInitResult["gitAction"] = "existing";
+  let gitSource: string | undefined;
+
+  try {
+    await ensureRepository(syncDirectory);
+  } catch {
+    const syncDirectoryExists = await pathExists(syncDirectory);
+
+    if (syncDirectoryExists) {
+      const entries = await readdir(syncDirectory);
+
+      if (entries.length > 0) {
+        throw new DevsyncError(
+          `Sync directory already exists and is not empty: ${syncDirectory}`,
+        );
+      }
+    }
+
+    const gitResult = await initializeRepository(
+      syncDirectory,
+      request.repository?.trim() || undefined,
+    );
+
+    gitAction = gitResult.action;
+    gitSource = gitResult.source;
+  }
+
+  await mkdir(resolveSyncArtifactsDirectoryPath(syncDirectory), {
+    recursive: true,
+  });
+
+  if (await pathExists(configPath)) {
+    const config = await readSyncConfig(syncDirectory, context.environment);
+
+    assertInitRequestMatchesConfig(config, request, context.environment);
+
+    return {
+      alreadyInitialized: true,
+      configPath,
+      entryCount: config.entries.length,
+      gitAction,
+      ...(gitSource === undefined ? {} : { gitSource }),
+      generatedIdentity: false,
+      identityFile: config.age.identityFile,
+      recipientCount: config.age.recipients.length,
+      ruleCount: countConfiguredRules(config),
+      syncDirectory,
+    };
+  }
+
+  const ageBootstrap = await resolveInitAgeBootstrap(request, context);
+
+  const initialConfig = createInitialSyncConfig({
+    identityFile: ageBootstrap.configuredIdentityFile,
+    recipients: ageBootstrap.recipients,
+  });
+
+  parseSyncConfig(initialConfig, context.environment);
+  await writeFile(configPath, formatSyncConfig(initialConfig), "utf8");
+
+  return {
+    alreadyInitialized: false,
+    configPath,
+    entryCount: 0,
+    gitAction,
+    ...(gitSource === undefined ? {} : { gitSource }),
+    generatedIdentity: ageBootstrap.generatedIdentity,
+    identityFile: resolveConfiguredAbsolutePath(
+      ageBootstrap.configuredIdentityFile,
+      context.environment,
+    ),
+    recipientCount: ageBootstrap.recipients.length,
+    ruleCount: 0,
+    syncDirectory,
+  };
+};