conductor-oss 0.3.4 → 0.4.0

package/web/.next/standalone/node_modules/basic-ftp/dist/parseControlResponse.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseControlResponse = parseControlResponse;
+exports.isSingleLine = isSingleLine;
+exports.isMultiline = isMultiline;
+exports.positiveCompletion = positiveCompletion;
+exports.positiveIntermediate = positiveIntermediate;
+const LF = "\n";
+/**
+ * Parse an FTP control response as a collection of messages. A message is a complete
+ * single- or multiline response. A response can also contain multiple multiline responses
+ * that will each be represented by a message. A response can also be incomplete
+ * and be completed on the next incoming data chunk for which case this function also
+ * describes a `rest`. This function converts all CRLF to LF.
+ */
+function parseControlResponse(text) {
+    const lines = text.split(/\r?\n/).filter(isNotBlank);
+    const messages = [];
+    let startAt = 0;
+    let tokenRegex;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // No group has been opened.
+        if (!tokenRegex) {
+            if (isMultiline(line)) {
+                // Open a group by setting an expected token.
+                const token = line.substr(0, 3);
+                tokenRegex = new RegExp(`^${token}(?:$| )`);
+                startAt = i;
+            }
+            else if (isSingleLine(line)) {
+                // Single lines can be grouped immediately.
+                messages.push(line);
+            }
+        }
+        // Group has been opened, expect closing token.
+        else if (tokenRegex.test(line)) {
+            tokenRegex = undefined;
+            messages.push(lines.slice(startAt, i + 1).join(LF));
+        }
+    }
+    // The last group might not have been closed, report it as a rest.
+    const rest = tokenRegex ? lines.slice(startAt).join(LF) + LF : "";
+    return { messages, rest };
+}
+function isSingleLine(line) {
+    return /^\d\d\d(?:$| )/.test(line);
+}
+function isMultiline(line) {
+    return /^\d\d\d-/.test(line);
+}
+/**
+ * Return true if an FTP return code describes a positive completion.
+ */
+function positiveCompletion(code) {
+    return code >= 200 && code < 300;
+}
+/**
+ * Return true if an FTP return code describes a positive intermediate response.
+ */
+function positiveIntermediate(code) {
+    return code >= 300 && code < 400;
+}
+function isNotBlank(str) {
+    return str.trim() !== "";
+}

package/web/.next/standalone/node_modules/basic-ftp/dist/parseList.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseList = parseList;
+const dosParser = __importStar(require("./parseListDOS"));
+const unixParser = __importStar(require("./parseListUnix"));
+const mlsdParser = __importStar(require("./parseListMLSD"));
+/**
+ * Available directory listing parsers. These are candidates that will be tested
+ * in the order presented. The first candidate will be used to parse the whole list.
+ */
+const availableParsers = [
+    dosParser,
+    unixParser,
+    mlsdParser // Keep MLSD last, may accept filename only
+];
+function firstCompatibleParser(line, parsers) {
+    return parsers.find(parser => parser.testLine(line) === true);
+}
+function isNotBlank(str) {
+    return str.trim() !== "";
+}
+function isNotMeta(str) {
+    return !str.startsWith("total");
+}
+const REGEX_NEWLINE = /\r?\n/;
+/**
+ * Parse raw directory listing.
+ */
+function parseList(rawList) {
+    const lines = rawList
+        .split(REGEX_NEWLINE)
+        .filter(isNotBlank)
+        .filter(isNotMeta);
+    if (lines.length === 0) {
+        return [];
+    }
+    const testLine = lines[lines.length - 1];
+    const parser = firstCompatibleParser(testLine, availableParsers);
+    if (!parser) {
+        throw new Error("This library only supports MLSD, Unix- or DOS-style directory listing. Your FTP server seems to be using another format. You can see the transmitted listing when setting `client.ftp.verbose = true`. You can then provide a custom parser to `client.parseList`, see the documentation for details.");
+    }
+    const files = lines
+        .map(parser.parseLine)
+        .filter((info) => info !== undefined);
+    return parser.transformList(files);
+}

package/web/.next/standalone/node_modules/basic-ftp/dist/parseListDOS.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testLine = testLine;
+exports.parseLine = parseLine;
+exports.transformList = transformList;
+const FileInfo_1 = require("./FileInfo");
+/**
+ * This parser is based on the FTP client library source code in Apache Commons Net provided
+ * under the Apache 2.0 license. It has been simplified and rewritten to better fit the Javascript language.
+ *
+ * https://github.com/apache/commons-net/blob/master/src/main/java/org/apache/commons/net/ftp/parser/NTFTPEntryParser.java
+ */
+const RE_LINE = new RegExp("(\\S+)\\s+(\\S+)\\s+" // MM-dd-yy whitespace hh:mma|kk:mm swallow trailing spaces
+    + "(?:(<DIR>)|([0-9]+))\\s+" // <DIR> or ddddd swallow trailing spaces
+    + "(\\S.*)" // First non-space followed by rest of line (name)
+);
+/**
+ * Returns true if a given line might be a DOS-style listing.
+ *
+ * - Example: `12-05-96  05:03PM       <DIR>          myDir`
+ */
+function testLine(line) {
+    return /^\d{2}/.test(line) && RE_LINE.test(line);
+}
+/**
+ * Parse a single line of a DOS-style directory listing.
+ */
+function parseLine(line) {
+    const groups = line.match(RE_LINE);
+    if (groups === null) {
+        return undefined;
+    }
+    const name = groups[5];
+    if (name === "." || name === "..") { // Ignore parent directory links
+        return undefined;
+    }
+    const file = new FileInfo_1.FileInfo(name);
+    const fileType = groups[3];
+    if (fileType === "<DIR>") {
+        file.type = FileInfo_1.FileType.Directory;
+        file.size = 0;
+    }
+    else {
+        file.type = FileInfo_1.FileType.File;
+        file.size = parseInt(groups[4], 10);
+    }
+    file.rawModifiedAt = groups[1] + " " + groups[2];
+    return file;
+}
+function transformList(files) {
+    return files;
+}

package/web/.next/standalone/node_modules/basic-ftp/dist/parseListMLSD.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testLine = testLine;
+exports.parseLine = parseLine;
+exports.transformList = transformList;
+exports.parseMLSxDate = parseMLSxDate;
+const FileInfo_1 = require("./FileInfo");
+function parseSize(value, info) {
+    info.size = parseInt(value, 10);
+}
+/**
+ * Parsers for MLSD facts.
+ */
+const factHandlersByName = {
+    "size": parseSize, // File size
+    "sizd": parseSize, // Directory size
+    "unique": (value, info) => {
+        info.uniqueID = value;
+    },
+    "modify": (value, info) => {
+        info.modifiedAt = parseMLSxDate(value);
+        info.rawModifiedAt = info.modifiedAt.toISOString();
+    },
+    "type": (value, info) => {
+        // There seems to be confusion on how to handle symbolic links for Unix. RFC 3659 doesn't describe
+        // this but mentions some examples using the syntax `type=OS.unix=slink:<target>`. But according to
+        // an entry in the Errata (https://www.rfc-editor.org/errata/eid1500) this syntax can't be valid.
+        // Instead it proposes to use `type=OS.unix=symlink` and to then list the actual target of the
+        // symbolic link as another entry in the directory listing. The unique identifiers can then be used
+        // to derive the connection between link(s) and target. We'll have to handle both cases as there
+        // are differing opinions on how to deal with this. Here are some links on this topic:
+        // - ProFTPD source: https://github.com/proftpd/proftpd/blob/56e6dfa598cbd4ef5c6cba439bcbcd53a63e3b21/modules/mod_facts.c#L531
+        // - ProFTPD bug: http://bugs.proftpd.org/show_bug.cgi?id=3318
+        // - ProFTPD statement: http://www.proftpd.org/docs/modules/mod_facts.html
+        // – FileZilla bug: https://trac.filezilla-project.org/ticket/9310
+        if (value.startsWith("OS.unix=slink")) {
+            info.type = FileInfo_1.FileType.SymbolicLink;
+            info.link = value.substr(value.indexOf(":") + 1);
+            return 1 /* FactHandlerResult.Continue */;
+        }
+        switch (value) {
+            case "file":
+                info.type = FileInfo_1.FileType.File;
+                break;
+            case "dir":
+                info.type = FileInfo_1.FileType.Directory;
+                break;
+            case "OS.unix=symlink":
+                info.type = FileInfo_1.FileType.SymbolicLink;
+                // The target of the symbolic link might be defined in another line in the directory listing.
+                // We'll handle this in `transformList()` below.
+                break;
+            case "cdir": // Current directory being listed
+            case "pdir": // Parent directory
+                return 2 /* FactHandlerResult.IgnoreFile */; // Don't include these entries in the listing
+            default:
+                info.type = FileInfo_1.FileType.Unknown;
+        }
+        return 1 /* FactHandlerResult.Continue */;
+    },
+    "unix.mode": (value, info) => {
+        const digits = value.substr(-3);
+        info.permissions = {
+            user: parseInt(digits[0], 10),
+            group: parseInt(digits[1], 10),
+            world: parseInt(digits[2], 10)
+        };
+    },
+    "unix.ownername": (value, info) => {
+        info.user = value;
+    },
+    "unix.owner": (value, info) => {
+        if (info.user === undefined)
+            info.user = value;
+    },
+    get "unix.uid"() {
+        return this["unix.owner"];
+    },
+    "unix.groupname": (value, info) => {
+        info.group = value;
+    },
+    "unix.group": (value, info) => {
+        if (info.group === undefined)
+            info.group = value;
+    },
+    get "unix.gid"() {
+        return this["unix.group"];
+    }
+    // Regarding the fact "perm":
+    // We don't handle permission information stored in "perm" because its information is conceptually
+    // different from what users of FTP clients usually associate with "permissions". Those that have
+    // some expectations (and probably want to edit them with a SITE command) often unknowingly expect
+    // the Unix permission system. The information passed by "perm" describes what FTP commands can be
+    // executed with a file/directory. But even this can be either incomplete or just meant as a "guide"
+    // as the spec mentions. From https://tools.ietf.org/html/rfc3659#section-7.5.5: "The permissions are
+    // described here as they apply to FTP commands. They may not map easily into particular permissions
+    // available on the server's operating system." The parser by Apache Commons tries to translate these
+    // to Unix permissions – this is misleading users and might not even be correct.
+};
+/**
+ * Split a string once at the first position of a delimiter. For example
+ * `splitStringOnce("a b c d", " ")` returns `["a", "b c d"]`.
+ */
+function splitStringOnce(str, delimiter) {
+    const pos = str.indexOf(delimiter);
+    const a = str.substr(0, pos);
+    const b = str.substr(pos + delimiter.length);
+    return [a, b];
+}
+/**
+ * Returns true if a given line might be part of an MLSD listing.
+ *
+ * - Example 1: `size=15227;type=dir;perm=el;modify=20190419065730; test one`
+ * - Example 2: ` file name` (leading space)
+ */
+function testLine(line) {
+    return /^\S+=\S+;/.test(line) || line.startsWith(" ");
+}
+/**
+ * Parse single line as MLSD listing, see specification at https://tools.ietf.org/html/rfc3659#section-7.
+ */
+function parseLine(line) {
+    const [packedFacts, name] = splitStringOnce(line, " ");
+    if (name === "" || name === "." || name === "..") {
+        return undefined;
+    }
+    const info = new FileInfo_1.FileInfo(name);
+    const facts = packedFacts.split(";");
+    for (const fact of facts) {
+        const [factName, factValue] = splitStringOnce(fact, "=");
+        if (!factValue) {
+            continue;
+        }
+        const factHandler = factHandlersByName[factName.toLowerCase()];
+        if (!factHandler) {
+            continue;
+        }
+        const result = factHandler(factValue, info);
+        if (result === 2 /* FactHandlerResult.IgnoreFile */) {
+            return undefined;
+        }
+    }
+    return info;
+}
+function transformList(files) {
+    // Create a map of all files that are not symbolic links by their unique ID
+    const nonLinksByID = new Map();
+    for (const file of files) {
+        if (!file.isSymbolicLink && file.uniqueID !== undefined) {
+            nonLinksByID.set(file.uniqueID, file);
+        }
+    }
+    const resolvedFiles = [];
+    for (const file of files) {
+        // Try to associate unresolved symbolic links with a target file/directory.
+        if (file.isSymbolicLink && file.uniqueID !== undefined && file.link === undefined) {
+            const target = nonLinksByID.get(file.uniqueID);
+            if (target !== undefined) {
+                file.link = target.name;
+            }
+        }
+        // The target of a symbolic link is listed as an entry in the directory listing but might
+        // have a path pointing outside of this directory. In that case we don't want this entry
+        // to be part of the listing. We generally don't want these kind of entries at all.
+        const isPartOfDirectory = !file.name.includes("/");
+        if (isPartOfDirectory) {
+            resolvedFiles.push(file);
+        }
+    }
+    return resolvedFiles;
+}
+/**
+ * Parse date as specified in https://tools.ietf.org/html/rfc3659#section-2.3.
+ *
+ * Message contains response code and modified time in the format: YYYYMMDDHHMMSS[.sss]
+ * For example `19991005213102` or `19980615100045.014`.
+ */
+function parseMLSxDate(fact) {
+    return new Date(Date.UTC(+fact.slice(0, 4), // Year
+    +fact.slice(4, 6) - 1, // Month
+    +fact.slice(6, 8), // Date
+    +fact.slice(8, 10), // Hours
+    +fact.slice(10, 12), // Minutes
+    +fact.slice(12, 14), // Seconds
+    +fact.slice(15, 18) // Milliseconds
+    ));
+}

package/web/.next/standalone/node_modules/basic-ftp/dist/parseListUnix.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testLine = testLine;
+exports.parseLine = parseLine;
+exports.transformList = transformList;
+const FileInfo_1 = require("./FileInfo");
+const JA_MONTH = "\u6708";
+const JA_DAY = "\u65e5";
+const JA_YEAR = "\u5e74";
+/**
+ * This parser is based on the FTP client library source code in Apache Commons Net provided
+ * under the Apache 2.0 license. It has been simplified and rewritten to better fit the Javascript language.
+ *
+ * https://github.com/apache/commons-net/blob/master/src/main/java/org/apache/commons/net/ftp/parser/UnixFTPEntryParser.java
+ *
+ * Below is the regular expression used by this parser.
+ *
+ * Permissions:
+ *    r   the file is readable
+ *    w   the file is writable
+ *    x   the file is executable
+ *    -   the indicated permission is not granted
+ *    L   mandatory locking occurs during access (the set-group-ID bit is
+ *        on and the group execution bit is off)
+ *    s   the set-user-ID or set-group-ID bit is on, and the corresponding
+ *        user or group execution bit is also on
+ *    S   undefined bit-state (the set-user-ID bit is on and the user
+ *        execution bit is off)
+ *    t   the 1000 (octal) bit, or sticky bit, is on [see chmod(1)], and
+ *        execution is on
+ *    T   the 1000 bit is turned on, and execution is off (undefined bit-
+ *        state)
+ *    e   z/OS external link bit
+ *    Final letter may be appended:
+ *    +   file has extended security attributes (e.g. ACL)
+ *    Note: local listings on MacOSX also use '@'
+ *    this is not allowed for here as does not appear to be shown by FTP servers
+ *    {@code @}   file has extended attributes
+ */
+const RE_LINE = new RegExp("([bcdelfmpSs-])" // file type
+    + "(((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]?)))\\+?" // permissions
+    + "\\s*" // separator TODO why allow it to be omitted??
+    + "(\\d+)" // link count
+    + "\\s+" // separator
+    + "(?:(\\S+(?:\\s\\S+)*?)\\s+)?" // owner name (optional spaces)
+    + "(?:(\\S+(?:\\s\\S+)*)\\s+)?" // group name (optional spaces)
+    + "(\\d+(?:,\\s*\\d+)?)" // size or n,m
+    + "\\s+" // separator
+    /**
+     * numeric or standard format date:
+     *   yyyy-mm-dd (expecting hh:mm to follow)
+     *   MMM [d]d
+     *   [d]d MMM
+     *   N.B. use non-space for MMM to allow for languages such as German which use
+     *   diacritics (e.g. umlaut) in some abbreviations.
+     *   Japanese uses numeric day and month with suffixes to distinguish them
+     *   [d]dXX [d]dZZ
+     */
+    + "(" +
+    "(?:\\d+[-/]\\d+[-/]\\d+)" + // yyyy-mm-dd
+    "|(?:\\S{3}\\s+\\d{1,2})" + // MMM [d]d
+    "|(?:\\d{1,2}\\s+\\S{3})" + // [d]d MMM
+    "|(?:\\d{1,2}" + JA_MONTH + "\\s+\\d{1,2}" + JA_DAY + ")" +
+    ")"
+    + "\\s+" // separator
+    /**
+     * year (for non-recent standard format) - yyyy
+     * or time (for numeric or recent standard format) [h]h:mm
+     * or Japanese year - yyyyXX
+     */
+    + "((?:\\d+(?::\\d+)?)|(?:\\d{4}" + JA_YEAR + "))" // (20)
+    + "\\s" // separator
+    + "(.*)"); // the rest (21)
+/**
+ * Returns true if a given line might be a Unix-style listing.
+ *
+ * - Example: `-rw-r--r--+   1 patrick  staff   1057 Dec 11 14:35 test.txt`
+ */
+function testLine(line) {
+    return RE_LINE.test(line);
+}
+/**
+ * Parse a single line of a Unix-style directory listing.
+ */
+function parseLine(line) {
+    const groups = line.match(RE_LINE);
+    if (groups === null) {
+        return undefined;
+    }
+    const name = groups[21];
+    if (name === "." || name === "..") { // Ignore parent directory links
+        return undefined;
+    }
+    const file = new FileInfo_1.FileInfo(name);
+    file.size = parseInt(groups[18], 10);
+    file.user = groups[16];
+    file.group = groups[17];
+    file.hardLinkCount = parseInt(groups[15], 10);
+    file.rawModifiedAt = groups[19] + " " + groups[20];
+    file.permissions = {
+        user: parseMode(groups[4], groups[5], groups[6]),
+        group: parseMode(groups[8], groups[9], groups[10]),
+        world: parseMode(groups[12], groups[13], groups[14]),
+    };
+    // Set file type
+    switch (groups[1].charAt(0)) {
+        case "d":
+            file.type = FileInfo_1.FileType.Directory;
+            break;
+        case "e": // NET-39 => z/OS external link
+            file.type = FileInfo_1.FileType.SymbolicLink;
+            break;
+        case "l":
+            file.type = FileInfo_1.FileType.SymbolicLink;
+            break;
+        case "b":
+        case "c":
+            file.type = FileInfo_1.FileType.File; // TODO change this if DEVICE_TYPE implemented
+            break;
+        case "f":
+        case "-":
+            file.type = FileInfo_1.FileType.File;
+            break;
+        default:
+            // A 'whiteout' file is an ARTIFICIAL entry in any of several types of
+            // 'translucent' filesystems, of which a 'union' filesystem is one.
+            file.type = FileInfo_1.FileType.Unknown;
+    }
+    // Separate out the link name for symbolic links
+    if (file.isSymbolicLink) {
+        const end = name.indexOf(" -> ");
+        if (end !== -1) {
+            file.name = name.substring(0, end);
+            file.link = name.substring(end + 4);
+        }
+    }
+    return file;
+}
+function transformList(files) {
+    return files;
+}
+function parseMode(r, w, x) {
+    let value = 0;
+    if (r !== "-") {
+        value += FileInfo_1.FileInfo.UnixPermission.Read;
+    }
+    if (w !== "-") {
+        value += FileInfo_1.FileInfo.UnixPermission.Write;
+    }
+    const execToken = x.charAt(0);
+    if (execToken !== "-" && execToken.toUpperCase() !== execToken) {
+        value += FileInfo_1.FileInfo.UnixPermission.Execute;
+    }
+    return value;
+}