@miranda0808/maya-codex 0.1.0 → 0.1.1

package/vendor/shared-installer/src/install.js

@@ -1,157 +1,168 @@
-"use strict";
-
-const path = require("node:path");
-const { renderBootstrap } = require("./bootstrap");
-const {
-  assertExistingDirectory,
-  copyOpaqueFile,
-  ensureDirectory,
-  fromPosixPath,
-  joinPosixPath,
-  listFilesRecursive,
-  pathExists,
-  resolveTargetDirectory,
-  toPosixPath,
-  writeTextFile,
-} = require("./fs");
-const { loadManifest, resolveInstallerRoot, resolvePayloadRoot } = require("./manifest");
-
-async function expandManifestFiles(files, context) {
-  const operations = [];
-
-  for (const entry of files) {
-    const sourceBase = entry.template ? context.installerRoot : context.payloadRoot;
-    const sourceRoot = fromPosixPath(sourceBase, entry.source);
-    const sourceDetails = await require("node:fs/promises").stat(sourceRoot);
-
-    if (sourceDetails.isDirectory()) {
-      const children = await listFilesRecursive(sourceRoot);
-
-      for (const child of children) {
-        const destinationRelative = joinPosixPath(entry.destination, child);
-        operations.push({
-          destinationPath: fromPosixPath(context.targetDirectory, destinationRelative),
-          destinationRelative,
-          sourcePath: path.join(sourceRoot, ...child.split("/")),
-          sourceRelative: joinPosixPath(entry.source, child),
-          template: false,
-        });
-      }
-
-      continue;
-    }
-
-    operations.push({
-      destinationPath: fromPosixPath(context.targetDirectory, entry.destination),
-      destinationRelative: entry.destination,
-      sourcePath: sourceRoot,
-      sourceRelative: entry.source,
-      template: entry.template,
-    });
-  }
-
-  return operations;
-}
-
-async function buildInstallPlan(options = {}) {
-  if (!options.host) {
-    throw new Error("A host id is required.");
-  }
-
-  const installerRoot = resolveInstallerRoot(options);
-  const payloadRoot = resolvePayloadRoot(options);
-  const targetDirectory = resolveTargetDirectory({ cwd: options.cwd, target: options.target });
-  await assertExistingDirectory(targetDirectory);
-
-  const commonManifest = await loadManifest("common", { installerRoot });
-  const hostManifest = await loadManifest(options.host, { installerRoot });
-  const operations = [
-    ...(await expandManifestFiles(commonManifest.files, { installerRoot, payloadRoot, targetDirectory })),
-    ...(await expandManifestFiles(hostManifest.files, { installerRoot, payloadRoot, targetDirectory })),
-  ];
-
-  const plannedOperations = [];
-
-  for (const operation of operations) {
-    plannedOperations.push({
-      ...operation,
-      exists: await pathExists(operation.destinationPath),
-    });
-  }
-
-  const conflicts = plannedOperations
-    .filter((operation) => operation.exists)
-    .map((operation) => operation.destinationRelative);
-
-  return {
-    conflicts,
-    dryRun: Boolean(options.dryRun),
-    force: Boolean(options.force),
-    host: options.host,
-    installerRoot,
-    manifests: {
-      common: commonManifest.manifestPath,
-      host: hostManifest.manifestPath,
-    },
-    operations: plannedOperations,
-    payloadRoot,
-    targetDirectory,
-  };
-}
-
-function summarizePlan(plan) {
-  return {
-    conflicts: [...plan.conflicts],
-    dryRun: plan.dryRun,
-    force: plan.force,
-    host: plan.host,
-    manifests: { ...plan.manifests },
-    operations: plan.operations.map((operation) => ({
-      destinationRelative: operation.destinationRelative,
-      exists: operation.exists,
-      mode: operation.template ? "template" : "copy",
-      sourceRelative: operation.sourceRelative,
-    })),
-    targetDirectory: plan.targetDirectory,
-  };
-}
-
-async function installMaya(options = {}) {
-  const plan = await buildInstallPlan(options);
-
-  if (plan.conflicts.length > 0 && !plan.force && !plan.dryRun) {
-    throw new Error(
-      `Refusing to overwrite files that already exists without --force: ${plan.conflicts.join(", ")}`,
-    );
-  }
-
-  if (plan.dryRun) {
-    return summarizePlan(plan);
-  }
-
-  const writtenFiles = [];
-
-  for (const operation of plan.operations) {
-    await ensureDirectory(path.dirname(operation.destinationPath));
-
-    if (operation.template) {
-      const content = await renderBootstrap(operation, { host: plan.host });
-      await writeTextFile(operation.destinationPath, content);
-    } else {
-      await copyOpaqueFile(operation.sourcePath, operation.destinationPath);
-    }
-
-    writtenFiles.push(operation.destinationRelative);
-  }
-
-  return {
-    ...summarizePlan(plan),
-    writtenFiles,
-  };
-}
-
-module.exports = {
-  buildInstallPlan,
-  installMaya,
-  summarizePlan,
-};
+"use strict";
+
+const path = require("node:path");
+const { renderBootstrap } = require("./bootstrap");
+const {
+  assertExistingDirectory,
+  copyOpaqueFile,
+  ensureDirectory,
+  ensureGitignoreEntries,
+  fromPosixPath,
+  joinPosixPath,
+  listFilesRecursive,
+  pathExists,
+  resolveTargetDirectory,
+  writeTextFile,
+} = require("./fs");
+const { loadManifest, resolveInstallerRoot, resolvePayloadRoot } = require("./manifest");
+
+const META_GITIGNORE_ENTRIES = [".env", ".env.local"];
+
+async function expandManifestFiles(files, context) {
+  const operations = [];
+
+  for (const entry of files) {
+    const sourceBase = entry.template ? context.installerRoot : context.payloadRoot;
+    const sourceRoot = fromPosixPath(sourceBase, entry.source);
+    const sourceDetails = await require("node:fs/promises").stat(sourceRoot);
+
+    if (sourceDetails.isDirectory()) {
+      const children = await listFilesRecursive(sourceRoot);
+
+      for (const child of children) {
+        const destinationRelative = joinPosixPath(entry.destination, child);
+        operations.push({
+          destinationPath: fromPosixPath(context.targetDirectory, destinationRelative),
+          destinationRelative,
+          sourcePath: path.join(sourceRoot, ...child.split("/")),
+          sourceRelative: joinPosixPath(entry.source, child),
+          template: false,
+        });
+      }
+
+      continue;
+    }
+
+    operations.push({
+      destinationPath: fromPosixPath(context.targetDirectory, entry.destination),
+      destinationRelative: entry.destination,
+      sourcePath: sourceRoot,
+      sourceRelative: entry.source,
+      template: entry.template,
+    });
+  }
+
+  return operations;
+}
+
+async function buildInstallPlan(options = {}) {
+  if (!options.host) {
+    throw new Error("A host id is required.");
+  }
+
+  const installerRoot = resolveInstallerRoot(options);
+  const payloadRoot = resolvePayloadRoot(options);
+  const targetDirectory = resolveTargetDirectory({ cwd: options.cwd, target: options.target });
+  await assertExistingDirectory(targetDirectory);
+
+  const commonManifest = await loadManifest("common", { installerRoot });
+  const hostManifest = await loadManifest(options.host, { installerRoot });
+  const operations = [
+    ...(await expandManifestFiles(commonManifest.files, { installerRoot, payloadRoot, targetDirectory })),
+    ...(await expandManifestFiles(hostManifest.files, { installerRoot, payloadRoot, targetDirectory })),
+  ];
+
+  const plannedOperations = [];
+
+  for (const operation of operations) {
+    plannedOperations.push({
+      ...operation,
+      exists: await pathExists(operation.destinationPath),
+    });
+  }
+
+  const conflicts = plannedOperations
+    .filter((operation) => operation.exists)
+    .map((operation) => operation.destinationRelative);
+
+  return {
+    conflicts,
+    dryRun: Boolean(options.dryRun),
+    force: Boolean(options.force),
+    host: options.host,
+    installerRoot,
+    manifests: {
+      common: commonManifest.manifestPath,
+      host: hostManifest.manifestPath,
+    },
+    operations: plannedOperations,
+    payloadRoot,
+    targetDirectory,
+  };
+}
+
+function summarizePlan(plan) {
+  return {
+    conflicts: [...plan.conflicts],
+    dryRun: plan.dryRun,
+    force: plan.force,
+    host: plan.host,
+    manifests: { ...plan.manifests },
+    operations: plan.operations.map((operation) => ({
+      destinationRelative: operation.destinationRelative,
+      exists: operation.exists,
+      mode: operation.template ? "template" : "copy",
+      sourceRelative: operation.sourceRelative,
+    })),
+    targetDirectory: plan.targetDirectory,
+  };
+}
+
+async function installMaya(options = {}) {
+  const plan = await buildInstallPlan(options);
+
+  if (plan.conflicts.length > 0 && !plan.force && !plan.dryRun) {
+    throw new Error(
+      `Refusing to overwrite files that already exists without --force: ${plan.conflicts.join(", ")}`,
+    );
+  }
+
+  if (plan.dryRun) {
+    return summarizePlan(plan);
+  }
+
+  const writtenFiles = [];
+
+  for (const operation of plan.operations) {
+    await ensureDirectory(path.dirname(operation.destinationPath));
+
+    if (operation.template) {
+      const content = await renderBootstrap(operation, { host: plan.host });
+      await writeTextFile(operation.destinationPath, content);
+    } else {
+      await copyOpaqueFile(operation.sourcePath, operation.destinationPath);
+    }
+
+    writtenFiles.push(operation.destinationRelative);
+  }
+
+  const gitignoreResult = await ensureGitignoreEntries(
+    path.join(plan.targetDirectory, ".gitignore"),
+    META_GITIGNORE_ENTRIES,
+  );
+
+  if (gitignoreResult.changed) {
+    writtenFiles.push(".gitignore");
+  }
+
+  return {
+    ...summarizePlan(plan),
+    writtenFiles,
+  };
+}
+
+module.exports = {
+  buildInstallPlan,
+  installMaya,
+  summarizePlan,
+};