freestyle-sync 0.1.12 → 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";
@@ -103,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,
@@ -480,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 = [];
@@ -636,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.
@@ -666,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("--")) {
@@ -1703,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) {
@@ -1722,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`);
@@ -1793,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.12",
+  "version": "0.1.13",
   "type": "module",
   "main": "dist/src/main.js",
   "exports": {