@vendian/cli 0.0.1 → 0.0.2

package/README.md

@@ -4,6 +4,7 @@ Command-line tools for signing in to Vendian and running local agent workflows.
 
 ```bash
 npm install -g @vendian/cli
+vendian
 vendian login
 vendian cloud local serve --agents-dir ./agents
 ```
@@ -11,15 +12,19 @@ vendian cloud local serve --agents-dir ./agents
 ## Commands
 
 ```bash
+vendian
 vendian login
 vendian doctor
 vendian update
 vendian cloud local serve --agents-dir ./agents
 ```
 
+Run `vendian` with no arguments to open the interactive menu. It shows your
+current endpoint connections and guides common local workflows.
+
 `vendian login` opens a browser sign-in, prepares the local runtime, and stores
-the credentials needed by the CLI. `vendian setup` is kept as an alias for
-existing users.
+the credentials needed by the CLI for the selected endpoint. `vendian setup` is
+kept as an alias for existing users.
 
 `vendian doctor` checks the local installation. `vendian update` refreshes the
 managed runtime without changing your agents.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vendian/cli",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Public Vendian CLI bootstrapper and launcher",
   "license": "UNLICENSED",
   "private": false,

package/src/auth.js

@@ -52,6 +52,32 @@ export async function loginWithVendianOAuth({ backend, apiUrl, noBrowser = false
   }
 }
 
+export function loadCloudConfig(env = process.env, platform = process.platform) {
+  const file = cloudConfigPath(env, platform);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export function cloudAuthStatus({ backend, apiUrl, env = process.env, platform = process.platform } = {}) {
+  const targetApiUrl = resolveApiUrl({ backend, apiUrl, env });
+  const config = loadCloudConfig(env, platform);
+  const profiles = config.profiles && typeof config.profiles === 'object' ? config.profiles : {};
+  const profile = profiles[targetApiUrl];
+  return {
+    apiUrl: targetApiUrl,
+    activeApiUrl: typeof config.active_api_url === 'string' ? config.active_api_url : undefined,
+    profile: profile && typeof profile === 'object' ? profile : undefined,
+    authenticated: Boolean(profile?.access_token),
+    email: typeof profile?.email === 'string' ? profile.email : undefined,
+    expiresAt: typeof profile?.expires_at === 'string' ? profile.expires_at : undefined,
+    profiles
+  };
+}
+
 async function getOAuthConfig(apiUrl, redirectUri) {
   const url = new URL(`${apiUrl}/api/v1/cli/auth/oauth/config`);
   url.searchParams.set('redirectUri', redirectUri);

package/src/doctor.js

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { loadConfig, redact } from './config.js';
+import { loadConfig } from './config.js';
 import { registryConfig } from './install.js';
 import { managedVenvPath, venvPython, venvVendian } from './paths.js';
 import { findPython, hasUv, pythonVersion, verifyVendianImports } from './python.js';
@@ -18,6 +18,5 @@ export function doctor({ env = process.env, platform = process.platform } = {})
   console.log(`Managed Python: ${fs.existsSync(pythonPath) ? pythonVersion(pythonPath) || 'present' : 'missing'}`);
   console.log(`Vendian executable: ${fs.existsSync(vendianPath) ? vendianPath : 'missing'}`);
   console.log(`Vendian imports: ${fs.existsSync(pythonPath) && verifyVendianImports(pythonPath) ? 'ok' : 'missing'}`);
-  console.log(`GitLab host: ${registry.gitlabHost}`);
-  console.log(`Package token: ${registry.token ? `${redact(registry.token)} (${registry.tokenSource})` : 'missing'}`);
+  console.log(`Package access: ${registry.token ? `configured (${registry.tokenSource})` : 'missing'}`);
 }

package/src/install.js

@@ -59,7 +59,7 @@ export function installVendianPackages({ pythonPath, venvPath, config, env = pro
   const registry = registryConfig(config, env, platform);
   const indexes = buildIndexUrls(registry);
   if (!indexes) {
-    throw new Error('A GitLab package token is required until backend-issued package tokens are available. Run `vendian setup` or set GITLAB_TOKEN.');
+    throw new Error('Package access is missing. Run `vendian login`.');
   }
 
   const specs = packageSpecs(registry);
@@ -82,7 +82,7 @@ export function installVendianPackages({ pythonPath, venvPath, config, env = pro
     status = runInherit(pythonPath, ['-m', 'pip', ...installArgs]);
   }
   if (status !== 0) {
-    throw new Error('Could not install Vendian SDK/runtime packages. Check token access and package versions.');
+    throw new Error('Could not install Vendian runtime packages. Check package access and try again.');
   }
 
   writeInstallMarker(venvPath, {

package/src/main.js

@@ -1,41 +1,46 @@
 import { doctor } from './doctor.js';
 import { forwardToPythonVendian } from './forward.js';
 import { setup } from './setup.js';
+import { runTui } from './tui.js';
 
 function printHelp() {
-  console.log(`Vendian CLI bootstrapper
+  console.log(`Vendian CLI
 
 Usage:
-  vendian login                 Sign in and install the private Vendian CLI/runtime
+  vendian                       Open the interactive menu
+  vendian login                 Sign in and prepare the local runtime
   vendian setup                 Alias for vendian login
   vendian doctor                Check local bootstrap health
   vendian update                Update the managed Vendian CLI/runtime
-  vendian <command>             Forward to the managed Python Vendian CLI
+  vendian <command>             Run a Vendian cloud command
 
 Examples:
   vendian login
-  vendian login --backend prod
+  vendian login --backend staging
   vendian cloud local serve --agents-dir ./agents
 
 Environment:
   VENDIAN_CLI_HOME              Override managed CLI home
   VENDIAN_API_URL               Override Vendian backend API URL
-  GITLAB_TOKEN                  Local-dev package registry token fallback
-  GITLAB_USERNAME               Local-dev package registry username fallback
-  GITLAB_HOST                   Defaults to gitlab.com
-  SDK_PUBLIC_PROJECT_ID         Defaults to Vendian SDK project
-  SDK_RUNTIME_PROJECT_ID        Defaults to Vendian runtime project
 `);
 }
 
 export async function main(argv) {
   const [command, ...rest] = argv;
-  if (!command || command === '--help' || command === '-h') {
+  if (!command) {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      await runTui();
+    } else {
+      printHelp();
+    }
+    return;
+  }
+  if (command === '--help' || command === '-h') {
     printHelp();
     return;
   }
   if (command === '--version' || command === 'version') {
-    console.log('0.1.0');
+    console.log('0.0.1');
     return;
   }
   if (isBootstrapCommand(command)) {
@@ -60,7 +65,8 @@ export function isBootstrapCommand(command) {
 function parseSetupOptions(args) {
   const options = {
     nonInteractive: args.includes('--yes') || args.includes('--non-interactive'),
-    noBrowser: args.includes('--no-browser')
+    noBrowser: args.includes('--no-browser'),
+    forceAuth: args.includes('--force') || args.includes('--reauth')
   };
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];

package/src/setup.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
-import { loginWithVendianOAuth, saveCloudToken } from './auth.js';
+import { cloudAuthStatus, loginWithVendianOAuth, saveCloudToken } from './auth.js';
 import { DEFAULT_GITLAB_HOST, DEFAULT_SDK_PUBLIC_PROJECT_ID, DEFAULT_SDK_RUNTIME_PROJECT_ID } from './constants.js';
-import { loadConfig, saveConfig, redact } from './config.js';
+import { loadConfig, saveConfig } from './config.js';
 import { installVendianPackages, registryConfig } from './install.js';
 import { managedVenvPath, venvVendian } from './paths.js';
 import { findPython, ensureVenv, pythonVersion, verifyVendianImports } from './python.js';
@@ -12,11 +12,13 @@ export async function setup({
   backend = undefined,
   apiUrl = undefined,
   noBrowser = false,
+  forceAuth = false,
   env = process.env,
   platform = process.platform
 } = {}) {
   const existing = loadConfig(env, platform);
   const registry = registryConfig(existing, env, platform);
+  const auth = cloudAuthStatus({ backend, apiUrl, env, platform });
   const next = {
     ...existing,
     gitlabHost: registry.gitlabHost || DEFAULT_GITLAB_HOST,
@@ -24,48 +26,52 @@ export async function setup({
     sdkPublicProjectId: registry.sdkProjectId || DEFAULT_SDK_PUBLIC_PROJECT_ID,
     sdkRuntimeProjectId: registry.runtimeProjectId || DEFAULT_SDK_RUNTIME_PROJECT_ID
   };
-  let cloudAuthApiUrl;
+  let cloudAuthApiUrl = auth.authenticated ? auth.apiUrl : undefined;
 
-  console.log('Vendian setup');
-  console.log('This installs the private Vendian Python CLI/runtime into a managed local environment.');
+  console.log('Vendian login');
+  console.log('This signs in to Vendian and prepares the local runtime.');
   console.log('Agent requirements.txt files stay reserved for agent-owned dependencies.');
   console.log('');
 
-  if (!registry.token && !nonInteractive) {
-    console.log('Opening Vendian sign-in to get package access...');
+  if ((!auth.authenticated || forceAuth) && !nonInteractive) {
+    console.log(`Opening Vendian sign-in for ${auth.apiUrl}...`);
     const login = await loginWithVendianOAuth({ backend, apiUrl, noBrowser, env });
     saveCloudToken(login, { env, platform });
     cloudAuthApiUrl = login.apiUrl;
     const packageCredentials = login.packageCredentials;
-    if (!packageCredentials?.token) {
+    if (!registry.token && !packageCredentials?.token) {
       throw new Error('Vendian login succeeded, but the backend did not return package credentials. Configure CLI_PACKAGE_REGISTRY_TOKEN on the backend.');
     }
-    next.gitlabHost = packageCredentials.gitlabHost || next.gitlabHost;
-    next.gitlabUsername = packageCredentials.username || next.gitlabUsername;
-    next.sdkPublicProjectId = packageCredentials.sdkProjectId || next.sdkPublicProjectId;
-    next.sdkRuntimeProjectId = packageCredentials.runtimeProjectId || next.sdkRuntimeProjectId;
-    next.vendianAgentsVersion = packageCredentials.vendianAgentsVersion || next.vendianAgentsVersion;
-    next.vendianAgentsRuntimeVersion = packageCredentials.vendianAgentsRuntimeVersion || next.vendianAgentsRuntimeVersion;
+    if (packageCredentials) {
+      next.gitlabHost = packageCredentials.gitlabHost || next.gitlabHost;
+      next.gitlabUsername = packageCredentials.username || next.gitlabUsername;
+      next.sdkPublicProjectId = packageCredentials.sdkProjectId || next.sdkPublicProjectId;
+      next.sdkRuntimeProjectId = packageCredentials.runtimeProjectId || next.sdkRuntimeProjectId;
+      next.vendianAgentsVersion = packageCredentials.vendianAgentsVersion || next.vendianAgentsVersion;
+      next.vendianAgentsRuntimeVersion = packageCredentials.vendianAgentsRuntimeVersion || next.vendianAgentsRuntimeVersion;
 
-    const secret = savePackageTokenSecret(packageCredentials.token, next, platform);
-    if (secret.ok) {
-      Object.assign(next, secret.config || {});
-      delete next.gitlabToken;
-      console.log(`Package token saved with ${secret.provider}.`);
-    } else {
-      next.gitlabToken = packageCredentials.token;
-      console.log('Package token saved in the local Vendian CLI config file.');
+      const secret = savePackageTokenSecret(packageCredentials.token, next, platform);
+      if (secret.ok) {
+        Object.assign(next, secret.config || {});
+        delete next.gitlabToken;
+        console.log('Package access saved.');
+      } else {
+        next.gitlabToken = packageCredentials.token;
+        console.log('Package access saved in the local Vendian CLI config file.');
+      }
     }
+  } else if (auth.authenticated) {
+    console.log(`Cloud authentication already saved for ${auth.apiUrl}${auth.email ? ` (${auth.email})` : ''}.`);
   } else if (registry.token) {
     if (registry.tokenSource !== 'secret-store') {
       next.gitlabToken = registry.token;
     }
-    console.log(`Using GitLab package token ${redact(registry.token)}.`);
+    console.log('Using saved package access.');
   }
 
   const installRegistry = registryConfig(next, env, platform);
   if (!installRegistry.token) {
-    throw new Error('Setup needs package access. Run interactive `vendian login` to sign in, or set GITLAB_TOKEN for local development.');
+    throw new Error('Package access is missing. Run interactive `vendian login` to sign in.');
   }
 
   const python = findPython(platform);
@@ -98,9 +104,9 @@ export async function setup({
 }
 
 export function setupCompletionLines({ cloudAuthApiUrl, backend, apiUrl } = {}) {
-  const lines = ['Vendian setup complete.'];
+  const lines = ['Vendian login complete.'];
   if (cloudAuthApiUrl) {
-    lines.push(`Cloud authentication saved for ${cloudAuthApiUrl}.`);
+    lines.push(`Connected to ${cloudAuthApiUrl}.`);
     lines.push('Next: vendian cloud local serve --agents-dir ./agents');
     return lines;
   }

package/src/tui.js

@@ -0,0 +1,119 @@
+import readline from 'node:readline/promises';
+import { BACKEND_TARGETS } from './constants.js';
+import { cloudAuthStatus } from './auth.js';
+import { doctor } from './doctor.js';
+import { forwardToPythonVendian } from './forward.js';
+import { setup } from './setup.js';
+
+const ENDPOINTS = [
+  { key: 'local', label: 'Local' },
+  { key: 'dev', label: 'Dev' },
+  { key: 'staging', label: 'Staging' },
+  { key: 'prod', label: 'Production' }
+];
+
+export async function runTui({ env = process.env, platform = process.platform, input = process.stdin, output = process.stdout } = {}) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    while (true) {
+      output.write(`${renderHome({ env, platform })}\n`);
+      const choice = await ask(rl, 'Choose an option');
+      if (choice === '1') {
+        await connectEndpoint(rl, output, { env, platform });
+      } else if (choice === '2') {
+        const agentsDir = (await ask(rl, 'Agents directory', './agents')).trim() || './agents';
+        await forwardToPythonVendian(['cloud', 'local', 'serve', '--agents-dir', agentsDir], { env, platform });
+        return;
+      } else if (choice === '3') {
+        doctor({ env, platform });
+      } else if (choice === '4') {
+        await setup({ nonInteractive: true, env, platform });
+      } else if (choice === '5') {
+        output.write(`${helpText()}\n`);
+      } else if (choice === '6' || choice.toLowerCase() === 'q') {
+        return;
+      } else {
+        output.write('Unknown option.\n');
+      }
+      output.write('\n');
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+export function renderHome({ env = process.env, platform = process.platform } = {}) {
+  const rows = endpointRows({ env, platform });
+  return [
+    '',
+    'Vendian CLI',
+    '-----------',
+    'Connections:',
+    ...rows.map((row) => `  ${row.label.padEnd(10)} ${row.status}${row.detail ? ` - ${row.detail}` : ''}`),
+    '',
+    '1. Connect or switch endpoint',
+    '2. Start local agent server',
+    '3. Run doctor',
+    '4. Update managed runtime',
+    '5. Help',
+    '6. Exit'
+  ].join('\n');
+}
+
+export function endpointRows({ env = process.env, platform = process.platform } = {}) {
+  return ENDPOINTS.map((endpoint) => {
+    const status = cloudAuthStatus({ backend: endpoint.key, env, platform });
+    const active = status.activeApiUrl === status.apiUrl;
+    return {
+      key: endpoint.key,
+      label: endpoint.label,
+      apiUrl: status.apiUrl,
+      status: status.authenticated ? (active ? 'connected' : 'signed in') : 'not signed in',
+      detail: status.authenticated ? status.email || status.apiUrl : status.apiUrl
+    };
+  });
+}
+
+async function connectEndpoint(rl, output, { env, platform }) {
+  output.write('\nConnect endpoint:\n');
+  ENDPOINTS.forEach((endpoint, index) => {
+    output.write(`${index + 1}. ${endpoint.label} (${BACKEND_TARGETS[endpoint.key]})\n`);
+  });
+  output.write('5. Custom API URL\n');
+  const choice = await ask(rl, 'Endpoint');
+  if (choice === '5') {
+    const apiUrl = (await ask(rl, 'API URL')).trim();
+    if (!apiUrl) {
+      output.write('API URL is required.\n');
+      return;
+    }
+    await setup({ apiUrl, forceAuth: true, env, platform });
+    return;
+  }
+
+  const endpoint = ENDPOINTS[Number(choice) - 1];
+  if (!endpoint) {
+    output.write('Unknown endpoint.\n');
+    return;
+  }
+  await setup({ backend: endpoint.key, forceAuth: true, env, platform });
+}
+
+function helpText() {
+  return [
+    '',
+    'Common commands:',
+    '  vendian login',
+    '  vendian login --backend staging',
+    '  vendian login --api-url http://localhost:3000',
+    '  vendian cloud local serve --agents-dir ./agents',
+    '  vendian doctor',
+    '  vendian update'
+  ].join('\n');
+}
+
+async function ask(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` (${defaultValue})` : '';
+  const answer = await rl.question(`${question}${suffix}: `);
+  return answer.trim() || defaultValue || '';
+}