newo 3.4.0 → 3.4.1

package/src/domain/strategies/sync/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Sync Strategies Module Exports
+ *
+ * This module exports all sync strategies that implement ISyncStrategy.
+ * Each strategy handles synchronization for a specific resource type.
+ */
+
+// Core interface
+export * from './ISyncStrategy.js';
+
+// Project strategy (projects, agents, flows, skills)
+export {
+  ProjectSyncStrategy,
+  createProjectSyncStrategy,
+  type LocalProjectData,
+  type LocalFlowData,
+  type LocalSkillData
+} from './ProjectSyncStrategy.js';
+
+// Attribute strategy (customer and project attributes)
+export {
+  AttributeSyncStrategy,
+  createAttributeSyncStrategy,
+  type LocalAttributeData
+} from './AttributeSyncStrategy.js';
+
+// Integration strategy (integrations, connectors, webhooks)
+export {
+  IntegrationSyncStrategy,
+  createIntegrationSyncStrategy,
+  type LocalIntegrationData
+} from './IntegrationSyncStrategy.js';
+
+// AKB strategy (knowledge base articles)
+export {
+  AkbSyncStrategy,
+  createAkbSyncStrategy,
+  type LocalAkbData
+} from './AkbSyncStrategy.js';
+
+// Conversation strategy (conversation history - pull only)
+export {
+  ConversationSyncStrategy,
+  createConversationSyncStrategy,
+  type LocalConversationData
+} from './ConversationSyncStrategy.js';

package/src/sync/migrate.ts

@@ -216,48 +216,102 @@ async function migrateProjectStructure(
             idn: sourceFlow.idn,
             title: sourceFlow.title
           });
-          flowId = flowResponse.id;
+
+          // Handle "pending-sync" response - re-fetch to get actual flow ID
+          if (flowResponse.id === 'pending-sync' || !flowResponse.id.match(/^[0-9a-f-]{36}$/i)) {
+            // Retry with increasing wait times
+            let createdFlow: any = null;
+            for (const waitMs of [1500, 3000, 5000]) {
+              await new Promise(resolve => setTimeout(resolve, waitMs));
+              const refreshedAgents = await listAgents(destClient, projectId);
+              const refreshedAgent = refreshedAgents.find(a => a.id === agentId);
+              createdFlow = refreshedAgent?.flows?.find(f => f.idn === sourceFlow.idn);
+              if (createdFlow) break;
+            }
+
+            if (createdFlow) {
+              flowId = createdFlow.id;
+            } else {
+              if (verbose) console.error(`   ⚠️  Flow ${sourceFlow.idn} created but could not retrieve ID after retries`);
+              continue; // Skip this flow
+            }
+          } else {
+            flowId = flowResponse.id;
+          }
           flowsCreated++;
         }
 
-        // Read flow metadata for events and states
-        const flowMetaPath = path.join(
+        // Flow directory path
+        const flowDirPath = path.join(
           customerProjectsDir(sourceCustomer.idn),
           sourceProj.idn,
           sourceAgent.idn,
-          sourceFlow.idn,
-          'metadata.yaml'
+          sourceFlow.idn
         );
 
-        if (await fs.pathExists(flowMetaPath)) {
-          const flowMeta = yaml.load(await fs.readFile(flowMetaPath, 'utf8')) as any;
-
-          // Create skills
-          const destSkills = await listFlowSkills(destClient, flowId);
+        if (await fs.pathExists(flowDirPath)) {
+          // Read flow metadata for events and states
+          const flowMetaPath = path.join(flowDirPath, 'metadata.yaml');
+          const flowMeta = await fs.pathExists(flowMetaPath)
+            ? yaml.load(await fs.readFile(flowMetaPath, 'utf8')) as any
+            : {};
+
+          // Create skills by reading skill subdirectories
+          let destSkills: any[];
+          try {
+            destSkills = await listFlowSkills(destClient, flowId);
+          } catch (err: any) {
+            if (verbose) console.error(`   ⚠️  Failed to list skills for flow ${sourceFlow.idn} (${flowId}): ${err.message}`);
+            continue; // Skip this flow if we can't list skills
+          }
           const destSkillMap = new Map(destSkills.map(s => [s.idn, s]));
 
-          for (const sourceSkill of flowMeta.skills || []) {
-            if (destSkillMap.has(sourceSkill.idn)) continue;
+          // Get all subdirectories in flow directory (these are skills)
+          const flowDirContents = await fs.readdir(flowDirPath, { withFileTypes: true });
+          const skillDirs = flowDirContents.filter(d => d.isDirectory());
+
+          for (const skillDir of skillDirs) {
+            const skillIdn = skillDir.name;
+            if (destSkillMap.has(skillIdn)) continue;
+
+            // Read skill metadata
+            const skillMetaPath = path.join(flowDirPath, skillIdn, 'metadata.yaml');
+            if (!await fs.pathExists(skillMetaPath)) continue;
+
+            const skillMeta = yaml.load(await fs.readFile(skillMetaPath, 'utf8')) as any;
 
             try {
               await createSkill(destClient, flowId, {
-                idn: sourceSkill.idn,
-                title: sourceSkill.title,
-                runner_type: sourceSkill.runner_type,
-                model: sourceSkill.model,
+                idn: skillMeta.idn || skillIdn,
+                title: skillMeta.title || skillIdn,
+                runner_type: skillMeta.runner_type || 'guidance',
+                model: skillMeta.model,
                 prompt_script: ''
               });
               skillsCreated++;
+              if (verbose) console.log(`   ✅ Created skill: ${skillIdn}`);
             } catch (error: any) {
               if (verbose && error.response?.status !== 409) {
-                console.error(`   ⚠️  Failed to create skill ${sourceSkill.idn}: ${error.message}`);
+                console.error(`   ⚠️  Failed to create skill ${skillIdn}: ${error.message}`);
               }
             }
           }
 
-          // Create events with full metadata
+          // Get current skills in destination to validate event references
+          const currentDestSkills = await listFlowSkills(destClient, flowId);
+          const destSkillIdnSet = new Set(currentDestSkills.map(s => s.idn));
+
+          // Create events with full metadata (only if referenced skill exists)
           for (const event of flowMeta.events || []) {
             try {
+              // Skip events that reference skills not yet created
+              if (event.skill_idn && !destSkillIdnSet.has(event.skill_idn)) {
+                if (verbose) {
+                  console.log(`   ⏭️  Skipping event ${event.idn} - skill ${event.skill_idn} not yet created`);
+                }
+                continue;
+              }
+
               const eventRequest: CreateFlowEventRequest = {
                 idn: event.idn,
                 description: event.description || event.idn,
@@ -276,8 +330,9 @@ async function migrateProjectStructure(
 
               await createFlowEvent(destClient, flowId, eventRequest);
             } catch (error: any) {
-              if (verbose && error.response?.status !== 409 && error.response?.status !== 422) {
-                console.error(`   ⚠️  Failed to create event ${event.idn}: ${error.message}`);
+              // Don't log 409 (already exists) or 422 (validation) errors as they're expected
+              if (error.response?.status !== 409 && error.response?.status !== 422) {
+                if (verbose) console.error(`   ⚠️  Failed to create event ${event.idn}: ${error.message}`);
               }
             }
           }
@@ -448,7 +503,6 @@ async function migrateAKB(
 async function migrateIntegrationConnectors(
   sourceClient: AxiosInstance,
   destClient: AxiosInstance,
-  // @ts-ignore - Parameter kept for future use
   verbose: boolean
 ): Promise<number> {
   const sourceIntegrations = await listIntegrations(sourceClient);
@@ -461,6 +515,11 @@ async function migrateIntegrationConnectors(
     const destInt = destIntMap.get(sourceInt.idn);
     if (!destInt) continue;
 
+    // Build set of allowed setting idns from destination integration schema
+    const destSettingIdns = new Set(
+      (destInt.connector_settings_descriptions || []).map(s => s.idn)
+    );
+
     const sourceConnectors = await listConnectors(sourceClient, sourceInt.id);
     const destConnectors = await listConnectors(destClient, destInt.id);
     const destConnMap = new Map(destConnectors.map(c => [c.connector_idn, c]));
@@ -468,17 +527,37 @@ async function migrateIntegrationConnectors(
     for (const sourceConn of sourceConnectors) {
       if (destConnMap.has(sourceConn.connector_idn)) continue;
 
+      // Filter settings to only include those that exist in destination schema
+      const filteredSettings = sourceConn.settings.filter(s => {
+        const allowed = destSettingIdns.size === 0 || destSettingIdns.has(s.idn);
+        if (!allowed && verbose) {
+          console.log(`   ⏭️  Skipping setting ${s.idn} for ${sourceConn.connector_idn} (not in dest schema)`);
+        }
+        return allowed;
+      });
+
+      // Log if settings were filtered
+      if (filteredSettings.length !== sourceConn.settings.length && verbose) {
+        const skippedCount = sourceConn.settings.length - filteredSettings.length;
+        console.log(`   📋 Filtered ${skippedCount} settings for ${sourceConn.connector_idn}`);
+      }
+
       try {
         await createConnector(destClient, destInt.id, {
           title: sourceConn.title,
           connector_idn: sourceConn.connector_idn,
           integration_idn: sourceInt.idn,
-          settings: sourceConn.settings
+          settings: filteredSettings
         });
         connectorsCreated++;
+        if (verbose) {
+          console.log(`   ✅ Created connector: ${sourceConn.connector_idn} (${sourceInt.idn})`);
+        }
       } catch (error: any) {
-        if (verbose && error.response?.status !== 409) {
-          console.error(`   ⚠️  Failed to create connector ${sourceConn.connector_idn}: ${error.message}`);
+        // Always log connector creation failures (not just in verbose mode)
+        const errMsg = error.response?.data?.reason || error.message;
+        if (error.response?.status !== 409) {
+          console.error(`   ⚠️  Failed to create connector ${sourceConn.connector_idn} (${sourceInt.idn}): ${errMsg}`);
         }
       }
     }

package/src/types.ts

@@ -587,6 +587,21 @@ export interface PublishFlowResponse {
 
 // Sandbox Chat Types
 
+export interface IntegrationSettingDescription {
+  readonly title: string;
+  readonly idn: string;
+  readonly control_type: string;
+  readonly value_type: string;
+  readonly is_required: boolean;
+  readonly is_readonly: boolean;
+  readonly default_value?: string | null;
+  readonly description?: string | null;
+  readonly group?: string | null;
+  readonly possible_values?: readonly string[] | null;
+  readonly possible_values_only?: boolean;
+  readonly possible_values_url?: string | null;
+}
+
 export interface Integration {
   readonly id: string;
   readonly title: string;
@@ -594,6 +609,8 @@ export interface Integration {
   readonly description: string;
   readonly is_disabled: boolean;
   readonly channel: string;
+  readonly integration_settings_descriptions?: readonly IntegrationSettingDescription[];
+  readonly connector_settings_descriptions?: readonly IntegrationSettingDescription[];
 }
 
 export interface IntegrationSetting {
@@ -874,4 +891,122 @@ export interface AddProjectFromRegistryRequest {
   registry_idn: string;
   registry_item_idn: string;
   registry_item_version: string | null;
+}
+
+// Create NEWO Customer Types (v3 API)
+
+export interface CustomerMember {
+  email: string;
+  role: 'owner' | 'account_manager' | 'technical_owner' | 'referral';
+  tenants?: string[];
+  first_name?: string;
+  external_account_id?: string;
+  contact_email?: string;
+}
+
+export interface CustomerAttributeInput {
+  idn: string;
+  value: string;
+  is_hidden?: boolean;
+  group?: string;
+}
+
+export interface CustomerProjectInput {
+  idn: string;
+  title?: string;
+  registry_idn?: string;
+  registry_item_idn?: string;
+  registry_item_version?: string;
+  is_auto_update_enabled?: boolean;
+}
+
+export interface CreateNewoCustomerRequest {
+  secret: string;
+  customer: {
+    organization_name: string;
+    tenant: string;
+    comment?: string;
+    query_params?: string;
+    members: CustomerMember[];
+    contact_email: string;
+    contact_phone?: string;
+    external_customer_id?: string;
+    organization_type?: 'customer' | 'partner';
+    organization_status?: 'temporal' | 'permanent';
+    billing_method?: string;
+    platform_links?: {
+      portal?: string;
+      builder?: string;
+      creator?: string;
+      chat_widget?: string;
+    };
+    organization_logo?: {
+      title?: string;
+      external_logo_id?: string;
+    };
+    attributes?: CustomerAttributeInput[];
+    a_service?: {
+      partner_idn: string;
+      member_idn: string;
+    };
+  };
+  projects?: CustomerProjectInput[];
+}
+
+export interface CreateNewoCustomerResponse {
+  id: string;
+  idn: string;
+}
+
+// Analytics Logs Types
+
+export type LogLevel = 'info' | 'warning' | 'error';
+export type LogType = 'system' | 'operation' | 'call';
+
+export interface LogEntry {
+  readonly log_id: string;
+  readonly level: LogLevel;
+  readonly log_type: LogType;
+  readonly project_idn: string;
+  readonly data: {
+    readonly external_event_id?: string;
+    readonly reference_idn?: string;
+    readonly operation_type?: string;
+    readonly arguments?: readonly { name: string; value: string }[];
+    readonly user_actor_id?: string;
+    readonly integration_idn?: string;
+    readonly connector_idn?: string;
+    readonly to_integration_idn?: string;
+    readonly to_connector_idn?: string;
+    readonly flow_idn?: string;
+    readonly skill_idn?: string;
+    readonly agent_idn?: string;
+    readonly line?: number;
+    readonly runtime_context_id?: string;
+    readonly [key: string]: unknown;
+  };
+  readonly message: string;
+  readonly datetime: string;
+}
+
+export interface LogsResponse {
+  readonly items: readonly LogEntry[];
+}
+
+export interface LogsQueryParams {
+  page?: number;
+  per?: number;
+  from_datetime?: string;
+  to_datetime?: string;
+  levels?: LogLevel | LogLevel[];
+  log_types?: LogType | LogType[];
+  message?: string;
+  project_idn?: string;
+  flow_idn?: string;
+  skill_idn?: string;
+  external_event_id?: string;
+  runtime_context_id?: string;
+  user_persona_ids?: string;
+  user_actor_ids?: string;
+  agent_persona_ids?: string;
 }