terminus-cloud-settings-sync-plus 0.0.0-stage → 1.0.1

package/dist/src/data/s3-data.d.ts

@@ -0,0 +1,15 @@
+declare const AmazonData: {
+    regions: {
+        text: string;
+        value: string;
+    }[];
+    wasabi: {
+        text: string;
+        value: string;
+    }[];
+    DIGITAL_OCEAN: {
+        text: string;
+        value: string;
+    }[];
+};
+export default AmazonData;

package/dist/src/data/setting-items.d.ts

@@ -0,0 +1,198 @@
+declare const CloudSyncSettingsData: {
+    defaultSyncInterval: number;
+    /**
+     * Tolerance applied when local and remote timestamps have to decide the sync
+     * direction (only on the very first cycle, before a content baseline
+     * exists). Absorbs client clock drift and the second-level granularity of
+     * FTP `MDTM` / WebDav `lastmod`.
+     */
+    syncSkewToleranceSeconds: number;
+    tabbySettingsFilename: string;
+    storedSettingsFilename: string;
+    syncStateFilename: string;
+    cloudSettingsFilename: string;
+    tabbyLocalEncryptedFile: string;
+    values: {
+        BUILT_IN: string;
+        S3: string;
+        WASABI: string;
+        DIGITAL_OCEAN: string;
+        BLACKBLAZE: string;
+        S3_COMPATIBLE: string;
+        WEBDAV: string;
+        FTP: string;
+        GIST: string;
+        DROPBOX: string;
+    };
+    amazonEndpoints: {
+        WASABI: string;
+        DIGITAL_OCEAN: string;
+        BLACKBLAZE: string;
+        S3_COMPATIBLE: string;
+    };
+    serviceProvidersList: {
+        name: string;
+        value: string;
+    }[];
+    BuiltinLoginMode: {
+        LOGIN: string;
+        RESET_PASSWORD: string;
+    };
+    availablePluginVersions: any[];
+    formData: {
+        [x: string]: {
+            email: string;
+            password: string;
+            reset_password_email: string;
+            appId?: undefined;
+            appSecret?: undefined;
+            location?: undefined;
+            bucket?: undefined;
+            region?: undefined;
+            endpointUrl?: undefined;
+            host?: undefined;
+            username?: undefined;
+            port?: undefined;
+            protocol?: undefined;
+            type?: undefined;
+            name?: undefined;
+            accessToken?: undefined;
+            id?: undefined;
+            apiKey?: undefined;
+        } | {
+            appId: string;
+            appSecret: string;
+            location: string;
+            bucket: string;
+            region: string;
+            email?: undefined;
+            password?: undefined;
+            reset_password_email?: undefined;
+            endpointUrl?: undefined;
+            host?: undefined;
+            username?: undefined;
+            port?: undefined;
+            protocol?: undefined;
+            type?: undefined;
+            name?: undefined;
+            accessToken?: undefined;
+            id?: undefined;
+            apiKey?: undefined;
+        } | {
+            endpointUrl: string;
+            appId: string;
+            appSecret: string;
+            location: string;
+            bucket: string;
+            region: string;
+            email?: undefined;
+            password?: undefined;
+            reset_password_email?: undefined;
+            host?: undefined;
+            username?: undefined;
+            port?: undefined;
+            protocol?: undefined;
+            type?: undefined;
+            name?: undefined;
+            accessToken?: undefined;
+            id?: undefined;
+            apiKey?: undefined;
+        } | {
+            host: string;
+            username: string;
+            password: string;
+            location: string;
+            port: string;
+            email?: undefined;
+            reset_password_email?: undefined;
+            appId?: undefined;
+            appSecret?: undefined;
+            bucket?: undefined;
+            region?: undefined;
+            endpointUrl?: undefined;
+            protocol?: undefined;
+            type?: undefined;
+            name?: undefined;
+            accessToken?: undefined;
+            id?: undefined;
+            apiKey?: undefined;
+        } | {
+            protocol: string;
+            host: string;
+            username: string;
+            password: string;
+            location: string;
+            port: number;
+            email?: undefined;
+            reset_password_email?: undefined;
+            appId?: undefined;
+            appSecret?: undefined;
+            bucket?: undefined;
+            region?: undefined;
+            endpointUrl?: undefined;
+            type?: undefined;
+            name?: undefined;
+            accessToken?: undefined;
+            id?: undefined;
+            apiKey?: undefined;
+        } | {
+            type: string;
+            name: string;
+            accessToken: string;
+            id: string;
+            email?: undefined;
+            password?: undefined;
+            reset_password_email?: undefined;
+            appId?: undefined;
+            appSecret?: undefined;
+            location?: undefined;
+            bucket?: undefined;
+            region?: undefined;
+            endpointUrl?: undefined;
+            host?: undefined;
+            username?: undefined;
+            port?: undefined;
+            protocol?: undefined;
+            apiKey?: undefined;
+        } | {
+            apiKey: string;
+            email?: undefined;
+            password?: undefined;
+            reset_password_email?: undefined;
+            appId?: undefined;
+            appSecret?: undefined;
+            location?: undefined;
+            bucket?: undefined;
+            region?: undefined;
+            endpointUrl?: undefined;
+            host?: undefined;
+            username?: undefined;
+            port?: undefined;
+            protocol?: undefined;
+            type?: undefined;
+            name?: undefined;
+            accessToken?: undefined;
+            id?: undefined;
+        };
+    };
+    external_urls: {
+        ApiUrl: string;
+        BlackBlazeHelp: string;
+        checkForUpdateUrl: string;
+        githubIssuesUrl: string;
+    };
+    isCloudStorageS3Compatibility(provider: string): boolean;
+    gistUrls: {
+        viewItems: {
+            github: string;
+            gitee: string;
+            gitlab: string;
+        };
+        github: string;
+        gitee: string;
+        gitlab: string;
+    };
+    donationUrl: string;
+    pluginUrl: string;
+};
+export default CloudSyncSettingsData;

package/dist/src/index.d.ts

@@ -0,0 +1,47 @@
+import { AppService, ConfigService, PlatformService } from 'terminus-core';
+export default class CloudSyncSettingsModule {
+    private app;
+    private platform;
+    private configService;
+    constructor(app: AppService, platform: PlatformService, configService: ConfigService);
+    /**
+     * Schedule the next auto-sync run after the configured interval, replacing
+     * any run already pending so the loop can never fork into two timers.
+     */
+    subscribeToAutoSyncEvent(): void;
+    /**
+     * Push local changes as soon as Tabby reports its config was modified.
+     *
+     * Tabby also emits `changed$` when *we* write a pulled config, so the local
+     * hash is compared against the recorded sync baseline first. Without that
+     * check every pull immediately triggered a push, which bumped the remote
+     * timestamp, which made the next cycle pull again — the ping-pong users saw
+     * as "syncing is not right".
+     */
+    subscribeToConfigChangeEvent(): void;
+    private detectSshConfigChange;
+    /** Upload the local config after a debounced change event, if it really changed. */
+    private pushLocalConfigChange;
+    /**
+     * Whether the config on disk is equivalent to what was last synced, in which
+     * case the change event was an echo of our own write rather than a real edit.
+     */
+    private isLocalConfigAlreadySynced;
+    /**
+     * Run one auto-sync cycle: pull/push with the cloud, then reschedule the
+     * next run. The loop is always rescheduled (even on failure or when sync is
+     * disabled) so a single error can no longer permanently stop auto-sync.
+     *
+     * Overlap is prevented by the shared {@link SyncLock} rather than a local
+     * flag, so the settings UI and the config-change listener are serialised
+     * against this loop too.
+     */
+    syncCloudSettings(): Promise<void>;
+    private isTabbySyncActive;
+    /** Append the syncing loader element to the document body. */
+    injectLoaderIndicator(): void;
+    /** Show the syncing loader indicator, if present. */
+    showLoaderIndicator(): void;
+    /** Hide the syncing loader indicator, if present. */
+    hideLoaderIndicator(): void;
+}

package/dist/src/interface/index.d.ts

@@ -0,0 +1,65 @@
+export interface AmazonParams {
+    endpointUrl: string;
+    appId: string;
+    appSecret: string;
+    bucket: string;
+    region: string;
+    location: string;
+}
+export interface FtpParams {
+    protocol: string;
+    host: string;
+    username: string;
+    password: string;
+    location: string;
+}
+export interface GistParams {
+    type: string;
+    name: string;
+    id: string;
+    accessToken: string;
+}
+export interface WebDavParams {
+    host: string;
+    username: string;
+    password: string;
+    location: string;
+    port: string;
+}
+export interface DropboxParams {
+    isConnected?: boolean;
+    accessToken: string;
+    refreshToken: string;
+    location: string;
+    email?: string;
+    lastErrorMessage?: string;
+}
+export interface ConnectionGroup {
+    name: string;
+    collapsed: boolean;
+    type: string;
+}
+/**
+ * Shape of the encrypted `sync-settings.json` file persisted next to the
+ * Tabby config. `configs` holds the provider-specific credentials/options.
+ */
+export interface StoredSettings {
+    adapter: string;
+    enabled: boolean;
+    showLoader: boolean;
+    interval_insync: number;
+    excludedSshBlocksByTarget?: Record<string, Array<{
+        key: string;
+        lines: string[];
+    }>>;
+    configs: any;
+}
+/**
+ * Normalized result returned by every cloud adapter's `sync` /
+ * `syncLocalSettingsToCloud` call so callers no longer need to guard against
+ * a bare boolean return value.
+ */
+export interface SyncResult {
+    result: boolean;
+    message: string;
+}

package/dist/src/providers/cloud-sync-actions.d.ts

@@ -0,0 +1,15 @@
+import { AppService, ConfigService, PlatformService } from 'terminus-core';
+export declare type CloudSyncStatus = 'unconfigured' | 'disabled' | 'ready' | 'syncing' | 'conflict';
+export declare class CloudSyncActions {
+    private app;
+    private config;
+    private platform;
+    constructor(app: AppService, config: ConfigService, platform: PlatformService);
+    get isTabbySyncActive(): boolean;
+    get status(): CloudSyncStatus;
+    private refuseWhenTabbySyncIsActive;
+    syncNow(): Promise<void>;
+    uploadLocalSettings(): Promise<void>;
+    downloadCloudSettings(): Promise<void>;
+    openSettings(): void;
+}

package/dist/src/providers/cloud-sync-command.provider.d.ts

@@ -0,0 +1,16 @@
+import { CloudSyncActions } from './cloud-sync-actions';
+export declare const CommandProvider: any;
+declare type CommandContext = {
+    tab?: any;
+};
+declare type Command = {
+    id?: string;
+    label: string;
+    run: () => Promise<void>;
+};
+export declare class CloudSyncCommandProvider extends CommandProvider {
+    private actions;
+    constructor(actions: CloudSyncActions);
+    provide(_context: CommandContext): Promise<Command[]>;
+}
+export {};

package/dist/src/providers/cloud-sync-toolbar.provider.d.ts

@@ -0,0 +1,7 @@
+import { ToolbarButton, ToolbarButtonProvider } from 'terminus-core';
+import { CloudSyncActions } from './cloud-sync-actions';
+export declare class CloudSyncToolbarProvider extends ToolbarButtonProvider {
+    private actions;
+    constructor(actions: CloudSyncActions);
+    provide(): ToolbarButton[];
+}

package/dist/src/services/dev-constants.d.ts

@@ -0,0 +1,4 @@
+declare const DevEnvConstants: {
+    ENABLE_DEBUG: boolean;
+};
+export default DevEnvConstants;

package/dist/src/services/tabby-sync-upgrade.d.ts

@@ -0,0 +1,10 @@
+import { PlatformService } from 'terminus-core';
+export declare class TabbySyncUpgradeService {
+    private platform;
+    constructor(platform: PlatformService);
+    /**
+     * Installs (or upgrades to) the given version of this plugin.
+     * @param version Target plugin version to install.
+     */
+    installPlugin(version: string): Promise<void>;
+}

package/dist/src/services/toast.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Self-contained toast notifications for the Cloud Sync Settings plugin.
+ *
+ * Why not reuse Tabby's `ToastrService`? Two reasons:
+ *
+ *  1. Isolation. Tabby configures a single global `ToastrModule` with
+ *     `positionClass: 'toast-bottom-center'` and `toastClass: 'toast'`, and
+ *     restyles `#toast-container` in `app/src/toastr.scss`. Anything the plugin
+ *     pushed through that service inherited those choices, and any styling the
+ *     plugin added would have leaked into Tabby's own notifications.
+ *  2. Reach. Toasts are raised from plain singletons (`settings-helper`, the
+ *     cloud adapters) that live outside Angular's injector, so an injectable
+ *     service had to be threaded through as a parameter on ~30 method
+ *     signatures just to be available.
+ *
+ * This module renders its own container into `document.body` and injects its own
+ * stylesheet, both under `tabby-cloud-sync-*` / `.tcss-toast*` names, so it
+ * cannot collide with Tabby's `#toast-container` or with Bootstrap's `.toast`.
+ * Every colour is stated explicitly rather than inherited, so a Tabby theme
+ * change can never render a message unreadable.
+ */
+export declare type PluginToastType = 'success' | 'error' | 'warning' | 'info';
+export interface PluginToastOptions {
+    /** Milliseconds before the toast dismisses itself. `0` keeps it until clicked. */
+    timeout?: number;
+    /** Optional bold line rendered above the message. */
+    title?: string;
+}
+declare class PluginToastService {
+    private container;
+    private live;
+    /** Show a success message. */
+    success(message: string, options?: PluginToastOptions): void;
+    /** Show an error message. */
+    error(message: string, options?: PluginToastOptions): void;
+    /** Show a warning message. */
+    warning(message: string, options?: PluginToastOptions): void;
+    /** Show a neutral, informational message. */
+    info(message: string, options?: PluginToastOptions): void;
+    /**
+     * Render a toast in the bottom-right corner.
+     *
+     * Repeating a message that is already on screen restarts its timer instead
+     * of stacking a duplicate, which matters because several code paths report
+     * the same validation failure (e.g. "Please fill in all the fields.") on
+     * every keystroke-triggered revalidation.
+     */
+    show(type: PluginToastType, message: string, options?: PluginToastOptions): void;
+    /** Dismiss every visible toast immediately. */
+    clear(): void;
+    private buildElement;
+    private scheduleDismiss;
+    private dismiss;
+    /**
+     * Create the container and stylesheet on first use. Both are looked up by
+     * id first so a plugin reload cannot leave two containers behind.
+     */
+    private ensureContainer;
+}
+declare const _default: PluginToastService;
+export default _default;

package/dist/src/settings.d.ts

@@ -0,0 +1,7 @@
+import { SettingsTabProvider } from 'terminus-settings';
+export declare class SyncConfigSettingsTabProvider extends SettingsTabProvider {
+    id: string;
+    icon: string;
+    title: string;
+    getComponentType(): any;
+}

package/dist/src/utils/CloudSyncSettingsHelper.d.ts

@@ -0,0 +1,8 @@
+declare class CloudSyncSettingsHelper {
+    getS3regionsList: (provider: string) => {
+        text: string;
+        value: string;
+    }[];
+}
+declare const cloudSyncSettingsHelper: CloudSyncSettingsHelper;
+export default cloudSyncSettingsHelper;

package/dist/src/utils/Logger.d.ts

@@ -0,0 +1,29 @@
+import { PlatformService } from 'terminus-core';
+/**
+ * Thin wrapper around winston that writes a daily rotating log file next to the
+ * Tabby config. Winston loggers are cached per log file so we do not rebuild the
+ * transports (and re-open the file handle) on every `new Logger(platform)`,
+ * which previously happened dozens of times per sync cycle.
+ */
+export default class Logger {
+    private static loggerCache;
+    private platform;
+    private logger;
+    constructor(platform: PlatformService);
+    /** Absolute path of today's log file. */
+    getCurrentLoggerFile(): string;
+    /** Absolute path of the log file for the given `DD-MM-YYYY` date string. */
+    private getLoggerFileForDate;
+    /** Build or reuse a cached winston logger bound to `filename`. */
+    private static getWinstonLogger;
+    /**
+     * Query the persisted log entries for a given day.
+     *
+     * @param callback Node-style `(err, result)` callback.
+     * @param date Day to query in `DD-MM-YYYY` format (defaults to today).
+     * @param limit Maximum number of entries to return.
+     */
+    getLogContents(callback: any, date?: string, limit?: number): any;
+    /** Append a log entry at the given level (defaults to `info`). */
+    log(content: any, level?: string): void;
+}

package/dist/src/utils/cloud-components/AmazonS3.d.ts

@@ -0,0 +1,38 @@
+import { ConfigService, PlatformService } from 'terminus-core';
+import { AmazonParams, SyncResult } from '../../interface';
+declare class AmazonS3Class {
+    private provider;
+    private PERMISSIONS;
+    private TEST_FILE;
+    /** Select which S3-compatible provider subsequent calls should target. */
+    setProvider(provider: string): void;
+    /** Normalise the raw form params into a per-call config object. */
+    private resolveConfig;
+    /** Compute the remote object key for the encrypted config file. */
+    private getRemoteFileKey;
+    /**
+     * Verify the S3 credentials by uploading a small test file.
+     *
+     * @return `{ code: 1 }` on success or `{ code: 0, message }` on failure.
+     */
+    testConnection: (platform: PlatformService, s3_params: AmazonParams) => Promise<any>;
+    /**
+     * Two-way sync between the local Tabby config and an S3-compatible bucket.
+     *
+     * @param firstInit When `true` prompts the user to choose the initial sync
+     *  direction. Otherwise {@link resolveSyncDirection} compares content
+     *  hashes against the recorded baseline to decide.
+     */
+    sync(config: ConfigService, platform: PlatformService, params: AmazonParams, firstInit?: boolean): Promise<SyncResult>;
+    /**
+     * Force-push the local Tabby config to the configured S3 bucket.
+     *
+     * Concurrency is handled by the shared lock in `SettingsHelper`, so there is
+     * no adapter-local re-entrancy flag here any more.
+     */
+    syncLocalSettingsToCloud(platform: PlatformService): Promise<SyncResult>;
+    /** Build an AWS S3 client for the resolved provider/endpoint. */
+    private createClient;
+}
+declare const _default: AmazonS3Class;
+export default _default;

package/dist/src/utils/cloud-components/Dropbox.d.ts

@@ -0,0 +1,50 @@
+import { ConfigService, PlatformService } from 'terminus-core';
+import { DropboxParams, SyncResult } from '../../interface';
+import { EventEmitter } from '@angular/core';
+declare class DropboxSync {
+    private _isFirstInit;
+    private _emitter;
+    private emitterActions;
+    private readonly adapterId;
+    /** Wire up the internal emitter so file-to-cloud events resolve the sync. */
+    internalEmitterHandler(): void;
+    /** Emit a `dropbox-sync-complete` event to any subscribed UI component. */
+    private emitSyncComplete;
+    /** Ask the provider UI to unlock an existing remote V2 config. */
+    private emitEncryptionSecretRequired;
+    /** Read a Dropbox file blob as a UTF-8 string. */
+    private readBlob;
+    /**
+     * Two-way sync between the local Tabby config and Dropbox.
+     *
+     * @param firstInit When `true` prompts the user to choose the initial sync
+     *  direction and reports completion through the emitter. Otherwise
+     *  {@link resolveSyncDirection} compares content hashes against the
+     *  recorded baseline to decide.
+     */
+    sync(config: ConfigService, platform: PlatformService, params: DropboxParams, firstInit?: boolean, emitter?: EventEmitter<any>): Promise<SyncResult>;
+    /**
+     * Attempt to refresh the Dropbox access token using the stored refresh
+     * token when a download fails. Persists the refreshed tokens on success.
+     */
+    private tryRefreshToken;
+    /**
+     * Upload the encrypted local config to Dropbox.
+     *
+     * Kept separate from {@link syncLocalSettingsToCloud} so a push driven by a
+     * sync cycle does not have to re-read the stored settings or contend with
+     * the shared sync lock, which the cycle already holds.
+     */
+    private uploadLocalSettings;
+    /**
+     * Force-push the local Tabby config to Dropbox.
+     *
+     * Concurrency is handled by the shared lock in `SettingsHelper`, so there is
+     * no adapter-local re-entrancy flag here any more; the old per-adapter flags
+     * could silently turn a scheduled push into a no-op that still reported
+     * success.
+     */
+    syncLocalSettingsToCloud(platform: PlatformService): Promise<SyncResult>;
+}
+declare const _default: DropboxSync;
+export default _default;

package/dist/src/utils/cloud-components/FTP.d.ts

@@ -0,0 +1,46 @@
+import { ConfigService, PlatformService } from 'terminus-core';
+import { FtpParams, SyncResult } from '../../interface';
+declare class FTP {
+    private ftpClient;
+    private readonly adapterId;
+    /**
+     * Two-way sync between the local Tabby config and an FTP/FTPS server.
+     *
+     * @param firstInit When `true` prompts the user to choose the initial sync
+     *  direction. Otherwise {@link resolveSyncDirection} compares content
+     *  hashes against the recorded baseline to decide.
+     */
+    sync(config: ConfigService, platform: PlatformService, params: FtpParams, firstInit?: boolean): Promise<SyncResult>;
+    /**
+     * Download the remote config into `tempFileLocal` and check that it arrived
+     * whole.
+     *
+     * `Client.downloadTo` creates the destination file *before* the transfer
+     * starts, so a connection dropped half way through leaves a file that
+     * exists and may even parse as YAML. Comparing the local size against the
+     * server's `SIZE` is what turns that silent corruption into a detectable
+     * error.
+     */
+    private downloadRemoteConfig;
+    /**
+     * Encrypt the local config and upload it to the configured remote path.
+     *
+     * Returns a {@link SyncResult} rather than `void`: a failed upload used to
+     * only raise a toast, so a sync cycle would record a baseline for content
+     * the server never received and then believe both sides agreed.
+     */
+    private uploadLocalSettings;
+    /**
+     * Force-push the local Tabby config to the FTP server.
+     *
+     * Concurrency is handled by the shared lock in `SettingsHelper`, so there is
+     * no adapter-local re-entrancy flag here any more; the old per-adapter flags
+     * could silently turn a scheduled push into a no-op that still reported
+     * success.
+     */
+    syncLocalSettingsToCloud(platform: PlatformService): Promise<SyncResult>;
+    /** Establish an authenticated FTP/FTPS connection. */
+    private static createClient;
+}
+declare const _default: FTP;
+export default _default;

package/dist/src/utils/cloud-components/WebDav.d.ts

@@ -0,0 +1,34 @@
+import { ConfigService, PlatformService } from 'terminus-core';
+import { SyncResult, WebDavParams } from '../../interface';
+declare class WebDav {
+    private readonly adapterId;
+    /**
+     * Two-way sync between the local Tabby config and a WebDav server.
+     *
+     * @param firstInit When `true` prompts the user to choose the initial sync
+     *  direction. Otherwise {@link resolveSyncDirection} compares content
+     *  hashes against the recorded baseline to decide.
+     */
+    sync(config: ConfigService, platform: PlatformService, params: WebDavParams, firstInit?: boolean): Promise<SyncResult>;
+    /**
+     * Upload the encrypted local config to the given remote path.
+     *
+     * Kept separate from {@link syncLocalSettingsToCloud} so a push driven by a
+     * sync cycle does not have to re-read the stored settings or contend with
+     * the shared sync lock, which the cycle already holds.
+     */
+    private uploadLocalSettings;
+    /**
+     * Force-push the local Tabby config to the WebDav server.
+     *
+     * Concurrency is handled by the shared lock in `SettingsHelper`, so there is
+     * no adapter-local re-entrancy flag here any more; the old per-adapter flags
+     * could silently turn a scheduled push into a no-op that still reported
+     * success.
+     */
+    syncLocalSettingsToCloud(platform: PlatformService): Promise<SyncResult>;
+    /** Build a WebDav client from the stored connection params. */
+    private static createClient;
+}
+declare const _default: WebDav;
+export default _default;