@tinyrack/devsync 1.0.3 → 1.2.2

package/src/services/repo-snapshot.ts

@@ -1,197 +0,0 @@
-import { lstat, readFile, readlink } from "node:fs/promises";
-import { join } from "node:path";
-
-import {
-  findOwningSyncEntry,
-  type ResolvedSyncConfig,
-  resolveManagedSyncMode,
-  resolveSyncArtifactsDirectoryPath,
-} from "#app/config/sync.ts";
-
-import { decryptSecretFile } from "./crypto.ts";
-import { DevsyncError } from "./error.ts";
-import {
-  getPathStats,
-  isExecutableMode,
-  listDirectoryEntries,
-  pathExists,
-} from "./filesystem.ts";
-import { addSnapshotNode, type SnapshotNode } from "./local-snapshot.ts";
-import {
-  assertStorageSafeRepoPath,
-  isSecretArtifactPath,
-  stripSecretArtifactSuffix,
-} from "./repo-artifacts.ts";
-
-const readPlainSnapshotNode = async (
-  absolutePath: string,
-  repoPath: string,
-  config: ResolvedSyncConfig,
-  snapshot: Map<string, SnapshotNode>,
-) => {
-  assertStorageSafeRepoPath(repoPath);
-  const mode = resolveManagedSyncMode(config, repoPath);
-
-  if (mode === "ignore") {
-    return;
-  }
-
-  if (findOwningSyncEntry(config, repoPath) === undefined) {
-    throw new DevsyncError(
-      `Unmanaged plain sync path found in repository: ${repoPath}`,
-    );
-  }
-
-  if (mode === "secret") {
-    throw new DevsyncError(
-      `Secret sync path is stored in plain text in the repository: ${repoPath}`,
-    );
-  }
-
-  const stats = await lstat(absolutePath);
-
-  if (stats.isSymbolicLink()) {
-    addSnapshotNode(snapshot, repoPath, {
-      linkTarget: await readlink(absolutePath),
-      type: "symlink",
-    });
-
-    return;
-  }
-
-  if (!stats.isFile()) {
-    throw new DevsyncError(
-      `Unsupported plain repository entry: ${absolutePath}`,
-    );
-  }
-
-  addSnapshotNode(snapshot, repoPath, {
-    contents: await readFile(absolutePath),
-    executable: isExecutableMode(stats.mode),
-    secret: false,
-    type: "file",
-  });
-};
-
-const readRepositoryTree = async (
-  rootDirectory: string,
-  config: ResolvedSyncConfig,
-  snapshot: Map<string, SnapshotNode>,
-  prefix?: string,
-) => {
-  if (!(await pathExists(rootDirectory))) {
-    return;
-  }
-
-  const entries = await listDirectoryEntries(rootDirectory);
-
-  for (const entry of entries) {
-    const absolutePath = join(rootDirectory, entry.name);
-    const relativePath =
-      prefix === undefined ? entry.name : `${prefix}/${entry.name}`;
-    const stats = await lstat(absolutePath);
-
-    if (stats.isDirectory()) {
-      assertStorageSafeRepoPath(relativePath);
-      await readRepositoryTree(absolutePath, config, snapshot, relativePath);
-      continue;
-    }
-
-    if (stats.isSymbolicLink()) {
-      if (isSecretArtifactPath(relativePath)) {
-        throw new DevsyncError(
-          `Secret repository entries must be regular files, not symlinks: ${relativePath}`,
-        );
-      }
-
-      await readPlainSnapshotNode(absolutePath, relativePath, config, snapshot);
-      continue;
-    }
-
-    if (isSecretArtifactPath(relativePath)) {
-      const repoPath = stripSecretArtifactSuffix(relativePath);
-
-      if (repoPath === undefined || repoPath.length === 0) {
-        throw new DevsyncError(
-          `Secret repository files must include a path before ${relativePath}`,
-        );
-      }
-
-      assertStorageSafeRepoPath(repoPath);
-      const mode = resolveManagedSyncMode(config, repoPath);
-
-      if (findOwningSyncEntry(config, repoPath) === undefined) {
-        throw new DevsyncError(
-          `Unmanaged secret sync path found in repository: ${repoPath}`,
-        );
-      }
-
-      if (mode === "ignore") {
-        continue;
-      }
-
-      if (mode !== "secret") {
-        throw new DevsyncError(
-          `Plain sync path is stored in secret form in the repository: ${repoPath}`,
-        );
-      }
-
-      addSnapshotNode(snapshot, repoPath, {
-        contents: await decryptSecretFile(
-          await readFile(absolutePath, "utf8"),
-          config.age.identityFile,
-        ),
-        executable: isExecutableMode(stats.mode),
-        secret: true,
-        type: "file",
-      });
-      continue;
-    }
-
-    if (!stats.isFile()) {
-      throw new DevsyncError(
-        `Unsupported plain repository entry: ${absolutePath}`,
-      );
-    }
-
-    await readPlainSnapshotNode(absolutePath, relativePath, config, snapshot);
-  }
-};
-
-export const buildRepositorySnapshot = async (
-  syncDirectory: string,
-  config: ResolvedSyncConfig,
-) => {
-  const snapshot = new Map<string, SnapshotNode>();
-  const artifactsDirectory = resolveSyncArtifactsDirectoryPath(syncDirectory);
-
-  await readRepositoryTree(artifactsDirectory, config, snapshot);
-
-  for (const entry of config.entries) {
-    if (entry.kind !== "directory") {
-      continue;
-    }
-
-    const artifactPath = join(artifactsDirectory, ...entry.repoPath.split("/"));
-    const stats = await getPathStats(artifactPath);
-
-    if (stats !== undefined && !stats.isDirectory()) {
-      throw new DevsyncError(
-        `Directory sync entry is not stored as a directory in the repository: ${entry.repoPath}`,
-      );
-    }
-
-    const mode = resolveManagedSyncMode(config, entry.repoPath);
-    const hasTrackedChildren = [...snapshot.keys()].some((repoPath) => {
-      return repoPath.startsWith(`${entry.repoPath}/`);
-    });
-
-    if (stats?.isDirectory() && (mode !== "ignore" || hasTrackedChildren)) {
-      addSnapshotNode(snapshot, entry.repoPath, {
-        type: "directory",
-      });
-    }
-  }
-
-  return snapshot;
-};

package/src/services/runtime.ts

@@ -1,57 +0,0 @@
-import {
-  resolveSyncArtifactsDirectoryPath,
-  resolveSyncConfigFilePath,
-} from "#app/config/sync.ts";
-import {
-  resolveDevsyncSyncDirectory,
-  resolveHomeDirectory,
-} from "#app/config/xdg.ts";
-
-import { ensureGitRepository } from "./git.ts";
-
-export type SyncPaths = Readonly<{
-  artifactsDirectory: string;
-  configPath: string;
-  homeDirectory: string;
-  syncDirectory: string;
-}>;
-
-export type SyncContext = Readonly<{
-  cwd: string;
-  environment: NodeJS.ProcessEnv;
-  paths: SyncPaths;
-}>;
-
-export const createSyncPaths = (
-  environment: NodeJS.ProcessEnv = process.env,
-): SyncPaths => {
-  const syncDirectory = resolveDevsyncSyncDirectory(environment);
-
-  return {
-    artifactsDirectory: resolveSyncArtifactsDirectoryPath(syncDirectory),
-    configPath: resolveSyncConfigFilePath(syncDirectory),
-    homeDirectory: resolveHomeDirectory(environment),
-    syncDirectory,
-  };
-};
-
-export const createSyncContext = (
-  options: Readonly<{
-    cwd?: string;
-    environment?: NodeJS.ProcessEnv;
-  }> = {},
-): SyncContext => {
-  const environment = options.environment ?? process.env;
-
-  return {
-    cwd: options.cwd ?? process.cwd(),
-    environment,
-    paths: createSyncPaths(environment),
-  };
-};
-
-export const ensureSyncRepository = async (
-  context: Pick<SyncContext, "paths">,
-) => {
-  await ensureGitRepository(context.paths.syncDirectory);
-};

package/src/services/set.ts

@@ -1,383 +0,0 @@
-import { join } from "node:path";
-
-import {
-  findOwningSyncEntry,
-  type ResolvedSyncConfigEntry,
-  type ResolvedSyncOverride,
-  readSyncConfig,
-  resolveEntryRelativeRepoPath,
-  resolveRelativeSyncMode,
-  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 {
-  buildRepoPathWithinRoot,
-  isExplicitLocalPath,
-  resolveCommandTargetPath,
-  tryBuildRepoPathWithinRoot,
-  tryNormalizeRepoPathInput,
-} from "./paths.ts";
-import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
-
-export type SyncSetRequest = Readonly<{
-  recursive: boolean;
-  state: SyncMode;
-  target: string;
-}>;
-
-type SyncSetScope = "default" | "exact" | "subtree";
-type SyncSetAction = "added" | "removed" | "unchanged" | "updated";
-
-export type SyncSetResult = Readonly<{
-  action: SyncSetAction;
-  configPath: string;
-  entryRepoPath: string;
-  localPath: string;
-  mode: SyncMode;
-  repoPath: string;
-  scope: SyncSetScope;
-  syncDirectory: string;
-}>;
-
-const resolveTargetPath = async (
-  target: string,
-  entry: ResolvedSyncConfigEntry,
-  context: Pick<SyncContext, "cwd" | "environment" | "paths">,
-) => {
-  if (isExplicitLocalPath(target)) {
-    const localPath = resolveCommandTargetPath(
-      target,
-      context.environment,
-      context.cwd,
-    );
-    const stats = await getPathStats(localPath);
-
-    if (stats === undefined) {
-      throw new DevsyncError(`Sync set target does not exist: ${localPath}`);
-    }
-
-    return {
-      localPath,
-      repoPath: buildRepoPathWithinRoot(
-        localPath,
-        context.paths.homeDirectory,
-        "Sync set target",
-      ),
-      stats,
-    };
-  }
-
-  const repoPath = tryNormalizeRepoPathInput(target);
-
-  if (repoPath === undefined) {
-    throw new DevsyncError(
-      `Sync set target must be a local path or repository path: ${target}`,
-    );
-  }
-
-  const relativePath = resolveEntryRelativeRepoPath(entry, repoPath);
-  const localPath =
-    relativePath === undefined || relativePath === ""
-      ? entry.localPath
-      : join(entry.localPath, ...relativePath.split("/"));
-
-  return {
-    localPath,
-    repoPath,
-    stats: await getPathStats(localPath),
-  };
-};
-
-const resolveSetTarget = async (
-  target: string,
-  config: Awaited<ReturnType<typeof readSyncConfig>>,
-  context: Pick<SyncContext, "cwd" | "environment" | "paths">,
-) => {
-  const trimmedTarget = target.trim();
-
-  if (trimmedTarget.length === 0) {
-    throw new DevsyncError("Target path is required.");
-  }
-
-  const homeDirectory = context.paths.homeDirectory;
-  const explicitLocalPath = isExplicitLocalPath(trimmedTarget);
-  const localTargetPath = resolveCommandTargetPath(
-    trimmedTarget,
-    context.environment,
-    context.cwd,
-  );
-  const localRepoPath = explicitLocalPath
-    ? buildRepoPathWithinRoot(localTargetPath, homeDirectory, "Sync set target")
-    : tryBuildRepoPathWithinRoot(
-        localTargetPath,
-        homeDirectory,
-        "Sync set target",
-      );
-
-  if (localRepoPath !== undefined) {
-    const localStats = await getPathStats(localTargetPath);
-
-    if (explicitLocalPath && localStats === undefined) {
-      throw new DevsyncError(
-        `Sync set target does not exist: ${localTargetPath}`,
-      );
-    }
-
-    const entry = findOwningSyncEntry(config, localRepoPath);
-
-    if (entry?.kind === "directory") {
-      const relativePath = resolveEntryRelativeRepoPath(entry, localRepoPath);
-
-      if (relativePath !== undefined) {
-        return {
-          entry,
-          localPath: localTargetPath,
-          relativePath,
-          repoPath: localRepoPath,
-          stats: localStats,
-        };
-      }
-    }
-
-    if (explicitLocalPath) {
-      throw new DevsyncError(
-        `Sync set target must be inside a tracked directory entry: ${trimmedTarget}`,
-      );
-    }
-  }
-
-  const repoPath = tryNormalizeRepoPathInput(trimmedTarget);
-
-  if (repoPath === undefined) {
-    throw new DevsyncError(
-      `Sync set target must be a local path or repository path: ${trimmedTarget}`,
-    );
-  }
-
-  const entry = findOwningSyncEntry(config, repoPath);
-
-  if (entry === undefined || entry.kind !== "directory") {
-    throw new DevsyncError(
-      `Sync set target must be inside a tracked directory entry: ${trimmedTarget}`,
-    );
-  }
-
-  const resolvedTarget = await resolveTargetPath(trimmedTarget, entry, context);
-  const relativePath = resolveEntryRelativeRepoPath(
-    entry,
-    resolvedTarget.repoPath,
-  );
-
-  if (relativePath === undefined) {
-    throw new DevsyncError(
-      `Sync set target must be inside a tracked directory entry: ${trimmedTarget}`,
-    );
-  }
-
-  return {
-    entry,
-    localPath: resolvedTarget.localPath,
-    relativePath,
-    repoPath: resolvedTarget.repoPath,
-    stats: resolvedTarget.stats,
-  };
-};
-
-const updateEntryMode = (
-  entry: ResolvedSyncConfigEntry,
-  mode: SyncMode,
-): {
-  action: SyncSetAction;
-  entry: ResolvedSyncConfigEntry;
-} => {
-  if (entry.mode === mode) {
-    return {
-      action: "unchanged",
-      entry,
-    };
-  }
-
-  return {
-    action: "updated",
-    entry: {
-      ...entry,
-      mode,
-    },
-  };
-};
-
-const updateChildOverride = (
-  entry: ResolvedSyncConfigEntry,
-  input: Readonly<{
-    match: Extract<SyncSetScope, "exact" | "subtree">;
-    mode: SyncMode;
-    relativePath: string;
-  }>,
-): {
-  action: SyncSetAction;
-  entry: ResolvedSyncConfigEntry;
-} => {
-  const existingOverride = entry.overrides.find((override) => {
-    return (
-      override.match === input.match && override.path === input.relativePath
-    );
-  });
-  const remainingOverrides = entry.overrides.filter((override) => {
-    return !(
-      override.match === input.match && override.path === input.relativePath
-    );
-  });
-  const inheritedMode = resolveRelativeSyncMode(
-    entry.mode,
-    remainingOverrides,
-    input.relativePath,
-  );
-
-  if (input.mode === inheritedMode) {
-    if (existingOverride === undefined) {
-      return {
-        action: "unchanged",
-        entry,
-      };
-    }
-
-    return {
-      action: "removed",
-      entry: {
-        ...entry,
-        overrides: remainingOverrides,
-      },
-    };
-  }
-
-  if (existingOverride?.mode === input.mode) {
-    return {
-      action: "unchanged",
-      entry,
-    };
-  }
-
-  const nextOverride = {
-    match: input.match,
-    mode: input.mode,
-    path: input.relativePath,
-  } satisfies ResolvedSyncOverride;
-
-  return {
-    action: existingOverride === undefined ? "added" : "updated",
-    entry: {
-      ...entry,
-      overrides: [...remainingOverrides, nextOverride],
-    },
-  };
-};
-
-export const setSyncTargetMode = async (
-  request: SyncSetRequest,
-  context: SyncContext,
-): Promise<SyncSetResult> => {
-  await ensureSyncRepository(context);
-
-  const config = await readSyncConfig(
-    context.paths.syncDirectory,
-    context.environment,
-  );
-  const target = await resolveSetTarget(request.target, config, context);
-
-  if (target.relativePath === "") {
-    if (!request.recursive) {
-      throw new DevsyncError(
-        "Tracked directory roots require --recursive to update the entry mode.",
-      );
-    }
-
-    const update = updateEntryMode(target.entry, request.state);
-    const nextConfig = createSyncConfigDocument(config);
-
-    nextConfig.entries = sortSyncConfigEntries(
-      nextConfig.entries.map((entry) => {
-        if (entry.repoPath !== target.entry.repoPath) {
-          return entry;
-        }
-
-        return createSyncConfigDocumentEntry(update.entry);
-      }),
-    );
-
-    if (update.action !== "unchanged") {
-      await writeValidatedSyncConfig(context.paths.syncDirectory, nextConfig, {
-        environment: context.environment,
-      });
-    }
-
-    return {
-      action: update.action,
-      configPath: context.paths.configPath,
-      entryRepoPath: target.entry.repoPath,
-      localPath: target.localPath,
-      mode: request.state,
-      repoPath: target.repoPath,
-      scope: "default",
-      syncDirectory: context.paths.syncDirectory,
-    };
-  }
-
-  if (target.stats?.isDirectory() && !request.recursive) {
-    throw new DevsyncError(
-      "Directory targets require --recursive. Use a file path for exact overrides.",
-    );
-  }
-
-  if (
-    request.recursive &&
-    target.stats !== undefined &&
-    !target.stats.isDirectory()
-  ) {
-    throw new DevsyncError(
-      "--recursive can only be used with directories or tracked directory roots.",
-    );
-  }
-
-  const scope = request.recursive ? "subtree" : "exact";
-  const update = updateChildOverride(target.entry, {
-    match: scope,
-    mode: request.state,
-    relativePath: target.relativePath,
-  });
-  const nextConfig = createSyncConfigDocument(config);
-
-  nextConfig.entries = sortSyncConfigEntries(
-    nextConfig.entries.map((entry) => {
-      if (entry.repoPath !== target.entry.repoPath) {
-        return entry;
-      }
-
-      return createSyncConfigDocumentEntry(update.entry);
-    }),
-  );
-
-  if (update.action !== "unchanged") {
-    await writeValidatedSyncConfig(context.paths.syncDirectory, nextConfig, {
-      environment: context.environment,
-    });
-  }
-
-  return {
-    action: update.action,
-    configPath: context.paths.configPath,
-    entryRepoPath: target.entry.repoPath,
-    localPath: target.localPath,
-    mode: request.state,
-    repoPath: target.repoPath,
-    scope,
-    syncDirectory: context.paths.syncDirectory,
-  };
-};