@moxxy/cli 0.0.12 → 0.1.1

package/src/commands/settings.js

@@ -0,0 +1,224 @@
+import { p, isInteractive, showResult } from '../ui.js';
+import { parseFlags } from './auth.js';
+import { getMoxxyHome } from './init.js';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const VALID_NETWORK_MODES = ['safe', 'unsafe'];
+
+function settingsPath() {
+  return join(getMoxxyHome(), 'settings.yaml');
+}
+
+function loadSettings() {
+  try {
+    const raw = readFileSync(settingsPath(), 'utf-8');
+    if (!raw.trim()) return {};
+    const settings = {};
+    for (const line of raw.split('\n')) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) settings[match[1]] = match[2].trim();
+    }
+    return settings;
+  } catch {
+    return {};
+  }
+}
+
+function saveSettings(settings) {
+  const dir = getMoxxyHome();
+  mkdirSync(dir, { recursive: true });
+  const lines = Object.entries(settings).map(([k, v]) => `${k}: ${v}`);
+  writeFileSync(settingsPath(), lines.join('\n') + '\n');
+}
+
+export function parseSettingsCommand(args) {
+  const [action, ...rest] = args;
+  const flags = parseFlags(rest);
+  return { action, flags };
+}
+
+async function settingsGet(flags) {
+  const settings = loadSettings();
+  const key = flags.key;
+
+  if (flags.json) {
+    console.log(JSON.stringify(key ? { key, value: settings[key] ?? null } : settings, null, 2));
+    return;
+  }
+
+  if (key) {
+    const value = settings[key] ?? '(not set)';
+    p.log.info(`${key}: ${value}`);
+  } else {
+    const entries = Object.entries(settings);
+    if (entries.length === 0) {
+      p.log.info('No settings configured. Using defaults.');
+      p.log.info('  network_mode: safe (default)');
+    } else {
+      for (const [k, v] of entries) {
+        p.log.info(`${k}: ${v}`);
+      }
+    }
+  }
+}
+
+async function settingsSet(flags) {
+  const key = flags.key;
+  const value = flags.value;
+
+  if (!key) throw new Error('Required: --key');
+  if (value === undefined) throw new Error('Required: --value');
+
+  // Validate known keys
+  if (key === 'network_mode' && !VALID_NETWORK_MODES.includes(value)) {
+    throw new Error(`Invalid network_mode '${value}'. Must be one of: ${VALID_NETWORK_MODES.join(', ')}`);
+  }
+
+  const settings = loadSettings();
+  settings[key] = value;
+  saveSettings(settings);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ status: 'updated', key, value }, null, 2));
+  } else {
+    showResult({ status: 'updated', key, value }, p);
+  }
+}
+
+async function settingsNetworkMode(flags) {
+  const settings = loadSettings();
+  const current = settings.network_mode || 'safe';
+
+  // No value provided — show current or toggle interactively
+  if (!flags.mode && !flags._positional) {
+    if (isInteractive()) {
+      const selected = await p.select({
+        message: `Network mode (currently: ${current})`,
+        options: [
+          { value: 'safe', label: 'Safe', hint: 'agent asks user before accessing non-allowlisted domains' },
+          { value: 'unsafe', label: 'Unsafe', hint: 'domain allowlist is bypassed entirely' },
+        ],
+        initialValue: current,
+      });
+      if (p.isCancel(selected)) return;
+      settings.network_mode = selected;
+      saveSettings(settings);
+      p.log.success(`Network mode set to: ${selected}`);
+    } else {
+      if (flags.json) {
+        console.log(JSON.stringify({ network_mode: current }, null, 2));
+      } else {
+        p.log.info(`network_mode: ${current}`);
+      }
+    }
+    return;
+  }
+
+  const mode = flags.mode || flags._positional;
+  if (!VALID_NETWORK_MODES.includes(mode)) {
+    throw new Error(`Invalid mode '${mode}'. Must be one of: ${VALID_NETWORK_MODES.join(', ')}`);
+  }
+
+  settings.network_mode = mode;
+  saveSettings(settings);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ status: 'updated', network_mode: mode }, null, 2));
+  } else {
+    p.log.success(`Network mode set to: ${mode}`);
+  }
+}
+
+async function settingsBrowserRendering(flags) {
+  const settings = loadSettings();
+  const current = settings.browser_rendering === 'true';
+
+  // No value provided — show current or toggle interactively
+  if (!flags._positional) {
+    if (isInteractive()) {
+      const selected = await p.select({
+        message: `Browser rendering (currently: ${current ? 'enabled' : 'disabled'})`,
+        options: [
+          { value: 'true', label: 'Enabled', hint: 'agents can render JS-heavy pages via headless Chrome' },
+          { value: 'false', label: 'Disabled', hint: 'agents use HTTP-only browsing' },
+        ],
+        initialValue: current ? 'true' : 'false',
+      });
+      if (p.isCancel(selected)) return;
+      settings.browser_rendering = selected;
+      saveSettings(settings);
+      p.log.success(`Browser rendering ${selected === 'true' ? 'enabled' : 'disabled'}.`);
+    } else {
+      if (flags.json) {
+        console.log(JSON.stringify({ browser_rendering: current }, null, 2));
+      } else {
+        p.log.info(`browser_rendering: ${current}`);
+      }
+    }
+    return;
+  }
+
+  const val = flags._positional;
+  if (!['true', 'false', 'on', 'off', 'enable', 'disable'].includes(val)) {
+    throw new Error(`Invalid value '${val}'. Use: true/false, on/off, or enable/disable`);
+  }
+
+  const enabled = ['true', 'on', 'enable'].includes(val);
+  settings.browser_rendering = String(enabled);
+  saveSettings(settings);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ status: 'updated', browser_rendering: enabled }, null, 2));
+  } else {
+    p.log.success(`Browser rendering ${enabled ? 'enabled' : 'disabled'}.`);
+  }
+}
+
+export async function runSettings(_client, args) {
+  const { action, flags } = parseSettingsCommand(args);
+
+  // Collect first positional arg after the action for convenience
+  // e.g. `moxxy settings network-mode unsafe`
+  const restArgs = args.slice(1).filter(a => !a.startsWith('--'));
+  if (restArgs.length > 0 && !flags._positional) {
+    flags._positional = restArgs[0];
+  }
+
+  switch (action) {
+    case 'get':
+      await settingsGet(flags);
+      break;
+    case 'set':
+      await settingsSet(flags);
+      break;
+    case 'network-mode':
+      await settingsNetworkMode(flags);
+      break;
+    case 'browser-rendering':
+      await settingsBrowserRendering(flags);
+      break;
+    default:
+      if (isInteractive() && !action) {
+        // Interactive: show settings menu
+        const selected = await p.select({
+          message: 'Settings',
+          options: [
+            { value: 'network-mode', label: 'Network mode', hint: 'safe / unsafe domain access' },
+            { value: 'browser-rendering', label: 'Browser rendering', hint: 'headless Chrome for JS-heavy sites' },
+            { value: 'get', label: 'View all settings', hint: 'show current configuration' },
+          ],
+        });
+        if (p.isCancel(selected)) return;
+        await runSettings(_client, [selected]);
+      } else {
+        throw new Error(
+          'Usage: moxxy settings <action>\n' +
+          '  network-mode [safe|unsafe]         Get or set network mode\n' +
+          '  browser-rendering [true|false]     Enable/disable headless Chrome rendering\n' +
+          '  get [--key <k>]                    View settings\n' +
+          '  set --key <k> --value <v>          Set a setting'
+        );
+      }
+  }
+}

package/src/commands/skill.js

@@ -0,0 +1,125 @@
+/**
+ * Skill commands: create/remove/list.
+ */
+import { parseFlags } from './auth.js';
+import { isInteractive, handleCancel, withSpinner, showResult, pickAgent, pickSkill, p } from '../ui.js';
+
+export async function runSkill(client, args) {
+  let [action, ...rest] = args;
+  const flags = parseFlags(rest);
+
+  // Interactive sub-menu when no valid action
+  if (!['create', 'remove', 'list'].includes(action) && isInteractive()) {
+    action = await p.select({
+      message: 'Skill action',
+      options: [
+        { value: 'create',  label: 'Create skill',  hint: 'install a skill on an agent' },
+        { value: 'remove',  label: 'Remove skill',  hint: 'remove a skill from an agent' },
+        { value: 'list',    label: 'List skills',   hint: 'list agent skills' },
+      ],
+    });
+    handleCancel(action);
+  }
+
+  switch (action) {
+    case 'create': {
+      let agentId = flags.agent;
+
+      // Interactive wizard when missing agent
+      if (!agentId && isInteractive()) {
+        agentId = await pickAgent(client, 'Select agent for skill');
+
+        const content = flags.content || handleCancel(await p.text({
+          message: 'Skill content (SKILL.md with YAML frontmatter)',
+          placeholder: 'Paste skill content...',
+          validate: (val) => { if (!val) return 'Content is required'; },
+        }));
+
+        const body = { content };
+        const result = await withSpinner('Creating skill...', () =>
+          client.request(`/v1/agents/${encodeURIComponent(agentId)}/skills/install`, 'POST', body), 'Skill created.');
+
+        showResult('Skill Created', {
+          Agent: agentId,
+          Name: result.name,
+          Version: result.version,
+        });
+
+        return result;
+      }
+
+      if (!agentId) throw new Error('Required: --agent');
+      const body = {
+        content: flags.content || '',
+      };
+      const result = await client.request(`/v1/agents/${encodeURIComponent(agentId)}/skills/install`, 'POST', body);
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    }
+
+    case 'remove': {
+      let agentId = flags.agent;
+      let skillId = flags.skill;
+
+      if ((!agentId || !skillId) && isInteractive()) {
+        if (!agentId) {
+          agentId = await pickAgent(client, 'Select agent');
+        }
+        if (!skillId) {
+          skillId = await pickSkill(client, agentId, 'Select skill to remove');
+        }
+
+        const confirmed = await p.confirm({
+          message: 'Remove this skill?',
+          initialValue: false,
+        });
+        handleCancel(confirmed);
+        if (!confirmed) {
+          p.log.info('Cancelled.');
+          return;
+        }
+      }
+
+      if (!agentId || !skillId) throw new Error('Required: --agent, --skill');
+      const result = await client.deleteSkill(agentId, skillId);
+      if (isInteractive()) {
+        p.log.success(`Skill ${skillId} removed.`);
+      } else {
+        console.log(`Skill ${skillId} removed.`);
+      }
+      return result;
+    }
+
+    case 'list': {
+      let agentId = flags.agent;
+      if (!agentId && isInteractive()) {
+        agentId = await pickAgent(client, 'Select agent to list skills');
+      }
+      if (!agentId) throw new Error('Required: --agent');
+
+      const skills = isInteractive()
+        ? await withSpinner('Fetching skills...', () =>
+            client.listSkills(agentId), 'Skills loaded.')
+        : await client.listSkills(agentId);
+
+      if (isInteractive()) {
+        if (Array.isArray(skills) && skills.length > 0) {
+          for (const s of skills) {
+            p.log.info(`${s.name} v${s.version}  (${s.slug || s.name})`);
+          }
+        } else {
+          p.log.warn('No skills found for this agent.');
+        }
+      } else {
+        console.log(JSON.stringify(skills, null, 2));
+      }
+      return skills;
+    }
+
+    default: {
+      const { showHelp } = await import('../help.js');
+      showHelp('skill', p);
+      break;
+    }
+  }
+}

package/src/commands/template.js

@@ -0,0 +1,237 @@
+/**
+ * Template commands: list/get/create/update/remove/assign.
+ */
+import { parseFlags } from './auth.js';
+import { isInteractive, handleCancel, withSpinner, showResult, pickAgent, p } from '../ui.js';
+
+async function pickTemplate(client, message = 'Select template') {
+  const templates = await client.listTemplates();
+  if (!templates || templates.length === 0) {
+    throw new Error('No templates found. Create one first.');
+  }
+  const options = templates.map(t => ({
+    value: t.slug,
+    label: t.name,
+    hint: t.description,
+  }));
+  const selected = await p.select({ message, options });
+  handleCancel(selected);
+  return selected;
+}
+
+export async function runTemplate(client, args) {
+  let [action, ...rest] = args;
+  const flags = parseFlags(rest);
+
+  // Interactive sub-menu when no valid action
+  if (!['list', 'get', 'create', 'update', 'remove', 'assign'].includes(action) && isInteractive()) {
+    action = await p.select({
+      message: 'Template action',
+      options: [
+        { value: 'list',   label: 'List templates',   hint: 'list all templates' },
+        { value: 'get',    label: 'Get template',     hint: 'view template details' },
+        { value: 'create', label: 'Create template',  hint: 'create a new template' },
+        { value: 'update', label: 'Update template',  hint: 'update an existing template' },
+        { value: 'remove', label: 'Remove template',  hint: 'delete a template' },
+        { value: 'assign', label: 'Assign template',  hint: 'assign a template to an agent' },
+      ],
+    });
+    handleCancel(action);
+  }
+
+  switch (action) {
+    case 'list': {
+      const templates = isInteractive()
+        ? await withSpinner('Fetching templates...', () =>
+            client.listTemplates(), 'Templates loaded.')
+        : await client.listTemplates();
+
+      if (isInteractive()) {
+        if (Array.isArray(templates) && templates.length > 0) {
+          for (const t of templates) {
+            const tags = t.tags && t.tags.length > 0 ? ` [${t.tags.join(', ')}]` : '';
+            p.log.info(`${t.name} v${t.version}  (${t.slug})${tags}`);
+          }
+        } else {
+          p.log.warn('No templates found.');
+        }
+      } else {
+        console.log(JSON.stringify(templates, null, 2));
+      }
+      return templates;
+    }
+
+    case 'get': {
+      let slug = flags.slug || rest[0];
+      if (!slug && isInteractive()) {
+        slug = await pickTemplate(client, 'Select template to view');
+      }
+      if (!slug) throw new Error('Required: --slug or positional argument');
+
+      const template = isInteractive()
+        ? await withSpinner('Fetching template...', () =>
+            client.getTemplate(slug), 'Template loaded.')
+        : await client.getTemplate(slug);
+
+      if (isInteractive()) {
+        showResult('Template', {
+          Name: template.name,
+          Slug: template.slug,
+          Version: template.version,
+          Description: template.description,
+          Tags: (template.tags || []).join(', ') || '(none)',
+        });
+        if (template.body) {
+          p.log.info(`\nContent:\n${template.body}`);
+        }
+      } else {
+        console.log(JSON.stringify(template, null, 2));
+      }
+      return template;
+    }
+
+    case 'create': {
+      let content = flags.content;
+
+      if (!content && isInteractive()) {
+        content = handleCancel(await p.text({
+          message: 'Template content (TEMPLATE.md with YAML frontmatter)',
+          placeholder: 'Paste template content...',
+          validate: (val) => { if (!val) return 'Content is required'; },
+        }));
+      }
+      if (!content) throw new Error('Required: --content');
+
+      const result = isInteractive()
+        ? await withSpinner('Creating template...', () =>
+            client.createTemplate(content), 'Template created.')
+        : await client.createTemplate(content);
+
+      if (isInteractive()) {
+        showResult('Template Created', {
+          Name: result.name,
+          Slug: result.slug,
+          Version: result.version,
+        });
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      return result;
+    }
+
+    case 'update': {
+      let slug = flags.slug;
+      let content = flags.content;
+
+      if ((!slug || !content) && isInteractive()) {
+        if (!slug) {
+          slug = await pickTemplate(client, 'Select template to update');
+        }
+        if (!content) {
+          content = handleCancel(await p.text({
+            message: 'New template content',
+            placeholder: 'Paste updated content...',
+            validate: (val) => { if (!val) return 'Content is required'; },
+          }));
+        }
+      }
+      if (!slug || !content) throw new Error('Required: --slug, --content');
+
+      const result = isInteractive()
+        ? await withSpinner('Updating template...', () =>
+            client.updateTemplate(slug, content), 'Template updated.')
+        : await client.updateTemplate(slug, content);
+
+      if (isInteractive()) {
+        showResult('Template Updated', {
+          Slug: slug,
+          Name: result.name,
+          Version: result.version,
+        });
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      return result;
+    }
+
+    case 'remove': {
+      let slug = flags.slug || rest[0];
+
+      if (!slug && isInteractive()) {
+        slug = await pickTemplate(client, 'Select template to remove');
+        const confirmed = await p.confirm({
+          message: `Remove template "${slug}"?`,
+          initialValue: false,
+        });
+        handleCancel(confirmed);
+        if (!confirmed) {
+          p.log.info('Cancelled.');
+          return;
+        }
+      }
+      if (!slug) throw new Error('Required: --slug or positional argument');
+
+      await (isInteractive()
+        ? withSpinner('Removing template...', () =>
+            client.deleteTemplate(slug), 'Template removed.')
+        : client.deleteTemplate(slug));
+
+      if (isInteractive()) {
+        p.log.success(`Template ${slug} removed.`);
+      } else {
+        console.log(`Template ${slug} removed.`);
+      }
+      return;
+    }
+
+    case 'assign': {
+      let agentId = flags.agent;
+      let slug = flags.slug || flags.template;
+
+      if ((!agentId || slug === undefined) && isInteractive()) {
+        if (!agentId) {
+          agentId = await pickAgent(client, 'Select agent');
+        }
+
+        const clearOrAssign = await p.select({
+          message: 'Action',
+          options: [
+            { value: 'assign', label: 'Assign template', hint: 'assign a template to this agent' },
+            { value: 'clear',  label: 'Clear template',  hint: 'remove template assignment' },
+          ],
+        });
+        handleCancel(clearOrAssign);
+
+        if (clearOrAssign === 'clear') {
+          slug = null;
+        } else {
+          slug = await pickTemplate(client, 'Select template to assign');
+        }
+      }
+
+      if (!agentId) throw new Error('Required: --agent');
+
+      const result = isInteractive()
+        ? await withSpinner('Updating agent template...', () =>
+            client.setAgentTemplate(agentId, slug), 'Agent template updated.')
+        : await client.setAgentTemplate(agentId, slug);
+
+      if (isInteractive()) {
+        if (slug) {
+          p.log.success(`Template "${slug}" assigned to agent "${agentId}".`);
+        } else {
+          p.log.success(`Template cleared from agent "${agentId}".`);
+        }
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      return result;
+    }
+
+    default: {
+      const { showHelp } = await import('../help.js');
+      showHelp('template', p);
+      break;
+    }
+  }
+}