@tuskydp/cli 0.1.0 → 0.1.1

package/src/mcp/tools/vaults.ts

@@ -0,0 +1,114 @@
+/**
+ * MCP tools — Vault management
+ */
+
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpContext } from '../context.js';
+import { wrapToolError } from './helpers.js';
+
+export function registerVaultTools(server: McpServer, ctx: McpContext) {
+  // ── Create vault ─────────────────────────────────────────────────────
+  server.tool(
+    'tusky_vault_create',
+    'Create a new storage vault. Visibility is immutable after creation.',
+    {
+      name: z.string().describe('Vault name'),
+      description: z.string().optional().describe('Vault description'),
+      visibility: z.enum(['public', 'private']).optional().describe(
+        'Vault visibility. "private" enables client-side encryption. Defaults to "private".',
+      ),
+    },
+    async ({ name, description, visibility }) => {
+      try {
+        const vault = await ctx.sdk.vaults.create({
+          name,
+          description,
+          visibility: visibility ?? 'private',
+        });
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(vault, null, 2) }],
+        };
+      } catch (err) {
+        return wrapToolError(err);
+      }
+    },
+  );
+
+  // ── List vaults ──────────────────────────────────────────────────────
+  server.tool(
+    'tusky_vault_list',
+    'List all vaults in the account',
+    {},
+    async () => {
+      try {
+        const vaults = await ctx.sdk.vaults.list();
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(vaults, null, 2) }],
+        };
+      } catch (err) {
+        return wrapToolError(err);
+      }
+    },
+  );
+
+  // ── Get vault ────────────────────────────────────────────────────────
+  server.tool(
+    'tusky_vault_get',
+    'Get details of a specific vault by ID',
+    {
+      vaultId: z.string().describe('Vault ID'),
+    },
+    async ({ vaultId }) => {
+      try {
+        const vault = await ctx.sdk.vaults.get(vaultId);
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(vault, null, 2) }],
+        };
+      } catch (err) {
+        return wrapToolError(err);
+      }
+    },
+  );
+
+  // ── Update vault ─────────────────────────────────────────────────────
+  server.tool(
+    'tusky_vault_update',
+    'Update a vault name or description (visibility cannot be changed)',
+    {
+      vaultId: z.string().describe('Vault ID'),
+      name: z.string().optional().describe('New vault name'),
+      description: z.string().optional().describe('New vault description'),
+    },
+    async ({ vaultId, name, description }) => {
+      try {
+        const vault = await ctx.sdk.vaults.update(vaultId, { name, description });
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(vault, null, 2) }],
+        };
+      } catch (err) {
+        return wrapToolError(err);
+      }
+    },
+  );
+
+  // ── Delete vault ─────────────────────────────────────────────────────
+  server.tool(
+    'tusky_vault_delete',
+    'Delete a vault. Use force=true to delete even if the vault contains files.',
+    {
+      vaultId: z.string().describe('Vault ID'),
+      force: z.boolean().optional().describe('Force delete even if vault contains files'),
+    },
+    async ({ vaultId, force }) => {
+      try {
+        await ctx.sdk.vaults.delete(vaultId, { force });
+        return {
+          content: [{ type: 'text' as const, text: `Vault ${vaultId} deleted successfully.` }],
+        };
+      } catch (err) {
+        return wrapToolError(err);
+      }
+    },
+  );
+}

package/src/sdk.ts

@@ -0,0 +1,115 @@
+/**
+ * SDK client factory for CLI commands + AuthClient for pre-auth flows.
+ *
+ * The TuskyClient SDK requires an API key, so it can't be used for
+ * register/login/createApiKeyWithJwt flows. AuthClient handles those
+ * with raw fetch calls.
+ */
+
+import { TuskyClient, TuskyError } from '@tuskydp/sdk';
+import type { Command } from 'commander';
+import { getApiUrl, getApiKey } from './config.js';
+
+const CLI_VERSION = '0.1.0';
+
+// ---------------------------------------------------------------------------
+// SDK client factory (for authenticated commands)
+// ---------------------------------------------------------------------------
+
+/** Create a TuskyClient from Commander options (uses stored API key). */
+export function getSDKClient(program: Command): TuskyClient {
+  const apiUrl = getApiUrl(program.opts().apiUrl);
+  const apiKey = getApiKey(program.opts().apiKey);
+  return new TuskyClient({ apiKey, baseUrl: apiUrl });
+}
+
+/**
+ * Create a TuskyClient from Commander options, resolved from a sub-command
+ * whose parent holds the global options.
+ */
+export function getSDKClientFromParent(program: Command): TuskyClient {
+  const root = program.parent || program;
+  const apiUrl = getApiUrl(root.opts().apiUrl);
+  const apiKey = getApiKey(root.opts().apiKey);
+  return new TuskyClient({ apiKey, baseUrl: apiUrl });
+}
+
+/** Create a TuskyClient from explicit url + key (used in TUI). */
+export function createSDKClient(apiUrl: string, apiKey: string): TuskyClient {
+  return new TuskyClient({ apiKey, baseUrl: apiUrl });
+}
+
+// ---------------------------------------------------------------------------
+// AuthClient — pre-authentication flows (no API key needed)
+// ---------------------------------------------------------------------------
+
+/**
+ * Lightweight client for unauthenticated / JWT-authenticated API calls.
+ * Used for register, login, createApiKeyWithJwt, and getPlans.
+ */
+export class AuthClient {
+  private apiUrl: string;
+
+  constructor(apiUrl: string) {
+    this.apiUrl = apiUrl.replace(/\/$/, '');
+  }
+
+  private async fetchJSON<T>(url: string, init: RequestInit): Promise<T> {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({ error: response.statusText }));
+      throw new TuskyError(response.status, (body as Record<string, string>).error || 'Unknown error');
+    }
+    return response.json() as Promise<T>;
+  }
+
+  async register(email: string, password: string, accessCode: string, displayName?: string) {
+    return this.fetchJSON<{ user: { email: string; id: string }; accessToken: string; refreshToken: string }>(
+      `${this.apiUrl}/api/auth/register`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'User-Agent': `tusky-cli/${CLI_VERSION}` },
+        body: JSON.stringify({ email, password, displayName, accessCode }),
+      },
+    );
+  }
+
+  async login(email: string, password: string) {
+    return this.fetchJSON<{ user: { email: string; id: string }; accessToken: string; refreshToken: string }>(
+      `${this.apiUrl}/api/auth/login`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'User-Agent': `tusky-cli/${CLI_VERSION}` },
+        body: JSON.stringify({ email, password }),
+      },
+    );
+  }
+
+  async createApiKeyWithJwt(accessToken: string, name: string) {
+    return this.fetchJSON<{ apiKey: string; name: string; keyPrefix: string }>(
+      `${this.apiUrl}/api/auth/api-keys`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${accessToken}`,
+          'User-Agent': `tusky-cli/${CLI_VERSION}`,
+        },
+        body: JSON.stringify({ name }),
+      },
+    );
+  }
+
+  async getPlans() {
+    return this.fetchJSON<{ plans: any[] }>(
+      `${this.apiUrl}/api/plans`,
+      {
+        method: 'GET',
+        headers: { 'User-Agent': `tusky-cli/${CLI_VERSION}` },
+      },
+    );
+  }
+}
+
+// Re-export TuskyError for catch blocks that need to check error type
+export { TuskyError } from '@tuskydp/sdk';

package/src/tui/auth-screen.ts

@@ -0,0 +1,176 @@
+import blessed from 'blessed';
+import { TuskyClient } from '@tuskydp/sdk';
+import { AuthClient, createSDKClient } from '../sdk.js';
+import { cliConfig, getApiUrl } from '../config.js';
+import { textInputDialog, selectDialog } from './dialogs.js';
+import { showError, showMessage } from './helpers.js';
+
+export async function showAuthScreen(
+  screen: blessed.Widgets.Screen,
+): Promise<{ apiKey: string; apiUrl: string } | null> {
+  return new Promise((resolve) => {
+    const container = blessed.box({
+      parent: screen,
+      top: 0,
+      left: 0,
+      width: '100%',
+      height: '100%',
+      tags: true,
+    });
+
+    const logo = blessed.box({
+      parent: container,
+      top: 2,
+      left: 'center',
+      width: 'shrink',
+      height: 'shrink',
+      tags: true,
+      content: [
+        '{bold}{cyan-fg}╔════════════════════════════╗{/cyan-fg}{/bold}',
+        '{bold}{cyan-fg}║       TUSKY  TUI           ║{/cyan-fg}{/bold}',
+        '{bold}{cyan-fg}║  Decentralized Storage     ║{/cyan-fg}{/bold}',
+        '{bold}{cyan-fg}╚════════════════════════════╝{/cyan-fg}{/bold}',
+      ].join('\n'),
+    });
+
+    const prompt = blessed.box({
+      parent: container,
+      top: 8,
+      left: 'center',
+      width: 40,
+      height: 3,
+      tags: true,
+      content: '{center}Not authenticated.{/center}\n{center}Choose an option to continue:{/center}',
+    });
+
+    const menu = blessed.list({
+      parent: container,
+      top: 12,
+      left: 'center',
+      width: 30,
+      height: 5,
+      border: { type: 'line' },
+      style: {
+        border: { fg: 'cyan' },
+        fg: 'white',
+        selected: {
+          bg: 'cyan',
+          fg: 'black',
+        },
+      },
+      keys: true,
+      vi: true,
+      items: ['Sign Up (email)', 'Login (email)', 'Login (API key)'],
+      interactive: true,
+    });
+
+    const quitHint = blessed.box({
+      parent: container,
+      top: 18,
+      left: 'center',
+      width: 'shrink',
+      height: 1,
+      tags: true,
+      content: '{gray-fg}q to quit{/gray-fg}',
+    });
+
+    menu.on('select', async (_item: any, index: number) => {
+      if (index === 0) {
+        // Sign Up
+        const email = await textInputDialog(screen, 'Enter email');
+        if (!email) {
+          menu.focus();
+          screen.render();
+          return;
+        }
+        const password = await textInputDialog(screen, 'Enter password');
+        if (!password) {
+          menu.focus();
+          screen.render();
+          return;
+        }
+        const accessCode = await textInputDialog(screen, 'Enter access code');
+        if (!accessCode) {
+          menu.focus();
+          screen.render();
+          return;
+        }
+        const apiUrl = getApiUrl();
+        const authClient = new AuthClient(apiUrl);
+        try {
+          const { accessToken } = await authClient.register(email, password, accessCode);
+          const keyResult = await authClient.createApiKeyWithJwt(accessToken, 'TUI Key');
+          cliConfig.set('apiKey', keyResult.apiKey);
+          cliConfig.set('apiUrl', apiUrl);
+          container.destroy();
+          screen.render();
+          resolve({ apiKey: keyResult.apiKey, apiUrl });
+        } catch (err: any) {
+          showError(screen, err.message);
+          menu.focus();
+          screen.render();
+        }
+      } else if (index === 1) {
+        // Login with email
+        const email = await textInputDialog(screen, 'Enter email');
+        if (!email) {
+          menu.focus();
+          screen.render();
+          return;
+        }
+        const password = await textInputDialog(screen, 'Enter password');
+        if (!password) {
+          menu.focus();
+          screen.render();
+          return;
+        }
+        const apiUrl = getApiUrl();
+        const authClient = new AuthClient(apiUrl);
+        try {
+          const { accessToken } = await authClient.login(email, password);
+          const keyResult = await authClient.createApiKeyWithJwt(accessToken, 'CLI Key');
+          cliConfig.set('apiKey', keyResult.apiKey);
+          cliConfig.set('apiUrl', apiUrl);
+          container.destroy();
+          screen.render();
+          resolve({ apiKey: keyResult.apiKey, apiUrl });
+        } catch (err: any) {
+          showError(screen, 'Login failed: ' + err.message);
+          menu.focus();
+          screen.render();
+        }
+      } else {
+        // Login with API key
+        const key = await textInputDialog(screen, 'Paste API key');
+        if (!key) {
+          menu.focus();
+          screen.render();
+          return;
+        }
+        const apiUrl = getApiUrl();
+        const sdk = createSDKClient(apiUrl, key);
+        try {
+          await sdk.account.get();
+          cliConfig.set('apiKey', key);
+          cliConfig.set('apiUrl', apiUrl);
+          container.destroy();
+          screen.render();
+          resolve({ apiKey: key, apiUrl });
+        } catch (err: any) {
+          showError(screen, 'Invalid API key: ' + err.message);
+          menu.focus();
+          screen.render();
+        }
+      }
+    });
+
+    menu.key(['q'], () => {
+      container.destroy();
+      screen.render();
+      resolve(null);
+    });
+
+    menu.focus();
+    screen.render();
+  });
+}