@moxxy/cli 0.0.12 → 0.1.0

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;
+    }
+  }
+}

package/src/commands/uninstall.js

@@ -0,0 +1,196 @@
+/**
+ * Uninstall command: remove all Moxxy data from the system.
+ * Removes ~/.moxxy (database, agents, config) but does NOT remove the CLI package.
+ */
+import { p, handleCancel } from '../ui.js';
+import { LOGO } from '../cli.js';
+import { getMoxxyHome } from './init.js';
+import { shellUnsetInstruction, shellProfileName } from '../platform.js';
+import { existsSync, rmSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
+
+export async function runUninstall(client, args) {
+  console.log(LOGO);
+  p.intro('Uninstall Moxxy');
+
+  const moxxyHome = getMoxxyHome();
+
+  // ── 1. Show what will be removed ──
+
+  const items = [];
+
+  if (existsSync(moxxyHome)) {
+    const size = getDirSize(moxxyHome);
+    items.push(`${moxxyHome}  (${formatBytes(size)})`);
+
+    // List contents for visibility
+    if (existsSync(join(moxxyHome, 'moxxy.db'))) {
+      items.push('  - Database (moxxy.db)');
+    }
+    if (existsSync(join(moxxyHome, 'agents'))) {
+      const agents = readdirSync(join(moxxyHome, 'agents'));
+      items.push(`  - ${agents.length} agent workspace(s)`);
+    }
+    if (existsSync(join(moxxyHome, 'config'))) {
+      items.push('  - Configuration files');
+    }
+  } else {
+    p.log.info(`Moxxy home not found at ${moxxyHome}. Nothing to remove.`);
+  }
+
+  // Check for running gateway
+  let gatewayRunning = false;
+  try {
+    const resp = await fetch(`${client.baseUrl}/v1/providers`);
+    if (resp) gatewayRunning = true;
+  } catch {
+    // Not running
+  }
+
+  if (gatewayRunning) {
+    p.log.warn('Gateway is currently running. It should be stopped first.');
+  }
+
+  if (items.length === 0 && !gatewayRunning) {
+    p.outro('Nothing to uninstall.');
+    return;
+  }
+
+  // ── 2. Show removal summary ──
+
+  if (items.length > 0) {
+    p.note(items.join('\n'), 'The following will be permanently deleted');
+  }
+
+  // ── 3. Confirm ──
+
+  const confirmed = await p.confirm({
+    message: 'Are you sure you want to remove all Moxxy data? This cannot be undone.',
+    initialValue: false,
+  });
+  handleCancel(confirmed);
+
+  if (!confirmed) {
+    p.outro('Uninstall cancelled.');
+    return;
+  }
+
+  // Double confirmation for safety
+  const reallyConfirmed = await p.confirm({
+    message: 'Really delete everything? Type Yes to confirm.',
+    initialValue: false,
+  });
+  handleCancel(reallyConfirmed);
+
+  if (!reallyConfirmed) {
+    p.outro('Uninstall cancelled.');
+    return;
+  }
+
+  // ── 4. Stop gateway if running ──
+
+  if (gatewayRunning) {
+    p.log.step('Stopping gateway...');
+    try {
+      if (platform() === 'win32') {
+        // Windows: use netstat + taskkill
+        const out = execSync('netstat -ano | findstr :3000', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const pids = new Set();
+        for (const line of out.split('\n').filter(Boolean)) {
+          const parts = line.trim().split(/\s+/);
+          const pid = parts[parts.length - 1];
+          if (pid && pid !== '0') pids.add(pid);
+        }
+        for (const pid of pids) {
+          try { execSync(`taskkill /PID ${pid} /F`, { stdio: 'pipe' }); } catch { /* already dead */ }
+        }
+        if (pids.size > 0) p.log.success('Gateway stopped.');
+      } else {
+        // Unix: use lsof
+        const pids = execSync("lsof -ti:3000 2>/dev/null || true", { encoding: 'utf-8' }).trim();
+        if (pids) {
+          for (const pid of pids.split('\n').filter(Boolean)) {
+            try { process.kill(parseInt(pid), 'SIGTERM'); } catch { /* already dead */ }
+          }
+          p.log.success('Gateway stopped.');
+        }
+      }
+    } catch {
+      p.log.warn('Could not stop gateway automatically. Please stop it manually.');
+    }
+  }
+
+  // ── 4b. Stop running plugins ──
+
+  try {
+    const { pluginPaths, readRegistry, isProcessAlive } = await import('../lib/plugin-registry.js');
+    const { registryFile } = pluginPaths();
+    if (existsSync(registryFile)) {
+      const registry = readRegistry();
+      for (const plug of Object.values(registry.plugins)) {
+        if (plug.pid && isProcessAlive(plug.pid)) {
+          try {
+            process.kill(plug.pid, 'SIGTERM');
+            p.log.info(`Stopped plugin: ${plug.name} (PID ${plug.pid})`);
+          } catch { /* already dead */ }
+        }
+      }
+    }
+  } catch { /* no plugins */ }
+
+  // ── 5. Remove ~/.moxxy ──
+
+  if (existsSync(moxxyHome)) {
+    try {
+      rmSync(moxxyHome, { recursive: true, force: true });
+      p.log.success(`Removed ${moxxyHome}`);
+    } catch (err) {
+      p.log.error(`Failed to remove ${moxxyHome}: ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // ── 6. Clean environment reminder ──
+
+  const envVars = ['MOXXY_TOKEN', 'MOXXY_API_URL', 'MOXXY_HOME'].filter(v => process.env[v]);
+
+  const instructions = [];
+  if (envVars.length > 0) {
+    instructions.push(`Remove these from ${shellProfileName()}:`);
+    for (const v of envVars) {
+      instructions.push(`  ${shellUnsetInstruction(v)}`);
+    }
+  }
+  instructions.push('');
+  instructions.push('To remove the CLI itself:');
+  instructions.push('  npm remove -g moxxy-cli');
+
+  p.note(instructions.join('\n'), 'Manual cleanup');
+
+  p.outro('Moxxy has been uninstalled. Goodbye!');
+}
+
+function getDirSize(dirPath) {
+  let size = 0;
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        size += getDirSize(fullPath);
+      } else {
+        try { size += statSync(fullPath).size; } catch { /* skip */ }
+      }
+    }
+  } catch { /* skip */ }
+  return size;
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}