newo 3.3.3 → 3.4.1

package/dist/sync/migrate.js

@@ -156,38 +156,94 @@ verbose) {
                         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 = 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(customerProjectsDir(sourceCustomer.idn), sourceProj.idn, sourceAgent.idn, sourceFlow.idn, 'metadata.yaml');
-                if (await fs.pathExists(flowMetaPath)) {
-                    const flowMeta = yaml.load(await fs.readFile(flowMetaPath, 'utf8'));
-                    // Create skills
-                    const destSkills = await listFlowSkills(destClient, flowId);
+                // Flow directory path
+                const flowDirPath = path.join(customerProjectsDir(sourceCustomer.idn), sourceProj.idn, sourceAgent.idn, sourceFlow.idn);
+                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'))
+                        : {};
+                    // Create skills by reading skill subdirectories
+                    let destSkills;
+                    try {
+                        destSkills = await listFlowSkills(destClient, flowId);
+                    }
+                    catch (err) {
+                        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))
+                    // 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'));
                         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) {
                             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 = {
                                 idn: event.idn,
                                 description: event.description || event.idn,
@@ -205,8 +261,10 @@ verbose) {
                             await createFlowEvent(destClient, flowId, eventRequest);
                         }
                         catch (error) {
-                            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}`);
                             }
                         }
                     }
@@ -350,9 +408,7 @@ verbose) {
     }
     return { personas: personasCreated, articles: articlesImported };
 }
-async function migrateIntegrationConnectors(sourceClient, destClient, 
-// @ts-ignore - Parameter kept for future use
-verbose) {
+async function migrateIntegrationConnectors(sourceClient, destClient, verbose) {
     const sourceIntegrations = await listIntegrations(sourceClient);
     const destIntegrations = await listIntegrations(destClient);
     const destIntMap = new Map(destIntegrations.map(i => [i.idn, i]));
@@ -361,24 +417,44 @@ verbose) {
         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]));
         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) {
-                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/dist/types.d.ts

@@ -494,6 +494,20 @@ export interface PublishFlowRequest {
 export interface PublishFlowResponse {
     success: boolean;
 }
+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;
@@ -501,6 +515,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 {
     readonly title: string;
@@ -703,4 +719,150 @@ export interface AkbYamlTopic {
     labels: string[];
     topic_summary: string;
 }
+export interface Registry {
+    readonly id: string;
+    readonly idn: string;
+    readonly account_id: string;
+    readonly is_public: boolean;
+}
+export interface RegistryItemProjectImage {
+    readonly id: string;
+    readonly idn: string;
+    readonly image_hash: string;
+    readonly storage_id: string;
+    readonly customer_idn: string;
+    readonly account_id: string;
+    readonly created_at: string;
+}
+export interface RegistryItem {
+    readonly id: string;
+    readonly idn: string;
+    readonly version: string;
+    readonly project_image: RegistryItemProjectImage;
+    readonly account_id: string;
+    readonly account_idn: string | null;
+    readonly account_email: string | null;
+    readonly is_public: boolean;
+    readonly active_project_count: number;
+    readonly created_at: string;
+    readonly published_at: string;
+}
+export interface AddProjectFromRegistryRequest {
+    idn: string;
+    title: string;
+    version?: string;
+    description?: string;
+    is_auto_update_enabled?: boolean;
+    registry_idn: string;
+    registry_item_idn: string;
+    registry_item_version: string | null;
+}
+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;
+}
+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;
+}
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newo",
-  "version": "3.3.3",
+  "version": "3.4.1",
   "description": "NEWO CLI: Professional command-line tool with modular architecture for NEWO AI Agent development. Features account migration, integration management, webhook automation, AKB knowledge base, project attributes, sandbox testing, IDN-based file management, real-time progress tracking, intelligent sync operations, and comprehensive multi-customer support.",
   "type": "module",
   "bin": {
@@ -61,6 +61,7 @@
   },
   "dependencies": {
     "axios": "^1.7.7",
+    "chokidar": "^5.0.0",
     "dotenv": "^16.4.5",
     "fs-extra": "^11.2.0",
     "js-yaml": "^4.1.0",
@@ -69,6 +70,7 @@
   },
   "devDependencies": {
     "@types/chai": "^4.3.11",
+    "@types/chokidar": "^1.7.5",
     "@types/fs-extra": "^11.0.4",
     "@types/js-yaml": "^4.0.9",
     "@types/minimist": "^1.2.5",

package/src/api.ts

@@ -52,7 +52,14 @@ import type {
   OutgoingWebhook,
   IncomingWebhook,
   PersonaSearchResponse,
-  AkbTopicsResponse
+  AkbTopicsResponse,
+  Registry,
+  RegistryItem,
+  AddProjectFromRegistryRequest,
+  CreateNewoCustomerRequest,
+  CreateNewoCustomerResponse,
+  LogsQueryParams,
+  LogsResponse
 } from './types.js';
 
 // Per-request retry tracking to avoid shared state issues
@@ -103,7 +110,7 @@ export async function makeClient(verbose: boolean = false, token?: string): Prom
       // Use per-request retry tracking to avoid shared state issues
       const config = error.config as InternalAxiosRequestConfig & { [RETRY_SYMBOL]?: boolean };
       
-      if (status === 401 && !config?.[RETRY_SYMBOL]) {
+      if ((status === 401 || status === 403) && !config?.[RETRY_SYMBOL]) {
         if (config) {
           config[RETRY_SYMBOL] = true;
           if (verbose) console.log('🔄 Retrying with fresh token...');
@@ -552,4 +559,72 @@ export async function createIncomingWebhook(
 ): Promise<{ id: string; url: string }> {
   const response = await client.post('/api/v1/webhooks/incoming', webhookData);
   return response.data;
+}
+
+// Registry API Functions
+
+export async function listRegistries(client: AxiosInstance): Promise<Registry[]> {
+  const response = await client.get<Registry[]>('/api/v1/designer/registries');
+  return response.data;
+}
+
+export async function listRegistryItems(client: AxiosInstance, registryId: string): Promise<RegistryItem[]> {
+  const response = await client.get<RegistryItem[]>(`/api/v1/designer/registries/${registryId}/items`);
+  return response.data;
+}
+
+export async function addProjectFromRegistry(
+  client: AxiosInstance,
+  projectData: AddProjectFromRegistryRequest
+): Promise<CreateProjectResponse> {
+  // Uses the same endpoint as createProject, but with registry fields populated
+  const response = await client.post<CreateProjectResponse>('/api/v1/designer/projects', projectData);
+  return response.data;
+}
+
+// Create NEWO Customer (v3 API - creates a new customer account)
+export async function createNewoCustomer(
+  client: AxiosInstance,
+  customerData: CreateNewoCustomerRequest
+): Promise<CreateNewoCustomerResponse> {
+  const response = await client.post<CreateNewoCustomerResponse>('/api/v3/customer', customerData);
+  return response.data;
+}
+
+// Analytics Logs API
+export async function getLogs(
+  client: AxiosInstance,
+  params: LogsQueryParams
+): Promise<LogsResponse> {
+  // Build query params, handling arrays for levels and log_types
+  const queryParams = new URLSearchParams();
+
+  if (params.page !== undefined) queryParams.set('page', String(params.page));
+  if (params.per !== undefined) queryParams.set('per', String(params.per));
+  if (params.from_datetime) queryParams.set('from_datetime', params.from_datetime);
+  if (params.to_datetime) queryParams.set('to_datetime', params.to_datetime);
+  if (params.message) queryParams.set('message', params.message);
+  if (params.project_idn) queryParams.set('project_idn', params.project_idn);
+  if (params.flow_idn) queryParams.set('flow_idn', params.flow_idn);
+  if (params.skill_idn) queryParams.set('skill_idn', params.skill_idn);
+  if (params.external_event_id) queryParams.set('external_event_id', params.external_event_id);
+  if (params.runtime_context_id) queryParams.set('runtime_context_id', params.runtime_context_id);
+  if (params.user_persona_ids) queryParams.set('user_persona_ids', params.user_persona_ids);
+  if (params.user_actor_ids) queryParams.set('user_actor_ids', params.user_actor_ids);
+  if (params.agent_persona_ids) queryParams.set('agent_persona_ids', params.agent_persona_ids);
+
+  // Handle levels (can be single or array)
+  if (params.levels) {
+    const levelsValue = Array.isArray(params.levels) ? params.levels.join(',') : params.levels;
+    queryParams.set('levels', levelsValue);
+  }
+
+  // Handle log_types (can be single or array)
+  if (params.log_types) {
+    const typesValue = Array.isArray(params.log_types) ? params.log_types.join(',') : params.log_types;
+    queryParams.set('log_types', typesValue);
+  }
+
+  const response = await client.get<LogsResponse>(`/api/v1/analytics/logs?${queryParams.toString()}`);
+  return response.data;
 }