@myvillage/cli 1.10.2 → 1.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.10.2",
+  "version": "1.17.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/agent-runtime/loop.js

@@ -12,7 +12,8 @@ import { getMCPTools, cleanupMCPClients } from './mcp-client.js';
 import { gatherContext } from './context.js';
 import { isWithinActiveHours, getNextCheckInMs } from './scheduler.js';
 import { parse as parseYaml } from 'yaml';
-import { postAgentHeartbeat } from '../utils/api.js';
+import { postAgentHeartbeat, listAgentTasks, claimAgentTask, completeAgentTask } from '../utils/api.js';
+import { readAgentWisdom } from '../utils/wisdom.js';
 
 export async function agentLoop(agentName, { signal }) {
   const agentDir = join(homedir(), '.myvillage', 'agents', agentName);
@@ -107,19 +108,47 @@ export async function agentLoop(agentName, { signal }) {
     };
     let feedItemsRead = 0;
     let mentionsFound = 0;
+    // Hoisted so the catch block can mark in-flight tasks FAILED.
+    let activeTask = null;
 
     try {
       // Read prompt.md fresh each iteration (villager may have edited it)
       const promptPath = join(agentDir, 'prompt.md');
-      const systemPrompt = existsSync(promptPath)
+      const basePrompt = existsSync(promptPath)
         ? readFileSync(promptPath, 'utf-8')
         : `You are an agent named ${config.display_name || agentName}. Be helpful and concise.`;
 
+      // Append wisdom skills to the system prompt. We inline the full bodies
+      // for v1 — agent skill packs are small and this keeps the loop simple.
+      // (If they grow large, switch to lazy-load via a `wisdom_load` tool.)
+      const wisdom = readAgentWisdom(agentName);
+      let systemPrompt = basePrompt;
+      if (wisdom.length > 0) {
+        const skills = wisdom.map(w => {
+          const header = `### Skill: ${w.name}${w.description ? ` — ${w.description}` : ''}${w.trigger ? `\nWhen: ${w.trigger}` : ''}`;
+          return `${header}\n\n${w.body.trim()}`;
+        }).join('\n\n---\n\n');
+        systemPrompt = `${basePrompt}\n\n## Available Skills\n\nThese are skill packs you can apply when the trigger matches the current situation.\n\n${skills}`;
+        logActivity(agentDir, { type: 'wisdom_loaded', count: wisdom.length, names: wisdom.map(w => w.name) });
+      }
+
+      // Try to pull an assigned task first. Tasks take priority over ambient
+      // feed-monitoring. If nothing is queued, fall through to the default.
+      if (config.man?.village_agent_id) {
+        activeTask = await pollAndClaim(config.man.village_agent_id, agentDir);
+      }
+
       // Gather context (returns { text, mentionsCount })
       const contextResult = await gatherContext(config, lastCheckIn, recentActions);
-      const context = contextResult.text;
+      let context = contextResult.text;
       mentionsFound = contextResult.mentionsCount;
 
+      if (activeTask) {
+        const taskLine = `TASK ${activeTask.id} (${activeTask.taskType}): ${activeTask.instruction || JSON.stringify(activeTask.input || {})}`;
+        context = `${taskLine}\n\n${context}`;
+        logActivity(agentDir, { type: 'task_claimed', taskId: activeTask.id, taskType: activeTask.taskType });
+      }
+
       // Count feed items from context
       feedItemsRead = (context.match(/^- @/gm) || []).length;
 
@@ -220,6 +249,20 @@ export async function agentLoop(agentName, { signal }) {
       // Keep only last 50 actions to bound memory
       if (recentActions.length > 50) recentActions.splice(0, recentActions.length - 50);
 
+      // If a task was being processed, mark it complete with the model's output.
+      if (activeTask && config.man?.village_agent_id) {
+        try {
+          await completeAgentTask(config.man.village_agent_id, activeTask.id, {
+            output: { text: result.text || '', toolCalls: activity.toolCalls },
+            tokensUsed: (result.usage?.promptTokens || 0) + (result.usage?.completionTokens || 0),
+            durationMs: Date.now() - loopStart,
+          });
+          logActivity(agentDir, { type: 'task_completed', taskId: activeTask.id });
+        } catch (taskErr) {
+          logActivity(agentDir, { type: 'error', error: `Failed to mark task complete: ${taskErr.message}` });
+        }
+      }
+
       // Send server-side heartbeat
       if (config.man?.agent_id) {
         try {
@@ -242,6 +285,18 @@ export async function agentLoop(agentName, { signal }) {
         type: 'error',
         error: err.message,
       });
+      // If a task was in flight when we crashed, mark it FAILED so it isn't lost
+      if (activeTask && config.man?.village_agent_id) {
+        try {
+          await completeAgentTask(config.man.village_agent_id, activeTask.id, {
+            errorMessage: err.message,
+            durationMs: Date.now() - loopStart,
+          });
+          logActivity(agentDir, { type: 'task_failed', taskId: activeTask.id });
+        } catch {
+          // best-effort
+        }
+      }
     }
 
     lastCheckIn = new Date().toISOString();
@@ -288,6 +343,29 @@ function updateHeartbeat(agentDir) {
   }
 }
 
+// Pull up to 5 pending tasks and claim the first one we can win the race for.
+// Returns the claimed task or null. Errors are swallowed and logged — the loop
+// should keep running on transient backend issues.
+async function pollAndClaim(villageAgentId, agentDir) {
+  try {
+    const result = await listAgentTasks(villageAgentId, { status: 'PENDING', limit: 5 });
+    const pending = result.tasks || [];
+    if (pending.length === 0) return null;
+    for (const task of pending) {
+      try {
+        const claim = await claimAgentTask(villageAgentId, task.id);
+        return claim.data || task;
+      } catch {
+        // Race lost (409) or transient — try the next task
+      }
+    }
+    return null;
+  } catch (err) {
+    logActivity(agentDir, { type: 'error', error: `Task poll failed: ${err.message}` });
+    return null;
+  }
+}
+
 function sleep(ms, signal) {
   return new Promise((resolve) => {
     if (signal?.aborted) { resolve(); return; }

package/src/commands/agent-client.js

@@ -0,0 +1,435 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
+import { villageSpinner, brand } from '../utils/brand.js';
+import { isAuthenticated } from '../utils/auth.js';
+import {
+  listMyAgents,
+  registerClientAgent as apiRegisterClientAgent,
+  listClientAgentConfigs as apiListClientAgentConfigs,
+  getClientAgentConfig as apiGetClientAgentConfig,
+  updateClientAgentConfig as apiUpdateClientAgentConfig,
+  deactivateClientAgent as apiDeactivateClientAgent,
+  rotateClientAgentKey as apiRotateClientAgentKey,
+} from '../utils/api.js';
+import { formatClientAgentConfig, formatClientAgentList } from '../utils/formatters.js';
+
+// ── Schedule Presets ────────────────────────────────────
+
+const SCHEDULE_PRESETS = [
+  { name: 'Daily at 9am', value: '0 9 * * *' },
+  { name: 'Weekly Monday 9am', value: '0 9 * * 1' },
+  { name: 'Monthly 1st at 9am', value: '0 9 1 * *' },
+  { name: 'Custom cron expression', value: 'CUSTOM' },
+  { name: 'None (manual only)', value: '' },
+];
+
+const WORKFLOW_TYPES = [
+  { name: 'Submission Processor — classify submissions, draft outreach', value: 'SUBMISSION_PROCESSOR' },
+  { name: 'Digest Generator — weekly/daily activity summaries', value: 'DIGEST_GENERATOR' },
+  { name: 'Member Matcher — match new signups with existing members', value: 'MEMBER_MATCHER' },
+  { name: 'Stale Data Detector — flag inactive members', value: 'STALE_DATA_DETECTOR' },
+  { name: 'Custom', value: 'CUSTOM' },
+];
+
+// ── Helpers ─────────────────────────────────────────────
+
+function displayApiKey(apiKey, clientId) {
+  console.log('');
+  console.log(chalk.yellow.bold('  ⚠  IMPORTANT: Save your API key now — it will not be shown again!'));
+  console.log('');
+  console.log(`  ${chalk.dim('Client ID:')} ${brand.teal(clientId)}`);
+  console.log(`  ${chalk.dim('API Key:')}   ${brand.gold(apiKey)}`);
+  console.log('');
+}
+
+async function promptSaveToEnvFile(apiKey, clientId) {
+  const { saveToFile } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'saveToFile',
+    message: 'Save API key to a .env file?',
+    default: false,
+  }]);
+
+  if (saveToFile) {
+    const { filePath } = await inquirer.prompt([{
+      type: 'input',
+      name: 'filePath',
+      message: 'File path:',
+      default: '.env.local',
+    }]);
+
+    const lines = `\n# MyVillageOS Client Agent\nMYVILLAGE_AGENT_API_KEY=${apiKey}\nMYVILLAGE_AGENT_CLIENT_ID=${clientId}\n`;
+
+    if (existsSync(filePath)) {
+      appendFileSync(filePath, lines);
+    } else {
+      writeFileSync(filePath, lines.trimStart());
+    }
+    console.log(brand.green(`  ✓ API key saved to ${filePath}\n`));
+  }
+}
+
+async function resolveAgentId(handle) {
+  const result = await listMyAgents();
+  const agents = result.data || result;
+  if (!Array.isArray(agents) || agents.length === 0) return null;
+
+  const match = agents.find(a =>
+    a.handle === handle || a.handle === handle.replace(/^@/, '')
+  );
+  return match || null;
+}
+
+// ── Register Client ─────────────────────────────────────
+
+export async function agentRegisterClientCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.\n'));
+    return;
+  }
+
+  try {
+    const isNonInteractive = options.agent && options.clientId && options.name && options.url;
+
+    let data;
+
+    if (isNonInteractive) {
+      // Resolve agent handle to ID
+      const spinner = villageSpinner('Resolving agent...').start();
+      const agent = await resolveAgentId(options.agent);
+      if (!agent) {
+        spinner.fail(`Agent "${options.agent}" not found.`);
+        return;
+      }
+      spinner.succeed(`Found agent @${agent.handle}`);
+
+      data = {
+        villageAgentId: agent.villageAgent?.id || agent.villageAgentId || agent.id,
+        clientId: options.clientId.toLowerCase(),
+        clientName: options.name,
+        baseUrl: options.url,
+        workflowType: (options.workflow || 'SUBMISSION_PROCESSOR').toUpperCase(),
+        schedule: options.schedule || null,
+        timezone: options.timezone || 'America/Chicago',
+      };
+    } else {
+      // Interactive mode
+      const agentSpinner = villageSpinner('Loading your agents...').start();
+      const agentResult = await listMyAgents();
+      const agents = agentResult.data || agentResult;
+      agentSpinner.stop();
+
+      if (!Array.isArray(agents) || agents.length === 0) {
+        console.log(brand.teal('\n  No agents found. Create one first with: myvillage agent create\n'));
+        return;
+      }
+
+      const answers = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'selectedAgent',
+          message: 'Which agent should manage this client?',
+          choices: agents.map(a => ({
+            name: `@${a.handle} — ${a.displayName || a.handle}`,
+            value: a,
+          })),
+        },
+        {
+          type: 'input',
+          name: 'clientId',
+          message: 'Client identifier (lowercase, no spaces):',
+          validate: input => /^[a-z0-9_-]{3,40}$/.test(input) || 'Must be 3-40 chars: lowercase letters, numbers, hyphens, underscores.',
+          filter: input => input.toLowerCase().replace(/[^a-z0-9_-]/g, ''),
+        },
+        {
+          type: 'input',
+          name: 'clientName',
+          message: 'Client display name:',
+          validate: input => input.trim().length > 0 || 'Name is required.',
+        },
+        {
+          type: 'input',
+          name: 'baseUrl',
+          message: 'Client base URL:',
+          validate: input => {
+            try {
+              new URL(input);
+              return true;
+            } catch {
+              return 'Must be a valid URL (e.g., https://maywood-chatkit.vercel.app)';
+            }
+          },
+        },
+        {
+          type: 'list',
+          name: 'workflowType',
+          message: 'Workflow type:',
+          choices: WORKFLOW_TYPES,
+        },
+        {
+          type: 'list',
+          name: 'schedulePreset',
+          message: 'Schedule:',
+          choices: SCHEDULE_PRESETS,
+        },
+      ]);
+
+      let schedule = answers.schedulePreset;
+      if (schedule === 'CUSTOM') {
+        const { customCron } = await inquirer.prompt([{
+          type: 'input',
+          name: 'customCron',
+          message: 'Cron expression (e.g., 0 9 * * 1):',
+          validate: input => input.trim().split(/\s+/).length === 5 || 'Must be a 5-field cron expression.',
+        }]);
+        schedule = customCron;
+      }
+
+      const { confirm } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: `Register "${answers.clientName}" (${answers.clientId}) with @${answers.selectedAgent.handle}?`,
+        default: true,
+      }]);
+
+      if (!confirm) {
+        console.log(chalk.dim('\n  Cancelled.\n'));
+        return;
+      }
+
+      const selectedAgent = answers.selectedAgent;
+      data = {
+        villageAgentId: selectedAgent.villageAgent?.id || selectedAgent.villageAgentId || selectedAgent.id,
+        clientId: answers.clientId,
+        clientName: answers.clientName,
+        baseUrl: answers.baseUrl,
+        workflowType: answers.workflowType,
+        schedule: schedule || null,
+        timezone: options.timezone || 'America/Chicago',
+      };
+    }
+
+    const regSpinner = villageSpinner('Registering client agent...').start();
+    const result = await apiRegisterClientAgent(data);
+    regSpinner.succeed('Client agent registered!');
+
+    displayApiKey(result.apiKey, data.clientId);
+
+    if (!isNonInteractive) {
+      await promptSaveToEnvFile(result.apiKey, data.clientId);
+    } else if (options.envFile) {
+      const lines = `\n# MyVillageOS Client Agent\nMYVILLAGE_AGENT_API_KEY=${result.apiKey}\nMYVILLAGE_AGENT_CLIENT_ID=${data.clientId}\n`;
+      if (existsSync(options.envFile)) {
+        appendFileSync(options.envFile, lines);
+      } else {
+        writeFileSync(options.envFile, lines.trimStart());
+      }
+      console.log(brand.green(`  ✓ API key saved to ${options.envFile}\n`));
+    }
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`\n  ✗ Failed to register client agent: ${message}\n`));
+  }
+}
+
+// ── List Clients ────────────────────────────────────────
+
+export async function agentListClientsCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.\n'));
+    return;
+  }
+
+  try {
+    const spinner = villageSpinner('Loading client agent configs...').start();
+    const result = await apiListClientAgentConfigs();
+    spinner.stop();
+
+    const configs = result.data || result;
+    formatClientAgentList(Array.isArray(configs) ? configs : []);
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`\n  ✗ Failed to list client agents: ${message}\n`));
+  }
+}
+
+// ── View Client ─────────────────────────────────────────
+
+export async function agentViewClientCommand(configId) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.\n'));
+    return;
+  }
+
+  try {
+    const spinner = villageSpinner('Loading client agent config...').start();
+    const result = await apiGetClientAgentConfig(configId);
+    spinner.stop();
+
+    const config = result.data || result;
+    formatClientAgentConfig(config);
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`\n  ✗ Failed to load client agent config: ${message}\n`));
+  }
+}
+
+// ── Edit Client ─────────────────────────────────────────
+
+export async function agentEditClientCommand(configId) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.\n'));
+    return;
+  }
+
+  try {
+    const spinner = villageSpinner('Loading client agent config...').start();
+    const result = await apiGetClientAgentConfig(configId);
+    spinner.stop();
+
+    const config = result.data || result;
+
+    console.log(chalk.dim(`\n  Editing: ${config.clientName} (${config.clientId})\n`));
+
+    // Match current schedule to a preset
+    const currentPresetMatch = SCHEDULE_PRESETS.find(p => p.value === config.schedule);
+    const currentPreset = currentPresetMatch ? currentPresetMatch.value : (config.schedule ? 'CUSTOM' : '');
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'clientName',
+        message: 'Client name:',
+        default: config.clientName,
+      },
+      {
+        type: 'input',
+        name: 'baseUrl',
+        message: 'Base URL:',
+        default: config.baseUrl,
+        validate: input => {
+          try { new URL(input); return true; } catch { return 'Must be a valid URL.'; }
+        },
+      },
+      {
+        type: 'list',
+        name: 'workflowType',
+        message: 'Workflow type:',
+        choices: WORKFLOW_TYPES,
+        default: config.workflowType,
+      },
+      {
+        type: 'list',
+        name: 'schedulePreset',
+        message: 'Schedule:',
+        choices: SCHEDULE_PRESETS,
+        default: currentPreset,
+      },
+      {
+        type: 'input',
+        name: 'timezone',
+        message: 'Timezone:',
+        default: config.timezone || 'America/Chicago',
+      },
+      {
+        type: 'confirm',
+        name: 'isActive',
+        message: 'Active?',
+        default: config.isActive,
+      },
+    ]);
+
+    let schedule = answers.schedulePreset;
+    if (schedule === 'CUSTOM') {
+      const { customCron } = await inquirer.prompt([{
+        type: 'input',
+        name: 'customCron',
+        message: 'Cron expression:',
+        default: config.schedule || '',
+        validate: input => input.trim().split(/\s+/).length === 5 || 'Must be a 5-field cron expression.',
+      }]);
+      schedule = customCron;
+    }
+
+    const updateData = {
+      clientName: answers.clientName,
+      baseUrl: answers.baseUrl,
+      workflowType: answers.workflowType,
+      schedule: schedule || null,
+      timezone: answers.timezone,
+      isActive: answers.isActive,
+    };
+
+    const saveSpinner = villageSpinner('Saving changes...').start();
+    await apiUpdateClientAgentConfig(configId, updateData);
+    saveSpinner.succeed('Client agent config updated!');
+    console.log('');
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`\n  ✗ Failed to update client agent config: ${message}\n`));
+  }
+}
+
+// ── Deactivate Client ───────────────────────────────────
+
+export async function agentDeactivateClientCommand(configId) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.\n'));
+    return;
+  }
+
+  try {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Deactivate client agent config ${configId}? This will stop all automated workflows.`,
+      default: false,
+    }]);
+
+    if (!confirm) {
+      console.log(chalk.dim('\n  Cancelled.\n'));
+      return;
+    }
+
+    const spinner = villageSpinner('Deactivating...').start();
+    await apiDeactivateClientAgent(configId);
+    spinner.succeed('Client agent deactivated.');
+    console.log('');
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`\n  ✗ Failed to deactivate: ${message}\n`));
+  }
+}
+
+// ── Rotate Client Key ───────────────────────────────────
+
+export async function agentRotateClientKeyCommand(configId) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.\n'));
+    return;
+  }
+
+  try {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Rotate API key for ${configId}? The current key will be invalidated immediately.`,
+      default: false,
+    }]);
+
+    if (!confirm) {
+      console.log(chalk.dim('\n  Cancelled.\n'));
+      return;
+    }
+
+    const spinner = villageSpinner('Rotating API key...').start();
+    const result = await apiRotateClientAgentKey(configId);
+    spinner.succeed('API key rotated!');
+
+    displayApiKey(result.apiKey, configId);
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`\n  ✗ Failed to rotate API key: ${message}\n`));
+  }
+}