newo 3.4.0 → 3.4.2

package/dist/cli/commands/logs.js

@@ -0,0 +1,283 @@
+/**
+ * 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 { 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) {
+    switch (level) {
+        case 'error': return colors.red;
+        case 'warning': return colors.yellow;
+        case 'info': return colors.blue;
+        default: return colors.white;
+    }
+}
+function getTypeColor(type) {
+    switch (type) {
+        case 'call': return colors.cyan;
+        case 'operation': return colors.magenta;
+        case 'system': return colors.green;
+        default: return colors.white;
+    }
+}
+function formatLogEntry(log, showColors = true) {
+    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 = [];
+    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, showColors = true) {
+    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, args, verbose) {
+    // Select customer
+    const selectedCustomer = requireSingleCustomer(customerConfig, args.customer);
+    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 = {
+        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(',');
+        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(',');
+        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, params, asJson, raw) {
+    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) {
+        const err = error;
+        console.error('Failed to fetch logs:', err.response?.status, err.response?.data || err.message);
+    }
+}
+async function tailLogs(client, params, asJson) {
+    console.log('🔄 Watching for new logs (Ctrl+C to stop)...\n');
+    const seenLogIds = new Set();
+    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 = {
+                ...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) {
+            // 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() {
+    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
+`);
+}
+//# sourceMappingURL=logs.js.map

package/dist/cli/commands/pull.js

@@ -1,32 +1,136 @@
 /**
  * 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 { setupCli } from '../../cli-new/bootstrap.js';
+import { ALL_RESOURCE_TYPES, RESOURCE_TYPES } from '../../cli-new/di/tokens.js';
+/**
+ * Parse resource list from comma-separated string
+ */
+function parseResourceList(input) {
+    if (!input)
+        return [];
+    return input.split(',').map(r => r.trim().toLowerCase()).filter(Boolean);
+}
+/**
+ * Validate resource types
+ */
+function validateResources(resources) {
+    const validTypes = new Set(ALL_RESOURCE_TYPES);
+    const valid = [];
+    const invalid = [];
+    for (const r of resources) {
+        if (validTypes.has(r)) {
+            valid.push(r);
+        }
+        else {
+            invalid.push(r);
+        }
+    }
+    return { valid, invalid };
+}
+/**
+ * Pull using V2 SyncEngine with selective sync
+ */
+async function pullWithV2Engine(customerConfig, customer, resources, verbose, silentOverwrite) {
+    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, args, verbose) {
     const { selectedCustomer, allCustomers, isMultiCustomer } = selectSingleCustomer(customerConfig, args.customer);
     // Check for force/silent overwrite flag
     const silentOverwrite = Boolean(args.force || args.f);
+    // Check for selective sync flags
+    const onlyResources = parseResourceList(args.only);
+    const excludeResources = parseResourceList(args.exclude);
+    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 = '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`);
     }

package/dist/cli/commands/push.js

@@ -1,37 +1,147 @@
 /**
  * Push command handler
+ *
+ * Supports selective resource sync with --only and --exclude flags:
+ *   newo push --only projects,attributes
+ *   newo push --exclude integrations
+ *   newo push --all  (explicit all resources)
+ *
+ * Available resources: projects, attributes, integrations, akb
+ * Note: conversations is read-only and cannot be pushed
  */
 import { makeClient } from '../../api.js';
 import { pushChanged } from '../../sync.js';
 import { getValidAccessToken } from '../../auth.js';
 import { selectSingleCustomer, interactiveCustomerSelection } from '../customer-selection.js';
+import { setupCli } from '../../cli-new/bootstrap.js';
+import { PUSHABLE_RESOURCE_TYPES } from '../../cli-new/di/tokens.js';
+/**
+ * Parse resource list from comma-separated string
+ */
+function parseResourceList(input) {
+    if (!input)
+        return [];
+    return input.split(',').map(r => r.trim().toLowerCase()).filter(Boolean);
+}
+/**
+ * Validate resource types for push
+ */
+function validateResources(resources) {
+    const validTypes = new Set(PUSHABLE_RESOURCE_TYPES);
+    const valid = [];
+    const invalid = [];
+    for (const r of resources) {
+        if (r === 'conversations') {
+            invalid.push(r + ' (read-only)');
+        }
+        else if (validTypes.has(r)) {
+            valid.push(r);
+        }
+        else {
+            invalid.push(r);
+        }
+    }
+    return { valid, invalid };
+}
+/**
+ * Push using V2 SyncEngine with selective sync
+ */
+async function pushWithV2Engine(customerConfig, customer, resources, verbose) {
+    const { syncEngine, logger } = setupCli(customerConfig, verbose);
+    if (resources === 'all') {
+        const result = await syncEngine.pushAll(customer);
+        logger.info(`✅ Pushed: ${result.totalCreated} created, ${result.totalUpdated} updated, ${result.totalDeleted} deleted`);
+        if (result.errors.length > 0) {
+            logger.warn(`⚠️  ${result.errors.length} error(s) occurred`);
+            result.errors.forEach(e => logger.error(`   ${e}`));
+        }
+    }
+    else {
+        const result = await syncEngine.pushSelected(customer, resources);
+        logger.info(`✅ Pushed: ${result.totalCreated} created, ${result.totalUpdated} updated, ${result.totalDeleted} deleted`);
+        if (result.errors.length > 0) {
+            logger.warn(`⚠️  ${result.errors.length} error(s) occurred`);
+            result.errors.forEach(e => logger.error(`   ${e}`));
+        }
+    }
+}
 export async function handlePushCommand(customerConfig, args, verbose) {
     const { selectedCustomer, allCustomers, isMultiCustomer } = selectSingleCustomer(customerConfig, args.customer);
     const shouldPublish = !args['no-publish'];
+    // Check for selective sync flags
+    const onlyResources = parseResourceList(args.only);
+    const excludeResources = parseResourceList(args.exclude);
+    const pushAllResources = Boolean(args.all);
+    // Validate resource types
+    if (onlyResources.length > 0) {
+        const { invalid } = validateResources(onlyResources);
+        if (invalid.length > 0) {
+            console.error(`❌ Cannot push resource(s): ${invalid.join(', ')}`);
+            console.error(`   Available for push: ${PUSHABLE_RESOURCE_TYPES.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    if (excludeResources.length > 0) {
+        const { invalid } = validateResources(excludeResources);
+        if (invalid.length > 0 && !invalid.every(r => r.includes('read-only'))) {
+            console.error(`❌ Unknown resource type(s): ${invalid.join(', ')}`);
+            console.error(`   Available: ${PUSHABLE_RESOURCE_TYPES.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    // Determine which resources to push
+    let resourcesToPush = 'all';
+    if (onlyResources.length > 0) {
+        resourcesToPush = onlyResources;
+        console.log(`📦 Pushing selected resources: ${onlyResources.join(', ')}`);
+    }
+    else if (excludeResources.length > 0) {
+        resourcesToPush = PUSHABLE_RESOURCE_TYPES.filter(r => !excludeResources.includes(r));
+        console.log(`📦 Pushing resources (excluding: ${excludeResources.join(', ')})`);
+    }
+    else if (pushAllResources) {
+        resourcesToPush = 'all';
+        console.log(`📦 Pushing ALL resources`);
+    }
+    // Use V2 engine if selective sync requested, otherwise use legacy for backward compatibility
+    const useV2Engine = onlyResources.length > 0 || excludeResources.length > 0 || pushAllResources;
     if (selectedCustomer) {
-        // Single customer push
-        const accessToken = await getValidAccessToken(selectedCustomer);
-        const client = await makeClient(verbose, accessToken);
-        await pushChanged(client, selectedCustomer, verbose, shouldPublish);
+        if (useV2Engine) {
+            await pushWithV2Engine(customerConfig, selectedCustomer, resourcesToPush, verbose);
+        }
+        else {
+            // Legacy behavior
+            const accessToken = await getValidAccessToken(selectedCustomer);
+            const client = await makeClient(verbose, accessToken);
+            await pushChanged(client, selectedCustomer, verbose, shouldPublish);
+        }
     }
     else if (isMultiCustomer) {
         // Multiple customers exist with no default, ask user
         const customersToProcess = await interactiveCustomerSelection(allCustomers);
         if (customersToProcess.length === 1) {
-            // Single customer selected
             const customer = customersToProcess[0];
-            const accessToken = await getValidAccessToken(customer);
-            const client = await makeClient(verbose, accessToken);
-            await pushChanged(client, customer, verbose, shouldPublish);
+            if (useV2Engine) {
+                await pushWithV2Engine(customerConfig, customer, resourcesToPush, verbose);
+            }
+            else {
+                const accessToken = await getValidAccessToken(customer);
+                const client = await makeClient(verbose, accessToken);
+                await pushChanged(client, customer, verbose, shouldPublish);
+            }
         }
         else {
-            // Multi-customer push (user selected "All customers")
             console.log(`🔄 Pushing to ${customersToProcess.length} customers...`);
             for (const customer of customersToProcess) {
                 console.log(`\n📤 Pushing for customer: ${customer.idn}`);
-                const accessToken = await getValidAccessToken(customer);
-                const client = await makeClient(verbose, accessToken);
-                await pushChanged(client, customer, verbose, shouldPublish);
+                if (useV2Engine) {
+                    await pushWithV2Engine(customerConfig, customer, resourcesToPush, verbose);
+                }
+                else {
+                    const accessToken = await getValidAccessToken(customer);
+                    const client = await makeClient(verbose, accessToken);
+                    await pushChanged(client, customer, verbose, shouldPublish);
+                }
             }
             console.log(`\n✅ Push completed for all ${customersToProcess.length} customers`);
         }

package/dist/cli/commands/update-attribute.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleUpdateAttributeCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=update-attribute.d.ts.map

package/dist/cli/commands/update-attribute.js

@@ -0,0 +1,78 @@
+/**
+ * Update Customer Attribute Command Handler
+ */
+import { makeClient, getCustomerAttributes, updateCustomerAttribute } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { requireSingleCustomer } from '../customer-selection.js';
+export async function handleUpdateAttributeCommand(customerConfig, args, verbose = false) {
+    try {
+        const selectedCustomer = requireSingleCustomer(customerConfig, args.customer);
+        // Parse arguments
+        const idn = args._[1];
+        if (!idn) {
+            console.error('Error: Attribute IDN is required');
+            console.error('Usage: newo update-attribute <idn> [--value <value>] [--title <title>] [--description <desc>] [--group <group>] [--hidden] [--value-type <type>] [--possible-values <val1,val2>]');
+            process.exit(1);
+        }
+        // Get access token and create client
+        const accessToken = await getValidAccessToken(selectedCustomer);
+        const client = await makeClient(verbose, accessToken);
+        // Fetch existing attributes to find the one to update
+        const response = await getCustomerAttributes(client, true);
+        const existing = response.attributes.find((a) => a.idn === idn);
+        if (!existing) {
+            console.error(`❌ Attribute '${idn}' not found. Use 'newo create-attribute' to create it.`);
+            process.exit(1);
+        }
+        if (!existing.id) {
+            console.error(`❌ Attribute '${idn}' has no ID. Cannot update.`);
+            process.exit(1);
+        }
+        // Build updated attribute - only override fields that were explicitly provided
+        const updated = {
+            id: existing.id,
+            idn: existing.idn,
+            value: args.value !== undefined ? String(args.value) : existing.value,
+            title: args.title || existing.title,
+            description: args.description || existing.description,
+            group: args.group || existing.group,
+            is_hidden: args.hidden !== undefined ? Boolean(args.hidden) : existing.is_hidden,
+            possible_values: args['possible-values']
+                ? args['possible-values'].split(',').map(v => v.trim())
+                : existing.possible_values,
+            value_type: args['value-type'] || existing.value_type
+        };
+        if (verbose) {
+            console.log(`📝 Updating customer attribute: ${idn} (ID: ${existing.id})`);
+            if (args.value !== undefined)
+                console.log(`   Value: ${existing.value} -> ${updated.value}`);
+            if (args.title)
+                console.log(`   Title: ${existing.title} -> ${updated.title}`);
+            if (args.description)
+                console.log(`   Description: updated`);
+            if (args.group)
+                console.log(`   Group: ${existing.group} -> ${updated.group}`);
+            if (args['value-type'])
+                console.log(`   Type: ${existing.value_type} -> ${updated.value_type}`);
+            if (args.hidden !== undefined)
+                console.log(`   Hidden: ${existing.is_hidden} -> ${updated.is_hidden}`);
+        }
+        await updateCustomerAttribute(client, updated);
+        console.log(`✅ Customer attribute updated: ${idn}`);
+        if (args.value !== undefined)
+            console.log(`   Value: ${updated.value}`);
+        if (args['value-type'])
+            console.log(`   Type: ${updated.value_type}`);
+        if (args.title)
+            console.log(`   Title: ${updated.title}`);
+        if (args.description)
+            console.log(`   Description: updated`);
+        if (args.group)
+            console.log(`   Group: ${updated.group}`);
+    }
+    catch (error) {
+        console.error('❌ Failed to update customer attribute:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=update-attribute.js.map

package/dist/cli/commands/watch.d.ts

@@ -0,0 +1,6 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+/**
+ * Main watch command handler
+ */
+export declare function handleWatchCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose: boolean): Promise<void>;
+//# sourceMappingURL=watch.d.ts.map