phio 0.3.5 → 0.4.0

package/vendor/ftp-deploy/types.ts

@@ -0,0 +1,226 @@
+export const currentSyncFileVersion = "1.0.0";
+export const syncFileDescription = "DO NOT DELETE THIS FILE. This file is used to keep track of which files have been synced in the most recent deployment. If you delete this file a resync will need to be done (which can take a while) - read more: https://github.com/SamKirkland/FTP-Deploy-Action";
+
+export interface IFtpDeployArguments {
+    server: string;
+    username: string;
+    /** Not used when protocol is "sftp" (use private-key-path instead). */
+    password?: string;
+
+    /**
+     * Server port
+     * @default 21 (ftp/ftps) or 2222 (sftp)
+     */
+    port?: number;
+
+    /**
+     * "ftp": provides no encryption
+     * "ftps": full encryption newest standard (aka "explicit" ftps)
+     * "ftps-legacy": full encryption legacy standard (aka "implicit" ftps)
+     * "sftp": SSH file transfer (Ed25519 key auth)
+     * @default "ftp"
+     */
+    protocol?: "ftp" | "ftps" | "ftps-legacy" | "sftp";
+
+    /** PEM or OpenSSH private key path. Required when protocol is "sftp". */
+    "private-key-path"?: string;
+
+    /** @default "./" */
+    "local-dir"?: string;
+
+    /** @default "./" */
+    "server-dir"?: string;
+
+    /** @default ".ftp-deploy-sync-state.json" */
+    "state-name"?: string;
+
+    /**
+     * Prints which modifications will be made with current config options, but doesn't actually make any changes
+     * @default false
+     */
+    "dry-run"?: boolean;
+
+    /**
+     * Deletes ALL contents of server-dir, even items in excluded with 'exclude' argument
+     * @default false
+     */
+    "dangerous-clean-slate"?: boolean;
+
+    /**
+     * An array of glob patterns, these files will ONLY be included in the publish/delete process
+     * @default [ "**\/*" ]
+     */
+    include?: string[];
+
+    /**
+     * An array of glob patterns, these files will not be included in the publish/delete process
+     * @default [ ".git*", ".git*\/**", "node_modules\/**", "node_modules\/**\/*" ]
+     */
+    exclude?: string[];
+
+    /**
+     * How much information should print. minimal=only important info, standard=important info and basic file changes, verbose=print everything the script is doing
+     * @default "info"
+     */
+    "log-level"?: "minimal" | "standard" | "verbose";
+
+    /**
+     * When using protocol "ftps" or "ftps-legacy" should the cert name need to match exactly?
+     * Set this to "strict" to ensure your data is being encrypted
+     * 
+     * Defaults to loose because of the sheer volume of shared hosts that give ftp domains a cert without a matching common name
+     * @default "loose"
+     */
+    security?: "strict" | "loose";
+
+    /**
+     * Timeout in milliseconds for FTP operations as handled by underlying basic-ftp connection library.
+     * @default 30000 (30 seconds)
+     */
+    timeout?: number;
+}
+
+export interface IFtpDeployArgumentsWithDefaults {
+    server: string;
+    username: string;
+    password: string;
+    port: number;
+    protocol: "ftp" | "ftps" | "ftps-legacy" | "sftp";
+    "private-key-path": string | undefined;
+    "local-dir": string;
+    "server-dir": string;
+    "state-name": string;
+    "dry-run": boolean;
+    "dangerous-clean-slate": boolean;
+    include: string[];
+    exclude: string[];
+    "log-level": "minimal" | "standard" | "verbose";
+    security: "strict" | "loose";
+    timeout: number;
+}
+
+export interface IFile {
+    type: "file";
+    name: string;
+    size: number;
+    hash: string;
+}
+
+export interface IFolder {
+    type: "folder";
+    name: string;
+    size: undefined;
+}
+
+export type Record = IFolder | IFile;
+
+export interface IFileList {
+    /** Give some info to people opening this file wondering what it is */
+    description: string;
+
+    /** version number of this diff file */
+    version: "1.0.0";
+
+    /** UTC time of the last publish start */
+    generatedTime: number;
+    data: Record[];
+}
+
+export type DiffResult = {
+    upload: Record[];
+    delete: Record[];
+    replace: Record[];
+    same: Record[];
+
+    /** number of bytes that will need to be uploaded */
+    sizeUpload: number;
+
+    /** number of bytes that will need to be removed */
+    sizeDelete: number;
+
+    /** number of bytes that will need to be replaced */
+    sizeReplace: number;
+}
+
+export interface IDiff {
+    getDiffs(localFiles: IFileList, serverFiles: IFileList): DiffResult;
+}
+
+export interface IFilePath {
+    /** will be null when no folders exist in path */
+    folders: string[] | null;
+
+    /** will be null when no file exists in path */
+    file: string | null;
+}
+
+export enum ErrorCode {
+    // The requested action is being initiated, expect another reply before proceeding with a new command.
+    RestartMarkerReplay = 110,
+    ServiceReadyInNNNMinutes = 120,
+    DataConnectionAlreadyOpenStartingTransfer = 125,
+    FileStatusOkayOpeningDataConnection = 150,
+
+    // The requested action has been successfully completed.
+    CommandNotImplemented = 202,
+    SystemStatus = 211,
+    DirectoryStatus = 212,
+    FileStatus = 213,
+    HelpMessage = 214,
+    IANAOfficialName = 215,
+    ReadyForNewUser = 220,
+    ClosingControlConnection = 221,
+    DataConnectionOpen = 225,
+    SuccessNowClosingDataConnection = 226,
+    EnteringPassiveMode = 227,
+    EnteringLongPassiveMode = 228,
+    EnteringExtendedPassiveMode = 229,
+    UserLoggedIn = 230,
+    UserLoggedOut = 231,
+    LogoutWillCompleteWhenTransferDone = 232,
+    ServerAcceptsAuthenticationMethod = 234,
+    ActionComplete = 250,
+    PathNameCreated = 257,
+
+    // The command has been accepted, but the requested action is on hold, pending receipt of further information.
+    UsernameOkayPasswordNeeded = 331,
+    NeedAccountForLogin = 332,
+    RequestedFileActionPendingFurtherInformation = 350,
+
+
+    // The command was not accepted and the requested action did not take place, but the error condition is temporary and the action may be requested again.
+    ServiceNotAvailable = 421,
+    CantOpenDataConnection = 425,
+    ConnectionClosed = 426,
+    InvalidUsernameOrPassword = 430,
+    HostUnavailable = 434,
+    FileActionNotTaken = 450,
+    LocalErrorProcessing = 451,
+    InsufficientStorageSpaceOrFileInUse = 452,
+
+    // Syntax error, command unrecognized and the requested action did not take place. This may include errors such as command line too long.
+    SyntaxErrorInParameters = 501,
+    CommandNotImpemented = 502,
+    BadSequenceOfCommands = 503,
+    CommandNotImplementedForThatParameter = 504,
+    NotLoggedIn = 530,
+    NeedAccountForStoringFiles = 532,
+    CouldNotConnectToServerRequiresSSL = 534,
+    FileNotFoundOrNoAccess = 550,
+    UnknownPageType = 551,
+    ExceededStorageAllocation = 552,
+    FileNameNotAllowed = 553,
+
+    // Replies regarding confidentiality and integrity
+    IntegrityProtectedReply = 631,
+    ConfidentialityAndIntegrityProtectedReply = 632,
+    ConfidentialityProtectedReply = 633,
+
+
+    // Common Winsock Error Codes[2] (These are not FTP return codes)
+    ConnectionClosedByServer = 10054,
+    CannotConnect = 10060,
+    CannotConnectRefusedByServer = 10061,
+    DirectoryNotEmpty = 10066,
+    TooManyUsers = 10068,
+};

package/vendor/ftp-deploy/utilities.ts

@@ -0,0 +1,217 @@
+import prettyMilliseconds from "pretty-ms";
+import { includeDefaults, excludeDefaults } from "./module";
+import { ErrorCode, IFtpDeployArguments, IFtpDeployArgumentsWithDefaults } from "./types";
+import multimatch from "multimatch";
+
+export interface ILogger {
+    all(...data: any[]): void;
+    standard(...data: any[]): void;
+    verbose(...data: any[]): void;
+}
+
+export class Logger implements ILogger {
+    constructor(level: "minimal" | "standard" | "verbose") {
+        this.level = level;
+    }
+
+    private level: "minimal" | "standard" | "verbose";
+
+    public all(...data: any[]): void {
+        console.log(...data);
+    }
+
+    public standard(...data: any[]): void {
+        if (this.level === "minimal") { return; }
+
+        console.log(...data);
+    }
+
+    public verbose(...data: any[]): void {
+        if (this.level !== "verbose") { return; }
+
+        console.log(...data);
+    }
+}
+
+export function pluralize(count: number, singular: string, plural: string) {
+    if (count === 1) {
+        return singular;
+    }
+
+    return plural;
+}
+
+export function formatNumber(number: number): string {
+    return number.toLocaleString();
+}
+
+/**
+ * retry a request
+ * 
+ * @example retryRequest(logger, async () => await item());
+ */
+export async function retryRequest<T>(logger: ILogger, callback: () => Promise<T>): Promise<T> {
+    try {
+        return await callback();
+    }
+    catch (e: any) {
+        if (e.code >= 400 && e.code <= 499) {
+            logger.standard("400 level error from server when performing action - retrying...");
+            logger.standard(e);
+
+            if (e.code === ErrorCode.ConnectionClosed) {
+                logger.all("Connection closed. This library does not currently handle reconnects");
+                // await global.reconnect();
+                // todo reset current working dir
+                throw e;
+            }
+
+            return await callback();
+        }
+        else {
+            throw e;
+        }
+    }
+}
+
+interface ITimers {
+    [key: string]: Timer | undefined;
+}
+
+type AvailableTimers = "connecting" | "hash" | "upload" | "total" | "changingDir" | "logging";
+
+export interface ITimings {
+    start(type: AvailableTimers): void;
+    stop(type: AvailableTimers): void;
+    getTime(type: AvailableTimers): number;
+    getTimeFormatted(type: AvailableTimers): string;
+}
+
+export class Timings implements ITimings {
+    private timers: ITimers = {};
+
+    public start(type: AvailableTimers): void {
+        if (this.timers[type] === undefined) {
+            this.timers[type] = new Timer();
+        }
+
+        this.timers[type]!.start();
+    }
+
+    public stop(type: AvailableTimers): void {
+        this.timers[type]!.stop();
+    }
+
+    public getTime(type: AvailableTimers): number {
+        const timer = this.timers[type];
+        if (timer === undefined || timer.time === null) {
+            return 0;
+        }
+
+        return timer.time;
+    }
+
+    public getTimeFormatted(type: AvailableTimers): string {
+        const timer = this.timers[type];
+        if (timer === undefined || timer.time === null) {
+            return "💣 Failed";
+        }
+
+        return prettyMilliseconds(timer.time, { verbose: true });
+    }
+}
+
+/**
+ * first number is seconds
+ * second number is nanoseconds
+ */
+type HRTime = [number, number];
+
+export class Timer {
+    private totalTime: HRTime | null = null;
+    private startTime: HRTime | null = null;
+    private endTime: HRTime | null = null;
+
+    start() {
+        this.startTime = process.hrtime();
+    }
+
+    stop() {
+        if (this.startTime === null) {
+            throw new Error("Called .stop() before calling .start()");
+        }
+
+        this.endTime = process.hrtime(this.startTime);
+
+        const currentSeconds = this.totalTime === null ? 0 : this.totalTime[0];
+        const currentNS = this.totalTime === null ? 0 : this.totalTime[1];
+
+        this.totalTime = [
+            currentSeconds + this.endTime[0],
+            currentNS + this.endTime[1]
+        ];
+    }
+
+    get time() {
+        if (this.totalTime === null) {
+            return null;
+        }
+
+        return (this.totalTime[0] * 1000) + (this.totalTime[1] / 1000000);
+    }
+}
+
+export function getDefaultSettings(withoutDefaults: IFtpDeployArguments): IFtpDeployArgumentsWithDefaults {
+    if (withoutDefaults["local-dir"] !== undefined) {
+        if (!withoutDefaults["local-dir"].endsWith("/")) {
+            throw new Error("local-dir should be a folder (must end with /)");
+        }
+    }
+
+    if (withoutDefaults["server-dir"] !== undefined) {
+        if (!withoutDefaults["server-dir"].endsWith("/")) {
+            throw new Error("server-dir should be a folder (must end with /)");
+        }
+    }
+
+    const protocol = withoutDefaults.protocol ?? "ftp";
+
+    return {
+        "server": withoutDefaults.server,
+        "username": withoutDefaults.username,
+        "password": withoutDefaults.password ?? "",
+        "port": withoutDefaults.port ?? (protocol === "sftp" ? 2222 : 21),
+        "protocol": protocol,
+        "private-key-path": withoutDefaults["private-key-path"],
+        "local-dir": withoutDefaults["local-dir"] ?? "./",
+        "server-dir": withoutDefaults["server-dir"] ?? "./",
+        "state-name": withoutDefaults["state-name"] ?? ".ftp-deploy-sync-state.json",
+        "dry-run": withoutDefaults["dry-run"] ?? false,
+        "dangerous-clean-slate": withoutDefaults["dangerous-clean-slate"] ?? false,
+        "include": withoutDefaults.include ?? includeDefaults,
+        "exclude": withoutDefaults.exclude ?? excludeDefaults,
+        "log-level": withoutDefaults["log-level"] ?? "standard",
+        "security": withoutDefaults.security ?? "loose",
+        "timeout": withoutDefaults.timeout ?? 30000,
+    };
+}
+
+interface IStats {
+    path: string;
+    isDirectory(): boolean;
+}
+
+export function applyExcludeFilter(stat: IStats, excludeFilters: Readonly<string[]>): boolean {
+    // match exclude, return immediatley
+    if (excludeFilters.length > 0) {
+        // todo this could be a performance problem...
+        const pathWithFolderSlash = stat.path + (stat.isDirectory() ? "/" : "");
+        const excludeMatch = multimatch(pathWithFolderSlash, excludeFilters, { matchBase: true, dot: true });
+
+        if (excludeMatch.length > 0) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/src/commands/WhoAmICommand.ts

@@ -1,15 +0,0 @@
-import { Command } from 'commander'
-import { config } from '../lib/config'
-
-export const WhoAmICommand = () => {
-  return new Command(`whoami`)
-    .description(`Show the current user`)
-    .action(() => {
-      const email = config(`email`)
-      if (email) {
-        console.log(`Current user is: ${email}`)
-        return
-      }
-      console.log(`No user is currently logged in`)
-    })
-}

package/src/global.d.ts

@@ -1,3 +0,0 @@
-declare module '@sentool/fetch-event-source' {
-  export function fetchEventSource(url: string, options: any): void
-}