@upstart.gg/sdk 0.0.104 → 0.0.105

package/src/node/cli/commands/publish/uploader.ts

@@ -1,333 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import crypto from "node:crypto";
-import fg from "fast-glob";
-import { API_BASE_URL, DEFAULT_UPLOAD_MAX_CONCURRENCY } from "../../constants";
-import http from "node:http";
-import https from "node:https";
-import { pipeline } from "node:stream";
-import type { GenericApiError } from "../../types";
-import { logger } from "~/node/shared/logger";
-import chalk from "chalk";
-import FormData from "form-data";
-import parseGitIgnore from "./parse-gitignore";
-import PQueue from "p-queue";
-import ora from "ora";
-import { customAlphabet } from "nanoid";
-import { post } from "../../api";
-
-interface UploadStats {
-  fileName: string;
-  fileSize: number;
-  uploadDuration: number;
-  statusCode: number;
-  serverResponse: string;
-}
-
-class UploadError extends Error implements GenericApiError {
-  constructor(
-    public error: string,
-    public error_description: string,
-    public filename: string,
-  ) {
-    super(`${error}: ${error_description}`);
-    this.name = "UploadError";
-  }
-}
-
-interface UploadConfig {
-  maxDataSize: number;
-  retryAttempts: number;
-  retryDelay: number;
-}
-
-const defaultConfig: UploadConfig = {
-  maxDataSize: 12 * 1024 * 1024, // 12MB
-  retryAttempts: 2,
-  retryDelay: 1000,
-};
-
-const agent = new http.Agent({
-  keepAlive: true,
-  maxSockets: 10,
-  keepAliveMsecs: 3000, // Keep connections open for 3 seconds
-});
-
-async function discoverFiles(templateDir: string): Promise<string[]> {
-  const gitignore = path.join(templateDir, ".gitignore");
-  const gitignoreExists = fs.existsSync(gitignore);
-  const gitignored = gitignoreExists ? parseGitIgnore(fs.readFileSync(gitignore, "utf-8")).patterns : [];
-
-  return fg("**/*", {
-    cwd: templateDir,
-    onlyFiles: true,
-    dot: true,
-    absolute: true,
-    ignore: [
-      "node_modules/**",
-      ".cache/**",
-      "**/.DS_Store",
-      ".gitignore",
-      ".env",
-      ".env.*",
-      ".git/**",
-      "dist/**",
-      ...gitignored,
-    ],
-  });
-}
-
-async function uploadFile(
-  filePath: string,
-  relativePath: string,
-  uploadUrl: string,
-  templateId: string,
-  spinner: ReturnType<typeof ora>,
-  token: string,
-  config: UploadConfig,
-): Promise<UploadStats> {
-  const uploadWithRetry = async (attempt: number): Promise<UploadStats> => {
-    try {
-      return await performUpload(filePath, relativePath, uploadUrl, templateId, spinner, token, config);
-    } catch (error) {
-      if (attempt < config.retryAttempts) {
-        logger.warn(`Retrying upload for ${relativePath} (attempt ${attempt + 1})`);
-        await new Promise((resolve) => setTimeout(resolve, config.retryDelay));
-        return uploadWithRetry(attempt + 1);
-      }
-      throw error;
-    }
-  };
-
-  return uploadWithRetry(0);
-}
-
-async function performUpload(
-  filePath: string,
-  relativePath: string,
-  uploadUrl: string,
-  templateId: string,
-  spinner: ReturnType<typeof ora>,
-  token: string,
-  config: UploadConfig,
-): Promise<UploadStats> {
-  return new Promise<UploadStats>((resolve, reject) => {
-    const stats = fs.statSync(filePath);
-    const fileName = path.basename(filePath);
-    const startTime = Date.now();
-
-    const form = new FormData({
-      maxDataSize: config.maxDataSize,
-    });
-    const fileStream = fs.createReadStream(filePath);
-    let totalUploaded = 0;
-
-    const updateProgress = (chunk: Buffer | string) => {
-      totalUploaded += chunk.length;
-    };
-
-    fileStream.on("data", updateProgress);
-    form.append("file", fileStream, {
-      filename: fileName,
-      knownLength: stats.size,
-    });
-
-    const options: https.RequestOptions = {
-      agent,
-      method: "POST",
-      headers: {
-        authorization: `Bearer ${token}`,
-        "x-upstart-template-file-path": relativePath,
-        "x-upstart-template-id": templateId,
-        ...form.getHeaders(),
-      },
-    };
-
-    const protocol = uploadUrl.startsWith("https") ? https : http;
-    const req = protocol.request(uploadUrl, options, (res) => {
-      let responseBody = "";
-      res.on("data", (chunk) => {
-        responseBody += chunk;
-      });
-
-      res.on("end", () => {
-        const endTime = Date.now();
-        const uploadStats: UploadStats = {
-          fileName,
-          fileSize: stats.size,
-          uploadDuration: endTime - startTime,
-          statusCode: res.statusCode ?? 0,
-          serverResponse: responseBody,
-        };
-
-        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-          spinner.text = `Uploaded ${relativePath}`;
-          resolve(uploadStats);
-        } else {
-          let errorObject: UploadError;
-          if (res.headers["content-type"]?.startsWith("application/json")) {
-            const parsedError = JSON.parse(responseBody);
-            errorObject = new UploadError(
-              parsedError.error || "unknown_error",
-              parsedError.error_description || "Unknown error occurred",
-              relativePath,
-            );
-          } else {
-            errorObject = new UploadError(
-              "unknown_error",
-              responseBody || "Unknown error occurred",
-              relativePath,
-            );
-          }
-
-          spinner.fail(
-            `Failed to upload ${relativePath} [${errorObject.error}] ${errorObject.error_description}`,
-          );
-
-          reject(errorObject);
-        }
-      });
-    });
-
-    req.on("error", (error) => {
-      reject(new UploadError("request_error", error.message, relativePath));
-    });
-
-    pipeline(form, req, (err) => {
-      if (err) {
-        reject(
-          new UploadError("pipeline_error", `Pipeline failed for ${fileName}: ${err.message}`, relativePath),
-        );
-      }
-    });
-  });
-}
-
-function reportUploadStatistics(
-  templateId: string,
-  uploadedFiles: UploadStats[],
-  failedFiles: PromiseRejectedResult[],
-) {
-  if (failedFiles.length > 0) {
-    logger.error(chalk.red(`Failed to upload ${failedFiles.length} files:`));
-    failedFiles.forEach((failure) => {
-      const error = failure.reason as UploadError;
-      logger.error(`- ${error.filename}: ${error.error_description} (${error.error})`);
-    });
-  } else {
-    logger.info(
-      chalk.green(`Uploaded ${uploadedFiles.length} files successfully for template ${templateId}.\n`),
-    );
-  }
-}
-
-export async function uploadTemplate(
-  templateId: string,
-  templateDir: string,
-  token: string,
-  dryRun = false,
-  config: Partial<UploadConfig> = {},
-) {
-  const fullConfig = { ...defaultConfig, ...config };
-  const queue = new PQueue({ concurrency: DEFAULT_UPLOAD_MAX_CONCURRENCY });
-  const files = await discoverFiles(templateDir);
-  const filesCount = files.length;
-  const signatures: Record<string, string> = {};
-  // generate a upload id
-  const uploadId = generateUploadId();
-  let completedUploads = 0;
-
-  // compute signatures
-  for (const file of files) {
-    const relativePath = path.relative(templateDir, file);
-    const md5 = await sha1sum(file);
-    signatures[relativePath] = md5;
-  }
-
-  if (dryRun) {
-    logger.info("Dry run mode enabled. Skipping upload.\n");
-    logger.info("The following files would have been uploaded:");
-    files.forEach((file) => logger.info(`- ${file}`));
-    process.exit(0);
-  }
-
-  const spinner = ora(`Uploading ${filesCount} files...`).start();
-
-  // upload files
-  const uploadPromises = files.map((file) => {
-    const fullPath = path.resolve(templateDir, file);
-    const relativePath = path.relative(templateDir, file);
-    const url = `${API_BASE_URL}/v1/templates/${templateId}/upload/${uploadId}`;
-    return queue.add(async () => {
-      const result = await uploadFile(fullPath, relativePath, url, templateId, spinner, token, fullConfig);
-      completedUploads++;
-      return result;
-    });
-  });
-
-  const results = await Promise.allSettled(uploadPromises);
-  spinner.stop();
-
-  const uploadedFiles = results.filter(
-    (result): result is PromiseFulfilledResult<UploadStats> => result.status === "fulfilled",
-  );
-
-  const failedFiles = results.filter(
-    (result): result is PromiseRejectedResult => result.status === "rejected",
-  );
-
-  reportUploadStatistics(
-    templateId,
-    uploadedFiles.map((r) => r.value),
-    failedFiles,
-  );
-
-  // finalize upload
-  if (!failedFiles.length && uploadedFiles.length) {
-    const finalizeUrl = `${API_BASE_URL}/v1/templates/${templateId}/upload/${uploadId}/finalize`;
-    const finalizePayload = {
-      signatures,
-    };
-
-    const finalizeResponse = await post(finalizeUrl, finalizePayload);
-
-    if (finalizeResponse.isError) {
-      logger.error(
-        `Failed to finalize upload: ${finalizeResponse.data.error_description} (${finalizeResponse.data.error})`,
-      );
-      return {
-        filesCount,
-        uploadedFiles: uploadedFiles.map((r) => r.value),
-        failedFiles: [],
-        success: false,
-      };
-    }
-  }
-
-  return {
-    filesCount,
-    uploadedFiles: uploadedFiles.map((r) => r.value),
-    failedFiles,
-    success: failedFiles.length === 0,
-  };
-}
-
-async function sha1sum(filePath: string): Promise<string> {
-  const hash = await crypto.subtle.digest("SHA-1", fs.readFileSync(filePath));
-  // convert arrayBuffer to hex
-  return Array.from(new Uint8Array(hash))
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-}
-
-function generateUploadId(): string {
-  const randomId = customAlphabet("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5);
-  const now = new Date();
-  const year = now.getUTCFullYear();
-  const month = (now.getUTCMonth() + 1).toString().padStart(2, "0");
-  const day = now.getUTCDate().toString().padStart(2, "0");
-  const hours = now.getUTCHours().toString().padStart(2, "0");
-  const minutes = now.getUTCMinutes().toString().padStart(2, "0");
-  const seconds = now.getUTCSeconds().toString().padStart(2, "0");
-  return `${year}${month}${day}${hours}${minutes}${seconds}_${randomId()}`;
-}

package/src/node/cli/constants.ts

@@ -1,14 +0,0 @@
-export const CLI_PROJECT_NAME = "upstart-cli";
-export const CLI_LOGIN_POLL_INTERVAL = 5000; // seconds
-export const CLI_LOGIN_CLIENT_ID =
-  process.env.PUBLIC_UPSTART_OAUTH_CLIENT_ID ?? "50000000-0000-0000-0000-000000000001";
-
-export const API_BASE_URL = process.env.PUBLIC_UPSTART_API_BASE_URL ?? "https://api.upstart.gg";
-export const EDITOR_BASE_URL = process.env.PUBLIC_UPSTART_EDITOR_BASE_URL ?? "https://upstart.gg";
-export const DEFAULT_UPLOAD_MAX_CONCURRENCY = 10;
-
-export const OAUTH_ENDPOINT_DEVICE_CODE = "oauth/devicecode";
-export const OAUTH_ENDPOINT_TOKEN = "oauth/token";
-export const OAUTH_ENDPOINT_USER_INFO = "oauth/userinfo";
-
-export const API_ENDPOINT_REGISTER_TEMPLATE = "v1/templates";

package/src/node/cli/is-logged-in.ts

@@ -1,28 +0,0 @@
-import { OAUTH_ENDPOINT_USER_INFO } from "./constants";
-import { accessStore } from "./store";
-
-export async function isLoggedIn(checkRemote = false): Promise<boolean> {
-  const token = accessStore.get("access_token");
-  const expiration = accessStore.get("expires_at");
-
-  if (!token) {
-    return false;
-  }
-
-  if (expiration && expiration < Date.now()) {
-    console.log("Seems like your token expired...");
-    return false;
-  }
-
-  if (!checkRemote) {
-    return true;
-  }
-
-  // Check if token is valid
-
-  // import dynamically "./api" to avoid circular dependency
-  const { get } = await import("./api");
-  const { isSuccess } = await get(OAUTH_ENDPOINT_USER_INFO);
-
-  return isSuccess;
-}

package/src/node/cli/program.ts

@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-import { program, type Command, type OptionValues } from "commander";
-import type { BuildOptions, CommonOptions } from "./types";
-import { publish } from "./commands/publish/cmd-publish";
-import { login } from "./commands/login/cmd-login";
-import { buildTemplate } from "./commands/cmd-build";
-import { createLogger, type Logger } from "../shared/logger";
-import { logout } from "./commands/logout/cmd-logout";
-
-let logger: Logger;
-
-program
-  .name("enpage")
-  .option("-l, --logLevel <level>", `[string] info | warn | error | silent | debug`)
-  .option("--clearScreen", `[boolean] allow/disable clear screen when logging`)
-  .option("--dry-run", `[boolean] run command without making changes`)
-  .hook("preAction", (thisCommand) => {
-    logger = createLogger(
-      thisCommand.optsWithGlobals().logLevel,
-      thisCommand.optsWithGlobals().clearScreen,
-      true,
-    );
-    // for now, disable the form-data warning until they fix it
-    process.removeAllListeners("warning");
-    process.on("warning", (warning) => {
-      if (warning.name === "DeprecationWarning" && warning.message.includes("util.isArray")) {
-        return;
-      }
-      logger.warnOnce(`Warning: ${warning.name} - ${warning.message}`);
-    });
-  });
-
-program
-  .command("build")
-  .description("Build template")
-  .option(
-    "--ssr [type]",
-    `Enable server side rendering.
-Pass --ssr to generate a SSR-enabled build.
-Pass --ssr=local to generate a SSR-enabled build that can be tested locally.`,
-    Boolean,
-    false,
-  )
-  .option("--no-clean", `Don't clean directory before buidling`)
-  .action(function (this: Command) {
-    buildTemplate(getArgsOptionsObject<BuildOptions>(this));
-  });
-
-program
-  .command("publish")
-  .description("Publish a template to Enpage")
-  .argument("[directory]", "Directory to publish")
-  .option("--no-check", `Don't check for required files`)
-
-  .action(function (this: Command) {
-    publish(getArgsOptionsObject(this));
-  });
-
-program
-  .command("login")
-  .description("Login to Enpage")
-  .action(function (this: Command) {
-    login(getArgsOptionsObject(this));
-  });
-
-program
-  .command("logout")
-  .description("Logout from Enpage")
-  .action(function (this: Command) {
-    logout(getArgsOptionsObject(this));
-  });
-
-program.parse();
-
-function getArgsOptionsObject<O extends OptionValues>(cmd: Command) {
-  return { options: cmd.optsWithGlobals<CommonOptions & O>(), args: cmd.args, logger };
-}

package/src/node/cli/store.ts

@@ -1,64 +0,0 @@
-import type { CredentialsStore } from "./types";
-import { CLI_PROJECT_NAME, OAUTH_ENDPOINT_USER_INFO } from "./constants";
-import Conf from "conf";
-import path from "node:path";
-import crypto from "node:crypto";
-import fs from "node:fs";
-import { fileURLToPath } from "node:url";
-import { getPackageManager } from "./utils";
-import chalk from "chalk";
-
-const __dirname = fileURLToPath(new URL(".", import.meta.url));
-const key = getKey();
-const accessStore = new Conf<CredentialsStore>({
-  projectName: CLI_PROJECT_NAME,
-  encryptionKey: key,
-  clearInvalidConfig: true,
-});
-
-/**
- * Get access token or throw error if not found
- */
-export function getTokenOrThrow() {
-  const token = accessStore.get("access_token");
-  if (!token) {
-    const pkgCmd = getPackageManager();
-    throw new Error(
-      `Access token not found. Please run ${chalk.cyan(`${pkgCmd} run enpage:login`)} to authenticate.`,
-    );
-  }
-  return token;
-}
-
-function findNearestNodeModules(): string | null {
-  let currentDir = __dirname;
-  while (currentDir !== path.parse(currentDir).root) {
-    const nodeModulesPath = path.join(currentDir, "node_modules");
-    if (fs.existsSync(nodeModulesPath)) {
-      return nodeModulesPath;
-    }
-    currentDir = path.dirname(currentDir);
-  }
-  return null;
-}
-
-function getKey() {
-  const nodeModulesPath = findNearestNodeModules();
-  if (!nodeModulesPath) {
-    throw new Error("Could not find nearest node_modules directory.");
-  }
-  const tmpSecureStoreDir = path.join(nodeModulesPath, ".enpage-tmp");
-  if (!fs.existsSync(tmpSecureStoreDir)) {
-    fs.mkdirSync(tmpSecureStoreDir, { recursive: true, mode: 0o700 });
-  }
-  const keyPath = path.join(tmpSecureStoreDir, ".enpage-key");
-  if (!fs.existsSync(keyPath)) {
-    const key = crypto.randomBytes(32).toString("hex");
-    fs.writeFileSync(keyPath, key, { mode: 0o600 });
-    return key;
-  }
-  const key = fs.readFileSync(keyPath, "utf8");
-  return key;
-}
-
-export { accessStore };

package/src/node/cli/tests/api.test.ts

@@ -1,161 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { post, get } from "../api";
-import { accessStore } from "../store";
-
-vi.mock("../store", () => ({
-  accessStore: {
-    get: vi.fn(),
-  },
-  getToken: vi.fn(),
-}));
-
-vi.mock("../shared/logger", () => ({
-  logger: {
-    error: vi.fn(),
-  },
-}));
-
-global.fetch = vi.fn();
-
-describe("API functions", () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("post", () => {
-    it("should make a POST request with correct headers and body", async () => {
-      const mockResponse = { data: "test" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        statusText: "OK",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(mockResponse),
-      });
-
-      const result = await post("/test", { key: "value" });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.any(URL),
-        expect.objectContaining({
-          method: "POST",
-          headers: expect.objectContaining({
-            "Content-Type": "application/json",
-          }),
-          body: JSON.stringify({ key: "value" }),
-        }),
-      );
-      expect(result).toEqual({
-        isSuccess: true,
-        isError: false,
-        status: 200,
-        statusText: "OK",
-        data: mockResponse,
-      });
-    });
-
-    it("should handle URLSearchParams correctly", async () => {
-      const mockResponse = { data: "test" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        statusText: "OK",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(mockResponse),
-      });
-
-      const params = new URLSearchParams({ key: "value" });
-      await post("/test", params);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.any(URL),
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            "Content-Type": "application/x-www-form-urlencoded",
-          }),
-          body: params,
-        }),
-      );
-    });
-
-    it("should handle error responses", async () => {
-      const errorResponse = { error: "Test error" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: false,
-        status: 400,
-        statusText: "Bad Request",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(errorResponse),
-      });
-
-      const result = await post("/test", { key: "value" });
-
-      expect(result).toEqual({
-        isSuccess: false,
-        isError: true,
-        status: 400,
-        statusText: "Bad Request",
-        data: errorResponse,
-      });
-    });
-  });
-
-  describe("get", () => {
-    it("should make a GET request with correct headers", async () => {
-      const mockResponse = { data: "test" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        statusText: "OK",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(mockResponse),
-      });
-
-      vi.mocked(accessStore.get).mockReturnValue("test-token");
-
-      const result = await get("/test");
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.any(URL),
-        expect.objectContaining({
-          method: "GET",
-          headers: expect.objectContaining({
-            Authorization: "Bearer test-token",
-          }),
-        }),
-      );
-      expect(result).toEqual({
-        isSuccess: true,
-        isError: false,
-        status: 200,
-        statusText: "OK",
-        data: mockResponse,
-      });
-    });
-
-    it("should handle error responses", async () => {
-      const errorResponse = { error: "Test error" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: false,
-        status: 404,
-        statusText: "Not Found",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(errorResponse),
-      });
-
-      const result = await get("/test");
-
-      expect(result).toEqual({
-        isSuccess: false,
-        isError: true,
-        status: 404,
-        statusText: "Not Found",
-        data: errorResponse,
-      });
-    });
-  });
-});