syncodemayo 1.0.8 → 2.0.0

package/index.js

@@ -1,7 +0,0 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./lib"));
-//# sourceMappingURL=index.js.map

package/lib/Cli.js

@@ -1,122 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Client_1 = require("./Client");
-function changes(configPath, target) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const client = yield Client_1.Client.create(configPath);
-        const changeset = yield client.getTargetServer(target).sync(true);
-        if (changeset == null)
-            throw new Error("Change detection failed.");
-        const added = changeset.added.length;
-        const changed = changeset.changed.length;
-        const removed = changeset.removed.length;
-        if (added + changed + removed === 0) {
-            console.log("\nNo changes detected.");
-            return true;
-        }
-        if (added > 0) {
-            console.log("\nNew Local Files: (%s)", changeset.added.length);
-            changeset.added.forEach(f => console.log(" -", f));
-        }
-        if (changed > 0) {
-            console.log("\nChanged Local Files: (%s)", changeset.changed.length);
-            changeset.changed.forEach(f => console.log(" -", f));
-        }
-        if (removed > 0) {
-            console.log(`\nRemoved Local Files${client.config.local.deleteRemoteFiles ? '' : ' (disabled)'}: (%s)`, changeset.removed.length);
-            changeset.removed.forEach(f => console.log(" -", f));
-        }
-        return true;
-    });
-}
-exports.changes = changes;
-function check(configPath, target) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const client = yield Client_1.Client.create(configPath);
-        if (client.hasError) {
-            throw client.loadError || client.parseError;
-        }
-        if (!client.hasConfig && !client.hasError) {
-            console.log("This directory isn't configured for SyncoDeMayo!");
-            return false;
-        }
-        const targetServer = client.getTargetServer(target);
-        const isServerConfigured = yield targetServer.verify();
-        if (isServerConfigured) {
-            console.log("Target", JSON.stringify(targetServer.name), "is ready for syncing.");
-        }
-        else {
-            console.log("Target", JSON.stringify(targetServer.name), "isn't configured, run init.");
-            return false;
-        }
-        return true;
-    });
-}
-exports.check = check;
-function init(configPath, target) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const client = yield Client_1.Client.create(configPath);
-        if (!client.hasConfig && client.hasError) {
-            throw client.loadError || client.parseError;
-        }
-        if (!client.hasConfig) {
-            yield client.createConfig(configPath);
-            console.log("Created local config at", configPath);
-            return true;
-        }
-        const targetServer = client.getTargetServer(target);
-        const isServerConfigured = yield targetServer.verify();
-        if (!isServerConfigured) {
-            yield targetServer.prepare();
-            console.log("Created", targetServer.config.cache, "on server target", targetServer.config._name);
-            return true;
-        }
-        console.log("Everything seems to be configured correctly.");
-        return false;
-    });
-}
-exports.init = init;
-function ls(configPath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const client = yield Client_1.Client.create(configPath);
-        const targets = yield client.getTargetNames();
-        console.log("Defined server targets:");
-        targets.forEach(name => {
-            const target = client.config.targets[name];
-            const bullet = client.config.local.defaultTarget === target._name
-                ? " *"
-                : " -";
-            console.log(bullet, name, `\t(${target.user}@${target.host}:${target.path})`);
-        });
-        return true;
-    });
-}
-exports.ls = ls;
-function sync(configPath, target, forceConfirmation = false) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const client = yield Client_1.Client.create(configPath);
-        if (!client.hasConfig) {
-            if (client.hasError)
-                throw client.loadError || client.parseError;
-            else
-                throw new Error("This directory isn't configured for SyncoDeMayo!");
-        }
-        const changes = yield client.getTargetServer(target).sync(false, forceConfirmation);
-        if (changes != null) {
-            console.log("\nSummary:");
-            console.log("- %s files uploaded.", changes.added.length + changes.changed.length);
-            console.log(`- %s files removed. ${client.config.local.deleteRemoteFiles ? '' : '(disabled)'}`, changes.removed.length);
-        }
-        return true;
-    });
-}
-exports.sync = sync;
-//# sourceMappingURL=Cli.js.map

package/lib/Client.js

@@ -1,81 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const Config_1 = require("./Config");
-const TargetServer_1 = require("./TargetServer");
-const ConfigSchema_1 = require("./ConfigSchema");
-const Filelist_1 = require("./Filelist");
-class Client {
-    constructor(preferredPath) {
-        this.hasConfig = null;
-        this.DEFAULT_CONFIG = "syncodemayo.json";
-        this._path = preferredPath;
-        this.whenReady = new Promise((resolve) => {
-            Config_1.loadConfigFile(preferredPath)
-                .then((config) => {
-                this.config = config;
-                this._path = this.config._path;
-                this.hasConfig = true;
-                resolve(this);
-            })
-                .catch((err) => {
-                if (err.message.indexOf('Schema Error'))
-                    this.loadError = err;
-                if (err.message.indexOf('JSON'))
-                    this.parseError = err;
-                this.hasConfig = false;
-                resolve(this);
-            });
-        });
-    }
-    get hasError() {
-        return !!this.loadError || !!this.parseError;
-    }
-    createConfig(preferredPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const path = path_1.resolve(preferredPath || this._path || this.DEFAULT_CONFIG);
-            const alreadyExists = yield Filelist_1.localFileExists(path);
-            if (alreadyExists) {
-                throw new Error("Config already exists at " + path);
-            }
-            Filelist_1.writeLocalFile(path, JSON.stringify(ConfigSchema_1.DefaultConfig, null, 2));
-            return true;
-        });
-    }
-    getTargetNames() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasConfig === null)
-                throw new Error("Config not loaded yet.");
-            if (this.hasConfig === false) {
-                if (this.hasError) {
-                    const error = this.loadError || this.parseError;
-                    throw error;
-                }
-                else {
-                    throw new Error("This directory has no SyncoDeMayo config.");
-                }
-            }
-            return Object.keys(this.config.targets).filter(name => this.config.targets[name].enabled);
-        });
-    }
-    getTargetConfig(name) {
-        return Config_1.resolveTarget(this.config, name);
-    }
-    getTargetServer(name) {
-        return TargetServer_1.TargetServer.create(this.config, name);
-    }
-    static create(configPath) {
-        const client = new Client(configPath);
-        return client.whenReady;
-    }
-}
-exports.Client = Client;
-//# sourceMappingURL=Client.js.map

package/lib/Config.d.ts

@@ -1,32 +0,0 @@
-export interface IConfig {
-    local: ILocalConfig;
-    targets: {
-        [name: string]: ITargetConfig;
-    };
-    _path?: string;
-}
-export interface ILocalConfig {
-    path: string;
-    files: string;
-    exclude: string[];
-    defaultTarget: string;
-    deleteRemoteFiles: boolean;
-}
-export interface ITargetConfig {
-    host: string;
-    user: string;
-    pass?: string;
-    path: string;
-    port: number;
-    cache: string;
-    prompt?: boolean | string;
-    _name: string;
-    enabled?: boolean;
-    type?: string;
-}
-/**
- * Sending nulll as the preferred path will result in scan for the config
- */
-export declare function loadConfigFile(preferredPath?: string): Promise<IConfig>;
-export declare function resolvePassword(targetConfig: ITargetConfig): string;
-export declare function resolveTarget(config: IConfig, name: string | ITargetConfig | undefined): ITargetConfig;

package/lib/Config.js

@@ -1,115 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const ConfigSchema_1 = require("./ConfigSchema");
-const Filelist_1 = require("./Filelist");
-const stripJsonComments = require("strip-json-comments");
-function evalConfigFromFile(pathname) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof pathname !== 'string')
-            throw new Error(`Path must be a string. Got a ${typeof pathname}`);
-        const fullpath = path_1.resolve("./" + pathname);
-        if (!Filelist_1.localFileExists(fullpath))
-            throw new Error("SKIP");
-        const source = yield Filelist_1.readLocalFile(fullpath, false);
-        const data = JSON.parse(stripJsonComments(source));
-        // const data = require(fullpath) as IConfig
-        if (typeof data === 'object')
-            data._path = fullpath;
-        return data;
-    });
-}
-/**
- * Sending nulll as the preferred path will result in scan for the config
- */
-function loadConfigFile(preferredPath) {
-    const loadingPromise = new Promise((resolve, reject) => {
-        const potentialConfigs = (!!preferredPath)
-            ? [preferredPath]
-            : [
-                'syncodemayo.json',
-                '.syncodemayo.json',
-                'syncodemayo.js',
-                '.syncodemayo.js',
-                '.syncodemayo',
-                'sync-config.json',
-                'sync-config.js',
-                '.sync-config',
-            ];
-        const tryLoading = (path) => {
-            // console.log("Trying to load config:", path)
-            if (!!path) {
-                evalConfigFromFile(path)
-                    .then(resolve)
-                    .catch(err => {
-                    if (err.message === "SKIP")
-                        tryLoading(potentialConfigs.shift());
-                    else
-                        reject(err);
-                });
-            }
-            else {
-                reject(new Error("Local config not found."));
-            }
-        };
-        // Kick off config loading...
-        tryLoading(potentialConfigs.shift());
-    });
-    return loadingPromise
-        .then(ConfigSchema_1.validateConfig)
-        .then(massageConfigData);
-}
-exports.loadConfigFile = loadConfigFile;
-function massageConfigData(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        config.local.files = config.local.files || '**/**';
-        config.local.exclude = config.local.exclude || [];
-        config.local.defaultTarget = config.local.defaultTarget || "staging";
-        config.local.deleteRemoteFiles = config.local.deleteRemoteFiles === true;
-        Object.keys(config.targets).forEach(name => {
-            const target = config.targets[name];
-            target._name = name;
-            target.port = target.port || 21;
-            target.cache = target.cache || ".synco-filelist";
-            target.enabled = target.enabled !== false;
-            target.type = target.type || 'ftp'; // Will support more eventually
-            if (typeof target.prompt === 'undefined')
-                target.prompt = true;
-        });
-        return config;
-    });
-}
-function resolvePassword(targetConfig) {
-    const password = targetConfig.pass || process.env[`${targetConfig._name.toUpperCase()}_PWD`];
-    if (typeof password === 'undefined') {
-        throw new Error("Cannot find password for target: " + targetConfig._name);
-    }
-    return password;
-}
-exports.resolvePassword = resolvePassword;
-function resolveTarget(config, name) {
-    if (typeof name === 'undefined')
-        name = config.local.defaultTarget;
-    if (typeof name === 'object')
-        return name;
-    const lookingFor = name;
-    const targetName = Object.keys(config.targets).find(namedTarget => (lookingFor.toUpperCase() === config.targets[namedTarget]._name.toUpperCase()));
-    if (!targetName) {
-        throw new Error("Target '" + name + "' not found.");
-    }
-    const target = config.targets[targetName];
-    if (!target.enabled) {
-        throw new Error("Target '" + name + "' not enabled.");
-    }
-    return target;
-}
-exports.resolveTarget = resolveTarget;
-//# sourceMappingURL=Config.js.map

package/lib/ConfigSchema.d.ts

@@ -1,7 +0,0 @@
-import { IConfig } from './Config';
-import * as joi from 'joi';
-export declare const localSchema: joi.ObjectSchema;
-export declare const targetSchema: joi.ObjectSchema;
-export declare const configSchema: joi.ObjectSchema;
-export declare function validateConfig(config: IConfig): Promise<IConfig>;
-export declare const DefaultConfig: any;

package/lib/ConfigSchema.js

@@ -1,65 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const joi = require("joi");
-exports.localSchema = joi.object({
-    path: joi.string().required(),
-    files: joi.string(),
-    exclude: joi.array().items(joi.string()),
-    defaultTarget: joi.string(),
-    deleteRemoteFiles: joi.bool(),
-});
-exports.targetSchema = joi.object({
-    host: joi.string().required(),
-    user: joi.string().required(),
-    path: joi.string().required(),
-    pass: joi.string(),
-    port: joi.number(),
-    cache: joi.string(),
-    prompt: joi.alternatives([joi.bool(), joi.string()]),
-    enabled: joi.bool(),
-    // For future use...
-    type: joi.string(),
-});
-exports.configSchema = joi.object({
-    local: exports.localSchema.required(),
-    targets: joi.object().pattern(/.*/, exports.targetSchema).required()
-}).unknown(true);
-function validateConfig(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = exports.configSchema.validate(config);
-        if (!!result.error)
-            throw new Error("Config Schema Error: " + result.error.message);
-        return config;
-    });
-}
-exports.validateConfig = validateConfig;
-exports.DefaultConfig = {
-    local: {
-        path: "public",
-        files: "**/**",
-        exclude: ["**/*.map", "**/.DS_Store", "**/.git*"],
-        defaultTarget: "staging"
-    },
-    targets: {
-        staging: {
-            path: "Example/www/stage",
-            host: "www.example.com",
-            user: "USERNAME"
-        },
-        production: {
-            path: "Example/www",
-            host: "www.example.com",
-            user: "USERNAME",
-            prompt: "This will upload to PRODUCTION! Are you sure?"
-        }
-    }
-};
-//# sourceMappingURL=ConfigSchema.js.map

package/lib/Connection.d.ts

@@ -1,14 +0,0 @@
-import { ITargetConfig } from './Config';
-export declare class Connection {
-    private _ftpConn;
-    constructor(host: string, port: number, user: string, pass: string);
-    getRemoteFile(filename: string): Promise<string>;
-    remoteDirectoryExists(pathname: string): Promise<boolean>;
-    remoteFileExists(remotePath: string): Promise<boolean>;
-    putBuffer(buff: any, remotePath: string): Promise<boolean>;
-    putContent(content: string, remotePath: string): Promise<boolean>;
-    putFile(filename: string, remotePath: string): Promise<string>;
-    deleteRemoteFile(remotePath: string): Promise<boolean>;
-    close(): void;
-    static create(target: ITargetConfig): Connection;
-}

package/lib/Connection.js

@@ -1,111 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const JsFtp = require("jsftp");
-const JsFtpMkDirP = require("jsftp-mkdirp");
-const Config_1 = require("./Config");
-const Filelist_1 = require("./Filelist");
-const Ftp = JsFtpMkDirP(JsFtp);
-/*
-  TODO: Extract FTP from the connection to allow other connection types.. File/SFTP/S3/whatever
-*/
-// interface IRemoteConnection {
-//   get(filepath): Promise<string>
-//   put(filepath): Promise<boolean>
-// }
-class Connection {
-    constructor(host, port, user, pass) {
-        // log("Connecting to FTP:", { host, port, user, pass: `(${pass.length} chars)` })
-        this._ftpConn = new Ftp({ host, port, user, pass });
-        process.on('beforeExit', () => {
-            this.close(); // Ensure all connections are close when the app exits
-        });
-    }
-    getRemoteFile(filename) {
-        return new Promise((resolve, reject) => {
-            let content = "";
-            console.log(" <-", filename);
-            this._ftpConn.get(filename, function (err, socket) {
-                if (err != null) {
-                    return reject(err);
-                }
-                socket.on("data", (d) => content += d.toString());
-                socket.on('error', (err) => {
-                    console.log("Retrieval error.");
-                    reject(err);
-                });
-                socket.on("close", (connErr) => {
-                    if (connErr)
-                        reject(connErr);
-                    else
-                        resolve(content);
-                });
-                socket.resume();
-            });
-        });
-    }
-    remoteDirectoryExists(pathname) {
-        return new Promise((resolve, reject) => {
-            this._ftpConn.mkdirp(pathname, (err) => resolve(!err));
-        });
-    }
-    remoteFileExists(remotePath) {
-        return new Promise((resolve, reject) => {
-            this._ftpConn.raw.size(remotePath, (err, size) => resolve(!err));
-        });
-    }
-    putBuffer(buff, remotePath) {
-        return new Promise((resolve, reject) => {
-            console.log(" ->", remotePath);
-            this._ftpConn.put(buff, remotePath, (err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(true);
-            });
-        });
-    }
-    putContent(content, remotePath) {
-        return this.putBuffer(new Buffer(content), remotePath);
-    }
-    putFile(filename, remotePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const buffer = yield Filelist_1.readLocalFile(filename, true);
-            yield this.putBuffer(buffer, remotePath);
-            return remotePath;
-        });
-    }
-    deleteRemoteFile(remotePath) {
-        return new Promise((resolve, reject) => {
-            console.log("  x", remotePath);
-            this._ftpConn.raw('dele', remotePath, function (err, data) {
-                if (err)
-                    console.log("Error removing", remotePath, err.message);
-                if (err)
-                    resolve(false);
-                else
-                    resolve(true);
-            });
-        });
-    }
-    close() {
-        const conn = this._ftpConn;
-        conn && conn.raw && conn.raw.quit && conn.raw.quit((err, data) => {
-            if (err != null)
-                console.error(err);
-        });
-    }
-    static create(target) {
-        const pass = Config_1.resolvePassword(target);
-        return new Connection(target.host, target.port, target.user, pass);
-    }
-}
-exports.Connection = Connection;
-//# sourceMappingURL=Connection.js.map

package/lib/Filelist.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" />
-import { ILocalConfig, ITargetConfig } from './Config';
-import { Connection } from './Connection';
-export interface IFilelist {
-    [filename: string]: number;
-}
-export declare function localFileExists(path: string): Promise<boolean>;
-export declare function readLocalFile(path: string, asBuffer?: boolean): Promise<string | Buffer>;
-export declare function writeLocalFile(path: string, content: string): Promise<any>;
-export declare function getRemoteFilelist(target: ITargetConfig, conn: Connection): Promise<IFilelist>;
-export declare function buildLocalFilelist(config: ILocalConfig): Promise<IFilelist>;

package/lib/Filelist.js

@@ -1,59 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const glob = require("glob");
-const minimatch = require("minimatch");
-const crc = require("crc");
-const fs = require("fs");
-function localFileExists(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fs.existsSync(path);
-    });
-}
-exports.localFileExists = localFileExists;
-function readLocalFile(path, asBuffer = false) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const buff = fs.readFileSync(path);
-        return asBuffer ? buff : buff.toString();
-    });
-}
-exports.readLocalFile = readLocalFile;
-function writeLocalFile(path, content) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fs.writeFileSync(path, content);
-    });
-}
-exports.writeLocalFile = writeLocalFile;
-function getRemoteFilelist(target, conn) {
-    const path = `${target.path}/${target.cache}`;
-    // console.log(" <-", path)
-    return conn.getRemoteFile(path)
-        .then(JSON.parse)
-        .catch((err) => {
-        console.log("Missing or error parsing remote file list.", err);
-        console.log("\n   Run sync:init to setup SyncoDeMayo on the server.\n");
-        process.exit(1);
-    });
-}
-exports.getRemoteFilelist = getRemoteFilelist;
-function buildLocalFilelist(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Create the CRCs...
-        const excludeDirectories = (path) => !fs.statSync(path).isDirectory();
-        const excludeBlacklistedFiles = (path) => !config.exclude.some(pattern => minimatch(path, pattern, { dot: true }));
-        return glob
-            .sync(`${config.path}/${config.files}`)
-            .filter(excludeDirectories)
-            .filter(excludeBlacklistedFiles)
-            .reduce((hash, filepath) => (hash[filepath] = crc.crc32(fs.readFileSync(filepath)), hash), {});
-    });
-}
-exports.buildLocalFilelist = buildLocalFilelist;
-//# sourceMappingURL=Filelist.js.map

package/lib/Sync.d.ts

@@ -1,18 +0,0 @@
-import { IConfig, ITargetConfig } from './Config';
-import { Connection } from './Connection';
-export interface IChangeset {
-    added: string[];
-    changed: string[];
-    removed: string[];
-}
-export declare class Sync {
-    private _conn;
-    private _config;
-    private _target;
-    constructor(conn: Connection, config: IConfig, target: string | ITargetConfig);
-    run(isDryRun?: boolean, forceConfirmation?: boolean): Promise<IChangeset | null>;
-    private _confirmUpload(target, fileCount);
-    private _getFilelists(local, target, conn);
-    private _buildChangeset(localFiles, remoteFiles);
-    static create(conn: Connection, config: IConfig, target: string | ITargetConfig): Sync;
-}