@tuskydp/cli 0.2.1 → 0.3.0

package/src/tui/index.ts

@@ -1,5 +1,6 @@
 import blessed from 'blessed';
-import { readFileSync, statSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, statSync, readdirSync } from 'fs';
+import { randomUUID } from 'crypto';
 import { basename, join, resolve } from 'path';
 
 function collectFiles(dir: string): string[] {
@@ -15,19 +16,21 @@ function collectFiles(dir: string): string[] {
 import { lookup } from 'mime-types';
 import { createSDKClient } from '../sdk.js';
 import { cliConfig, getApiUrl } from '../config.js';
-import { encryptBuffer } from '../crypto.js';
+import { encryptBuffer, decryptBuffer } from '../crypto.js';
 import { loadMasterKey } from '../lib/keyring.js';
+import { isSealConfigured, sealEncrypt, sealDecrypt, getSuiKeypair } from '../seal.js';
 import { showAuthScreen } from './auth-screen.js';
 import { VaultsPanel, VaultItem } from './vaults-panel.js';
 import { FilesPanel } from './files-panel.js';
 import { StatusBar } from './status-bar.js';
 import { showOverview } from './overview.js';
+import { showTrashScreen } from './trash-screen.js';
 import { confirmDialog, textInputDialog, selectDialog, detailPopup, fileBrowserDialog } from './dialogs.js';
 import { formatBytes, formatDate, formatRow, showError, showMessage, statusColor, statusColorClose, getCurrentTheme, cycleTheme, Theme } from './helpers.js';
 
 function formatDetailTable(rows: [string, string][]): string {
   const labelW = Math.max(...rows.map(([l]) => l.length));
-  return rows.map(([label, value]) => `  {bold}${label.padEnd(labelW)}{/bold}  │  ${value}`).join('\n');
+  return rows.map(([label, value]) => `  {bold}${label.padEnd(labelW)}{/bold}  |  ${value}`).join('\n');
 }
 
 type FocusTarget = 'vaults' | 'files';
@@ -74,6 +77,7 @@ export async function launchTui() {
 
   const statusBar = new StatusBar(screen);
   const vaultsPanel = new VaultsPanel(screen, sdk, leftBox, (vault) => {
+    filesPanel.resetFolderNav();
     filesPanel.loadForVault(vault.id, vault.name);
   });
   const filesPanel = new FilesPanel(screen, sdk, rightBox);
@@ -85,11 +89,11 @@ export async function launchTui() {
     if (target === 'vaults') {
       vaultsPanel.focus();
       filesPanel.blur();
-      statusBar.setHints('n:new ←→:switch u:upload o:overview ?:help');
+      statusBar.setHints('n:new  <->:switch  u:upload  o:overview  T:trash  ?:help');
     } else {
       filesPanel.focus();
       vaultsPanel.blur();
-      statusBar.setHints('u:upload d:delete r:retry ←→:switch Enter:detail ?:help');
+      statusBar.setHints('d:download  u:upload  f:folder  R:remove  r:retry  T:trash  ?:help');
     }
   }
 
@@ -124,28 +128,74 @@ export async function launchTui() {
     }
   });
 
+  // ── Create vault (n) — now with shared option ──────────────────────
   screen.key(['n'], async () => {
     const name = await textInputDialog(screen, 'Vault name');
     if (!name) {
       setFocus(currentFocus);
       return;
     }
-    const visIdx = await selectDialog(screen, 'Visibility', ['private', 'public']);
+    const visIdx = await selectDialog(screen, 'Visibility', ['private', 'public', 'shared']);
     if (visIdx < 0) {
       setFocus(currentFocus);
       return;
     }
-    const visibility = visIdx === 0 ? 'private' as const : 'public' as const;
+    const visMap = ['private', 'public', 'shared'] as const;
+    const visibility = visMap[visIdx];
+
     try {
-      await sdk.vaults.create({ name, visibility });
+      if (visibility === 'shared') {
+        // Validate Sui address is linked
+        const acct = await sdk.account.get();
+        if (!(acct as any).suiAddress) {
+          showError(screen, 'Link a Sui address first: tusky account link-sui <addr>');
+          setFocus(currentFocus);
+          return;
+        }
+      }
+      const created = await sdk.vaults.create({ name, visibility });
       await vaultsPanel.load();
-      showMessage(screen, `Vault "${name}" created`);
+      let msg = `Vault "${name}" created [${visibility}]`;
+      if (visibility === 'shared' && created.sealAllowlistObjectId) {
+        msg += `\nSEAL allowlist: ${created.sealAllowlistObjectId}`;
+      }
+      showMessage(screen, msg);
+    } catch (err: any) {
+      showError(screen, err.message);
+    }
+    setFocus(currentFocus);
+  });
+
+  // ── Create folder (f) ──────────────────────────────────────────────
+  screen.key(['f'], async () => {
+    if (currentFocus !== 'files') return;
+    const vaultId = filesPanel.getCurrentVaultId();
+    if (!vaultId) {
+      showError(screen, 'Select a vault first');
+      return;
+    }
+
+    const name = await textInputDialog(screen, 'Folder name');
+    if (!name) {
+      setFocus(currentFocus);
+      return;
+    }
+
+    try {
+      await sdk.folders.create({
+        vaultId,
+        parentId: filesPanel.getCurrentFolderId() || undefined,
+        name,
+      });
+      await filesPanel.loadForVault(vaultId, filesPanel.getCurrentVaultName());
+      showMessage(screen, `Folder "${name}" created`);
     } catch (err: any) {
       showError(screen, err.message);
     }
     setFocus(currentFocus);
   });
 
+  // ── Upload (u) — with SEAL support and folder awareness ────────────
   screen.key(['u'], async () => {
     const vaultId = filesPanel.getCurrentVaultId();
     if (!vaultId) {
@@ -176,6 +226,7 @@ export async function launchTui() {
     try {
       const vault = await sdk.vaults.get(vaultId);
       const isPrivate = vault.visibility === 'private';
+      const isShared = vault.visibility === 'shared' && isSealConfigured(vault);
       let masterKey: Buffer | null = null;
 
       if (isPrivate) {
@@ -187,8 +238,18 @@ export async function launchTui() {
         }
       }
 
+      if (isShared) {
+        const keypair = getSuiKeypair();
+        if (!keypair) {
+          showError(screen, 'TUSKYDP_SUI_PRIVATE_KEY env var required for shared vault uploads');
+          setFocus(currentFocus);
+          return;
+        }
+      }
+
       let successCount = 0;
       const total = filePaths.length;
+      const currentFolderId = filesPanel.getCurrentFolderId();
 
       for (const filePath of filePaths) {
         const fileName = basename(filePath);
@@ -205,6 +266,8 @@ export async function launchTui() {
           encryptionIv?: string;
           plaintextSizeBytes?: number;
           plaintextChecksumSha256?: string;
+          sealIdentity?: string;
+          sealEncryptedObject?: string;
         } = {};
 
         if (isPrivate && masterKey) {
@@ -216,6 +279,17 @@ export async function launchTui() {
             plaintextSizeBytes: stat.size,
             plaintextChecksumSha256: plaintextChecksum,
           };
+        } else if (isShared) {
+          statusBar.setHints(`SEAL encrypting ${successCount + 1}/${total}: ${fileName}...`);
+          screen.render();
+          const fileNonce = randomUUID();
+          const sealResult = await sealEncrypt(new Uint8Array(fileBuffer), vault, fileNonce);
+          uploadBody = Buffer.from(sealResult.encryptedData);
+          encryptionMeta = {
+            sealIdentity: sealResult.sealIdentity,
+            sealEncryptedObject: sealResult.sealEncryptedObject,
+            plaintextSizeBytes: stat.size,
+          };
         } else {
           uploadBody = fileBuffer;
         }
@@ -225,6 +299,7 @@ export async function launchTui() {
           mimeType,
           sizeBytes: uploadBody.length,
           vaultId,
+          ...(currentFolderId ? { folderId: currentFolderId } : {}),
           ...encryptionMeta,
         });
 
@@ -240,7 +315,8 @@ export async function launchTui() {
         successCount++;
       }
 
-      showMessage(screen, `Uploaded ${successCount} file(s)`);
+      const label = isPrivate ? 'private' : isShared ? 'shared/SEAL' : 'public';
+      showMessage(screen, `Uploaded ${successCount} file(s) [${label}]`);
       await filesPanel.loadForVault(vaultId, filesPanel.getCurrentVaultName());
       await vaultsPanel.load();
     } catch (err: any) {
@@ -249,10 +325,115 @@ export async function launchTui() {
     setFocus(currentFocus);
   });
 
-  screen.key(['d', 'delete'], async () => {
+  // ── Download (d) — download selected file to local disk ─────────────
+  screen.key(['d'], async () => {
+    if (currentFocus !== 'files') return;
+    const file = filesPanel.getSelected();
+    if (!file) {
+      showError(screen, 'Select a file to download');
+      setFocus(currentFocus);
+      return;
+    }
+
+    statusBar.setHints(`Downloading "${file.name}"...`);
+    screen.render();
+
+    try {
+      // Get download URL + encryption info
+      let dlResponse = await sdk.files.getDownloadUrl(file.id);
+      let { downloadUrl, status: dlStatus, encryption } = dlResponse;
+
+      // Poll if rehydrating from cold storage
+      if (dlStatus === 'rehydrating') {
+        statusBar.setHints(`Rehydrating "${file.name}" from Walrus...`);
+        screen.render();
+        for (let i = 0; i < 30; i++) {
+          await new Promise(r => setTimeout(r, 2000));
+          const check = await sdk.files.getDownloadUrl(file.id);
+          if (check.status === 'ready') {
+            downloadUrl = check.downloadUrl;
+            encryption = check.encryption;
+            dlStatus = 'ready';
+            break;
+          }
+        }
+        if (dlStatus !== 'ready') {
+          showError(screen, 'File rehydration timed out. Try again later.');
+          setFocus(currentFocus);
+          return;
+        }
+      }
+
+      if (!downloadUrl) {
+        showError(screen, 'No download URL available.');
+        setFocus(currentFocus);
+        return;
+      }
+
+      // Download the bytes
+      statusBar.setHints(`Downloading "${file.name}"...`);
+      screen.render();
+      const response = await fetch(downloadUrl);
+      if (!response.ok) throw new Error(`Download failed: ${response.status}`);
+      const arrayBuf = await response.arrayBuffer();
+      let fileBuffer: Buffer = Buffer.from(new Uint8Array(arrayBuf));
+
+      // Decrypt if needed
+      if (encryption?.encrypted) {
+        if ('type' in encryption && encryption.type === 'seal') {
+          statusBar.setHints(`SEAL decrypting "${file.name}"...`);
+          screen.render();
+          const keypair = getSuiKeypair();
+          if (!keypair) {
+            showError(screen, 'TUSKYDP_SUI_PRIVATE_KEY env var required for shared vault files');
+            setFocus(currentFocus);
+            return;
+          }
+          const fileInfo = await sdk.files.get(file.id);
+          const vault = await sdk.vaults.get(fileInfo.vaultId);
+          const decrypted = await sealDecrypt(new Uint8Array(fileBuffer), vault, keypair);
+          fileBuffer = Buffer.from(decrypted);
+        } else {
+          statusBar.setHints(`Decrypting "${file.name}"...`);
+          screen.render();
+          const masterKey = loadMasterKey();
+          if (!masterKey) {
+            showError(screen, 'Encryption not unlocked. Run: tusky encryption unlock');
+            setFocus(currentFocus);
+            return;
+          }
+          const enc = encryption as { type: 'passphrase'; encrypted: true; wrappedKey: string; iv: string; plaintextChecksumSha256: string | null };
+          fileBuffer = decryptBuffer(
+            fileBuffer,
+            enc.wrappedKey,
+            enc.iv,
+            masterKey,
+            enc.plaintextChecksumSha256 ?? undefined,
+          );
+        }
+      }
+
+      // Write to disk
+      const outputPath = join(process.cwd(), file.name);
+      writeFileSync(outputPath, fileBuffer);
+
+      showMessage(screen, `Downloaded "${file.name}" (${formatBytes(fileBuffer.length)})\n-> ${outputPath}`);
+    } catch (err: any) {
+      showError(screen, err.message);
+    }
+    setFocus(currentFocus);
+  });
+
+  // ── Remove (R = Shift+r) — delete selected item ───────────────────
+  screen.key(['S-r'], async () => {
     if (currentFocus === 'vaults') {
       const vault = vaultsPanel.getSelected();
       if (!vault) return;
+      if (vault.isSharedMembership) {
+        showError(screen, 'Cannot delete a vault you are a member of (not owner)');
+        setFocus(currentFocus);
+        return;
+      }
       const confirmed = await confirmDialog(screen, `Delete vault "${vault.name}" and ALL its files?`);
       if (confirmed) {
         try {
@@ -266,27 +447,45 @@ export async function launchTui() {
       }
       setFocus(currentFocus);
     } else {
-      const file = filesPanel.getSelected();
-      if (!file) return;
-      const confirmed = await confirmDialog(screen, `Delete file "${file.name}"?`);
-      if (confirmed) {
-        try {
-          await sdk.files.delete(file.id);
-          const vaultId = filesPanel.getCurrentVaultId();
-          if (vaultId) {
-            await filesPanel.loadForVault(vaultId, filesPanel.getCurrentVaultName());
-            await vaultsPanel.load();
+      const item = filesPanel.getSelectedItem();
+      if (!item) return;
+
+      if (item.type === 'folder') {
+        const confirmed = await confirmDialog(screen, `Delete folder "${item.folder.name}"?`);
+        if (confirmed) {
+          try {
+            await sdk.folders.delete(item.folder.id);
+            const vaultId = filesPanel.getCurrentVaultId();
+            if (vaultId) {
+              await filesPanel.loadForVault(vaultId, filesPanel.getCurrentVaultName());
+            }
+            showMessage(screen, `Folder "${item.folder.name}" deleted`);
+          } catch (err: any) {
+            showError(screen, err.message);
+          }
+        }
+      } else if (item.type === 'file') {
+        const confirmed = await confirmDialog(screen, `Delete file "${item.file.name}"?`);
+        if (confirmed) {
+          try {
+            await sdk.files.delete(item.file.id);
+            const vaultId = filesPanel.getCurrentVaultId();
+            if (vaultId) {
+              await filesPanel.loadForVault(vaultId, filesPanel.getCurrentVaultName());
+              await vaultsPanel.load();
+            }
+            showMessage(screen, `File "${item.file.name}" moved to trash`);
+          } catch (err: any) {
+            showError(screen, err.message);
           }
-          showMessage(screen, `File "${file.name}" deleted`);
-        } catch (err: any) {
-          showError(screen, err.message);
         }
       }
       setFocus(currentFocus);
     }
   });
 
-  screen.key(['enter'], () => {
+  // ── Enter / Space — detail popup or folder navigation ──────────────
+  screen.key(['enter', 'space'], async () => {
     if (currentFocus === 'vaults') {
       const vault = vaultsPanel.getSelected();
       if (vault) {
@@ -298,11 +497,45 @@ export async function launchTui() {
           ['Files', String(vault.fileCount)],
           ['Size', formatBytes(vault.totalSizeBytes)],
         ];
+        if (vault.description) {
+          rows.push(['Description', vault.description]);
+        }
+        if (vault.createdAt) {
+          rows.push(['Created', formatDate(vault.createdAt)]);
+        }
+        if (vault.isSharedMembership) {
+          rows.push(['Your Role', vault.memberRole || 'member']);
+        }
+        if (vault.visibility === 'shared') {
+          rows.push(['', '']);
+          rows.push(['{cyan-fg}SEAL Config{/cyan-fg}', '']);
+          rows.push(['Allowlist', vault.sealAllowlistObjectId || 'N/A']);
+          rows.push(['Package', vault.sealPackageId || 'N/A']);
+          rows.push(['Threshold', String(vault.sealThreshold ?? 'N/A')]);
+          rows.push(['Key Servers', String(vault.sealKeyServerIds?.length ?? 0)]);
+        }
         detailPopup(screen, vault.name, formatDetailTable(rows));
       }
     } else {
-      const file = filesPanel.getSelected();
-      if (file) {
+      const item = filesPanel.getSelectedItem();
+      if (!item) return;
+
+      if (item.type === 'parent') {
+        // Navigate up
+        await filesPanel.navigateUp();
+        setFocus(currentFocus);
+        return;
+      }
+
+      if (item.type === 'folder') {
+        // Navigate into folder
+        await filesPanel.navigateToFolder(item.folder.id, item.folder.name);
+        setFocus(currentFocus);
+        return;
+      }
+
+      if (item.type === 'file') {
+        const file = item.file;
         const open = statusColor(file.status);
         const close = statusColorClose(file.status);
         const rows: [string, string][] = [
@@ -316,11 +549,21 @@ export async function launchTui() {
           ['Blob ID', file.walrusBlobId || 'N/A'],
           ['Blob Object', file.walrusBlobObjectId || 'N/A'],
         ];
+        if (file.folderId) {
+          rows.push(['Folder ID', file.folderId]);
+        }
+        if (file.autoRenew) {
+          rows.push(['Auto-Renew', '{green-fg}On{/green-fg}']);
+        }
+        if (file.ppuEpochEnd) {
+          rows.push(['PPU Epoch', formatDate(file.ppuEpochEnd)]);
+        }
         detailPopup(screen, file.name, formatDetailTable(rows));
       }
     }
   });
 
+  // ── Retry (r) ──────────────────────────────────────────────────────
   screen.key(['r'], async () => {
     if (currentFocus === 'files') {
       const file = filesPanel.getSelected();
@@ -343,11 +586,21 @@ export async function launchTui() {
     }
   });
 
+  // ── Overview (o) ───────────────────────────────────────────────────
   screen.key(['o'], async () => {
     await showOverview(screen, sdk);
     setFocus(currentFocus);
   });
 
+  // ── Trash (T = Shift+t) ───────────────────────────────────────────
+  screen.key(['S-t'], async () => {
+    await showTrashScreen(screen, sdk);
+    // Reload vaults panel in case restores happened
+    await vaultsPanel.load();
+    setFocus(currentFocus);
+  });
+
+  // ── Logout (L = Shift+l) ──────────────────────────────────────────
   screen.key(['S-l'], async () => {
     const confirmed = await confirmDialog(screen, 'Log out?');
     if (confirmed) {
@@ -388,19 +641,22 @@ export async function launchTui() {
       '{bold}{cyan-fg}Tusky TUI — Keyboard Shortcuts{/cyan-fg}{/bold}',
       '',
       '{bold}Navigation{/bold}',
-      '  ←/→        Switch between vaults/files',
+      '  <-/->      Switch between vaults/files',
       '  Tab        Switch between vaults/files',
       '  Up/Down    Navigate list',
+      '  Enter      Open folder / view details',
       '',
       '{bold}Actions{/bold}',
-      '  n          Create new vault',
-      '  u          Upload file to current vault',
-      '  d/Delete   Delete selected item',
-      '  r          Retry failed file',
-      '  Space/Enter  View details',
+      '  n          Create new vault (private/public/shared)',
+      '  f          Create folder in current vault',
+      '  u          Upload file to current vault/folder',
+      '  d          Download selected file',
+      '  R          Remove selected item (trash for files)',
+      '  r          Retry failed file sync',
       '',
       '{bold}Screens{/bold}',
       '  o          Overview (account, storage, files)',
+      '  T          Trash management (list, restore, delete)',
       '  t          Cycle theme',
       '  L          Logout',
       '  ?          This help',

package/src/tui/overview.ts

@@ -74,13 +74,27 @@ export async function showOverview(
 
         if (vaults.length > 0) {
           // Calculate column widths for vaults table
-          const vaultRows = vaults.map((v) => ({
-            name: v.name || '',
-            vis: v.visibility === 'private' ? 'private' : 'public',
-            visTag: v.visibility === 'private' ? '{yellow-fg}private{/yellow-fg}' : '{green-fg}public{/green-fg}',
-            files: String(v.fileCount || 0),
-            size: formatBytes(v.totalSizeBytes || 0),
-          }));
+          const vaultRows = vaults.map((v) => {
+            let vis: string;
+            let visTag: string;
+            if (v.visibility === 'private') {
+              vis = 'private';
+              visTag = '{yellow-fg}private{/yellow-fg}';
+            } else if (v.visibility === 'shared') {
+              vis = 'shared';
+              visTag = '{magenta-fg}shared{/magenta-fg}';
+            } else {
+              vis = 'public';
+              visTag = '{green-fg}public{/green-fg}';
+            }
+            return {
+              name: v.name || '',
+              vis,
+              visTag,
+              files: String(v.fileCount || 0),
+              size: formatBytes(v.totalSizeBytes || 0),
+            };
+          });
           const vNameW = Math.max(4, ...vaultRows.map((r) => r.name.length));
           const vVisW = 7; // "private" is longest
           const vFilesW = Math.max(5, ...vaultRows.map((r) => r.files.length));
@@ -122,7 +136,7 @@ export async function showOverview(
           content += `  ${'Name'.padEnd(maxNameW)}  ${'Size'.padStart(fSizeW)}  ${'Status'.padEnd(fStatW)}  ${'Date'.padEnd(fDateW)}\n`;
           content += `  ${'─'.repeat(maxNameW)}  ${'─'.repeat(fSizeW)}  ${'─'.repeat(fStatW)}  ${'─'.repeat(fDateW)}\n`;
           for (const r of fileRows) {
-            const truncName = r.name.length > maxNameW ? r.name.slice(0, maxNameW - 1) + '…' : r.name;
+            const truncName = r.name.length > maxNameW ? r.name.slice(0, maxNameW - 1) + '...' : r.name;
             const statusPad = ' '.repeat(Math.max(0, fStatW - r.status.length));
             content += `  ${truncName.padEnd(maxNameW)}  ${r.size.padStart(fSizeW)}  ${r.statusTag}${statusPad}  ${r.date}\n`;
           }