freestyle-sync 0.1.9 → 0.1.10

package/README.md

@@ -79,4 +79,26 @@ export default defineConfig({
         shellHistoryPlugin(),
     ],
 });
-```
+```
+
+Project sync can exclude folders and include additional local paths. Include paths may point outside the project directory; they are copied into the remote project at the configured relative target.
+
+```js
+export default defineConfig({
+    sync: {
+        exclude: ["dist", ".turbo"],
+        include: [
+            { source: "../shared-config", target: "shared-config" },
+        ],
+    },
+    plugins: [
+        nodeNpmPlugin(),
+    ],
+});
+```
+
+`nodeNpmPlugin()` excludes `node_modules` from upload by default and installs dependencies on the remote runtime using the project lockfile: `pnpm install --frozen-lockfile`, Yarn `--frozen-lockfile`/`--immutable`, or `npm ci`. To keep the previous behavior of syncing `node_modules` and only repairing native/workspace packages remotely, use:
+
+```js
+nodeNpmPlugin({ syncNodeModules: true })
+```

package/dist/src/main.js

@@ -10,7 +10,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import "dotenv/config";
 import { createHash } from "node:crypto";
 import { createReadStream, realpathSync } from "node:fs";
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { chmod, copyFile, lstat, mkdir, mkdtemp, readFile, readlink, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -182,7 +182,8 @@ export async function sync(sdkOptions) {
     progress.step("Scanning project files");
     const cache = currentCache;
     const base = cacheBaseForSync(options, cache);
-    const projectEntries = await scanProject(options.projectRoot, options.includeGitDir);
+    const projectSyncConfig = await resolveProjectSyncConfig(options);
+    const projectEntries = await scanProject(options.projectRoot, options.includeGitDir, projectSyncConfig);
     const projectCurrent = digestMap(projectEntries);
     const projectChanges = diffEntries(projectEntries, base.projectFiles);
     progress.step("Detecting auth and agent context");
@@ -719,23 +720,92 @@ async function writeCache(cachePath, cache) {
     await mkdir(path.dirname(cachePath), { recursive: true });
     await writeFile(cachePath, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
 }
-async function scanProject(projectRoot, includeGitDir) {
-    const entries = [];
-    await walk(projectRoot, "", entries, {
+async function resolveProjectSyncConfig(options) {
+    const configs = [];
+    if (config.sync)
+        configs.push(config.sync);
+    for (const plugin of plugins) {
+        const pluginConfig = await plugin.configureProjectSync?.({ options, utils: pluginUtils });
+        if (pluginConfig)
+            configs.push(pluginConfig);
+    }
+    return {
+        exclude: configs.flatMap((projectConfig) => projectConfig.exclude ?? []).map(normalizeProjectPattern),
+        include: configs.flatMap((projectConfig) => normalizeProjectIncludes(options.projectRoot, projectConfig.include ?? [])),
+    };
+}
+function normalizeProjectIncludes(projectRoot, includes) {
+    return includes.map((include) => {
+        const source = typeof include === "string" ? include : include.source;
+        const target = typeof include === "string" ? undefined : include.target;
+        const resolvedSource = path.resolve(projectRoot, source);
+        return {
+            source: resolvedSource,
+            target: normalizeProjectPattern(target ?? path.basename(resolvedSource)),
+        };
+    });
+}
+function normalizeProjectPattern(value) {
+    const normalized = path.posix.normalize(value.replace(/\\/g, "/")).replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!normalized || normalized === ".") {
+        throw new Error("project sync paths must not be empty");
+    }
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error(`project sync paths must stay inside the remote project: ${value}`);
+    }
+    return normalized;
+}
+async function scanProject(projectRoot, includeGitDir, syncConfig) {
+    const entriesByPath = new Map();
+    const rootEntries = [];
+    await walk(projectRoot, "", rootEntries, {
         skipDirectory(relativePath, name) {
             if (!includeGitDir && relativePath === ".git")
                 return true;
-            return false;
+            return shouldSkipProjectDirectory(relativePath, name, syncConfig.exclude);
+        },
+    });
+    upsertProjectEntries(entriesByPath, rootEntries);
+    for (const include of syncConfig.include) {
+        upsertProjectEntries(entriesByPath, await scanProjectInclude(include, syncConfig.exclude));
+    }
+    return Array.from(entriesByPath.values()).sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function scanProjectInclude(include, exclude) {
+    const stats = await lstat(include.source).catch((error) => {
+        throw new Error(`project sync include does not exist: ${include.source} (${error instanceof Error ? error.message : String(error)})`);
+    });
+    if (stats.isFile() || stats.isSymbolicLink()) {
+        return [await digestEntry(include.source, include.target)];
+    }
+    if (!stats.isDirectory()) {
+        return [];
+    }
+    const entries = [];
+    await walk(include.source, "", entries, {
+        mapRelativePath(relativePath) {
+            return `${include.target}/${relativePath}`;
+        },
+        skipDirectory(relativePath, name) {
+            return shouldSkipProjectDirectory(relativePath, name, exclude);
         },
     });
-    return entries.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+    return entries;
+}
+function upsertProjectEntries(entriesByPath, entries) {
+    for (const entry of entries)
+        entriesByPath.set(entry.relativePath, entry);
+}
+function shouldSkipProjectDirectory(relativePath, name, exclude) {
+    return exclude.some((excludedPath) => relativePath === excludedPath || name === excludedPath);
 }
 async function walk(root, relativePath, entries, options) {
     const absolutePath = path.join(root, relativePath);
     const dir = await import("node:fs/promises").then((fs) => fs.readdir(absolutePath, { withFileTypes: true }));
     for (const dirent of dir) {
         const childRelativePath = relativePath ? path.join(relativePath, dirent.name) : dirent.name;
-        const normalizedRelativePath = toPosix(childRelativePath);
+        const localRelativePath = toPosix(childRelativePath);
+        const normalizedRelativePath = options.mapRelativePath?.(localRelativePath) ?? localRelativePath;
         const childAbsolutePath = path.join(root, childRelativePath);
         if (dirent.isDirectory()) {
             if (options.skipDirectory(normalizedRelativePath, dirent.name)) {
@@ -1387,7 +1457,7 @@ async function ensureRemoteBase(vm, remoteProjectDir) {
 async function syncProject(vm, vmId, options, changes) {
     if (changes.changed.length > 0) {
         console.log(`VM ${vmId}: uploading ${changes.changed.length} changed project files...`);
-        const archive = await createProjectArchive(options.projectRoot, changes.changed);
+        const archive = await createProjectArchive(changes.changed);
         try {
             await uploadArchiveInChunks(vm, vmId, archive, "/tmp/freestyle-sync-project.tgz", "project");
             await checkedExec(vm, `mkdir -p ${shellQuote(options.remoteProjectDir)} && tar --no-same-owner --no-same-permissions -xzf /tmp/freestyle-sync-project.tgz -C ${shellQuote(options.remoteProjectDir)} && rm -f /tmp/freestyle-sync-project.tgz`);
@@ -1512,11 +1582,11 @@ async function runInstall(vm, projectRoot, remoteProjectDir) {
 }
 async function detectInstallCommand(projectRoot) {
     if (await exists(path.join(projectRoot, "pnpm-lock.yaml")))
-        return "corepack enable && pnpm install";
+        return "corepack enable && pnpm install --frozen-lockfile";
     if (await exists(path.join(projectRoot, "yarn.lock")))
-        return "corepack enable && yarn install";
-    if (await exists(path.join(projectRoot, "package-lock.json")))
-        return "npm install";
+        return "corepack enable && yarn_version=$(yarn --version) && case \"$yarn_version\" in 1.*) yarn install --frozen-lockfile ;; *) yarn install --immutable ;; esac";
+    if (await exists(path.join(projectRoot, "package-lock.json")) || await exists(path.join(projectRoot, "npm-shrinkwrap.json")))
+        return "npm ci";
     if (await exists(path.join(projectRoot, "requirements.txt")))
         return "python3 -m pip install -r requirements.txt";
     if (await exists(path.join(projectRoot, "pyproject.toml")))
@@ -1527,12 +1597,23 @@ async function detectInstallCommand(projectRoot) {
         return "go mod download";
     return undefined;
 }
-async function createProjectArchive(projectRoot, entries) {
+async function createProjectArchive(entries) {
     const tempDir = await mkdtemp(path.join(tmpdir(), "freestyle-sync-"));
-    const listPath = path.join(tempDir, "files.list");
+    const stagingDir = path.join(tempDir, "staging");
     const archivePath = path.join(tempDir, "project.tgz");
-    await writeFile(listPath, Buffer.from(entries.map((entry) => entry.relativePath).join("\0") + "\0"));
-    await createTar(["--null", "--no-xattrs", "-T", listPath, "-czf", archivePath, "-C", projectRoot]);
+    await mkdir(stagingDir, { recursive: true });
+    for (const entry of entries) {
+        const destination = path.join(stagingDir, ...entry.relativePath.split("/"));
+        await mkdir(path.dirname(destination), { recursive: true });
+        if (entry.kind === "symlink") {
+            await symlink(await readlink(entry.absolutePath), destination);
+        }
+        else {
+            await copyFile(entry.absolutePath, destination);
+            await chmod(destination, entry.mode);
+        }
+    }
+    await createTar(["--no-xattrs", "-czf", archivePath, "-C", stagingDir, "."]);
     return archivePath;
 }
 async function createContextArchive(entries) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freestyle-sync",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "type": "module",
   "main": "dist/src/main.js",
   "exports": {