tabby-sftp-ui 0.2.5 → 0.2.6

package/README.md

@@ -142,6 +142,11 @@ Then restart Tabby.
 
 ### Changelog
 
+- **0.2.6**
+  - Fix: Default remote path now detects Linux and Windows correctly (`/home/user`, `/root`, `/C:/Users/user`, etc.).
+  - Fix: Uploads work immediately after opening SFTP-UI (no need to change directories first).
+  - Fix: Remote path is resolved via SFTP canonicalize, shell CWD, and validated before upload.
+
 - **0.2.5**
   - Fix: SFTP UI tabs are not persisted across Tabby restarts (no more blank tabs when reopening Tabby).
   - Fix: SFTP-UI button is shown only on SSH tabs with an active session (not on local PowerShell/CMD terminals).

package/dist/index.js

@@ -267,6 +267,7 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
         this.app = app;
         // injected from the SSH tab when opened via SFTP-UI button
         this.sshSession = null;
+        this.shellSession = null;
         this.profile = null;
         this.recoveredStub = false;
         this.connecting = false;
@@ -281,6 +282,7 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
         this.remotePath = '/';
         this.remoteEntries = [];
         this.sftpSession = null;
+        this.connectPromise = null;
         this.localDropActive = false;
         this.remoteDropActive = false;
         this.transfers = [];
@@ -368,11 +370,32 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
         this.remotePathInput = this.remotePath;
         this.localPathInput = this.localPath;
         if (this.sshSession) {
-            void this.connect();
+            void this.waitForConnection();
         }
         this.loadRecentProfiles();
     }
     async connect() {
+        if (this.connected) {
+            return;
+        }
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+        this.connectPromise = this.connectInternal();
+        try {
+            await this.connectPromise;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+    }
+    async waitForConnection() {
+        if (this.connected) {
+            return;
+        }
+        await this.connect();
+    }
+    async connectInternal() {
         if (this.connecting || this.connected) {
             return;
         }
@@ -384,17 +407,30 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
         try {
             this.sftpSession = await this.sftp.openFromSSHSession(this.sshSession);
             this.connected = true;
-            this.remotePath = this.getDefaultRemotePath();
-            this.remotePathInput = this.remotePath;
+            await this.initializeRemotePath();
             await this.refreshRemote();
         }
         catch (e) {
             console.error('[SFTP-UI] SFTP connection failed', e);
+            this.connected = false;
+            this.sftpSession = null;
         }
         finally {
             this.connecting = false;
         }
     }
+    async initializeRemotePath() {
+        this.remotePath = await this.resolveDefaultRemotePath();
+        this.remotePathInput = this.remotePath;
+        if (await this.ensureRemoteDirectoryReady()) {
+            return;
+        }
+        // Shell CWD may not be ready yet when SFTP-UI opens immediately after SSH connect.
+        await new Promise(resolve => setTimeout(resolve, 500));
+        this.remotePath = await this.resolveDefaultRemotePath();
+        this.remotePathInput = this.remotePath;
+        await this.ensureRemoteDirectoryReady();
+    }
     async disconnect() {
         this.sftpSession = null;
         this.connected = false;
@@ -413,14 +449,26 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
         }
     }
     remoteUp() {
-        if (!this.connected || this.remotePath === '/') {
+        if (!this.canRemoteUp()) {
             return;
         }
-        const next = path__WEBPACK_IMPORTED_MODULE_0__.posix.dirname(this.remotePath);
-        this.remotePath = next === '.' ? '/' : next;
+        const next = this.remoteParentPath(this.remotePath);
+        this.remotePath = next;
         this.remotePathInput = this.remotePath;
         void this.refreshRemote();
     }
+    canRemoteUp() {
+        if (!this.connected) {
+            return false;
+        }
+        if (this.remotePath === '/') {
+            return false;
+        }
+        if (this.isWindowsSftpPath(this.remotePath)) {
+            return !/^\/[A-Za-z]:\/?$/.test(this.remotePath);
+        }
+        return true;
+    }
     async refreshLocal() {
         try {
             const names = await fs_promises__WEBPACK_IMPORTED_MODULE_2__.readdir(this.localPath);
@@ -633,10 +681,12 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
     async onDropOnRemote(ev) {
         ev.preventDefault();
         this.remoteDropActive = false;
-        if (!this.connected) {
+        await this.waitForConnection();
+        if (!this.connected || !this.sftpSession) {
             return;
         }
-        if (!this.sftpSession) {
+        if (!(await this.ensureRemoteDirectoryReady())) {
+            console.error('[SFTP-UI] Remote path is not ready for upload');
             return;
         }
         // Drag & drop from OS file manager (Explorer/Finder) into the remote pane
@@ -1370,6 +1420,9 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
         }
     }
     getRemoteBreadcrumbs() {
+        if (this.isWindowsSftpPath(this.remotePath)) {
+            return this.getWindowsSftpBreadcrumbs(this.remotePath);
+        }
         const parts = this.remotePath.split('/').filter(Boolean);
         const crumbs = [];
         let current = '/';
@@ -1394,9 +1447,7 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
         if (!this.connected) {
             return;
         }
-        const target = this.normalizeRemotePath(this.remotePathInput || '/');
-        this.remotePath = target;
-        this.remotePathInput = target;
+        this.syncRemotePathFromInput();
         void this.refreshRemote();
     }
     goToLocalPathInput() {
@@ -1583,21 +1634,169 @@ let SftpManagerTabComponent = class SftpManagerTabComponent extends tabby_core__
         if (!p) {
             return '/';
         }
-        let result = p.trim();
+        let result = p.trim().replace(/\\/g, '/');
+        const winDrive = result.match(/^\/([A-Za-z]):(?:\/(.*))?$/);
+        if (winDrive) {
+            const rest = winDrive[2] ?? '';
+            return rest
+                ? `/${winDrive[1]}:/${rest}`.replace(/\/+/g, '/')
+                : `/${winDrive[1]}:/`;
+        }
+        const bareDrive = result.match(/^([A-Za-z]):(?:\/(.*))?$/);
+        if (bareDrive) {
+            const rest = bareDrive[2] ?? '';
+            return rest
+                ? `/${bareDrive[1]}:/${rest}`.replace(/\/+/g, '/')
+                : `/${bareDrive[1]}:/`;
+        }
         if (!result.startsWith('/')) {
             result = '/' + result;
         }
-        // remove duplicate slashes
-        result = result.replace(/\/+/g, '/');
-        return result;
+        return result.replace(/\/+/g, '/');
     }
-    getDefaultRemotePath() {
-        const username = (this.profile && (this.profile.options?.username || this.profile.options?.user)) || '';
-        if (username) {
-            return username === 'root' ? `/root` : `/home/${username}`;
+    async resolveDefaultRemotePath() {
+        const canonical = await this.canonicalizeRemotePath('.');
+        if (canonical) {
+            const normalized = this.normalizeRemotePath(canonical);
+            if (await this.remotePathExists(normalized)) {
+                return normalized;
+            }
+        }
+        if (this.shellSession) {
+            try {
+                const cwd = await this.shellSession.getWorkingDirectory?.();
+                if (cwd) {
+                    const normalized = this.toRemoteSftpPath(cwd);
+                    if (await this.remotePathExists(normalized)) {
+                        return normalized;
+                    }
+                }
+            }
+            catch {
+                // fall through to SFTP-based detection
+            }
+        }
+        const username = this.getRemoteUsername();
+        for (const candidate of this.buildDefaultRemotePathCandidates(username)) {
+            if (await this.remotePathExists(candidate)) {
+                return candidate;
+            }
         }
         return '/';
     }
+    syncRemotePathFromInput() {
+        const normalized = this.normalizeRemotePath(this.remotePathInput || this.remotePath || '/');
+        this.remotePath = normalized;
+        this.remotePathInput = normalized;
+    }
+    async ensureRemoteDirectoryReady() {
+        if (!this.sftpSession) {
+            return false;
+        }
+        this.syncRemotePathFromInput();
+        if (await this.remotePathExists(this.remotePath)) {
+            return true;
+        }
+        const resolved = await this.resolveDefaultRemotePath();
+        this.remotePath = resolved;
+        this.remotePathInput = resolved;
+        return await this.remotePathExists(resolved);
+    }
+    getRemoteUsername() {
+        return (this.profile && (this.profile.options?.username || this.profile.options?.user)) || '';
+    }
+    buildDefaultRemotePathCandidates(username) {
+        const candidates = [];
+        if (username) {
+            candidates.push(`/C:/Users/${username}`);
+            if (username.toLowerCase() === 'administrator') {
+                candidates.push('/C:/Users/Administrator');
+            }
+            if (username === 'root') {
+                candidates.push('/root');
+            }
+            else {
+                candidates.push(`/home/${username}`);
+            }
+        }
+        candidates.push('/');
+        return candidates;
+    }
+    async canonicalizeRemotePath(p) {
+        const session = this.sftpSession;
+        const candidates = [
+            session?.canonicalize?.bind(session),
+            session?.realpath?.bind(session),
+            session?.sftp?.canonicalize?.bind(session.sftp),
+            session?.sftp?.realpath?.bind(session.sftp),
+        ].filter((fn) => typeof fn === 'function');
+        for (const fn of candidates) {
+            try {
+                return await fn(p);
+            }
+            catch {
+                // try the next available SFTP realpath implementation
+            }
+        }
+        return null;
+    }
+    async remotePathExists(p) {
+        if (!this.sftpSession) {
+            return false;
+        }
+        try {
+            if (this.sftpSession.stat) {
+                const st = await this.sftpSession.stat(p);
+                return st.isDirectory;
+            }
+            await this.sftpSession.readdir(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    toRemoteSftpPath(p) {
+        return this.normalizeRemotePath(p);
+    }
+    isWindowsSftpPath(p) {
+        return /^\/[A-Za-z]:\//.test(p) || /^\/[A-Za-z]:\/?$/.test(p);
+    }
+    getWindowsSftpBreadcrumbs(remotePath) {
+        const match = remotePath.match(/^\/([A-Za-z]):\/?(.*)$/);
+        if (!match) {
+            return [{ label: '/', path: '/' }];
+        }
+        const drive = match[1].toUpperCase();
+        const crumbs = [
+            { label: `${drive}:`, path: `/${drive}:/` },
+        ];
+        let current = `/${drive}:/`;
+        for (const part of match[2].split('/').filter(Boolean)) {
+            current = `${current}${part}/`;
+            crumbs.push({ label: part, path: current.replace(/\/+$/, '') || `/${drive}:/` });
+        }
+        return crumbs;
+    }
+    remoteParentPath(p) {
+        if (this.isWindowsSftpPath(p)) {
+            const match = p.match(/^\/([A-Za-z]):\/?(.*)$/);
+            if (!match) {
+                return '/';
+            }
+            const drive = match[1].toUpperCase();
+            const parts = match[2].split('/').filter(Boolean);
+            if (!parts.length) {
+                return '/';
+            }
+            parts.pop();
+            return parts.length
+                ? `/${drive}:/${parts.join('/')}`
+                : `/${drive}:/`;
+        }
+        const next = path__WEBPACK_IMPORTED_MODULE_0__.posix.dirname(p);
+        return next === '.' ? '/' : next;
+    }
     loadRecentProfiles() {
         try {
             const rec = this.profilesService.getRecentProfiles?.();
@@ -2494,7 +2693,7 @@ SftpManagerTabComponent = __decorate([
               />
             </div>
             <div class="pane-actions">
-              <button (click)="remoteUp()" [disabled]="!connected || remotePath === '/'">Up</button>
+              <button (click)="remoteUp()" [disabled]="!connected || !canRemoteUp()">Up</button>
               <button (click)="goToRemotePathInput()" [disabled]="!connected">Go</button>
               <button (click)="refreshRemote()" [disabled]="!connected">Refresh</button>
             </div>
@@ -2532,7 +2731,7 @@ SftpManagerTabComponent = __decorate([
             </div>
             <div
               class="entry"
-              *ngIf="connected && remotePath !== '/'"
+              *ngIf="connected && canRemoteUp()"
               (dblclick)="remoteUp()"
             >
               <span class="icon">⬆</span>
@@ -2969,6 +3168,7 @@ let SftpUiService = class SftpUiService {
                     inputs: {
                         sshSession,
                         profile,
+                        shellSession: sourceTab?.session ?? null,
                     },
                 });
                 tab.setTitle(`${baseTitle} + SFTP`);