@tinyrack/devsync 1.0.3 → 1.2.2

package/src/services/git.ts

@@ -1,74 +0,0 @@
-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.test.ts

@@ -1,109 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import { DevsyncError } from "#app/services/error.ts";
-import { initializeSync } from "#app/services/init.ts";
-import { createSyncContext } from "#app/services/runtime.ts";
-import {
-  createAgeKeyPair,
-  createTemporaryDirectory,
-  runGit,
-  writeIdentityFile,
-} from "../test/helpers/sync-fixture.ts";
-
-const temporaryDirectories: string[] = [];
-
-const createWorkspace = async () => {
-  const directory = await createTemporaryDirectory("devsync-init-");
-
-  temporaryDirectories.push(directory);
-
-  return directory;
-};
-
-const createEnvironment = (
-  homeDirectory: string,
-  xdgConfigHome: string,
-): NodeJS.ProcessEnv => {
-  return {
-    HOME: homeDirectory,
-    XDG_CONFIG_HOME: xdgConfigHome,
-  };
-};
-
-afterEach(async () => {
-  while (temporaryDirectories.length > 0) {
-    const directory = temporaryDirectories.pop();
-
-    if (directory !== undefined) {
-      await rm(directory, { force: true, recursive: true });
-    }
-  }
-});
-
-describe("init service", () => {
-  it("clones a configured repository source during initialization", async () => {
-    const workspace = await createWorkspace();
-    const homeDirectory = join(workspace, "home");
-    const xdgConfigHome = join(workspace, "xdg");
-    const sourceRepository = join(workspace, "remote-sync");
-    const ageKeys = await createAgeKeyPair();
-
-    await writeIdentityFile(xdgConfigHome, ageKeys.identity);
-    await runGit(["init", "-b", "main", sourceRepository], workspace);
-
-    const result = await initializeSync(
-      {
-        identityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
-        recipients: [ageKeys.recipient],
-        repository: sourceRepository,
-      },
-      createSyncContext({
-        environment: createEnvironment(homeDirectory, xdgConfigHome),
-      }),
-    );
-
-    expect(result.gitAction).toBe("cloned");
-    expect(result.gitSource).toBe(sourceRepository);
-    expect(
-      await readFile(join(result.syncDirectory, "config.json"), "utf8"),
-    ).toContain("$XDG_CONFIG_HOME/devsync/age/keys.txt");
-  });
-
-  it("rejects non-empty sync directories that are not git repositories", async () => {
-    const workspace = await createWorkspace();
-    const homeDirectory = join(workspace, "home");
-    const xdgConfigHome = join(workspace, "xdg");
-    const syncDirectory = join(xdgConfigHome, "devsync", "sync");
-    const ageKeys = await createAgeKeyPair();
-
-    await writeIdentityFile(xdgConfigHome, ageKeys.identity);
-    await mkdir(syncDirectory, { recursive: true });
-    await writeFile(join(syncDirectory, "placeholder.txt"), "keep\n", "utf8");
-
-    await expect(
-      initializeSync(
-        {
-          identityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
-          recipients: [ageKeys.recipient],
-        },
-        createSyncContext({
-          environment: createEnvironment(homeDirectory, xdgConfigHome),
-        }),
-      ),
-    ).rejects.toThrowError(DevsyncError);
-    await expect(
-      initializeSync(
-        {
-          identityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
-          recipients: [ageKeys.recipient],
-        },
-        createSyncContext({
-          environment: createEnvironment(homeDirectory, xdgConfigHome),
-        }),
-      ),
-    ).rejects.toThrowError(/already exists and is not empty/u);
-  });
-});

package/src/services/init.ts

@@ -1,244 +0,0 @@
-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,
-  };
-};