@moxxy/cli 0.0.12 → 0.1.1

package/src/commands/auth.js

@@ -0,0 +1,326 @@
+/**
+ * Auth commands: token create/list/revoke.
+ * Supports both interactive and non-interactive (flag-based) modes.
+ */
+import { isInteractive, handleCancel, withSpinner, showResult, p } from '../ui.js';
+import { resetTokens } from './init.js';
+
+const VALID_SCOPES = [
+  '*',
+  'agents:read', 'agents:write', 'runs:write',
+  'vault:read', 'vault:write', 'tokens:admin', 'events:read',
+  'channels:read', 'channels:write',
+];
+
+const MULTI_VALUE_FLAGS = new Set(['model']);
+
+export function parseFlags(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const rest = arg.slice(2);
+      const eqIdx = rest.indexOf('=');
+      let key, value;
+      if (eqIdx !== -1) {
+        key = rest.slice(0, eqIdx);
+        value = rest.slice(eqIdx + 1);
+      } else if (i + 1 < args.length) {
+        key = rest;
+        value = args[i + 1];
+        i++;
+      } else {
+        key = rest;
+        value = true;
+      }
+      if (MULTI_VALUE_FLAGS.has(key) && value !== true) {
+        if (!Array.isArray(flags[key])) {
+          flags[key] = flags[key] !== undefined ? [flags[key]] : [];
+        }
+        flags[key].push(value);
+      } else {
+        flags[key] = value;
+      }
+    }
+  }
+  return flags;
+}
+
+export function parseAuthCommand(args) {
+  const [sub, action, ...rest] = args;
+  const flags = parseFlags(rest);
+
+  if (sub === 'token' && action === 'create') {
+    const scopes = flags.scopes
+      ? flags.scopes.split(',').map(s => s.trim()).filter(Boolean)
+      : undefined;
+    return {
+      action: 'create',
+      scopes,
+      ttl: flags.ttl ? parseInt(flags.ttl, 10) : undefined,
+      description: flags.description,
+      json: flags.json === true,
+    };
+  }
+
+  if (sub === 'token' && action === 'list') {
+    return { action: 'list', json: flags.json === true };
+  }
+
+  if (sub === 'token' && action === 'revoke') {
+    return { action: 'revoke', id: rest[0] };
+  }
+
+  return { action: sub, sub: action };
+}
+
+export function buildTokenPayload(scopes, ttl) {
+  const payload = { scopes };
+  if (ttl !== undefined && ttl !== null) {
+    payload.ttl_seconds = ttl;
+  }
+  return payload;
+}
+
+export async function runAuth(client, args) {
+  const parsed = parseAuthCommand(args);
+
+  // Interactive sub-menu when no valid action
+  if (!['create', 'list', 'revoke'].includes(parsed.action) && isInteractive()) {
+    const action = await p.select({
+      message: 'Auth action',
+      options: [
+        { value: 'create', label: 'Create token', hint: 'generate a new API token' },
+        { value: 'list',   label: 'List tokens',  hint: 'show all tokens' },
+        { value: 'revoke', label: 'Revoke token', hint: 'revoke an existing token' },
+      ],
+    });
+    handleCancel(action);
+    parsed.action = action;
+  }
+
+  switch (parsed.action) {
+    case 'create': {
+      let scopes = parsed.scopes;
+      let ttl = parsed.ttl;
+
+      if (!scopes && isInteractive()) {
+        scopes = await p.multiselect({
+          message: 'Select token scopes',
+          options: VALID_SCOPES.map(s => ({ value: s, label: s })),
+          required: true,
+        });
+        handleCancel(scopes);
+
+        const ttlInput = await p.text({
+          message: 'Token TTL in seconds',
+          placeholder: 'leave empty for no expiry',
+        });
+        handleCancel(ttlInput);
+        ttl = ttlInput ? parseInt(ttlInput, 10) : undefined;
+
+        const descInput = await p.text({
+          message: 'Token description',
+          placeholder: 'optional',
+        });
+        handleCancel(descInput);
+        parsed.description = descInput || undefined;
+      }
+
+      if (!scopes) {
+        throw new Error('Scopes are required. Use --scopes or run interactively.');
+      }
+
+      const invalid = scopes.filter(s => !VALID_SCOPES.includes(s));
+      if (invalid.length > 0) throw new Error(`Invalid scopes: ${invalid.join(', ')}`);
+      if (scopes.length === 0) throw new Error('At least one scope is required');
+
+      const payload = buildTokenPayload(scopes, ttl);
+      if (parsed.description) payload.description = parsed.description;
+
+      let result;
+      if (isInteractive()) {
+        // Try with current token first
+        try {
+          result = await withSpinner('Creating token...', () =>
+            client.request('/v1/auth/tokens', 'POST', payload), 'Token created.');
+        } catch (err) {
+          if (err.status === 401 && isInteractive()) {
+            p.log.warn('Authentication failed. Your token may be missing or invalid.');
+            const recovery = await p.select({
+              message: 'How would you like to proceed?',
+              options: [
+                { value: 'reset', label: 'Reset tokens', hint: 'clear all existing tokens and create a new one' },
+                { value: 'paste', label: 'Paste a token', hint: 'use an existing valid token' },
+                { value: 'abort', label: 'Abort' },
+              ],
+            });
+            handleCancel(recovery);
+
+            if (recovery === 'reset') {
+              const confirm = await p.confirm({
+                message: 'This will revoke ALL existing tokens. Continue?',
+                initialValue: false,
+              });
+              handleCancel(confirm);
+              if (confirm && resetTokens()) {
+                p.log.success('All tokens cleared.');
+                client.token = '';
+                result = await withSpinner('Creating token...', () =>
+                  client.request('/v1/auth/tokens', 'POST', payload), 'Token created.');
+              } else if (confirm) {
+                throw new Error('Could not reset tokens. Is sqlite3 installed?');
+              } else {
+                throw err;
+              }
+            } else if (recovery === 'paste') {
+              const pastedToken = await p.text({
+                message: 'Paste a valid API token',
+                placeholder: 'mox_...',
+              });
+              handleCancel(pastedToken);
+              if (pastedToken) {
+                client.token = pastedToken;
+                result = await withSpinner('Retrying...', () =>
+                  client.request('/v1/auth/tokens', 'POST', payload), 'Token created.');
+              } else {
+                throw err;
+              }
+            } else {
+              throw err;
+            }
+          } else {
+            throw err;
+          }
+        }
+        showResult('Your API Token', {
+          ID: result.id,
+          Token: result.token,
+          Scopes: scopes.join(', '),
+        });
+        p.note(
+          `# Add to ~/.zshrc or ~/.bashrc:\nexport MOXXY_TOKEN="${result.token}"`,
+          'Save your token'
+        );
+        p.log.warn('This token will not be shown again. Save it now.');
+      } else {
+        result = await client.request('/v1/auth/tokens', 'POST', payload);
+        if (parsed.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Token created: ${result.id}`);
+          if (result.token) console.log(`Secret: ${result.token}`);
+        }
+      }
+      return result;
+    }
+
+    case 'list': {
+      let tokens;
+      if (isInteractive()) {
+        tokens = await withSpinner('Fetching tokens...', () =>
+          client.request('/v1/auth/tokens', 'GET'), 'Tokens loaded.');
+        for (const t of (tokens || [])) {
+          p.log.info(`${t.id}  scopes=[${(t.scopes || []).join(',')}]  status=${t.status || 'active'}`);
+        }
+        if (!tokens || tokens.length === 0) {
+          p.log.warn('No tokens found.');
+        }
+      } else {
+        tokens = await client.request('/v1/auth/tokens', 'GET');
+        if (parsed.json) {
+          console.log(JSON.stringify(tokens, null, 2));
+        } else {
+          for (const t of (tokens || [])) {
+            console.log(`  ${t.id}  scopes=[${(t.scopes || []).join(',')}]  status=${t.status || 'active'}`);
+          }
+        }
+      }
+      return tokens;
+    }
+
+    case 'revoke': {
+      let id = parsed.id;
+
+      if (!id && isInteractive()) {
+        const tokens = await withSpinner('Fetching tokens...', () =>
+          client.request('/v1/auth/tokens', 'GET'), 'Tokens loaded.');
+
+        if (!tokens || tokens.length === 0) {
+          p.log.warn('No tokens to revoke.');
+          return;
+        }
+
+        id = await p.select({
+          message: 'Select token to revoke',
+          options: tokens.map(t => ({
+            value: t.id,
+            label: t.id,
+            hint: `scopes=[${(t.scopes || []).join(',')}]`,
+          })),
+        });
+        handleCancel(id);
+      }
+
+      if (!id) throw new Error('Usage: moxxy auth token revoke <id>');
+
+      if (isInteractive()) {
+        await withSpinner('Revoking token...', () =>
+          client.request(`/v1/auth/tokens/${encodeURIComponent(id)}`, 'DELETE'), 'Token revoked.');
+      } else {
+        await client.request(`/v1/auth/tokens/${encodeURIComponent(id)}`, 'DELETE');
+        console.log(`Token ${id} revoked.`);
+      }
+      break;
+    }
+
+    default: {
+      const { showHelp } = await import('../help.js');
+      showHelp('auth', p);
+      break;
+    }
+  }
+}
+
+export async function tokenCreate(client, args) {
+  const flags = parseFlags(args);
+  const scopes = flags.scopes
+    ? flags.scopes.split(',').map(s => s.trim()).filter(Boolean)
+    : [];
+
+  const invalid = scopes.filter(s => !VALID_SCOPES.includes(s));
+  if (invalid.length > 0) throw new Error(`Invalid scopes: ${invalid.join(', ')}`);
+  if (scopes.length === 0) throw new Error('At least one scope is required');
+
+  const ttl = flags.ttl ? parseInt(flags.ttl, 10) : undefined;
+  const payload = buildTokenPayload(scopes, ttl);
+  const result = await client.request('/v1/auth/tokens', 'POST', payload);
+  if (flags.json === 'true' || flags.json === true) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`Token created: ${result.id}`);
+    if (result.token) console.log(`Secret: ${result.token}`);
+  }
+  return result;
+}
+
+export async function tokenList(client, args) {
+  const flags = parseFlags(args || []);
+  const tokens = await client.request('/v1/auth/tokens', 'GET');
+  if (flags.json === 'true' || flags.json === true) {
+    console.log(JSON.stringify(tokens, null, 2));
+  } else {
+    for (const t of (tokens || [])) {
+      console.log(`  ${t.id}  scopes=[${(t.scopes || []).join(',')}]  status=${t.status || 'active'}`);
+    }
+  }
+  return tokens;
+}
+
+export async function tokenRevoke(client, id) {
+  if (!id) throw new Error('Usage: moxxy auth token revoke <id>');
+  await client.request(`/v1/auth/tokens/${encodeURIComponent(id)}`, 'DELETE');
+  console.log(`Token ${id} revoked.`);
+}
+
+export { VALID_SCOPES };

package/src/commands/channel.js

@@ -0,0 +1,285 @@
+import { p, handleCancel, withSpinner, showResult } from '../ui.js';
+import { showHelp } from '../help.js';
+import { parseFlags } from './auth.js';
+
+export async function runChannel(client, args) {
+  const [subcommand, ...rest] = args;
+
+  switch (subcommand) {
+    case 'create':
+      await createChannel(client, rest);
+      break;
+    case 'list':
+      await listChannels(client, rest);
+      break;
+    case 'pair':
+      await pairChannel(client, rest);
+      break;
+    case 'delete':
+      await deleteChannel(client, rest);
+      break;
+    case 'bindings':
+      await listBindings(client, rest);
+      break;
+    case 'unbind':
+      await unbindChannel(client, rest);
+      break;
+    default:
+      showHelp('channel', p);
+  }
+}
+
+async function createChannel(client, args) {
+  const channelType = await p.select({
+    message: 'Channel type',
+    options: [
+      { value: 'telegram', label: 'Telegram', hint: 'BotFather bot token required' },
+      { value: 'discord', label: 'Discord', hint: 'coming soon (scaffold)' },
+    ],
+  });
+  handleCancel(channelType);
+
+  if (channelType === 'discord') {
+    p.log.info('Discord channel support is coming soon.');
+    return;
+  }
+
+  // Step 1: Select agent to bind
+  let agentId;
+  try {
+    const agents = await client.listAgents();
+    if (agents.length === 0) {
+      p.log.error('No agents found. Create one first: moxxy agent create');
+      return;
+    }
+    agentId = await p.select({
+      message: 'Select agent to bind',
+      options: agents.map(a => ({
+        value: a.name,
+        label: `${a.name} (${a.provider_id}/${a.model_id})`,
+      })),
+    });
+    handleCancel(agentId);
+  } catch (err) {
+    p.log.error(`Failed to list agents: ${err.message}`);
+    return;
+  }
+
+  // Step 2: Get bot token
+  p.note(
+    '1. Open Telegram and talk to @BotFather\n' +
+    '2. Send /newbot and follow the prompts\n' +
+    '3. Copy the bot token',
+    'Telegram Bot Setup'
+  );
+
+  const botToken = await p.password({
+    message: 'Paste your Telegram bot token',
+  });
+  handleCancel(botToken);
+
+  const displayName = await p.text({
+    message: 'Display name for this channel',
+    placeholder: 'My Moxxy Bot',
+  });
+  handleCancel(displayName);
+
+  // Step 3: Create channel
+  let channel;
+  try {
+    channel = await withSpinner('Creating channel...', () =>
+      client.request('/v1/channels', 'POST', {
+        channel_type: channelType,
+        display_name: displayName || 'Telegram Bot',
+        bot_token: botToken,
+      }), 'Channel created.');
+
+    showResult('Channel Created', {
+      ID: channel.id,
+      Type: channel.channel_type,
+      Name: channel.display_name,
+      Status: channel.status,
+    });
+  } catch (err) {
+    p.log.error(`Failed to create channel: ${err.message}`);
+    return;
+  }
+
+  // Step 4: Wait for pairing code
+  p.note(
+    '1. Open your Telegram bot and send /start\n' +
+    '2. Copy the 6-digit pairing code',
+    'Pair your chat'
+  );
+
+  const code = await p.text({
+    message: 'Enter 6-digit pairing code',
+    validate: (v) => {
+      if (!v || v.trim().length === 0) return 'Code is required';
+    },
+  });
+  handleCancel(code);
+
+  // Step 5: Pair
+  try {
+    const result = await withSpinner('Pairing...', () =>
+      client.request(`/v1/channels/${channel.id}/pair`, 'POST', {
+        code: code.trim(),
+        agent_id: agentId,
+      }), 'Paired successfully.');
+
+    showResult('Channel Paired', {
+      'Binding ID': result.id,
+      Channel: result.channel_id,
+      Agent: result.agent_id,
+      'External Chat': result.external_chat_id,
+    });
+  } catch (err) {
+    p.log.error(`Failed to pair: ${err.message}`);
+  }
+}
+
+async function listChannels(client, args) {
+  const flags = parseFlags(args);
+  try {
+    const channels = await client.request('/v1/channels', 'GET');
+    if (flags.json) {
+      console.log(JSON.stringify(channels, null, 2));
+      return;
+    }
+    if (channels.length === 0) {
+      p.log.info('No channels found. Create one with: moxxy channel create');
+      return;
+    }
+    for (const ch of channels) {
+      p.log.info(`${ch.id} | ${ch.channel_type} | ${ch.display_name} | ${ch.status}`);
+    }
+  } catch (err) {
+    p.log.error(`Failed to list channels: ${err.message}`);
+  }
+}
+
+async function pairChannel(client, args) {
+  const flags = parseFlags(args);
+  let code = flags.code;
+  let agentId = flags.agent;
+
+  if (!code) {
+    code = await p.text({ message: 'Enter 6-digit pairing code' });
+    handleCancel(code);
+  }
+
+  if (!agentId) {
+    try {
+      const agents = await client.listAgents();
+      if (agents.length === 0) {
+        p.log.error('No agents found. Create one first: moxxy agent create');
+        return;
+      }
+      agentId = await p.select({
+        message: 'Select agent to bind',
+        options: agents.map(a => ({
+          value: a.name,
+          label: `${a.name} (${a.provider_id}/${a.model_id})`,
+        })),
+      });
+      handleCancel(agentId);
+    } catch (err) {
+      p.log.error(`Failed to list agents: ${err.message}`);
+      return;
+    }
+  }
+
+  // Find the channel to pair with
+  let channelId;
+  try {
+    const channels = await client.request('/v1/channels', 'GET');
+    if (channels.length === 0) {
+      p.log.error('No channels found. Create one first: moxxy channel create');
+      return;
+    }
+    if (channels.length === 1) {
+      channelId = channels[0].id;
+    } else {
+      channelId = await p.select({
+        message: 'Select channel',
+        options: channels.map(c => ({
+          value: c.id,
+          label: `${c.id.substring(0, 8)} (${c.channel_type} - ${c.display_name})`,
+        })),
+      });
+      handleCancel(channelId);
+    }
+  } catch (err) {
+    p.log.error(`Failed to list channels: ${err.message}`);
+    return;
+  }
+
+  try {
+    const result = await withSpinner('Pairing...', () =>
+      client.request(`/v1/channels/${channelId}/pair`, 'POST', {
+        code,
+        agent_id: agentId,
+      }), 'Paired successfully.');
+
+    showResult('Channel Paired', {
+      'Binding ID': result.id,
+      Channel: result.channel_id,
+      Agent: result.agent_id,
+      'External Chat': result.external_chat_id,
+    });
+  } catch (err) {
+    p.log.error(`Failed to pair: ${err.message}`);
+  }
+}
+
+async function deleteChannel(client, args) {
+  const [channelId] = args;
+  if (!channelId) {
+    p.log.error('Usage: moxxy channel delete <channel-id>');
+    return;
+  }
+
+  try {
+    await withSpinner('Deleting channel...', () =>
+      client.request(`/v1/channels/${channelId}`, 'DELETE'), 'Channel deleted.');
+  } catch (err) {
+    p.log.error(`Failed to delete channel: ${err.message}`);
+  }
+}
+
+async function listBindings(client, args) {
+  const [channelId] = args;
+  if (!channelId) {
+    p.log.error('Usage: moxxy channel bindings <channel-id>');
+    return;
+  }
+
+  try {
+    const bindings = await client.request(`/v1/channels/${channelId}/bindings`, 'GET');
+    if (bindings.length === 0) {
+      p.log.info('No bindings found for this channel.');
+      return;
+    }
+    for (const b of bindings) {
+      p.log.info(`${b.id} | Agent: ${b.agent_id} | Chat: ${b.external_chat_id} | ${b.status}`);
+    }
+  } catch (err) {
+    p.log.error(`Failed to list bindings: ${err.message}`);
+  }
+}
+
+async function unbindChannel(client, args) {
+  const [channelId, bindingId] = args;
+  if (!channelId || !bindingId) {
+    p.log.error('Usage: moxxy channel unbind <channel-id> <binding-id>');
+    return;
+  }
+
+  try {
+    await withSpinner('Unbinding...', () =>
+      client.request(`/v1/channels/${channelId}/bindings/${bindingId}`, 'DELETE'), 'Unbound.');
+  } catch (err) {
+    p.log.error(`Failed to unbind: ${err.message}`);
+  }
+}