newo 1.4.0 → 1.5.1

package/dist/customer.d.ts

@@ -0,0 +1,23 @@
+import type { NewoEnvironment, CustomerConfig, MultiCustomerConfig } from './types.js';
+/**
+ * Parse environment variables to extract customer configurations
+ * Supports both array-based (NEWO_API_KEYS) and individual customer configs
+ */
+export declare function parseCustomerConfig(env: NewoEnvironment): MultiCustomerConfig;
+/**
+ * List all available customer IDNs
+ */
+export declare function listCustomers(config: MultiCustomerConfig): string[];
+/**
+ * Get customer configuration by IDN
+ */
+export declare function getCustomer(config: MultiCustomerConfig, customerIdn: string): CustomerConfig | null;
+/**
+ * Get default customer or throw error if none
+ */
+export declare function getDefaultCustomer(config: MultiCustomerConfig): CustomerConfig;
+/**
+ * Validate customer configuration
+ */
+export declare function validateCustomerConfig(config: MultiCustomerConfig): void;
+//# sourceMappingURL=customer.d.ts.map

package/dist/customer.js

@@ -0,0 +1,87 @@
+/**
+ * Parse environment variables to extract customer configurations
+ * Supports both array-based (NEWO_API_KEYS) and individual customer configs
+ */
+export function parseCustomerConfig(env) {
+    const customers = {};
+    // Parse customer-specific API keys
+    // Format: NEWO_CUSTOMER_[IDN]_API_KEY=api_key
+    for (const [key, value] of Object.entries(env)) {
+        if (key.startsWith('NEWO_CUSTOMER_') && key.endsWith('_API_KEY') && value) {
+            const idn = key.slice('NEWO_CUSTOMER_'.length, -'_API_KEY'.length).toLowerCase();
+            if (!customers[idn]) {
+                customers[idn] = { idn, apiKey: value };
+            }
+            else {
+                customers[idn].apiKey = value;
+            }
+            // Check for corresponding project ID
+            const projectIdKey = `NEWO_CUSTOMER_${idn.toUpperCase()}_PROJECT_ID`;
+            if (env[projectIdKey]) {
+                customers[idn].projectId = env[projectIdKey];
+            }
+        }
+    }
+    // Check for legacy single customer mode
+    if (env.NEWO_API_KEY && Object.keys(customers).length === 0) {
+        customers['default'] = {
+            idn: 'default',
+            apiKey: env.NEWO_API_KEY,
+            projectId: env.NEWO_PROJECT_ID
+        };
+    }
+    return {
+        customers,
+        defaultCustomer: env.NEWO_DEFAULT_CUSTOMER || (Object.keys(customers).length === 1 ? Object.keys(customers)[0] : undefined)
+    };
+}
+/**
+ * List all available customer IDNs
+ */
+export function listCustomers(config) {
+    return Object.keys(config.customers).sort();
+}
+/**
+ * Get customer configuration by IDN
+ */
+export function getCustomer(config, customerIdn) {
+    return config.customers[customerIdn] || null;
+}
+/**
+ * Get default customer or throw error if none
+ */
+export function getDefaultCustomer(config) {
+    if (config.defaultCustomer) {
+        const customer = getCustomer(config, config.defaultCustomer);
+        if (customer)
+            return customer;
+    }
+    const customerIdns = listCustomers(config);
+    if (customerIdns.length === 1) {
+        const firstCustomerIdn = customerIdns[0];
+        if (firstCustomerIdn) {
+            return config.customers[firstCustomerIdn];
+        }
+    }
+    if (customerIdns.length === 0) {
+        throw new Error('No customers configured. Please set NEWO_CUSTOMER_[IDN]_API_KEY in your .env file.');
+    }
+    throw new Error(`Multiple customers configured but no default specified. Available: ${customerIdns.join(', ')}. ` +
+        `Set NEWO_DEFAULT_CUSTOMER or use --customer flag.`);
+}
+/**
+ * Validate customer configuration
+ */
+export function validateCustomerConfig(config) {
+    const customers = listCustomers(config);
+    if (customers.length === 0) {
+        throw new Error('No customers configured. Please set NEWO_CUSTOMER_[IDN]_API_KEY in your .env file.');
+    }
+    for (const customerIdn of customers) {
+        const customer = config.customers[customerIdn];
+        if (!customer.apiKey) {
+            throw new Error(`Customer ${customerIdn} missing API key`);
+        }
+    }
+}
+//# sourceMappingURL=customer.js.map

package/dist/customerAsync.d.ts

@@ -0,0 +1,22 @@
+import type { NewoEnvironment, CustomerConfig, MultiCustomerConfig } from './types.js';
+/**
+ * Async version of customer configuration parsing that supports API key array initialization
+ */
+export declare function parseCustomerConfigAsync(env: NewoEnvironment, verbose?: boolean): Promise<MultiCustomerConfig>;
+/**
+ * List all available customer IDNs
+ */
+export declare function listCustomers(config: MultiCustomerConfig): string[];
+/**
+ * Get customer configuration by IDN
+ */
+export declare function getCustomer(config: MultiCustomerConfig, customerIdn: string): CustomerConfig | null;
+/**
+ * Get default customer or throw error if none
+ */
+export declare function getDefaultCustomer(config: MultiCustomerConfig): CustomerConfig;
+/**
+ * Validate customer configuration
+ */
+export declare function validateCustomerConfig(config: MultiCustomerConfig): void;
+//# sourceMappingURL=customerAsync.d.ts.map

package/dist/customerAsync.js

@@ -0,0 +1,67 @@
+import { initializeCustomersFromApiKeys, usesArrayBasedConfig } from './customerInit.js';
+import { parseCustomerConfig } from './customer.js';
+/**
+ * Async version of customer configuration parsing that supports API key array initialization
+ */
+export async function parseCustomerConfigAsync(env, verbose = false) {
+    // If using array-based config, initialize from API keys
+    if (usesArrayBasedConfig(env)) {
+        if (verbose)
+            console.log('📝 Using array-based API key configuration');
+        return await initializeCustomersFromApiKeys(env, verbose);
+    }
+    // Fall back to synchronous individual customer parsing
+    if (verbose)
+        console.log('📝 Using individual customer configuration');
+    return parseCustomerConfig(env);
+}
+/**
+ * List all available customer IDNs
+ */
+export function listCustomers(config) {
+    return Object.keys(config.customers).sort();
+}
+/**
+ * Get customer configuration by IDN
+ */
+export function getCustomer(config, customerIdn) {
+    return config.customers[customerIdn] || null;
+}
+/**
+ * Get default customer or throw error if none
+ */
+export function getDefaultCustomer(config) {
+    if (config.defaultCustomer) {
+        const customer = getCustomer(config, config.defaultCustomer);
+        if (customer)
+            return customer;
+    }
+    const customerIdns = listCustomers(config);
+    if (customerIdns.length === 1) {
+        const firstCustomerIdn = customerIdns[0];
+        if (firstCustomerIdn) {
+            return config.customers[firstCustomerIdn];
+        }
+    }
+    if (customerIdns.length === 0) {
+        throw new Error('No customers configured. Please set NEWO_API_KEYS or NEWO_CUSTOMER_[IDN]_API_KEY in your .env file.');
+    }
+    throw new Error(`Multiple customers configured but no default specified. Available: ${customerIdns.join(', ')}. ` +
+        `Set NEWO_DEFAULT_CUSTOMER or use --customer flag.`);
+}
+/**
+ * Validate customer configuration
+ */
+export function validateCustomerConfig(config) {
+    const customers = listCustomers(config);
+    if (customers.length === 0) {
+        throw new Error('No customers configured. Please set NEWO_API_KEYS or NEWO_CUSTOMER_[IDN]_API_KEY in your .env file.');
+    }
+    for (const customerIdn of customers) {
+        const customer = config.customers[customerIdn];
+        if (!customer.apiKey) {
+            throw new Error(`Customer ${customerIdn} missing API key`);
+        }
+    }
+}
+//# sourceMappingURL=customerAsync.js.map

package/dist/customerInit.d.ts

@@ -0,0 +1,10 @@
+import type { NewoEnvironment, MultiCustomerConfig } from './types.js';
+/**
+ * Initialize customer configurations from API keys array
+ */
+export declare function initializeCustomersFromApiKeys(env: NewoEnvironment, verbose?: boolean): Promise<MultiCustomerConfig>;
+/**
+ * Check if environment uses array-based configuration
+ */
+export declare function usesArrayBasedConfig(env: NewoEnvironment): boolean;
+//# sourceMappingURL=customerInit.d.ts.map

package/dist/customerInit.js

@@ -0,0 +1,78 @@
+import { getCustomerProfile, makeClient } from './api.js';
+import { exchangeApiKeyForToken } from './auth.js';
+/**
+ * Initialize customer configurations from API keys array
+ */
+export async function initializeCustomersFromApiKeys(env, verbose = false) {
+    if (!env.NEWO_API_KEYS) {
+        throw new Error('NEWO_API_KEYS not set. Provide API keys array in .env file.');
+    }
+    let apiKeyConfigs;
+    try {
+        apiKeyConfigs = JSON.parse(env.NEWO_API_KEYS);
+    }
+    catch (error) {
+        throw new Error(`Invalid NEWO_API_KEYS format. Must be valid JSON array: ${error}`);
+    }
+    if (!Array.isArray(apiKeyConfigs)) {
+        throw new Error('NEWO_API_KEYS must be an array');
+    }
+    const customers = {};
+    if (verbose)
+        console.log(`🔍 Initializing ${apiKeyConfigs.length} API keys...`);
+    for (const [index, keyConfig] of apiKeyConfigs.entries()) {
+        try {
+            // Normalize config
+            const apiKey = typeof keyConfig === 'string' ? keyConfig : keyConfig.key;
+            const projectId = typeof keyConfig === 'object' ? keyConfig.project_id : undefined;
+            if (verbose)
+                console.log(`  [${index + 1}/${apiKeyConfigs.length}] Exchanging API key for token...`);
+            // Create temporary customer config for token exchange
+            const tempCustomer = {
+                idn: 'temp',
+                apiKey,
+                projectId
+            };
+            // Exchange API key for token
+            const tokens = await exchangeApiKeyForToken(tempCustomer);
+            if (verbose)
+                console.log(`  [${index + 1}/${apiKeyConfigs.length}] Getting customer profile...`);
+            // Create client with token
+            const client = await makeClient(verbose, tokens.access_token);
+            // Get customer profile to extract IDN
+            const profile = await getCustomerProfile(client);
+            if (verbose) {
+                console.log(`  [${index + 1}/${apiKeyConfigs.length}] ✓ Customer: ${profile.idn} (${profile.organization_name})`);
+            }
+            // Store customer config with real IDN
+            customers[profile.idn] = {
+                idn: profile.idn,
+                apiKey,
+                projectId
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`  [${index + 1}/${apiKeyConfigs.length}] ❌ Failed to initialize API key: ${message}`);
+            // Continue with other keys rather than failing entirely
+        }
+    }
+    const customerIdns = Object.keys(customers);
+    if (customerIdns.length === 0) {
+        throw new Error('No valid API keys found. Check your NEWO_API_KEYS configuration.');
+    }
+    if (verbose) {
+        console.log(`✅ Initialized ${customerIdns.length} customers: ${customerIdns.join(', ')}`);
+    }
+    return {
+        customers,
+        defaultCustomer: env.NEWO_DEFAULT_CUSTOMER || (customerIdns.length === 1 ? customerIdns[0] : undefined)
+    };
+}
+/**
+ * Check if environment uses array-based configuration
+ */
+export function usesArrayBasedConfig(env) {
+    return Boolean(env.NEWO_API_KEYS);
+}
+//# sourceMappingURL=customerInit.js.map

package/dist/env.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Validated environment configuration
+ */
+export interface ValidatedEnv {
+    readonly NEWO_BASE_URL: string;
+    readonly NEWO_PROJECT_ID: string | undefined;
+    readonly NEWO_API_KEY: string | undefined;
+    readonly NEWO_API_KEYS: string | undefined;
+    readonly NEWO_ACCESS_TOKEN: string | undefined;
+    readonly NEWO_REFRESH_TOKEN: string | undefined;
+    readonly NEWO_REFRESH_URL: string | undefined;
+    readonly NEWO_DEFAULT_CUSTOMER: string | undefined;
+    readonly [key: string]: string | undefined;
+}
+/**
+ * Environment validation errors with clear messaging
+ */
+export declare class EnvValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validates required environment variables and returns typed configuration
+ */
+export declare function validateEnvironment(): ValidatedEnv;
+/**
+ * Global validated environment - call validateEnvironment() once at startup
+ */
+export declare let ENV: ValidatedEnv;
+/**
+ * Initialize environment validation - must be called at application startup
+ */
+export declare function initializeEnvironment(): ValidatedEnv;
+//# sourceMappingURL=env.d.ts.map

package/dist/env.js

@@ -0,0 +1,82 @@
+/**
+ * Environment validation errors with clear messaging
+ */
+export class EnvValidationError extends Error {
+    constructor(message) {
+        super(`Environment validation failed: ${message}`);
+        this.name = 'EnvValidationError';
+    }
+}
+/**
+ * Validates required environment variables and returns typed configuration
+ */
+export function validateEnvironment() {
+    const env = process.env;
+    const baseUrl = env.NEWO_BASE_URL?.trim() || 'https://app.newo.ai';
+    const projectId = env.NEWO_PROJECT_ID?.trim();
+    const apiKey = env.NEWO_API_KEY?.trim();
+    const accessToken = env.NEWO_ACCESS_TOKEN?.trim();
+    const refreshToken = env.NEWO_REFRESH_TOKEN?.trim();
+    const refreshUrl = env.NEWO_REFRESH_URL?.trim();
+    // Base URL validation
+    if (!isValidUrl(baseUrl)) {
+        throw new EnvValidationError(`NEWO_BASE_URL must be a valid URL. Received: ${baseUrl}`);
+    }
+    // Project ID is optional - if not set, pull all projects
+    // If provided, validate UUID format
+    if (projectId && !isValidUuid(projectId)) {
+        throw new EnvValidationError(`NEWO_PROJECT_ID must be a valid UUID when provided. Received: ${projectId}`);
+    }
+    // Authentication validation - at least one method required
+    const hasApiKey = !!apiKey;
+    const hasApiKeys = !!env.NEWO_API_KEYS?.trim();
+    const hasDirectTokens = !!(accessToken && refreshToken);
+    if (!hasApiKey && !hasApiKeys && !hasDirectTokens) {
+        throw new EnvValidationError('Authentication required: Set NEWO_API_KEY, NEWO_API_KEYS (recommended), or both NEWO_ACCESS_TOKEN and NEWO_REFRESH_TOKEN');
+    }
+    // If refresh URL is provided, validate it
+    if (refreshUrl && !isValidUrl(refreshUrl)) {
+        throw new EnvValidationError(`NEWO_REFRESH_URL must be a valid URL when provided. Received: ${refreshUrl}`);
+    }
+    return {
+        NEWO_BASE_URL: baseUrl,
+        NEWO_PROJECT_ID: projectId || undefined,
+        NEWO_API_KEY: apiKey,
+        NEWO_API_KEYS: env.NEWO_API_KEYS?.trim(),
+        NEWO_ACCESS_TOKEN: accessToken,
+        NEWO_REFRESH_TOKEN: refreshToken,
+        NEWO_REFRESH_URL: refreshUrl,
+        NEWO_DEFAULT_CUSTOMER: env.NEWO_DEFAULT_CUSTOMER?.trim(),
+    };
+}
+/**
+ * Validates if a string is a valid URL
+ */
+function isValidUrl(urlString) {
+    try {
+        new URL(urlString);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validates if a string is a valid UUID (v4 format)
+ */
+function isValidUuid(uuid) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(uuid);
+}
+/**
+ * Global validated environment - call validateEnvironment() once at startup
+ */
+export let ENV;
+/**
+ * Initialize environment validation - must be called at application startup
+ */
+export function initializeEnvironment() {
+    ENV = validateEnvironment();
+    return ENV;
+}
+//# sourceMappingURL=env.js.map

package/dist/fsutil.d.ts

@@ -0,0 +1,20 @@
+import type { RunnerType } from './types.js';
+export declare const NEWO_CUSTOMERS_DIR: string;
+export declare const STATE_DIR: string;
+export declare function customerDir(customerIdn: string): string;
+export declare function customerProjectsDir(customerIdn: string): string;
+export declare function customerStateDir(customerIdn: string): string;
+export declare function mapPath(customerIdn: string): string;
+export declare function hashesPath(customerIdn: string): string;
+export declare function ensureState(customerIdn: string): Promise<void>;
+export declare function projectDir(customerIdn: string, projectIdn: string): string;
+export declare function flowsYamlPath(customerIdn: string): string;
+export declare function skillPath(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string, runnerType?: RunnerType): string;
+export declare function metadataPath(customerIdn: string, projectIdn: string): string;
+export declare const ROOT_DIR: string;
+export declare const MAP_PATH: string;
+export declare const HASHES_PATH: string;
+export declare function writeFileSafe(filepath: string, content: string): Promise<void>;
+export declare const writeFileAtomic: typeof writeFileSafe;
+export declare function readIfExists(filepath: string): Promise<string | null>;
+//# sourceMappingURL=fsutil.d.ts.map

package/dist/fsutil.js

@@ -0,0 +1,51 @@
+import fs from 'fs-extra';
+import path from 'path';
+export const NEWO_CUSTOMERS_DIR = path.posix.join(process.cwd(), 'newo_customers');
+export const STATE_DIR = path.join(process.cwd(), '.newo');
+export function customerDir(customerIdn) {
+    return path.posix.join(NEWO_CUSTOMERS_DIR, customerIdn);
+}
+export function customerProjectsDir(customerIdn) {
+    return path.posix.join(customerDir(customerIdn), 'projects');
+}
+export function customerStateDir(customerIdn) {
+    return path.join(STATE_DIR, customerIdn);
+}
+export function mapPath(customerIdn) {
+    return path.join(customerStateDir(customerIdn), 'map.json');
+}
+export function hashesPath(customerIdn) {
+    return path.join(customerStateDir(customerIdn), 'hashes.json');
+}
+export async function ensureState(customerIdn) {
+    await fs.ensureDir(STATE_DIR);
+    await fs.ensureDir(customerStateDir(customerIdn));
+    await fs.ensureDir(customerProjectsDir(customerIdn));
+}
+export function projectDir(customerIdn, projectIdn) {
+    return path.posix.join(customerProjectsDir(customerIdn), projectIdn);
+}
+export function flowsYamlPath(customerIdn) {
+    return path.posix.join(customerProjectsDir(customerIdn), 'flows.yaml');
+}
+export function skillPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType = 'guidance') {
+    const extension = runnerType === 'nsl' ? '.jinja' : '.guidance';
+    return path.posix.join(customerProjectsDir(customerIdn), projectIdn, agentIdn, flowIdn, `${skillIdn}${extension}`);
+}
+export function metadataPath(customerIdn, projectIdn) {
+    return path.posix.join(customerProjectsDir(customerIdn), projectIdn, 'metadata.json');
+}
+// Legacy support - will be deprecated
+export const ROOT_DIR = path.posix.join(process.cwd(), 'projects');
+export const MAP_PATH = path.join(STATE_DIR, 'map.json');
+export const HASHES_PATH = path.join(STATE_DIR, 'hashes.json');
+export async function writeFileSafe(filepath, content) {
+    await fs.ensureDir(path.dirname(filepath));
+    await fs.writeFile(filepath, content, 'utf8');
+}
+// Deprecated: use writeFileSafe instead
+export const writeFileAtomic = writeFileSafe;
+export async function readIfExists(filepath) {
+    return (await fs.pathExists(filepath)) ? fs.readFile(filepath, 'utf8') : null;
+}
+//# sourceMappingURL=fsutil.js.map

package/dist/hash.d.ts

@@ -0,0 +1,5 @@
+import type { HashStore } from './types.js';
+export declare function sha256(str: string): string;
+export declare function loadHashes(customerIdn?: string): Promise<HashStore>;
+export declare function saveHashes(hashes: HashStore, customerIdn?: string): Promise<void>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.js

@@ -0,0 +1,40 @@
+import crypto from 'crypto';
+import fs from 'fs-extra';
+import { ensureState, hashesPath, HASHES_PATH } from './fsutil.js';
+export function sha256(str) {
+    return crypto.createHash('sha256').update(str, 'utf8').digest('hex');
+}
+export async function loadHashes(customerIdn) {
+    if (customerIdn) {
+        await ensureState(customerIdn);
+        try {
+            return await fs.readJson(hashesPath(customerIdn));
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return {};
+            }
+            throw error;
+        }
+    }
+    // Legacy support
+    try {
+        return await fs.readJson(HASHES_PATH);
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+}
+export async function saveHashes(hashes, customerIdn) {
+    if (customerIdn) {
+        await fs.writeJson(hashesPath(customerIdn), hashes, { spaces: 2 });
+    }
+    else {
+        // Legacy support
+        await fs.writeJson(HASHES_PATH, hashes, { spaces: 2 });
+    }
+}
+//# sourceMappingURL=hash.js.map

package/dist/sync.d.ts

@@ -0,0 +1,7 @@
+import type { AxiosInstance } from 'axios';
+import type { ProjectData, CustomerConfig } from './types.js';
+export declare function pullSingleProject(client: AxiosInstance, customer: CustomerConfig, projectId: string, projectIdn: string, verbose?: boolean): Promise<ProjectData>;
+export declare function pullAll(client: AxiosInstance, customer: CustomerConfig, projectId?: string | null, verbose?: boolean): Promise<void>;
+export declare function pushChanged(client: AxiosInstance, customer: CustomerConfig, verbose?: boolean): Promise<void>;
+export declare function status(customer: CustomerConfig, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=sync.d.ts.map