@upstart.gg/sdk 0.0.104 → 0.0.106

package/src/node/cli/commands/publish/parse-gitignore.ts

@@ -1,278 +0,0 @@
-/*!
- * parse-gitignore <https://github.com/jonschlinkert/parse-gitignore>
- * Copyright (c) 2015-present, Jon Schlinkert.
- * Released under the MIT License.
- *
- * Converted to typescript by Matthias E. <matthias@upstart.gg>
- */
-
-import * as fs from "node:fs";
-
-// eslint-disable-next-line no-control-regex
-const INVALID_PATH_CHARS_REGEX = /[<>"|?*\n\r\t\f\x00-\x1F]/;
-const GLOBSTAR_REGEX = /(?:^|\/)[*]{2}($|\/)/;
-const MAX_PATH_LENGTH = 260 - 12;
-
-interface ParseOptions {
-  path?: string;
-  dedupe?: boolean;
-  unique?: boolean;
-  ignore?: string[];
-  unignore?: string[];
-  format?: boolean;
-  formatSection?: (section: Section) => string;
-}
-
-interface Section {
-  name: string;
-  comment?: string;
-  patterns: string[];
-}
-
-interface ParsedGitignore {
-  sections: Section[];
-  patterns: string[];
-  path?: string;
-  input: Buffer;
-  format: (opts?: ParseOptions) => string;
-  dedupe: (opts?: ParseOptions) => ParsedGitignore;
-  globs: (opts?: ParseOptions) => GlobResult[];
-}
-
-interface GlobResult {
-  type: "ignore" | "unignore";
-  path: string | null;
-  patterns: string[];
-  index: number;
-}
-
-const isObject = (v: unknown): v is Record<string, unknown> =>
-  v !== null && typeof v === "object" && !Array.isArray(v);
-
-const isValidPath = (input: unknown): input is string =>
-  typeof input === "string" && input.length <= MAX_PATH_LENGTH && !INVALID_PATH_CHARS_REGEX.test(input);
-
-const split = (str: string): string[] => str.split(/\r\n?|\n/);
-const isComment = (str: string): boolean => str.startsWith("#");
-const isParsed = (input: unknown): input is ParsedGitignore =>
-  isObject(input) && Array.isArray(input.patterns) && Array.isArray(input.sections);
-
-const patterns = (input: string): string[] =>
-  split(input)
-    .map((l) => l.trim())
-    .filter((line) => line !== "" && !isComment(line));
-
-const parse = (input: string | ParsedGitignore, options: ParseOptions = {}): ParsedGitignore => {
-  let filepath = options.path;
-
-  if (isParsed(input)) return input;
-  if (isValidPath(input) && fs.existsSync(input)) {
-    filepath = input;
-    input = fs.readFileSync(input, "utf8");
-  }
-
-  const lines = split(input);
-  const names = new Map<string, Section>();
-
-  let parsed: ParsedGitignore = { sections: [], patterns: [] } as unknown as ParsedGitignore;
-  let section: Section = { name: "default", patterns: [] };
-  let prev: Section | null = null;
-
-  for (const line of lines) {
-    const value = line.trim();
-
-    if (value.startsWith("#")) {
-      const [, name] = /^#+\s*(.*)\s*$/.exec(value) || [];
-
-      if (prev) {
-        names.delete(prev.name);
-        prev.comment = prev.comment ? `${prev.comment}\n${value}` : value;
-        prev.name = name ? `${prev.name.trim()}\n${name.trim()}` : prev.name.trim();
-        names.set(prev.name.toLowerCase().trim(), prev);
-        continue;
-      }
-
-      section = { name: name?.trim() || "", comment: value, patterns: [] };
-      names.set(section.name.toLowerCase(), section);
-      parsed.sections.push(section);
-      prev = section;
-      continue;
-    }
-
-    if (value !== "") {
-      section.patterns.push(value);
-      parsed.patterns.push(value);
-    }
-
-    prev = null;
-  }
-
-  if (options.dedupe === true || options.unique === true) {
-    parsed = dedupe(parsed, { ...options, format: false });
-  }
-
-  parsed.path = filepath;
-  parsed.input = Buffer.from(input);
-  parsed.format = (opts?: ParseOptions) => format(parsed, { ...options, ...opts });
-  parsed.dedupe = (opts?: ParseOptions) => dedupe(parsed, { ...options, ...opts });
-  parsed.globs = (opts?: ParseOptions) => globs(parsed, { path: filepath, ...options, ...opts });
-  return parsed;
-};
-
-const parseFile = (filepath: string, options?: ParseOptions): ParsedGitignore =>
-  parse(fs.readFileSync(filepath, "utf8"), options);
-
-const dedupe = (input: string | ParsedGitignore, options: ParseOptions): ParsedGitignore => {
-  const parsed = parse(input, { ...options, dedupe: false });
-
-  const names = new Map<string, Section>();
-  const res: ParsedGitignore = { sections: [], patterns: [] } as unknown as ParsedGitignore;
-  let current: Section;
-
-  // first, combine duplicate sections
-  for (const section of parsed.sections) {
-    const { name = "", comment, patterns } = section;
-    const key = name.trim().toLowerCase();
-
-    for (const pattern of patterns) {
-      if (!res.patterns.includes(pattern)) {
-        res.patterns.push(pattern);
-      }
-    }
-
-    if (name && names.has(key)) {
-      current = names.get(key)!;
-      current.patterns = [...current.patterns, ...patterns];
-    } else {
-      current = { name, comment, patterns };
-      res.sections.push(current);
-      names.set(key, current);
-    }
-  }
-
-  // next, de-dupe patterns in each section
-  for (const section of res.sections) {
-    section.patterns = [...new Set(section.patterns)];
-  }
-
-  return res;
-};
-
-const glob = (pattern: string): string => {
-  // Return if a glob pattern has already been specified for sub-directories
-  if (GLOBSTAR_REGEX.test(pattern)) {
-    return pattern;
-  }
-
-  // If there is a separator at the beginning or middle (or both) of the pattern,
-  // then the pattern is relative to the directory level of the particular .gitignore
-  // file itself. Otherwise the pattern may also match at any level below the
-  // .gitignore level. relative paths only
-  let relative = false;
-  if (pattern.startsWith("/")) {
-    pattern = pattern.slice(1);
-    relative = true;
-  } else if (pattern.slice(1, pattern.length - 1).includes("/")) {
-    relative = true;
-  }
-
-  // If there is a separator at the end of the pattern then the pattern will only match directories.
-  pattern += pattern.endsWith("/") ? "**/" : "/**";
-
-  // If not relative, the pattern can match any files and directories.
-  return relative ? pattern : `**/${pattern}`;
-};
-
-const globs = (input: string | ParsedGitignore, options: ParseOptions = {}): GlobResult[] => {
-  const parsed = parse(input, options);
-  const result: GlobResult[] = [];
-  let index = 0;
-
-  const globPatterns = parsed.patterns
-    .concat(options.ignore || [])
-    .concat((options.unignore || []).map((p) => (!p.startsWith("!") ? `!${p}` : p)));
-
-  const push = (prefix: string, pattern: string) => {
-    const prev = result[result.length - 1];
-    const type = prefix ? "unignore" : "ignore";
-
-    if (prev && prev.type === type) {
-      if (!prev.patterns.includes(pattern)) {
-        prev.patterns.push(pattern);
-      }
-    } else {
-      result.push({ type, path: options.path || null, patterns: [pattern], index });
-      index++;
-    }
-  };
-
-  for (let pattern of globPatterns) {
-    let prefix = "";
-
-    // An optional prefix "!" which negates the pattern; any matching file excluded by
-    // a previous pattern will become included again
-    if (pattern.startsWith("!")) {
-      pattern = pattern.slice(1);
-      prefix = "!";
-    }
-
-    // add the raw pattern to the results
-    push(prefix, pattern.startsWith("/") ? pattern.slice(1) : pattern);
-
-    // add the glob pattern to the results
-    push(prefix, glob(pattern));
-  }
-
-  return result;
-};
-
-/**
- * Formats a .gitignore section
- */
-const formatSection = (section: Section = { name: "", patterns: [] }): string => {
-  const output = [section.comment || ""];
-
-  if (section.patterns?.length) {
-    output.push(section.patterns.join("\n"));
-    output.push("");
-  }
-
-  return output.join("\n");
-};
-
-/**
- * Format a .gitignore file from the given input or object from `.parse()`.
- * @param {String | ParsedGitignore} input File path or contents.
- * @param {ParseOptions} options
- * @return {String} Returns formatted string.
- * @api public
- */
-const format = (input: string | ParsedGitignore, options: ParseOptions = {}): string => {
-  const parsed = parse(input, options);
-
-  const fn = options.formatSection || formatSection;
-  const sections = parsed.sections || parsed;
-  const output: string[] = [];
-
-  for (const section of ([] as Section[]).concat(sections)) {
-    output.push(fn(section));
-  }
-
-  return output.join("\n");
-};
-
-export {
-  parse,
-  parseFile,
-  dedupe,
-  format,
-  globs,
-  formatSection,
-  patterns,
-  type ParseOptions,
-  type Section,
-  type ParsedGitignore,
-  type GlobResult,
-};
-
-export default parse;

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;
-}