freestyle-sync 0.1.11 → 0.1.13

package/dist/src/main.js

@@ -23,6 +23,11 @@ const CLI_NAME = "freestyle-sync";
 const CACHE_VERSION = 1;
 const PLUGIN_PREFERENCES_VERSION = 1;
 const ARCHIVE_CHUNK_BYTES = 512 * 1024;
+const ARCHIVE_UPLOAD_MIN_CONCURRENCY = 1;
+const ARCHIVE_UPLOAD_INITIAL_CONCURRENCY = 4;
+const ARCHIVE_UPLOAD_MAX_CONCURRENCY = 16;
+const ARCHIVE_UPLOAD_WRITE_ATTEMPTS = 3;
+const ARCHIVE_UPLOAD_RETRY_BASE_DELAY_MS = 200;
 const MS_PER_SECOND = 1000;
 const DEFAULT_APPLE_CONTAINER_IMAGE = "ubuntu:24.04";
 const DEFAULT_FREESTYLE_API_URL = "https://api.freestyle.sh";
@@ -30,6 +35,8 @@ const DEFAULT_STACK_API_URL = "https://api.stack-auth.com";
 const DEFAULT_STACK_PROJECT_ID = "0edf478c-f123-46fb-818f-34c0024a9f35";
 const DEFAULT_STACK_PUBLISHABLE_CLIENT_KEY = "pck_h2aft7g9pqjzrkdnzs199h1may5wjtdtdxeex7m2wzp1r";
 const STACK_REFRESH_TOKEN_ENV_KEY = "FREESTYLE_STACK_REFRESH_TOKEN";
+const GENERATED_UPLOAD_DIRECTORY_NAMES = new Set([".cache", ".freestyle-sync", ".git", ".next", ".turbo", ".vercel", ".vite", "build", "coverage", "dist", "node_modules", "target"]);
+const DEFAULT_PROJECT_EXCLUDES = [".freestyle-sync"];
 const USE_UNICODE_OUTPUT = process.stdout.isTTY && (process.env.TERM !== "dumb" || Boolean(process.env.TERM_PROGRAM));
 const USE_STYLED_OUTPUT = process.stdout.isTTY && process.env.NO_COLOR !== "1";
 const DEFAULT_CONFIG_DEPENDENCIES = [
@@ -101,7 +108,12 @@ if (isDirectCliExecution()) {
     });
 }
 async function main() {
-    const options = await parseArgs(process.argv.slice(2));
+    const args = process.argv.slice(2);
+    if (args[0] === "update") {
+        await runUpdateCommand(args.slice(1));
+        return;
+    }
+    const options = await parseArgs(args);
     const loadedConfig = await loadConfig(options.projectRoot);
     await sync({
         config: loadedConfig,
@@ -110,7 +122,6 @@ async function main() {
 }
 export async function sync(sdkOptions) {
     const options = await resolveCliOptions(sdkOptions.options);
-    printHeading(CLI_NAME);
     config = sdkOptions.config;
     plugins = config.plugins;
     const pluginPreferences = await updatePluginPreferences(options, sdkOptions.pluginPreferences);
@@ -479,16 +490,81 @@ async function ensureDefaultConfigDependencies(projectRoot) {
         throw new Error(`failed to install freestyle-sync config dependencies: ${details.trim() || String(error)}`);
     }
 }
+async function updateDefaultConfigDependencies(projectRoot) {
+    const specs = DEFAULT_CONFIG_DEPENDENCIES.map((dependency) => dependency.spec);
+    const { command, args } = await dependencyInstallCommand(projectRoot, specs);
+    console.log(`Updating freestyle-sync packages with ${command}...`);
+    try {
+        await execFileAsync(command, args, { cwd: projectRoot });
+    }
+    catch (error) {
+        const details = error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : String(error);
+        throw new Error(`failed to update freestyle-sync packages: ${details.trim() || String(error)}`);
+    }
+    console.log("Updated freestyle-sync and default plugins.");
+}
 async function isDependencyInstalled(projectRoot, name) {
     return exists(path.join(projectRoot, "node_modules", ...name.split("/"), "package.json"));
 }
 async function dependencyInstallCommand(projectRoot, specs) {
-    if (await exists(path.join(projectRoot, "pnpm-lock.yaml")))
+    const packageManager = await detectPackageManager(projectRoot);
+    if (packageManager === "bun")
+        return { command: "bun", args: ["add", "-d", ...specs] };
+    if (packageManager === "pnpm")
         return { command: "pnpm", args: ["add", "-D", ...specs] };
-    if (await exists(path.join(projectRoot, "yarn.lock")))
+    if (packageManager === "yarn")
         return { command: "yarn", args: ["add", "-D", ...specs] };
     return { command: "npm", args: ["install", "--save-dev", ...specs] };
 }
+async function detectPackageManager(projectRoot) {
+    if (await exists(path.join(projectRoot, "bun.lock")) || await exists(path.join(projectRoot, "bun.lockb")))
+        return "bun";
+    if (await exists(path.join(projectRoot, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (await exists(path.join(projectRoot, "yarn.lock")))
+        return "yarn";
+    if (await exists(path.join(projectRoot, "package-lock.json")) || await exists(path.join(projectRoot, "npm-shrinkwrap.json")))
+        return "npm";
+    const packageManager = await readPackageManagerField(projectRoot);
+    if (packageManager?.startsWith("bun@"))
+        return "bun";
+    if (packageManager?.startsWith("pnpm@"))
+        return "pnpm";
+    if (packageManager?.startsWith("yarn@"))
+        return "yarn";
+    return "npm";
+}
+async function readPackageManagerField(projectRoot) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(projectRoot, "package.json"), "utf8"));
+        return typeof parsed.packageManager === "string" ? parsed.packageManager : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function runUpdateCommand(args) {
+    const positional = [];
+    for (const arg of args) {
+        if (arg === "--help" || arg === "-h") {
+            printUpdateHelp();
+            return;
+        }
+        if (arg.startsWith("--")) {
+            throw new Error(`unknown update option: ${arg}`);
+        }
+        positional.push(arg);
+    }
+    if (positional.length > 1) {
+        throw new Error("expected at most one project path for update");
+    }
+    const projectRoot = path.resolve(positional[0] ?? process.cwd());
+    const projectStats = await stat(projectRoot).catch(() => null);
+    if (!projectStats?.isDirectory()) {
+        throw new Error(`project path is not a directory: ${projectRoot}`);
+    }
+    await updateDefaultConfigDependencies(projectRoot);
+}
 async function parseArgs(args) {
     const options = defaultCliOptions();
     const positional = [];
@@ -635,6 +711,10 @@ function printHelp() {
 
 Usage:
     ${CLI_NAME} [project-dir] [options]
+    ${CLI_NAME} update [project-dir]
+
+Commands:
+    update                 Update freestyle-sync and the default plugin packages.
 
 Options:
     --provider <name>        Runtime provider: freestyle or apple-container. Defaults to freestyle.
@@ -665,6 +745,16 @@ Options:
 	-h, --help               Show this help.
 `);
 }
+function printUpdateHelp() {
+    console.log(`${CLI_NAME} update refreshes freestyle-sync and the default plugin packages.
+
+Usage:
+    ${CLI_NAME} update [project-dir]
+
+The update command uses the project's package manager, including Bun when bun.lock,
+bun.lockb, or packageManager: "bun@..." is present.
+`);
+}
 function readOptionValue(args, index, option) {
     const value = args[index];
     if (!value || value.startsWith("--")) {
@@ -745,7 +835,7 @@ async function resolveProjectSyncConfig(options) {
             configs.push(pluginConfig);
     }
     return {
-        exclude: configs.flatMap((projectConfig) => projectConfig.exclude ?? []).map(normalizeProjectPattern),
+        exclude: [...DEFAULT_PROJECT_EXCLUDES, ...configs.flatMap((projectConfig) => projectConfig.exclude ?? [])].map(normalizeProjectPattern),
         include: configs.flatMap((projectConfig) => normalizeProjectIncludes(options.projectRoot, projectConfig.include ?? [])),
     };
 }
@@ -1081,6 +1171,8 @@ function printPlan(options, projectChanges, contextChanges, envExports, cache) {
     console.log(`${dim("  Project files:")} ${projectChanges.changed.length} changed, ${projectChanges.removed.length} removed, ${projectChanges.unchanged} unchanged`);
     console.log(`${dim("  Context files:")} ${contextChanges.changed.length} changed, ${contextChanges.removed.length} removed, ${contextChanges.unchanged} unchanged`);
     console.log(`${dim("  Estimated upload:")} ${formatBytes(totalEntrySize(projectChanges.changed))} project, ${formatBytes(totalEntrySize(contextChanges.changed))} context`);
+    printUploadBreakdown("Project upload contributors", projectUploadContributors(projectChanges.changed), "consider sync.exclude for generated folders");
+    printUploadBreakdown("Context upload contributors", contextUploadContributors(contextChanges.changed), "disable unneeded context plugins to skip");
     if (Object.keys(envExports).length > 0) {
         console.log(`${dim("  Environment exports:")} ${Object.keys(envExports).length}`);
     }
@@ -1089,6 +1181,40 @@ function printPlan(options, projectChanges, contextChanges, envExports, cache) {
 function totalEntrySize(entries) {
     return entries.reduce((total, entry) => total + entry.size, 0);
 }
+function projectUploadContributors(entries) {
+    return largestContributors(entries, (entry) => contributionPath(entry.relativePath));
+}
+function contextUploadContributors(entries) {
+    return largestContributors(entries, (entry) => entry.label);
+}
+function contributionPath(relativePath) {
+    const parts = relativePath.split("/").filter(Boolean);
+    if (parts.length <= 1)
+        return relativePath;
+    const generatedDirectoryIndex = parts.findIndex((part) => GENERATED_UPLOAD_DIRECTORY_NAMES.has(part));
+    if (generatedDirectoryIndex >= 0)
+        return parts.slice(0, generatedDirectoryIndex + 1).join("/");
+    return parts.slice(0, Math.min(parts.length - 1, 3)).join("/");
+}
+function largestContributors(entries, bucketForEntry) {
+    const buckets = new Map();
+    for (const entry of entries) {
+        const bucketName = bucketForEntry(entry);
+        const bucket = buckets.get(bucketName) ?? { path: bucketName, size: 0, files: 0 };
+        bucket.size += entry.size;
+        bucket.files += 1;
+        buckets.set(bucketName, bucket);
+    }
+    return Array.from(buckets.values()).sort((left, right) => right.size - left.size).slice(0, 6);
+}
+function printUploadBreakdown(title, contributors, hint) {
+    if (contributors.length === 0)
+        return;
+    console.log(`${dim(`  ${title}:`)} ${hint}`);
+    for (const contributor of contributors) {
+        console.log(`${dim("    -")} ${formatBytes(contributor.size).padStart(9)}  ${contributor.path} ${dim(`(${contributor.files} ${contributor.files === 1 ? "file" : "files"})`)}`);
+    }
+}
 function printHeading(name) {
     console.log(`${bold(name)} ${dim(`${symbol("→", "-")} Freestyle sync`)}`);
     console.log("");
@@ -1666,13 +1792,20 @@ async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, l
     const canRenderInlineProgress = process.stdout.isTTY;
     const logEvery = Math.max(1, Math.ceil(chunkCount / 4));
     const chunkManifest = [];
-    let index = 0;
-    for await (const chunk of createReadStream(archivePath, { highWaterMark: ARCHIVE_CHUNK_BYTES })) {
-        const chunkName = `${String(index).padStart(width, "0")}.chunk`;
-        const content = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        chunkManifest.push(`${chunkName} ${content.length}`);
-        await vm.fs.writeFile(`${chunkDir}/${chunkName}`, content);
-        const uploadedChunks = index + 1;
+    const maxUploadConcurrency = Math.max(ARCHIVE_UPLOAD_MIN_CONCURRENCY, Math.min(ARCHIVE_UPLOAD_MAX_CONCURRENCY, chunkCount));
+    let targetUploadConcurrency = Math.min(ARCHIVE_UPLOAD_INITIAL_CONCURRENCY, maxUploadConcurrency);
+    let successfulUploadsSinceIncrease = 0;
+    let uploadedChunks = 0;
+    const inFlightUploads = new Set();
+    const reportUploadedChunk = () => {
+        uploadedChunks += 1;
+        if (targetUploadConcurrency < maxUploadConcurrency) {
+            successfulUploadsSinceIncrease += 1;
+            if (successfulUploadsSinceIncrease >= targetUploadConcurrency) {
+                targetUploadConcurrency += 1;
+                successfulUploadsSinceIncrease = 0;
+            }
+        }
         if (chunkCount > 1) {
             const progressMessage = `VM ${vmId}: uploaded ${uploadedChunks}/${chunkCount} ${label} archive chunks`;
             if (canRenderInlineProgress) {
@@ -1685,7 +1818,38 @@ async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, l
                 console.log(progressMessage);
             }
         }
+    };
+    const waitForUploadedChunk = async () => {
+        const result = await Promise.race(inFlightUploads);
+        inFlightUploads.delete(result.upload);
+        if (!result.ok) {
+            throw result.error;
+        }
+        reportUploadedChunk();
+    };
+    const queueChunkUpload = (remotePath, content) => {
+        let upload;
+        upload = writeRemoteFileWithRetries(vm, remotePath, content, () => {
+            targetUploadConcurrency = Math.max(ARCHIVE_UPLOAD_MIN_CONCURRENCY, Math.floor(targetUploadConcurrency / 2));
+            successfulUploadsSinceIncrease = 0;
+        })
+            .then(() => ({ ok: true, upload }))
+            .catch((error) => ({ ok: false, upload, error }));
+        inFlightUploads.add(upload);
+    };
+    let index = 0;
+    for await (const chunk of createReadStream(archivePath, { highWaterMark: ARCHIVE_CHUNK_BYTES })) {
+        const chunkName = `${String(index).padStart(width, "0")}.chunk`;
+        const content = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        chunkManifest.push(`${chunkName} ${content.length}`);
+        queueChunkUpload(`${chunkDir}/${chunkName}`, content);
         index += 1;
+        while (inFlightUploads.size >= targetUploadConcurrency) {
+            await waitForUploadedChunk();
+        }
+    }
+    while (inFlightUploads.size > 0) {
+        await waitForUploadedChunk();
     }
     if (archiveSize > 0) {
         await vm.fs.writeTextFile(`${chunkDir}/manifest`, `${chunkManifest.join("\n")}\n`);
@@ -1756,6 +1920,21 @@ async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, l
             `rm -rf ${shellQuote(chunkDir)}`,
         ].join("\n"), 5 * 60 * MS_PER_SECOND);
 }
+async function writeRemoteFileWithRetries(vm, remotePath, content, onRetry) {
+    for (let attempt = 1; attempt <= ARCHIVE_UPLOAD_WRITE_ATTEMPTS; attempt += 1) {
+        try {
+            await vm.fs.writeFile(remotePath, content);
+            return;
+        }
+        catch (error) {
+            if (attempt >= ARCHIVE_UPLOAD_WRITE_ATTEMPTS) {
+                throw error;
+            }
+            onRetry();
+            await delay(ARCHIVE_UPLOAD_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1));
+        }
+    }
+}
 async function mkdirRemote(vm, directories) {
     for (const chunk of chunkArray(directories, 50)) {
         await checkedExec(vm, `mkdir -p ${chunk.map(shellQuote).join(" ")}`);

package/package.json

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