newo 3.3.3 → 3.4.1

package/src/cli/commands/list-registries.ts

@@ -0,0 +1,53 @@
+/**
+ * List Registries Command Handler - Lists available project registries
+ */
+import { makeClient, listRegistries } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { requireSingleCustomer } from '../customer-selection.js';
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+
+export async function handleListRegistriesCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean = false
+): Promise<void> {
+  try {
+    const selectedCustomer = requireSingleCustomer(customerConfig, args.customer as string | undefined);
+
+    if (verbose) {
+      console.log(`📋 Fetching registries for customer: ${selectedCustomer.idn}`);
+    }
+
+    // Get access token and create client
+    const accessToken = await getValidAccessToken(selectedCustomer);
+    const client = await makeClient(verbose, accessToken);
+
+    console.log('🔍 Fetching available project registries...\n');
+
+    const registries = await listRegistries(client);
+
+    if (registries.length === 0) {
+      console.log('No registries found.');
+      return;
+    }
+
+    console.log(`✅ Found ${registries.length} registries:\n`);
+
+    // Display registries in a table-like format
+    console.log('  IDN                     │ Public │ ID');
+    console.log('  ────────────────────────┼────────┼────────────────────────────────────');
+
+    for (const registry of registries) {
+      const publicStatus = registry.is_public ? 'Yes' : 'No';
+      const idnPadded = registry.idn.padEnd(22);
+      const publicPadded = publicStatus.padEnd(6);
+      console.log(`  ${idnPadded} │ ${publicPadded} │ ${registry.id}`);
+    }
+
+    console.log('\n💡 Use "newo list-registry-items <registry-idn>" to see available projects in a registry');
+
+  } catch (error: unknown) {
+    console.error('❌ Failed to list registries:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/src/cli/commands/list-registry-items.ts

@@ -0,0 +1,149 @@
+/**
+ * List Registry Items Command Handler - Lists available projects in a registry
+ */
+import { makeClient, listRegistries, listRegistryItems } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { requireSingleCustomer } from '../customer-selection.js';
+import type { MultiCustomerConfig, CliArgs, Registry, RegistryItem } from '../../types.js';
+
+interface GroupedItem {
+  idn: string;
+  versions: RegistryItem[];
+  latestVersion: string;
+  totalActiveProjects: number;
+}
+
+function groupItemsByIdn(items: RegistryItem[]): GroupedItem[] {
+  const groups = new Map<string, RegistryItem[]>();
+
+  for (const item of items) {
+    const existing = groups.get(item.idn) || [];
+    existing.push(item);
+    groups.set(item.idn, existing);
+  }
+
+  const result: GroupedItem[] = [];
+
+  for (const [idn, versions] of groups) {
+    // Sort versions by published_at descending (newest first)
+    const sortedVersions = [...versions].sort((a, b) =>
+      new Date(b.published_at).getTime() - new Date(a.published_at).getTime()
+    );
+
+    const latestItem = sortedVersions[0];
+    if (!latestItem) continue;
+
+    // Sum up active project counts across all versions
+    const totalActiveProjects = versions.reduce((sum, v) => sum + v.active_project_count, 0);
+
+    result.push({
+      idn,
+      versions: sortedVersions,
+      latestVersion: latestItem.version,
+      totalActiveProjects
+    });
+  }
+
+  // Sort by IDN alphabetically
+  return result.sort((a, b) => a.idn.localeCompare(b.idn));
+}
+
+export async function handleListRegistryItemsCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean = false
+): Promise<void> {
+  try {
+    const selectedCustomer = requireSingleCustomer(customerConfig, args.customer as string | undefined);
+
+    // Parse arguments
+    const registryIdn = args._[1] as string;
+    const showAllVersions = Boolean(args.all || args.a);
+
+    if (!registryIdn) {
+      console.error('Error: Registry IDN is required');
+      console.error('Usage: newo list-registry-items <registry-idn> [--all]');
+      console.error('');
+      console.error('Examples:');
+      console.error('  newo list-registry-items production');
+      console.error('  newo list-registry-items staging --all');
+      console.error('');
+      console.error('Run "newo list-registries" to see available registries');
+      process.exit(1);
+    }
+
+    if (verbose) {
+      console.log(`📋 Fetching items from registry: ${registryIdn}`);
+      console.log(`   Customer: ${selectedCustomer.idn}`);
+      console.log(`   Show all versions: ${showAllVersions}`);
+    }
+
+    // Get access token and create client
+    const accessToken = await getValidAccessToken(selectedCustomer);
+    const client = await makeClient(verbose, accessToken);
+
+    // First, get registries to find the ID
+    console.log(`🔍 Fetching registry "${registryIdn}"...`);
+    const registries = await listRegistries(client);
+    const registry = registries.find((r: Registry) => r.idn === registryIdn);
+
+    if (!registry) {
+      console.error(`❌ Registry "${registryIdn}" not found`);
+      console.error('');
+      console.error('Available registries:');
+      for (const r of registries) {
+        console.error(`  • ${r.idn}`);
+      }
+      process.exit(1);
+    }
+
+    console.log(`📦 Fetching projects from "${registryIdn}" registry (this may take a moment)...\n`);
+
+    const items = await listRegistryItems(client, registry.id);
+
+    if (items.length === 0) {
+      console.log(`No projects found in "${registryIdn}" registry.`);
+      return;
+    }
+
+    if (showAllVersions) {
+      // Show all versions
+      console.log(`✅ Found ${items.length} project versions in "${registryIdn}" registry:\n`);
+
+      console.log('  Project IDN            │ Version  │ Active │ Published');
+      console.log('  ───────────────────────┼──────────┼────────┼────────────────────');
+
+      for (const item of items) {
+        const idnPadded = item.idn.substring(0, 21).padEnd(21);
+        const versionPadded = item.version.substring(0, 8).padEnd(8);
+        const activePadded = String(item.active_project_count).padEnd(6);
+        const published = new Date(item.published_at).toISOString().split('T')[0];
+        console.log(`  ${idnPadded} │ ${versionPadded} │ ${activePadded} │ ${published}`);
+      }
+    } else {
+      // Group by project IDN and show only latest version
+      const grouped = groupItemsByIdn(items);
+
+      console.log(`✅ Found ${grouped.length} unique projects in "${registryIdn}" registry:\n`);
+
+      console.log('  Project IDN            │ Latest   │ Active │ Versions');
+      console.log('  ───────────────────────┼──────────┼────────┼──────────');
+
+      for (const group of grouped) {
+        const idnPadded = group.idn.substring(0, 21).padEnd(21);
+        const versionPadded = group.latestVersion.substring(0, 8).padEnd(8);
+        const activePadded = String(group.totalActiveProjects).padEnd(6);
+        const versionCount = String(group.versions.length).padEnd(8);
+        console.log(`  ${idnPadded} │ ${versionPadded} │ ${activePadded} │ ${versionCount}`);
+      }
+
+      console.log('\n💡 Use --all flag to see all versions');
+    }
+
+    console.log(`\n💡 Use "newo add-project <idn> --registry ${registryIdn} --item <project-idn>" to install a project`);
+
+  } catch (error: unknown) {
+    console.error('❌ Failed to list registry items:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/src/cli/commands/logs.ts

@@ -0,0 +1,329 @@
+/**
+ * Logs command - Fetch and display analytics logs from NEWO platform
+ *
+ * Usage:
+ *   newo logs                              # Last 1 hour of logs
+ *   newo logs --hours 24                   # Last 24 hours
+ *   newo logs --from "2026-01-11T00:00:00Z" --to "2026-01-12T00:00:00Z"
+ *   newo logs --level warning              # Only warnings
+ *   newo logs --type call                  # Only skill calls
+ *   newo logs --flow CACreatorFlow         # Filter by flow
+ *   newo logs --skill CreateActor          # Filter by skill
+ *   newo logs --follow                     # Tail mode (poll for new logs)
+ *   newo logs --json                       # Output as JSON
+ */
+
+import type { AxiosInstance } from 'axios';
+import type { MultiCustomerConfig, LogEntry, LogLevel, LogType, LogsQueryParams, CliArgs } from '../../types.js';
+import { makeClient, getLogs } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { requireSingleCustomer } from '../customer-selection.js';
+
+// ANSI color codes for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  magenta: '\x1b[35m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m'
+};
+
+function getLevelColor(level: LogLevel): string {
+  switch (level) {
+    case 'error': return colors.red;
+    case 'warning': return colors.yellow;
+    case 'info': return colors.blue;
+    default: return colors.white;
+  }
+}
+
+function getTypeColor(type: LogType): string {
+  switch (type) {
+    case 'call': return colors.cyan;
+    case 'operation': return colors.magenta;
+    case 'system': return colors.green;
+    default: return colors.white;
+  }
+}
+
+function formatLogEntry(log: LogEntry, showColors: boolean = true): string {
+  const c = showColors ? colors : { reset: '', dim: '', red: '', yellow: '', blue: '', cyan: '', green: '', magenta: '', white: '', gray: '' };
+
+  // Format datetime
+  const date = new Date(log.datetime);
+  const timeStr = date.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+  const msStr = String(date.getMilliseconds()).padStart(3, '0');
+  const dateTimeFormatted = `${c.dim}${timeStr}.${msStr}${c.reset}`;
+
+  // Format level with color
+  const levelColor = showColors ? getLevelColor(log.level) : '';
+  const levelStr = `${levelColor}${log.level.toUpperCase().padEnd(7)}${c.reset}`;
+
+  // Format type with color
+  const typeColor = showColors ? getTypeColor(log.log_type) : '';
+  const typeStr = `${typeColor}${log.log_type.padEnd(9)}${c.reset}`;
+
+  // Build context string from data
+  const contextParts: string[] = [];
+  if (log.data.flow_idn) contextParts.push(`${c.cyan}[${log.data.flow_idn}]${c.reset}`);
+  if (log.data.skill_idn) contextParts.push(`${c.green}[${log.data.skill_idn}]${c.reset}`);
+  if (log.data.line !== undefined) contextParts.push(`${c.dim}:${log.data.line}${c.reset}`);
+  if (log.data.integration_idn && log.data.connector_idn) {
+    contextParts.push(`${c.magenta}${log.data.integration_idn}/${log.data.connector_idn}${c.reset}`);
+  }
+
+  const contextStr = contextParts.length > 0 ? ` ${contextParts.join(' ')}` : '';
+
+  // Format message
+  const messageStr = log.message;
+
+  return `${dateTimeFormatted} ${levelStr} ${typeStr}${contextStr} ${messageStr}`;
+}
+
+function formatLogEntryCompact(log: LogEntry, showColors: boolean = true): string {
+  const c = showColors ? colors : { reset: '', dim: '', red: '', yellow: '', blue: '', cyan: '', green: '', magenta: '', white: '', gray: '' };
+
+  // Shorter format for tail mode
+  const date = new Date(log.datetime);
+  const timeStr = date.toLocaleTimeString('en-US', { hour12: false });
+
+  const levelColor = showColors ? getLevelColor(log.level) : '';
+  const levelIcon = log.level === 'error' ? '✗' : log.level === 'warning' ? '⚠' : '•';
+
+  return `${c.dim}${timeStr}${c.reset} ${levelColor}${levelIcon}${c.reset} ${log.message}`;
+}
+
+export async function handleLogsCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean
+): Promise<void> {
+  // Select customer
+  const selectedCustomer = requireSingleCustomer(customerConfig, args.customer as string | undefined);
+
+  console.log(`📊 Fetching logs for ${selectedCustomer.idn}...`);
+
+  // Get access token and create client
+  const token = await getValidAccessToken(selectedCustomer);
+  const client = await makeClient(verbose, token);
+
+  // Build query params
+  const params: LogsQueryParams = {
+    page: args.page ? parseInt(String(args.page), 10) : 1,
+    per: args.per ? parseInt(String(args.per), 10) : 50
+  };
+
+  // Time range
+  if (args.from) {
+    params.from_datetime = String(args.from);
+  } else {
+    // Default to last N hours (default 1 hour)
+    const hoursAgo = args.hours ? parseInt(String(args.hours), 10) : 1;
+    params.from_datetime = new Date(Date.now() - hoursAgo * 60 * 60 * 1000).toISOString();
+  }
+
+  if (args.to) {
+    params.to_datetime = String(args.to);
+  }
+
+  // Filters
+  if (args.level) {
+    const levelStr = String(args.level);
+    const levels = levelStr.split(',') as LogLevel[];
+    if (levels.length === 1 && levels[0]) {
+      params.levels = levels[0];
+    } else if (levels.length > 1) {
+      params.levels = levels;
+    }
+  }
+
+  if (args.type) {
+    const typeStr = String(args.type);
+    const types = typeStr.split(',') as LogType[];
+    if (types.length === 1 && types[0]) {
+      params.log_types = types[0];
+    } else if (types.length > 1) {
+      params.log_types = types;
+    }
+  }
+
+  if (args.project) params.project_idn = String(args.project);
+  if (args.flow) params.flow_idn = String(args.flow);
+  if (args.skill) params.skill_idn = String(args.skill);
+  if (args.message) params.message = String(args.message);
+  if (args['event-id']) params.external_event_id = String(args['event-id']);
+  if (args['runtime-id']) params.runtime_context_id = String(args['runtime-id']);
+  if (args['actor-id']) params.user_actor_ids = String(args['actor-id']);
+  if (args['persona-id']) params.user_persona_ids = String(args['persona-id']);
+
+  const follow = Boolean(args.follow || args.f);
+  const asJson = Boolean(args.json);
+  const raw = Boolean(args.raw);
+
+  if (follow) {
+    await tailLogs(client, params, asJson);
+  } else {
+    await fetchAndDisplayLogs(client, params, asJson, raw);
+  }
+}
+
+async function fetchAndDisplayLogs(
+  client: AxiosInstance,
+  params: LogsQueryParams,
+  asJson: boolean,
+  raw: boolean
+): Promise<void> {
+  try {
+    const response = await getLogs(client, params);
+    const logs = response.items;
+
+    if (asJson) {
+      console.log(JSON.stringify(logs, null, 2));
+      return;
+    }
+
+    if (logs.length === 0) {
+      console.log('\nNo logs found for the specified criteria.');
+      return;
+    }
+
+    console.log(`\n📝 Found ${logs.length} log entries:\n`);
+
+    // Sort by datetime ascending (oldest first)
+    const sortedLogs = [...logs].sort((a, b) =>
+      new Date(a.datetime).getTime() - new Date(b.datetime).getTime()
+    );
+
+    // Detect if stdout is a TTY (supports colors)
+    const useColors = process.stdout.isTTY !== false;
+
+    for (const log of sortedLogs) {
+      if (raw) {
+        console.log(JSON.stringify(log));
+      } else {
+        console.log(formatLogEntry(log, useColors));
+      }
+    }
+
+    console.log(`\n✅ Displayed ${logs.length} log entries`);
+  } catch (error: unknown) {
+    const err = error as { response?: { status?: number; data?: unknown }; message?: string };
+    console.error('Failed to fetch logs:', err.response?.status, err.response?.data || err.message);
+  }
+}
+
+async function tailLogs(
+  client: AxiosInstance,
+  params: LogsQueryParams,
+  asJson: boolean
+): Promise<void> {
+  console.log('🔄 Watching for new logs (Ctrl+C to stop)...\n');
+
+  const seenLogIds = new Set<string>();
+  let lastCheckTime = params.from_datetime || new Date(Date.now() - 60 * 60 * 1000).toISOString();
+  const useColors = process.stdout.isTTY !== false;
+
+  // Poll interval (2 seconds)
+  const pollInterval = 2000;
+
+  const poll = async () => {
+    try {
+      const pollParams: LogsQueryParams = {
+        ...params,
+        from_datetime: lastCheckTime,
+        page: 1,
+        per: 100
+      };
+
+      const response = await getLogs(client, pollParams);
+      const logs = response.items;
+
+      // Filter out already seen logs and sort by time
+      const newLogs = logs
+        .filter(log => !seenLogIds.has(log.log_id))
+        .sort((a, b) => new Date(a.datetime).getTime() - new Date(b.datetime).getTime());
+
+      for (const log of newLogs) {
+        seenLogIds.add(log.log_id);
+
+        if (asJson) {
+          console.log(JSON.stringify(log));
+        } else {
+          console.log(formatLogEntryCompact(log, useColors));
+        }
+
+        // Update last check time to the newest log we've seen
+        const logTime = new Date(log.datetime);
+        const lastTime = new Date(lastCheckTime);
+        if (logTime > lastTime) {
+          lastCheckTime = log.datetime;
+        }
+      }
+    } catch (error: unknown) {
+      // Silently ignore poll errors to avoid spamming the console
+    }
+  };
+
+  // Initial poll
+  await poll();
+
+  // Set up interval for continuous polling
+  const intervalId = setInterval(poll, pollInterval);
+
+  // Handle Ctrl+C gracefully
+  process.on('SIGINT', () => {
+    clearInterval(intervalId);
+    console.log('\n\n👋 Stopped watching logs');
+    process.exit(0);
+  });
+
+  // Keep the process running
+  await new Promise(() => {});
+}
+
+export function printLogsHelp(): void {
+  console.log(`
+Usage: newo logs [options]
+
+Fetch and display analytics logs from the NEWO platform.
+
+Time Range Options:
+  --hours <n>           Show logs from last N hours (default: 1)
+  --from <datetime>     Start datetime (ISO format, e.g., 2026-01-11T00:00:00Z)
+  --to <datetime>       End datetime (ISO format)
+
+Filter Options:
+  --level <levels>      Filter by log level: info, warning, error (comma-separated)
+  --type <types>        Filter by log type: system, operation, call (comma-separated)
+  --project <idn>       Filter by project IDN
+  --flow <idn>          Filter by flow IDN
+  --skill <idn>         Filter by skill IDN
+  --message <text>      Search in log messages
+  --event-id <uuid>     Filter by external event ID
+  --runtime-id <uuid>   Filter by runtime context ID
+  --actor-id <uuid>     Filter by user actor ID
+  --persona-id <uuid>   Filter by user persona ID
+
+Output Options:
+  --json                Output logs as JSON
+  --raw                 Output each log as a single JSON line
+  --per <n>             Number of logs per page (default: 50)
+  --page <n>            Page number (default: 1)
+
+Live Tailing:
+  --follow, -f          Continuously poll for new logs (like tail -f)
+
+Examples:
+  newo logs                                    # Last 1 hour of logs
+  newo logs --hours 24                         # Last 24 hours
+  newo logs --level warning,error              # Warnings and errors only
+  newo logs --type call --skill CreateActor    # Skill calls for CreateActor
+  newo logs --flow CACreatorFlow --follow      # Tail logs for specific flow
+  newo logs --json --per 100                   # Get 100 logs as JSON
+`);
+}

package/src/cli/commands/pull.ts

@@ -1,11 +1,79 @@
 /**
  * Pull command handler
+ *
+ * Supports selective resource sync with --only and --exclude flags:
+ *   newo pull --only projects,attributes
+ *   newo pull --exclude conversations,akb
+ *   newo pull --all  (explicit all resources)
+ *
+ * Available resources: projects, attributes, integrations, akb, conversations
  */
 import { makeClient } from '../../api.js';
 import { pullAll } from '../../sync.js';
 import { getValidAccessToken } from '../../auth.js';
 import { selectSingleCustomer } from '../customer-selection.js';
-import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+import { setupCli } from '../../cli-new/bootstrap.js';
+import { ALL_RESOURCE_TYPES, RESOURCE_TYPES } from '../../cli-new/di/tokens.js';
+import type { MultiCustomerConfig, CliArgs, CustomerConfig } from '../../types.js';
+
+/**
+ * Parse resource list from comma-separated string
+ */
+function parseResourceList(input: string | undefined): string[] {
+  if (!input) return [];
+  return input.split(',').map(r => r.trim().toLowerCase()).filter(Boolean);
+}
+
+/**
+ * Validate resource types
+ */
+function validateResources(resources: string[]): { valid: string[]; invalid: string[] } {
+  const validTypes = new Set(ALL_RESOURCE_TYPES);
+  const valid: string[] = [];
+  const invalid: string[] = [];
+
+  for (const r of resources) {
+    if (validTypes.has(r as typeof RESOURCE_TYPES[keyof typeof RESOURCE_TYPES])) {
+      valid.push(r);
+    } else {
+      invalid.push(r);
+    }
+  }
+
+  return { valid, invalid };
+}
+
+/**
+ * Pull using V2 SyncEngine with selective sync
+ */
+async function pullWithV2Engine(
+  customerConfig: MultiCustomerConfig,
+  customer: CustomerConfig,
+  resources: string[] | 'all',
+  verbose: boolean,
+  silentOverwrite: boolean
+): Promise<void> {
+  const { syncEngine, logger } = setupCli(customerConfig, verbose);
+
+  const pullOptions = {
+    verbose,
+    silentOverwrite
+  };
+
+  if (resources === 'all') {
+    const result = await syncEngine.pullAll(customer, pullOptions);
+    logger.info(`✅ Pulled ${result.totalItems} items from ${result.resources.length} resource types`);
+    if (result.errors.length > 0) {
+      logger.warn(`⚠️  ${result.errors.length} error(s) occurred`);
+    }
+  } else {
+    const result = await syncEngine.pullSelected(customer, resources, pullOptions);
+    logger.info(`✅ Pulled ${result.totalItems} items from ${result.resources.length} resource types`);
+    if (result.errors.length > 0) {
+      logger.warn(`⚠️  ${result.errors.length} error(s) occurred`);
+    }
+  }
+}
 
 export async function handlePullCommand(
   customerConfig: MultiCustomerConfig,
@@ -20,23 +88,72 @@ export async function handlePullCommand(
   // Check for force/silent overwrite flag
   const silentOverwrite = Boolean(args.force || args.f);
 
+  // Check for selective sync flags
+  const onlyResources = parseResourceList(args.only as string | undefined);
+  const excludeResources = parseResourceList(args.exclude as string | undefined);
+  const pullAllResources = Boolean(args.all);
+
+  // Validate resource types
+  if (onlyResources.length > 0) {
+    const { invalid } = validateResources(onlyResources);
+    if (invalid.length > 0) {
+      console.error(`❌ Unknown resource type(s): ${invalid.join(', ')}`);
+      console.error(`   Available: ${ALL_RESOURCE_TYPES.join(', ')}`);
+      process.exit(1);
+    }
+  }
+
+  if (excludeResources.length > 0) {
+    const { invalid } = validateResources(excludeResources);
+    if (invalid.length > 0) {
+      console.error(`❌ Unknown resource type(s): ${invalid.join(', ')}`);
+      console.error(`   Available: ${ALL_RESOURCE_TYPES.join(', ')}`);
+      process.exit(1);
+    }
+  }
+
+  // Determine which resources to pull
+  let resourcesToFetch: string[] | 'all' = 'all';
+
+  if (onlyResources.length > 0) {
+    resourcesToFetch = onlyResources;
+    console.log(`📦 Pulling selected resources: ${onlyResources.join(', ')}`);
+  } else if (excludeResources.length > 0) {
+    resourcesToFetch = ALL_RESOURCE_TYPES.filter(r => !excludeResources.includes(r));
+    console.log(`📦 Pulling resources (excluding: ${excludeResources.join(', ')})`);
+  } else if (pullAllResources) {
+    resourcesToFetch = 'all';
+    console.log(`📦 Pulling ALL resources`);
+  }
+
+  // Use V2 engine if selective sync requested, otherwise use legacy for backward compatibility
+  const useV2Engine = onlyResources.length > 0 || excludeResources.length > 0 || pullAllResources;
+
   if (selectedCustomer) {
-    // Single customer pull
-    const accessToken = await getValidAccessToken(selectedCustomer);
-    const client = await makeClient(verbose, accessToken);
-    const projectId = selectedCustomer.projectId || null;
-    await pullAll(client, selectedCustomer, projectId, verbose, silentOverwrite);
+    if (useV2Engine) {
+      await pullWithV2Engine(customerConfig, selectedCustomer, resourcesToFetch, verbose, silentOverwrite);
+    } else {
+      // Legacy behavior: pull projects + attributes only
+      const accessToken = await getValidAccessToken(selectedCustomer);
+      const client = await makeClient(verbose, accessToken);
+      const projectId = selectedCustomer.projectId || null;
+      await pullAll(client, selectedCustomer, projectId, verbose, silentOverwrite);
+    }
   } else if (isMultiCustomer) {
-    // Multi-customer pull
     if (verbose) console.log(`📥 No default customer specified, pulling from all ${allCustomers.length} customers`);
     console.log(`🔄 Pulling from ${allCustomers.length} customers...`);
 
     for (const customer of allCustomers) {
       console.log(`\n📥 Pulling from customer: ${customer.idn}`);
-      const accessToken = await getValidAccessToken(customer);
-      const client = await makeClient(verbose, accessToken);
-      const projectId = customer.projectId || null;
-      await pullAll(client, customer, projectId, verbose, silentOverwrite);
+
+      if (useV2Engine) {
+        await pullWithV2Engine(customerConfig, customer, resourcesToFetch, verbose, silentOverwrite);
+      } else {
+        const accessToken = await getValidAccessToken(customer);
+        const client = await makeClient(verbose, accessToken);
+        const projectId = customer.projectId || null;
+        await pullAll(client, customer, projectId, verbose, silentOverwrite);
+      }
     }
     console.log(`\n✅ Pull completed for all ${allCustomers.length} customers`);
   }