newo 3.2.0 → 3.3.0

package/src/api.ts

@@ -496,4 +496,60 @@ export async function getAkbTopics(
     params: { persona_id: personaId, page, per, order_by: orderBy }
   });
   return response.data;
+}
+
+// Project update
+export async function updateProject(
+  client: AxiosInstance,
+  projectId: string,
+  updateData: Partial<{
+    title: string;
+    description: string;
+    is_auto_update_enabled: boolean;
+    registry_idn: string;
+    registry_item_idn: string | null;
+    registry_item_version: string | null;
+  }>
+): Promise<void> {
+  await client.put(`/api/v1/designer/projects/${projectId}`, updateData);
+}
+
+// Agent update
+export async function updateAgent(
+  client: AxiosInstance,
+  agentId: string,
+  updateData: Partial<{
+    title: string;
+    description: string;
+    persona_id: string | null;
+  }>
+): Promise<void> {
+  await client.put(`/api/v1/designer/agents/${agentId}`, updateData);
+}
+
+// Webhook creation
+export async function createOutgoingWebhook(
+  client: AxiosInstance,
+  webhookData: {
+    connector_idn: string;
+    event_idn: string;
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    body_template?: string;
+  }
+): Promise<{ id: string }> {
+  const response = await client.post('/api/v1/webhooks', webhookData);
+  return response.data;
+}
+
+export async function createIncomingWebhook(
+  client: AxiosInstance,
+  webhookData: {
+    connector_idn: string;
+    event_idn: string;
+  }
+): Promise<{ id: string; url: string }> {
+  const response = await client.post('/api/v1/webhooks/incoming', webhookData);
+  return response.data;
 }

package/src/cli/commands/create-webhooks.ts

@@ -0,0 +1,100 @@
+/**
+ * Webhook creation command handler
+ */
+import { makeClient } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { selectSingleCustomer } from '../customer-selection.js';
+import { customerDir } from '../../fsutil.js';
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import path from 'path';
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+
+export async function handleCreateWebhooksCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean
+): Promise<void> {
+  const { selectedCustomer } = selectSingleCustomer(
+    customerConfig,
+    args.customer as string | undefined
+  );
+
+  if (!selectedCustomer) {
+    console.error('❌ No customer selected');
+    process.exit(1);
+  }
+
+  const accessToken = await getValidAccessToken(selectedCustomer);
+  const client = await makeClient(verbose, accessToken);
+
+  console.log(`\n📡 Creating webhooks for ${selectedCustomer.idn}...\n`);
+
+  const custDir = customerDir(selectedCustomer.idn);
+  let outgoingCreated = 0;
+  let incomingCreated = 0;
+
+  // Create outgoing webhooks
+  const outgoingFile = path.join(custDir, 'integrations/api/connectors/webhook/webhooks/outgoing.yaml');
+  if (await fs.pathExists(outgoingFile)) {
+    const outgoingData = yaml.load(await fs.readFile(outgoingFile, 'utf8')) as any;
+    const webhooks = outgoingData.webhooks || [];
+
+    console.log(`Found ${webhooks.length} outgoing webhooks in YAML file`);
+
+    for (const webhook of webhooks) {
+      try {
+        await client.post('/api/v1/webhooks', {
+          idn: webhook.idn,
+          description: webhook.description || '',
+          connector_idn: webhook.connector_idn,
+          url: webhook.url,
+          command_idns: webhook.command_idns || []
+        });
+        outgoingCreated++;
+        console.log(`   ✅ Created outgoing: ${webhook.idn}`);
+      } catch (error: any) {
+        const status = error.response?.status;
+
+        if (status === 409) {
+          console.log(`   ℹ️  Already exists: ${webhook.idn}`);
+        } else {
+          console.error(`   ❌ Failed: ${webhook.idn} - ${error.response?.data?.reason || error.message}`);
+        }
+      }
+    }
+  }
+
+  // Create incoming webhooks
+  const incomingFile = path.join(custDir, 'integrations/api/connectors/webhook/webhooks/incoming.yaml');
+  if (await fs.pathExists(incomingFile)) {
+    const incomingData = yaml.load(await fs.readFile(incomingFile, 'utf8')) as any;
+    const webhooks = incomingData.webhooks || [];
+
+    console.log(`\nFound ${webhooks.length} incoming webhooks in YAML file`);
+
+    for (const webhook of webhooks) {
+      try {
+        await client.post('/api/v1/webhooks/incoming', {
+          idn: webhook.idn,
+          description: webhook.description || '',
+          connector_idn: webhook.connector_idn,
+          event_idns: webhook.event_idns || [],
+          allowed_ips: webhook.allowed_ips || []
+        });
+        incomingCreated++;
+        console.log(`   ✅ Created incoming: ${webhook.idn}`);
+      } catch (error: any) {
+        const status = error.response?.status;
+
+        if (status === 409) {
+          console.log(`   ℹ️  Already exists: ${webhook.idn}`);
+        } else {
+          console.error(`   ❌ Failed: ${webhook.idn} - ${error.response?.data?.reason || error.message}`);
+        }
+      }
+    }
+  }
+
+  console.log(`\n✅ Created ${outgoingCreated} outgoing and ${incomingCreated} incoming webhooks\n`);
+}

package/src/cli/commands/help.ts

@@ -49,6 +49,11 @@ Enterprise Features:
   newo pull-akb [--customer <idn>]                          # download AKB articles for all personas with agents → ./newo_customers/<idn>/akb/
   newo push-akb [--customer <idn>]                          # upload AKB articles from local YAML files to platform
 
+Account Migration (NEW):
+  newo migrate-account --source <idn> --dest <idn> [--yes]  # migrate complete account from source to destination
+  newo verify --source <idn> --dest <idn>                    # verify migration by comparing entity counts
+  newo create-webhooks [--customer <idn>]                    # create webhooks from YAML files
+
 Flags:
   --customer <idn>             # specify customer (if not set, uses default or interactive selection)
   --all                        # include all available data (for conversations: all personas and acts)

package/src/cli/commands/migrate-account.ts

@@ -0,0 +1,104 @@
+/**
+ * Account migration command handler
+ */
+import { makeClient } from '../../api.js';
+import { migrateAccount } from '../../sync/migrate.js';
+import { getValidAccessToken } from '../../auth.js';
+import { getCustomer } from '../../customer.js';
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+
+export async function handleMigrateAccountCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean
+): Promise<void> {
+  // Get source and destination customer IDNs
+  const sourceIdn = args.source as string | undefined;
+  const destIdn = args.dest as string | undefined;
+
+  if (!sourceIdn || !destIdn) {
+    console.error('❌ Usage: newo migrate-account --source <sourceIdn> --dest <destIdn>');
+    console.error('Example: newo migrate-account --source NEWO_bb5lmJjg --dest NEq9OCwSXw');
+    process.exit(1);
+  }
+
+  const sourceCustomer = getCustomer(customerConfig, sourceIdn);
+  const destCustomer = getCustomer(customerConfig, destIdn);
+
+  if (!sourceCustomer) {
+    console.error(`❌ Source customer ${sourceIdn} not found in configuration`);
+    process.exit(1);
+  }
+
+  if (!destCustomer) {
+    console.error(`❌ Destination customer ${destIdn} not found in configuration`);
+    process.exit(1);
+  }
+
+  console.log('\n🔄 Account Migration');
+  console.log(`Source: ${sourceIdn}`);
+  console.log(`Destination: ${destIdn}`);
+  console.log('\n⚠️  This will copy ALL data from source to destination');
+  console.log('⚠️  Source account will NOT be modified (read-only)');
+
+  // Confirm migration
+  if (!args.yes && !args.y) {
+    const readline = await import('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const answer = await new Promise<string>((resolve) => {
+      rl.question('\nProceed with migration? (yes/NO): ', resolve);
+    });
+    rl.close();
+
+    if (answer.toLowerCase() !== 'yes') {
+      console.log('❌ Migration cancelled');
+      return;
+    }
+  }
+
+  // Authenticate
+  const sourceToken = await getValidAccessToken(sourceCustomer);
+  const destToken = await getValidAccessToken(destCustomer);
+
+  const sourceClient = await makeClient(verbose, sourceToken);
+  const destClient = await makeClient(verbose, destToken);
+
+  // Run migration
+  const result = await migrateAccount({
+    sourceCustomer,
+    destCustomer,
+    sourceClient,
+    destClient,
+    verbose
+  });
+
+  // Print summary
+  console.log('\n📊 MIGRATION SUMMARY\n');
+  console.log(`Projects created: ${result.projectsCreated}`);
+  console.log(`Agents created: ${result.agentsCreated}`);
+  console.log(`Flows created: ${result.flowsCreated}`);
+  console.log(`Skills created: ${result.skillsCreated}`);
+  console.log(`Attributes migrated: ${result.attributesMigrated}`);
+  console.log(`Personas created: ${result.personasCreated}`);
+  console.log(`AKB articles imported: ${result.articlesImported}`);
+  console.log(`Connectors created: ${result.connectorsCreated}`);
+  console.log(`Webhooks created: ${result.webhooksCreated}`);
+
+  if (result.errors.length > 0) {
+    console.log(`\n⚠️  Errors: ${result.errors.length}`);
+    result.errors.forEach(err => console.error(`   - ${err}`));
+  }
+
+  console.log(`\n${result.success ? '✅ Migration completed successfully!' : '❌ Migration completed with errors'}\n`);
+
+  if (result.success) {
+    console.log('📋 Next steps:');
+    console.log(`   1. Push skill content: npx newo push --customer ${destIdn}`);
+    console.log(`   2. Verify migration: npx newo verify --source ${sourceIdn} --dest ${destIdn}`);
+    console.log(`   3. Test agent: npx newo sandbox "test message" --customer ${destIdn}\n`);
+  }
+}

package/src/cli/commands/verify-migration.ts

@@ -0,0 +1,88 @@
+/**
+ * Migration verification command handler
+ */
+import { makeClient, listProjects, listAgents, listFlowSkills } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { getCustomer } from '../../customer.js';
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+
+export async function handleVerifyMigrationCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean
+): Promise<void> {
+  const sourceIdn = args.source as string | undefined;
+  const destIdn = args.dest as string | undefined;
+
+  if (!sourceIdn || !destIdn) {
+    console.error('❌ Usage: newo verify --source <sourceIdn> --dest <destIdn>');
+    console.error('Example: newo verify --source NEWO_bb5lmJjg --dest NEq9OCwSXw');
+    process.exit(1);
+  }
+
+  const sourceCustomer = getCustomer(customerConfig, sourceIdn);
+  const destCustomer = getCustomer(customerConfig, destIdn);
+
+  if (!sourceCustomer || !destCustomer) {
+    console.error('❌ Customer not found in configuration');
+    process.exit(1);
+  }
+
+  console.log('\n🔍 Migration Verification');
+  console.log(`Source: ${sourceIdn}`);
+  console.log(`Destination: ${destIdn}\n`);
+
+  const sourceToken = await getValidAccessToken(sourceCustomer);
+  const destToken = await getValidAccessToken(destCustomer);
+
+  const sourceClient = await makeClient(verbose, sourceToken);
+  const destClient = await makeClient(verbose, destToken);
+
+  // Count entities
+  const sourceProjects = await listProjects(sourceClient);
+  const destProjects = await listProjects(destClient);
+
+  let srcAgents = 0, srcFlows = 0, srcSkills = 0;
+  let dstAgents = 0, dstFlows = 0, dstSkills = 0;
+
+  for (const proj of sourceProjects) {
+    const agents = await listAgents(sourceClient, proj.id);
+    srcAgents += agents.length;
+
+    for (const agent of agents) {
+      srcFlows += (agent.flows || []).length;
+
+      for (const flow of agent.flows || []) {
+        const skills = await listFlowSkills(sourceClient, flow.id);
+        srcSkills += skills.length;
+      }
+    }
+  }
+
+  for (const proj of destProjects.filter(p => p.idn !== 'test')) {
+    const agents = await listAgents(destClient, proj.id);
+    dstAgents += agents.length;
+
+    for (const agent of agents) {
+      dstFlows += (agent.flows || []).length;
+
+      for (const flow of agent.flows || []) {
+        const skills = await listFlowSkills(destClient, flow.id);
+        dstSkills += skills.length;
+      }
+    }
+  }
+
+  console.log('📊 Entity Counts:\n');
+  console.log(`Projects:  ${sourceProjects.length} → ${destProjects.filter(p => p.idn !== 'test').length} ${sourceProjects.length === destProjects.filter(p => p.idn !== 'test').length ? '✅' : '❌'}`);
+  console.log(`Agents:    ${srcAgents} → ${dstAgents} ${srcAgents === dstAgents ? '✅' : '❌'}`);
+  console.log(`Flows:     ${srcFlows} → ${dstFlows} ${srcFlows === dstFlows ? '✅' : '❌'}`);
+  console.log(`Skills:    ${srcSkills} → ${dstSkills} ${srcSkills === dstSkills ? '✅' : '❌'}\n`);
+
+  if (srcAgents === dstAgents && srcFlows === dstFlows && srcSkills === dstSkills) {
+    console.log('✅ All entity counts match - Migration successful!\n');
+  } else {
+    console.log('⚠️  Entity counts differ - Migration may be incomplete\n');
+    process.exit(1);
+  }
+}

package/src/cli.ts

@@ -35,6 +35,9 @@ import { handleListActionsCommand } from './cli/commands/list-actions.js';
 import { handleProfileCommand } from './cli/commands/profile.js';
 import { handlePullAkbCommand } from './cli/commands/pull-akb.js';
 import { handlePushAkbCommand } from './cli/commands/push-akb.js';
+import { handleMigrateAccountCommand } from './cli/commands/migrate-account.js';
+import { handleVerifyMigrationCommand } from './cli/commands/verify-migration.js';
+import { handleCreateWebhooksCommand } from './cli/commands/create-webhooks.js';
 import type { CliArgs, NewoApiError } from './types.js';
 
 dotenv.config();
@@ -188,6 +191,19 @@ async function main(): Promise<void> {
         await handlePushAkbCommand(customerConfig, args, verbose);
         break;
 
+      case 'migrate-account':
+        await handleMigrateAccountCommand(customerConfig, args, verbose);
+        break;
+
+      case 'verify':
+      case 'verify-migration':
+        await handleVerifyMigrationCommand(customerConfig, args, verbose);
+        break;
+
+      case 'create-webhooks':
+        await handleCreateWebhooksCommand(customerConfig, args, verbose);
+        break;
+
       default:
         console.error('Unknown command:', cmd);
         console.error('Run "newo --help" for usage information');