@tuskydp/cli 0.1.0 → 0.1.1

package/src/tui/index.ts

@@ -0,0 +1,420 @@
+import blessed from 'blessed';
+import { readFileSync, statSync, readdirSync } from 'fs';
+import { basename, join, resolve } from 'path';
+
+function collectFiles(dir: string): string[] {
+  const results: string[] = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isFile()) results.push(full);
+    else if (entry.isDirectory()) results.push(...collectFiles(full));
+  }
+  return results;
+}
+import { lookup } from 'mime-types';
+import { createSDKClient } from '../sdk.js';
+import { cliConfig, getApiUrl } from '../config.js';
+import { encryptBuffer } from '../crypto.js';
+import { loadMasterKey } from '../lib/keyring.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 { 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');
+}
+
+type FocusTarget = 'vaults' | 'files';
+
+export async function launchTui() {
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: 'Tusky TUI',
+    fullUnicode: true,
+  });
+
+  // Check auth
+  let apiKey = cliConfig.get('apiKey');
+  let apiUrl = getApiUrl();
+
+  if (!apiKey) {
+    const authResult = await showAuthScreen(screen);
+    if (!authResult) {
+      screen.destroy();
+      process.exit(0);
+    }
+    apiKey = authResult.apiKey;
+    apiUrl = authResult.apiUrl;
+  }
+
+  const sdk = createSDKClient(apiUrl, apiKey);
+
+  // Create main layout
+  const leftBox = blessed.box({
+    parent: screen,
+    top: 0,
+    left: 0,
+    width: '40%',
+    height: '100%-1',
+  });
+
+  const rightBox = blessed.box({
+    parent: screen,
+    top: 0,
+    left: '40%',
+    width: '60%',
+    height: '100%-1',
+  });
+
+  const statusBar = new StatusBar(screen);
+  const vaultsPanel = new VaultsPanel(screen, sdk, leftBox, (vault) => {
+    filesPanel.loadForVault(vault.id, vault.name);
+  });
+  const filesPanel = new FilesPanel(screen, sdk, rightBox);
+
+  let currentFocus: FocusTarget = 'vaults';
+
+  function setFocus(target: FocusTarget) {
+    currentFocus = target;
+    if (target === 'vaults') {
+      vaultsPanel.focus();
+      filesPanel.blur();
+      statusBar.setHints('n:new ←→:switch u:upload o:overview ?:help');
+    } else {
+      filesPanel.focus();
+      vaultsPanel.blur();
+      statusBar.setHints('u:upload d:delete r:retry ←→:switch Enter:detail ?:help');
+    }
+  }
+
+  // Load account info for status bar
+  async function loadStatusBar() {
+    try {
+      const account = await sdk.account.get();
+      statusBar.setUser(
+        account.email || '',
+        account.planName || account.planTier || 'ppu',
+        formatBytes(account.storageUsedBytes || 0),
+        formatBytes(account.storageLimitBytes || 0),
+      );
+    } catch {
+      // Silently fail — status bar will show defaults
+    }
+  }
+
+  // Key bindings
+  screen.key(['q', 'C-c'], () => {
+    screen.destroy();
+    process.exit(0);
+  });
+
+  screen.key(['left'], () => {
+    setFocus('vaults');
+  });
+
+  screen.key(['right', 'tab'], () => {
+    if (filesPanel.getCurrentVaultId()) {
+      setFocus('files');
+    }
+  });
+
+  screen.key(['n'], async () => {
+    const name = await textInputDialog(screen, 'Vault name');
+    if (!name) {
+      setFocus(currentFocus);
+      return;
+    }
+    const visIdx = await selectDialog(screen, 'Visibility', ['private', 'public']);
+    if (visIdx < 0) {
+      setFocus(currentFocus);
+      return;
+    }
+    const visibility = visIdx === 0 ? 'private' as const : 'public' as const;
+    try {
+      await sdk.vaults.create({ name, visibility });
+      await vaultsPanel.load();
+      showMessage(screen, `Vault "${name}" created`);
+    } catch (err: any) {
+      showError(screen, err.message);
+    }
+    setFocus(currentFocus);
+  });
+
+  screen.key(['u'], async () => {
+    const vaultId = filesPanel.getCurrentVaultId();
+    if (!vaultId) {
+      showError(screen, 'Select a vault first');
+      setFocus(currentFocus);
+      return;
+    }
+
+    const selection = await fileBrowserDialog(screen);
+    if (!selection) {
+      setFocus(currentFocus);
+      return;
+    }
+
+    // Collect all file paths
+    let filePaths: string[] = [];
+    if (selection.isDirectory) {
+      filePaths = collectFiles(selection.path);
+      if (filePaths.length === 0) {
+        showError(screen, 'No files found in directory');
+        setFocus(currentFocus);
+        return;
+      }
+    } else {
+      filePaths = [selection.path];
+    }
+
+    try {
+      const vault = await sdk.vaults.get(vaultId);
+      const isPrivate = vault.visibility === 'private';
+      let masterKey: Buffer | null = null;
+
+      if (isPrivate) {
+        masterKey = loadMasterKey();
+        if (!masterKey) {
+          showError(screen, 'Encryption session not unlocked. Run: tusky encryption unlock');
+          setFocus(currentFocus);
+          return;
+        }
+      }
+
+      let successCount = 0;
+      const total = filePaths.length;
+
+      for (const filePath of filePaths) {
+        const fileName = basename(filePath);
+        statusBar.setHints(`Uploading ${successCount + 1}/${total}: ${fileName}...`);
+        screen.render();
+
+        const stat = statSync(filePath);
+        const fileBuffer = readFileSync(filePath);
+        const mimeType = lookup(filePath) || 'application/octet-stream';
+
+        let uploadBody: Buffer;
+        let encryptionMeta: {
+          wrappedKey?: string;
+          encryptionIv?: string;
+          plaintextSizeBytes?: number;
+          plaintextChecksumSha256?: string;
+        } = {};
+
+        if (isPrivate && masterKey) {
+          const { ciphertext, wrappedKey, iv, plaintextChecksum } = encryptBuffer(fileBuffer, masterKey);
+          uploadBody = ciphertext;
+          encryptionMeta = {
+            wrappedKey,
+            encryptionIv: iv,
+            plaintextSizeBytes: stat.size,
+            plaintextChecksumSha256: plaintextChecksum,
+          };
+        } else {
+          uploadBody = fileBuffer;
+        }
+
+        const { fileId, uploadUrl } = await sdk.files.requestUpload({
+          name: fileName,
+          mimeType,
+          sizeBytes: uploadBody.length,
+          vaultId,
+          ...encryptionMeta,
+        });
+
+        const uploadResponse = await fetch(uploadUrl, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/octet-stream' },
+          body: new Uint8Array(uploadBody),
+        });
+
+        if (!uploadResponse.ok) throw new Error(`Upload failed for ${fileName}: ${uploadResponse.status}`);
+
+        await sdk.files.confirmUpload(fileId);
+        successCount++;
+      }
+
+      showMessage(screen, `Uploaded ${successCount} file(s)`);
+      await filesPanel.loadForVault(vaultId, filesPanel.getCurrentVaultName());
+      await vaultsPanel.load();
+    } catch (err: any) {
+      showError(screen, err.message);
+    }
+    setFocus(currentFocus);
+  });
+
+  screen.key(['d', 'delete'], async () => {
+    if (currentFocus === 'vaults') {
+      const vault = vaultsPanel.getSelected();
+      if (!vault) return;
+      const confirmed = await confirmDialog(screen, `Delete vault "${vault.name}" and ALL its files?`);
+      if (confirmed) {
+        try {
+          await sdk.vaults.delete(vault.id, { force: true });
+          filesPanel.clear();
+          await vaultsPanel.load();
+          showMessage(screen, `Vault "${vault.name}" deleted`);
+        } catch (err: any) {
+          showError(screen, err.message);
+        }
+      }
+      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();
+          }
+          showMessage(screen, `File "${file.name}" deleted`);
+        } catch (err: any) {
+          showError(screen, err.message);
+        }
+      }
+      setFocus(currentFocus);
+    }
+  });
+
+  screen.key(['enter'], () => {
+    if (currentFocus === 'vaults') {
+      const vault = vaultsPanel.getSelected();
+      if (vault) {
+        const rows: [string, string][] = [
+          ['Name', vault.name],
+          ['Slug', vault.slug],
+          ['ID', vault.id],
+          ['Visibility', vault.visibility],
+          ['Files', String(vault.fileCount)],
+          ['Size', formatBytes(vault.totalSizeBytes)],
+        ];
+        detailPopup(screen, vault.name, formatDetailTable(rows));
+      }
+    } else {
+      const file = filesPanel.getSelected();
+      if (file) {
+        const open = statusColor(file.status);
+        const close = statusColorClose(file.status);
+        const rows: [string, string][] = [
+          ['Name', file.name],
+          ['ID', file.id],
+          ['MIME', file.mimeType],
+          ['Size', formatBytes(file.plaintextSizeBytes ?? file.sizeBytes)],
+          ['Status', `${open}${file.status}${close}`],
+          ['Encrypted', file.encrypted ? 'Yes' : 'No'],
+          ['Uploaded', file.createdAt ? formatDate(file.createdAt) : 'N/A'],
+          ['Blob ID', file.walrusBlobId || 'N/A'],
+          ['Blob Object', file.walrusBlobObjectId || 'N/A'],
+        ];
+        detailPopup(screen, file.name, formatDetailTable(rows));
+      }
+    }
+  });
+
+  screen.key(['r'], async () => {
+    if (currentFocus === 'files') {
+      const file = filesPanel.getSelected();
+      if (!file) return;
+      if (file.status !== 'error') {
+        showMessage(screen, 'Only error files can be retried');
+        return;
+      }
+      try {
+        await sdk.files.retry(file.id);
+        const vaultId = filesPanel.getCurrentVaultId();
+        if (vaultId) {
+          await filesPanel.loadForVault(vaultId, filesPanel.getCurrentVaultName());
+        }
+        showMessage(screen, `Retry queued for "${file.name}"`);
+      } catch (err: any) {
+        showError(screen, err.message);
+      }
+      setFocus(currentFocus);
+    }
+  });
+
+  screen.key(['o'], async () => {
+    await showOverview(screen, sdk);
+    setFocus(currentFocus);
+  });
+
+  screen.key(['S-l'], async () => {
+    const confirmed = await confirmDialog(screen, 'Log out?');
+    if (confirmed) {
+      cliConfig.delete('apiKey' as any);
+      screen.destroy();
+      process.exit(0);
+    }
+    setFocus(currentFocus);
+  });
+
+  function applyTheme(theme: Theme) {
+    // Vaults panel
+    vaultsPanel.list.style.border = { fg: currentFocus === 'vaults' ? theme.borderFocus : theme.border } as any;
+    vaultsPanel.list.style.fg = theme.fg;
+    vaultsPanel.list.style.selected = theme.selected as any;
+    (vaultsPanel.list.style as any).focus = { border: { fg: theme.borderFocus } };
+
+    // Files panel
+    filesPanel.list.style.border = { fg: currentFocus === 'files' ? theme.borderFocus : theme.border } as any;
+    filesPanel.list.style.fg = theme.fg;
+    filesPanel.list.style.selected = theme.selected as any;
+    (filesPanel.list.style as any).focus = { border: { fg: theme.borderFocus } };
+
+    // Status bar
+    statusBar.applyTheme(theme);
+
+    screen.render();
+  }
+
+  screen.key(['t'], () => {
+    const theme = cycleTheme();
+    applyTheme(theme);
+    showMessage(screen, `Theme: ${theme.name}`);
+  });
+
+  screen.key(['?'], () => {
+    const helpContent = [
+      '{bold}{cyan-fg}Tusky TUI — Keyboard Shortcuts{/cyan-fg}{/bold}',
+      '',
+      '{bold}Navigation{/bold}',
+      '  ←/→        Switch between vaults/files',
+      '  Tab        Switch between vaults/files',
+      '  Up/Down    Navigate list',
+      '',
+      '{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',
+      '',
+      '{bold}Screens{/bold}',
+      '  o          Overview (account, storage, files)',
+      '  t          Cycle theme',
+      '  L          Logout',
+      '  ?          This help',
+      '  q/Ctrl-C   Quit',
+    ].join('\n');
+    detailPopup(screen, 'Help', helpContent);
+  });
+
+  // Initial load
+  await Promise.all([
+    vaultsPanel.load(),
+    loadStatusBar(),
+  ]);
+
+  setFocus('vaults');
+  screen.render();
+}

package/src/tui/overview.ts

@@ -0,0 +1,155 @@
+import blessed from 'blessed';
+import type { TuskyClient } from '@tuskydp/sdk';
+import { formatBytes, formatDate, statusColor, statusColorClose } from './helpers.js';
+
+export async function showOverview(
+  screen: blessed.Widgets.Screen,
+  sdk: TuskyClient,
+): Promise<void> {
+  return new Promise((resolve) => {
+    const container = blessed.box({
+      parent: screen,
+      top: 0,
+      left: 0,
+      width: '100%',
+      height: '100%',
+      tags: true,
+      scrollable: true,
+      alwaysScroll: true,
+      keys: true,
+      vi: true,
+      scrollbar: {
+        style: { bg: 'cyan' },
+      },
+      border: { type: 'line' },
+      style: {
+        border: { fg: 'cyan' },
+        fg: 'white',
+      },
+      label: ' Overview ',
+    });
+
+    const loading = blessed.box({
+      parent: container,
+      top: 'center',
+      left: 'center',
+      width: 'shrink',
+      height: 1,
+      content: 'Loading...',
+      tags: true,
+    });
+
+    screen.render();
+
+    (async () => {
+      try {
+        const [account, vaults, filesData] = await Promise.all([
+          sdk.account.get(),
+          sdk.vaults.list(),
+          sdk.files.list({ limit: 20, sortBy: 'createdAt', order: 'desc' }),
+        ]);
+
+        loading.destroy();
+
+        const files = filesData.files;
+
+        const storageUsed = account.storageUsedBytes || 0;
+        const storageLimit = account.storageLimitBytes || 0;
+        const pct = storageLimit > 0 ? Math.round((storageUsed / storageLimit) * 100) : 0;
+        const barWidth = 30;
+        const filled = Math.round((pct / 100) * barWidth);
+        const barFill = '█'.repeat(filled);
+        const barEmpty = '░'.repeat(barWidth - filled);
+        const barColor = pct > 90 ? '{red-fg}' : pct > 70 ? '{yellow-fg}' : '{green-fg}';
+        const barColorClose = pct > 90 ? '{/red-fg}' : pct > 70 ? '{/yellow-fg}' : '{/green-fg}';
+
+        let content = '';
+        content += '{bold}{cyan-fg}Account{/cyan-fg}{/bold}\n';
+        content += `  Email:   ${account.email || 'N/A'}\n`;
+        content += `  Plan:    ${account.planName || account.planTier || 'ppu'}\n`;
+        content += `  Storage: ${formatBytes(storageUsed)} / ${formatBytes(storageLimit)}\n`;
+        content += `           ${barColor}${barFill}${barEmpty}${barColorClose} ${pct}%\n`;
+        content += '\n';
+        content += `{bold}{cyan-fg}Vaults (${vaults.length}){/cyan-fg}{/bold}\n`;
+
+        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 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));
+          const vSizeW = Math.max(4, ...vaultRows.map((r) => r.size.length));
+
+          // Header
+          content += `  ${'Name'.padEnd(vNameW)}  ${'Vis'.padEnd(vVisW)}  ${'Files'.padStart(vFilesW)}  ${'Size'.padStart(vSizeW)}\n`;
+          content += `  ${'─'.repeat(vNameW)}  ${'─'.repeat(vVisW)}  ${'─'.repeat(vFilesW)}  ${'─'.repeat(vSizeW)}\n`;
+          for (const r of vaultRows) {
+            // Pad the plain text width, but use the tagged version for display
+            const visPad = ' '.repeat(Math.max(0, vVisW - r.vis.length));
+            content += `  ${r.name.padEnd(vNameW)}  ${r.visTag}${visPad}  ${r.files.padStart(vFilesW)}  ${r.size.padStart(vSizeW)}\n`;
+          }
+        }
+
+        content += '\n';
+        content += '{bold}{cyan-fg}Recent Files{/cyan-fg}{/bold}\n';
+
+        if (files.length === 0) {
+          content += '  (no files yet)\n';
+        } else {
+          // Calculate column widths for files table
+          const fileRows = files.map((f) => ({
+            name: f.name || '',
+            size: formatBytes(f.plaintextSizeBytes ?? f.sizeBytes ?? 0),
+            status: f.status || '',
+            statusTag: `${statusColor(f.status)}${f.status}${statusColorClose(f.status)}`,
+            date: f.createdAt ? formatDate(f.createdAt) : 'N/A',
+          }));
+          const fNameW = Math.max(4, ...fileRows.map((r) => r.name.length));
+          const fSizeW = Math.max(4, ...fileRows.map((r) => r.size.length));
+          const fStatW = Math.max(6, ...fileRows.map((r) => r.status.length));
+          const fDateW = Math.max(4, ...fileRows.map((r) => r.date.length));
+
+          // Clamp name width to something reasonable
+          const maxNameW = Math.min(fNameW, 40);
+
+          // Header
+          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 statusPad = ' '.repeat(Math.max(0, fStatW - r.status.length));
+            content += `  ${truncName.padEnd(maxNameW)}  ${r.size.padStart(fSizeW)}  ${r.statusTag}${statusPad}  ${r.date}\n`;
+          }
+        }
+
+        content += '\n{gray-fg}Press Escape to return{/gray-fg}';
+
+        container.setContent(content);
+        container.focus();
+        screen.render();
+      } catch (err: any) {
+        loading.setContent(`{red-fg}Error: ${err.message}{/red-fg}`);
+        screen.render();
+      }
+    })();
+
+    container.key(['escape', 'q'], () => {
+      container.destroy();
+      screen.render();
+      resolve();
+    });
+
+    screen.key(['escape'], function escHandler() {
+      screen.unkey('escape', escHandler);
+      container.destroy();
+      screen.render();
+      resolve();
+    });
+  });
+}

package/src/tui/status-bar.ts

@@ -0,0 +1,61 @@
+import blessed from 'blessed';
+import type { Theme } from './helpers.js';
+
+export class StatusBar {
+  box: blessed.Widgets.BoxElement;
+  private screen: blessed.Widgets.Screen;
+  private email = '';
+  private plan = '';
+  private storageUsed = '';
+  private storageLimit = '';
+  private hints = '';
+
+  constructor(screen: blessed.Widgets.Screen) {
+    this.screen = screen;
+    this.box = blessed.box({
+      parent: screen,
+      bottom: 0,
+      left: 0,
+      width: '100%',
+      height: 1,
+      tags: true,
+      style: {
+        fg: 'white',
+        bg: 'blue',
+      },
+    });
+    this.render();
+  }
+
+  setUser(email: string, plan: string, storageUsed: string, storageLimit: string) {
+    this.email = email;
+    this.plan = plan;
+    this.storageUsed = storageUsed;
+    this.storageLimit = storageLimit;
+    this.render();
+  }
+
+  setHints(hints: string) {
+    this.hints = hints;
+    this.render();
+  }
+
+  private render() {
+    const left = this.email
+      ? `{bold}${this.email}{/bold} | ${this.plan} | ${this.storageUsed} / ${this.storageLimit}`
+      : '{bold}Tusky{/bold} — Decentralized Storage';
+    const right = this.hints ? `${this.hints} ` : '';
+    this.box.setContent(` ${left}${right ? '  |  ' + right : ''}`);
+    this.screen.render();
+  }
+
+  applyTheme(theme: Theme) {
+    this.box.style.bg = theme.statusBar.bg;
+    this.box.style.fg = theme.statusBar.fg;
+    this.render();
+  }
+
+  destroy() {
+    this.box.destroy();
+  }
+}