freestyle-sync 0.1.5 → 0.1.8

package/dist/src/main.js

@@ -11,19 +11,24 @@ 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 { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
-import { freestyle } from "freestyle";
+import { Freestyle } from "freestyle";
 export * from "./plugin-api.js";
 const execFileAsync = promisify(execFile);
 const CLI_NAME = "freestyle-sync";
 const CACHE_VERSION = 1;
 const PLUGIN_PREFERENCES_VERSION = 1;
-const ARCHIVE_CHUNK_CHARS = 1024 * 1024;
+const ARCHIVE_CHUNK_BYTES = 1024 * 1024;
 const MS_PER_SECOND = 1000;
+const DEFAULT_FREESTYLE_API_URL = "https://api.freestyle.sh";
+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 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 = [
@@ -1005,7 +1010,198 @@ function color(code, text) {
         return text;
     return `\u001b[${code}m${text}\u001b[0m`;
 }
+async function getFreestyleClient() {
+    const baseUrl = process.env.FREESTYLE_API_URL || DEFAULT_FREESTYLE_API_URL;
+    if (process.env.FREESTYLE_API_KEY) {
+        return new Freestyle({ apiKey: process.env.FREESTYLE_API_KEY, baseUrl });
+    }
+    const config = resolveStackConfig();
+    let auth = await readStoredFreestyleAuth(config);
+    if (!auth?.refreshToken && !readRefreshTokenFromEnv()) {
+        await runFreestyleLogin();
+        auth = await readStoredFreestyleAuth(config);
+    }
+    let refreshed = await refreshStackAccessToken(config, readRefreshTokenFromEnv() ?? auth?.refreshToken);
+    if (!refreshed) {
+        await runFreestyleLogin(["--force"]);
+        auth = await readStoredFreestyleAuth(config);
+        refreshed = await refreshStackAccessToken(config, readRefreshTokenFromEnv() ?? auth?.refreshToken);
+    }
+    if (!refreshed) {
+        throw new Error("Freestyle authentication failed. Run `npx freestyle login` or set FREESTYLE_API_KEY.");
+    }
+    if (refreshed.refreshToken && refreshed.refreshToken !== auth?.refreshToken) {
+        auth = await updateStoredFreestyleRefreshToken(config, auth, refreshed.refreshToken);
+    }
+    let teamId = process.env.FREESTYLE_TEAM_ID || auth?.defaultTeamId;
+    if (!teamId) {
+        await runFreestyleLogin();
+        auth = await readStoredFreestyleAuth(config);
+        teamId = process.env.FREESTYLE_TEAM_ID || auth?.defaultTeamId;
+    }
+    if (!teamId) {
+        throw new Error("No Freestyle team selected. Run `npx freestyle login` to configure a default team, or set FREESTYLE_TEAM_ID.");
+    }
+    return new Freestyle({
+        apiKey: "placeholder",
+        baseUrl,
+        fetch: createFreestyleProxyFetch(refreshed.accessToken, teamId),
+    });
+}
+function resolveStackConfig() {
+    return {
+        stackApiUrl: (process.env.FREESTYLE_STACK_API_URL || DEFAULT_STACK_API_URL).replace(/\/+$/, ""),
+        projectId: process.env.FREESTYLE_STACK_PROJECT_ID || process.env.NEXT_PUBLIC_STACK_PROJECT_ID || process.env.VITE_STACK_PROJECT_ID || DEFAULT_STACK_PROJECT_ID,
+        publishableClientKey: process.env.FREESTYLE_STACK_PUBLISHABLE_CLIENT_KEY || process.env.NEXT_PUBLIC_STACK_PUBLISHABLE_CLIENT_KEY || process.env.VITE_STACK_PUBLISHABLE_CLIENT_KEY || DEFAULT_STACK_PUBLISHABLE_CLIENT_KEY,
+        authFilePath: process.env.FREESTYLE_STACK_AUTH_FILE || path.join(homedir(), ".freestyle", "stack-auth.json"),
+    };
+}
+function readRefreshTokenFromEnv() {
+    const refreshToken = process.env[STACK_REFRESH_TOKEN_ENV_KEY]?.trim();
+    return refreshToken ? refreshToken : undefined;
+}
+async function readStoredFreestyleAuth(config) {
+    try {
+        const parsed = JSON.parse(await readFile(config.authFilePath, "utf8"));
+        if (typeof parsed.refreshToken !== "string" || parsed.refreshToken.length === 0)
+            return undefined;
+        return {
+            refreshToken: parsed.refreshToken,
+            defaultTeamId: typeof parsed.defaultTeamId === "string" ? parsed.defaultTeamId : undefined,
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        return undefined;
+    }
+}
+async function updateStoredFreestyleRefreshToken(config, auth, refreshToken) {
+    const next = {
+        refreshToken,
+        updatedAt: Date.now(),
+        defaultTeamId: auth?.defaultTeamId,
+    };
+    await mkdir(path.dirname(config.authFilePath), { recursive: true });
+    await writeFile(config.authFilePath, `${JSON.stringify(next, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    return {
+        refreshToken,
+        defaultTeamId: auth?.defaultTeamId,
+    };
+}
+async function refreshStackAccessToken(config, refreshToken) {
+    if (!refreshToken)
+        return undefined;
+    const response = await fetch(`${config.stackApiUrl}/api/v1/auth/sessions/current/refresh`, {
+        method: "POST",
+        headers: {
+            ...stackClientHeaders(config),
+            "x-stack-refresh-token": refreshToken,
+        },
+        body: "{}",
+    });
+    if (!response.ok)
+        return undefined;
+    const data = await response.json();
+    if (typeof data.access_token !== "string")
+        return undefined;
+    return {
+        accessToken: data.access_token,
+        refreshToken: typeof data.refresh_token === "string" ? data.refresh_token : undefined,
+    };
+}
+function stackClientHeaders(config) {
+    return {
+        "Content-Type": "application/json",
+        "x-stack-project-id": config.projectId,
+        "x-stack-access-type": "client",
+        "x-stack-publishable-client-key": config.publishableClientKey,
+    };
+}
+function createFreestyleProxyFetch(accessToken, teamId) {
+    const dashboardApiUrl = (process.env.FREESTYLE_DASHBOARD_URL || "https://dash.freestyle.sh").replace(/\/+$/, "");
+    return async (url, init) => {
+        const urlObject = typeof url === "string" ? new URL(url) : url instanceof URL ? url : new URL(url.url);
+        const requestPath = `${urlObject.pathname}${urlObject.search}`;
+        const proxyResponse = await fetch(`${dashboardApiUrl}/api/proxy/request`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                data: {
+                    accessToken,
+                    teamId,
+                    path: requestPath.startsWith("/") ? requestPath.slice(1) : requestPath,
+                    method: init?.method || "GET",
+                    headers: init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {},
+                    body: init?.body ? init.body.toString() : undefined,
+                },
+            }),
+        });
+        if (!proxyResponse.ok) {
+            const body = await proxyResponse.text();
+            const normalizedError = normalizeFreestyleProxyError(body, proxyResponse.status);
+            return new Response(normalizedError.body, {
+                status: proxyResponse.status,
+                statusText: proxyResponse.statusText,
+                headers: { "Content-Type": normalizedError.contentType },
+            });
+        }
+        const data = await proxyResponse.json();
+        return new Response(JSON.stringify(data), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        });
+    };
+}
+function normalizeFreestyleProxyError(errorText, status) {
+    const fallbackCode = status === 400 ? "BAD_REQUEST" : status === 401 ? "UNAUTHORIZED_ERROR" : status === 403 ? "FORBIDDEN" : "INTERNAL_ERROR";
+    try {
+        const parsed = JSON.parse(errorText);
+        if (typeof parsed.code === "string" && typeof parsed.message === "string") {
+            return { body: JSON.stringify(parsed), contentType: "application/json" };
+        }
+        const message = [parsed.error, parsed.message, parsed.reason].find((value) => typeof value === "string" && value.length > 0);
+        if (message) {
+            return {
+                body: JSON.stringify(freestyleErrorBody(fallbackCode, message)),
+                contentType: "application/json",
+            };
+        }
+    }
+    catch {
+    }
+    return {
+        body: JSON.stringify(freestyleErrorBody(fallbackCode, errorText || "Request failed")),
+        contentType: "application/json",
+    };
+}
+function freestyleErrorBody(code, message) {
+    if (code === "UNAUTHORIZED_ERROR") {
+        return { code, message, route: "/api/proxy/request", reason: message };
+    }
+    return { code, message };
+}
+async function runFreestyleLogin(extraArgs = []) {
+    console.log("No Freestyle API key found. Opening Freestyle login...");
+    const cliPath = path.join(path.dirname(fileURLToPath(import.meta.resolve("freestyle"))), "cli.mjs");
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [cliPath, "login", ...extraArgs], {
+            cwd: process.cwd(),
+            stdio: "inherit",
+            env: process.env,
+        });
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(signal ? `freestyle login was interrupted by ${signal}` : `freestyle login failed with exit code ${code ?? "unknown"}`));
+        });
+    });
+}
 async function getOrCreateVm(options, snapshotId) {
+    const freestyle = await getFreestyleClient();
     if (options.vmId) {
         const { vm } = await freestyle.vms.get({ vmId: options.vmId });
         await vm.start(options.idleTimeoutSeconds ? { idleTimeoutSeconds: options.idleTimeoutSeconds } : undefined);
@@ -1196,20 +1392,18 @@ async function createTar(args) {
     });
 }
 async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, label) {
-    const archive = await readFile(archivePath);
-    const encoded = archive.toString("base64");
-    const chunkCount = Math.max(1, Math.ceil(encoded.length / ARCHIVE_CHUNK_CHARS));
+    const archiveSize = (await stat(archivePath)).size;
+    const chunkCount = Math.max(1, Math.ceil(archiveSize / ARCHIVE_CHUNK_BYTES));
     const chunkDir = `/tmp/freestyle-sync-${label}-${Date.now()}.chunks`;
-    console.log(`VM ${vmId}: streaming ${formatBytes(archive.length)} ${label} archive in ${chunkCount} chunk${chunkCount === 1 ? "" : "s"}...`);
+    console.log(`VM ${vmId}: streaming ${formatBytes(archiveSize)} ${label} archive in ${chunkCount} chunk${chunkCount === 1 ? "" : "s"}...`);
     await checkedExec(vm, `rm -rf ${shellQuote(chunkDir)} && mkdir -p ${shellQuote(chunkDir)}`);
     const width = String(chunkCount - 1).length;
     const canRenderInlineProgress = process.stdout.isTTY;
     const logEvery = Math.max(1, Math.ceil(chunkCount / 4));
-    for (let index = 0; index < chunkCount; index += 1) {
-        const start = index * ARCHIVE_CHUNK_CHARS;
-        const chunk = encoded.slice(start, start + ARCHIVE_CHUNK_CHARS);
-        const chunkName = `${String(index).padStart(width, "0")}.b64`;
-        await vm.fs.writeTextFile(`${chunkDir}/${chunkName}`, chunk);
+    let index = 0;
+    for await (const chunk of createReadStream(archivePath, { highWaterMark: ARCHIVE_CHUNK_BYTES })) {
+        const chunkName = `${String(index).padStart(width, "0")}.chunk`;
+        await vm.fs.writeFile(`${chunkDir}/${chunkName}`, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
         const uploadedChunks = index + 1;
         if (chunkCount > 1) {
             const progressMessage = `VM ${vmId}: uploaded ${uploadedChunks}/${chunkCount} ${label} archive chunks`;
@@ -1223,8 +1417,11 @@ async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, l
                 console.log(progressMessage);
             }
         }
+        index += 1;
     }
-    await checkedExec(vm, `cat ${shellQuote(chunkDir)}/*.b64 | base64 -d > ${shellQuote(remoteArchivePath)} && rm -rf ${shellQuote(chunkDir)}`);
+    await checkedExec(vm, archiveSize === 0
+        ? `: > ${shellQuote(remoteArchivePath)} && rm -rf ${shellQuote(chunkDir)}`
+        : `cat ${shellQuote(chunkDir)}/*.chunk > ${shellQuote(remoteArchivePath)} && rm -rf ${shellQuote(chunkDir)}`);
 }
 async function mkdirRemote(vm, directories) {
     for (const chunk of chunkArray(directories, 50)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freestyle-sync",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "type": "module",
   "main": "dist/src/main.js",
   "exports": {
@@ -22,7 +22,8 @@
     "build": "rm -rf dist plugins/*/dist && tsc -p tsconfig.json && node scripts/prepare-plugin-packages.mjs",
     "check": "tsc --noEmit -p tsconfig.json",
     "prepack": "npm run build",
-    "publish": "npm run check && npm run build && npm publish --workspaces --access public && npm publish",
+    "publish": "npm run check && npm run build && npm run publish:workspaces && npm publish",
+    "publish:workspaces": "node scripts/publish-workspaces.mjs",
     "start": "node src/main.ts"
   },
   "dependencies": {