newo 1.5.0 → 1.5.2

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

@@ -1,12 +1,20 @@
 import type { RunnerType } from './types.js';
-export declare const ROOT_DIR: string;
+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 ensureState(): Promise<void>;
-export declare function projectDir(projectIdn: string): string;
-export declare function skillPath(projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string, runnerType?: RunnerType): string;
-export declare function metadataPath(projectIdn: string): string;
-export declare function writeFileAtomic(filepath: string, content: string): Promise<void>;
+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

@@ -1,27 +1,50 @@
 import fs from 'fs-extra';
 import path from 'path';
-export const ROOT_DIR = path.join(process.cwd(), 'projects');
+export const NEWO_CUSTOMERS_DIR = path.posix.join(process.cwd(), 'newo_customers');
 export const STATE_DIR = path.join(process.cwd(), '.newo');
-export const MAP_PATH = path.join(STATE_DIR, 'map.json');
-export const HASHES_PATH = path.join(STATE_DIR, 'hashes.json');
-export async function ensureState() {
+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(ROOT_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 projectDir(projectIdn) {
-    return path.join(ROOT_DIR, projectIdn);
+export function flowsYamlPath(customerIdn) {
+    return path.posix.join(customerProjectsDir(customerIdn), 'flows.yaml');
 }
-export function skillPath(projectIdn, agentIdn, flowIdn, skillIdn, runnerType = 'guidance') {
+export function skillPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType = 'guidance') {
     const extension = runnerType === 'nsl' ? '.jinja' : '.guidance';
-    return path.join(ROOT_DIR, projectIdn, agentIdn, flowIdn, `${skillIdn}${extension}`);
+    return path.posix.join(customerProjectsDir(customerIdn), projectIdn, agentIdn, flowIdn, `${skillIdn}${extension}`);
 }
-export function metadataPath(projectIdn) {
-    return path.join(ROOT_DIR, projectIdn, 'metadata.json');
+export function metadataPath(customerIdn, projectIdn) {
+    return path.posix.join(customerProjectsDir(customerIdn), projectIdn, 'metadata.json');
 }
-export async function writeFileAtomic(filepath, content) {
+// 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;
 }

package/dist/hash.d.ts

@@ -1,5 +1,5 @@
 import type { HashStore } from './types.js';
 export declare function sha256(str: string): string;
-export declare function loadHashes(): Promise<HashStore>;
-export declare function saveHashes(hashes: HashStore): Promise<void>;
+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

@@ -1,17 +1,40 @@
 import crypto from 'crypto';
 import fs from 'fs-extra';
-import { ensureState, HASHES_PATH } from './fsutil.js';
+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() {
-    await ensureState();
-    if (await fs.pathExists(HASHES_PATH)) {
-        return fs.readJson(HASHES_PATH);
+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;
     }
-    return {};
 }
-export async function saveHashes(hashes) {
-    await fs.writeJson(HASHES_PATH, hashes, { spaces: 2 });
+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

@@ -1,7 +1,7 @@
 import type { AxiosInstance } from 'axios';
-import type { ProjectData } from './types.js';
-export declare function pullSingleProject(client: AxiosInstance, projectId: string, projectIdn: string, verbose?: boolean): Promise<ProjectData>;
-export declare function pullAll(client: AxiosInstance, projectId?: string | null, verbose?: boolean): Promise<void>;
-export declare function pushChanged(client: AxiosInstance, verbose?: boolean): Promise<void>;
-export declare function status(verbose?: boolean): Promise<void>;
+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

package/dist/sync.js

@@ -1,18 +1,27 @@
 import { listProjects, listAgents, listFlowSkills, updateSkill, listFlowEvents, listFlowStates, getProjectMeta } from './api.js';
-import { ensureState, skillPath, writeFileAtomic, readIfExists, MAP_PATH, projectDir, metadataPath } from './fsutil.js';
+import { ensureState, skillPath, writeFileSafe, readIfExists, mapPath, metadataPath, flowsYamlPath } from './fsutil.js';
 import fs from 'fs-extra';
 import { sha256, loadHashes, saveHashes } from './hash.js';
 import yaml from 'js-yaml';
-import path from 'path';
-export async function pullSingleProject(client, projectId, projectIdn, verbose = false) {
+import pLimit from 'p-limit';
+// Concurrency limits for API operations
+const concurrencyLimit = pLimit(5);
+// Type guards for better type safety
+function isProjectMap(x) {
+    return !!x && typeof x === 'object' && 'projects' in x;
+}
+function isLegacyProjectMap(x) {
+    return !!x && typeof x === 'object' && 'agents' in x;
+}
+export async function pullSingleProject(client, customer, projectId, projectIdn, verbose = false) {
     if (verbose)
-        console.log(`🔍 Fetching agents for project ${projectId} (${projectIdn})...`);
+        console.log(`🔍 Fetching agents for project ${projectId} (${projectIdn}) for customer ${customer.idn}...`);
     const agents = await listAgents(client, projectId);
     if (verbose)
         console.log(`📦 Found ${agents.length} agents`);
     // Get and save project metadata
     const projectMeta = await getProjectMeta(client, projectId);
-    await writeFileAtomic(metadataPath(projectIdn), JSON.stringify(projectMeta, null, 2));
+    await writeFileSafe(metadataPath(customer.idn, projectIdn), JSON.stringify(projectMeta, null, 2));
     if (verbose)
         console.log(`✓ Saved metadata for ${projectIdn}`);
     const projectMap = { projectId, projectIdn, agents: {} };
@@ -22,9 +31,10 @@ export async function pullSingleProject(client, projectId, projectIdn, verbose =
         for (const flow of agent.flows ?? []) {
             projectMap.agents[aKey].flows[flow.idn] = { id: flow.id, skills: {} };
             const skills = await listFlowSkills(client, flow.id);
-            for (const skill of skills) {
-                const file = skillPath(projectIdn, agent.idn, flow.idn, skill.idn, skill.runner_type);
-                await writeFileAtomic(file, skill.prompt_script || '');
+            // Process skills concurrently with limited concurrency
+            await Promise.all(skills.map(skill => concurrencyLimit(async () => {
+                const file = skillPath(customer.idn, projectIdn, agent.idn, flow.idn, skill.idn, skill.runner_type);
+                await writeFileSafe(file, skill.prompt_script || '');
                 // Store complete skill metadata for push operations
                 projectMap.agents[aKey].flows[flow.idn].skills[skill.idn] = {
                     id: skill.id,
@@ -32,44 +42,44 @@ export async function pullSingleProject(client, projectId, projectIdn, verbose =
                     idn: skill.idn,
                     runner_type: skill.runner_type,
                     model: skill.model,
-                    parameters: skill.parameters,
+                    parameters: [...skill.parameters],
                     path: skill.path || undefined
                 };
                 console.log(`✓ Pulled ${file}`);
-            }
+            })));
         }
     }
     // Generate flows.yaml for this project
     if (verbose)
-        console.log(`📄 Generating flows.yaml for ${projectIdn}...`);
-    await generateFlowsYaml(client, agents, projectIdn, verbose);
+        console.log(`📄 Generating flows.yaml...`);
+    await generateFlowsYaml(client, customer, agents, verbose);
     return projectMap;
 }
-export async function pullAll(client, projectId = null, verbose = false) {
-    await ensureState();
+export async function pullAll(client, customer, projectId = null, verbose = false) {
+    await ensureState(customer.idn);
     if (projectId) {
         // Single project mode
         const projectMeta = await getProjectMeta(client, projectId);
-        const projectMap = await pullSingleProject(client, projectId, projectMeta.idn, verbose);
+        const projectMap = await pullSingleProject(client, customer, projectId, projectMeta.idn, verbose);
         const idMap = { projects: { [projectMeta.idn]: projectMap } };
-        await fs.writeJson(MAP_PATH, idMap, { spaces: 2 });
+        await fs.writeJson(mapPath(customer.idn), idMap, { spaces: 2 });
         // Generate hash tracking for this project
         const hashes = {};
         for (const [agentIdn, agentObj] of Object.entries(projectMap.agents)) {
             for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
                 for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
-                    const p = skillPath(projectMeta.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+                    const p = skillPath(customer.idn, projectMeta.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                     const content = await fs.readFile(p, 'utf8');
                     hashes[p] = sha256(content);
                 }
             }
         }
-        await saveHashes(hashes);
+        await saveHashes(hashes, customer.idn);
         return;
     }
     // Multi-project mode
     if (verbose)
-        console.log('🔍 Fetching all projects...');
+        console.log(`🔍 Fetching all projects for customer ${customer.idn}...`);
     const projects = await listProjects(client);
     if (verbose)
         console.log(`📦 Found ${projects.length} projects`);
@@ -78,40 +88,44 @@ export async function pullAll(client, projectId = null, verbose = false) {
     for (const project of projects) {
         if (verbose)
             console.log(`\n📁 Processing project: ${project.idn} (${project.title})`);
-        const projectMap = await pullSingleProject(client, project.id, project.idn, verbose);
+        const projectMap = await pullSingleProject(client, customer, project.id, project.idn, verbose);
         idMap.projects[project.idn] = projectMap;
         // Collect hashes for this project
         for (const [agentIdn, agentObj] of Object.entries(projectMap.agents)) {
             for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
                 for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
-                    const p = skillPath(project.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+                    const p = skillPath(customer.idn, project.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                     const content = await fs.readFile(p, 'utf8');
                     allHashes[p] = sha256(content);
                 }
             }
         }
     }
-    await fs.writeJson(MAP_PATH, idMap, { spaces: 2 });
-    await saveHashes(allHashes);
+    await fs.writeJson(mapPath(customer.idn), idMap, { spaces: 2 });
+    await saveHashes(allHashes, customer.idn);
 }
-export async function pushChanged(client, verbose = false) {
-    await ensureState();
-    if (!(await fs.pathExists(MAP_PATH))) {
-        throw new Error('Missing .newo/map.json. Run `newo pull` first.');
+export async function pushChanged(client, customer, verbose = false) {
+    await ensureState(customer.idn);
+    if (!(await fs.pathExists(mapPath(customer.idn)))) {
+        throw new Error(`Missing .newo/${customer.idn}/map.json. Run \`newo pull --customer ${customer.idn}\` first.`);
     }
     if (verbose)
-        console.log('📋 Loading project mapping...');
-    const idMap = await fs.readJson(MAP_PATH);
+        console.log(`📋 Loading project mapping for customer ${customer.idn}...`);
+    const idMapData = await fs.readJson(mapPath(customer.idn));
     if (verbose)
         console.log('🔍 Loading file hashes...');
-    const oldHashes = await loadHashes();
+    const oldHashes = await loadHashes(customer.idn);
     const newHashes = { ...oldHashes };
     if (verbose)
         console.log('🔄 Scanning for changes...');
     let pushed = 0;
     let scanned = 0;
-    // Handle both old single-project format and new multi-project format
-    const projects = 'projects' in idMap && idMap.projects ? idMap.projects : { '': idMap };
+    // Handle both old single-project format and new multi-project format with type guards
+    const projects = isProjectMap(idMapData) && idMapData.projects
+        ? idMapData.projects
+        : isLegacyProjectMap(idMapData)
+            ? { '': idMapData }
+            : (() => { throw new Error('Invalid project map format'); })();
     for (const [projectIdn, projectData] of Object.entries(projects)) {
         if (verbose && projectIdn)
             console.log(`📁 Scanning project: ${projectIdn}`);
@@ -123,8 +137,8 @@ export async function pushChanged(client, verbose = false) {
                     console.log(`    📁 Scanning flow: ${flowIdn}`);
                 for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
                     const p = projectIdn ?
-                        skillPath(projectIdn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type) :
-                        skillPath('', agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+                        skillPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type) :
+                        skillPath(customer.idn, '', agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                     scanned++;
                     if (verbose)
                         console.log(`      📄 Checking: ${p}`);
@@ -177,22 +191,26 @@ export async function pushChanged(client, verbose = false) {
     }
     if (verbose)
         console.log(`🔄 Scanned ${scanned} files, found ${pushed} changes`);
-    await saveHashes(newHashes);
+    await saveHashes(newHashes, customer.idn);
     console.log(pushed ? `✅ Push complete. ${pushed} file(s) updated.` : '✅ Nothing to push.');
 }
-export async function status(verbose = false) {
-    await ensureState();
-    if (!(await fs.pathExists(MAP_PATH))) {
-        console.log('No map. Run `newo pull` first.');
+export async function status(customer, verbose = false) {
+    await ensureState(customer.idn);
+    if (!(await fs.pathExists(mapPath(customer.idn)))) {
+        console.log(`No map for customer ${customer.idn}. Run \`newo pull --customer ${customer.idn}\` first.`);
         return;
     }
     if (verbose)
-        console.log('📋 Loading project mapping and hashes...');
-    const idMap = await fs.readJson(MAP_PATH);
-    const hashes = await loadHashes();
+        console.log(`📋 Loading project mapping and hashes for customer ${customer.idn}...`);
+    const idMapData = await fs.readJson(mapPath(customer.idn));
+    const hashes = await loadHashes(customer.idn);
     let dirty = 0;
-    // Handle both old single-project format and new multi-project format
-    const projects = 'projects' in idMap && idMap.projects ? idMap.projects : { '': idMap };
+    // Handle both old single-project format and new multi-project format with type guards
+    const projects = isProjectMap(idMapData) && idMapData.projects
+        ? idMapData.projects
+        : isLegacyProjectMap(idMapData)
+            ? { '': idMapData }
+            : (() => { throw new Error('Invalid project map format'); })();
     for (const [projectIdn, projectData] of Object.entries(projects)) {
         if (verbose && projectIdn)
             console.log(`📁 Checking project: ${projectIdn}`);
@@ -204,8 +222,8 @@ export async function status(verbose = false) {
                     console.log(`    📁 Checking flow: ${flowIdn}`);
                 for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
                     const p = projectIdn ?
-                        skillPath(projectIdn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type) :
-                        skillPath('', agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+                        skillPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type) :
+                        skillPath(customer.idn, '', agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                     const exists = await fs.pathExists(p);
                     if (!exists) {
                         console.log(`D  ${p}`);
@@ -237,21 +255,38 @@ export async function status(verbose = false) {
     }
     console.log(dirty ? `${dirty} changed file(s).` : 'Clean.');
 }
-async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
+async function generateFlowsYaml(client, customer, agents, verbose = false) {
     const flowsData = { flows: [] };
+    // Calculate total flows for progress tracking
+    const totalFlows = agents.reduce((sum, agent) => sum + (agent.flows?.length || 0), 0);
+    let processedFlows = 0;
+    if (!verbose && totalFlows > 0) {
+        console.log(`📄 Generating flows.yaml (${totalFlows} flows)...`);
+    }
     for (const agent of agents) {
         if (verbose)
             console.log(`  📁 Processing agent: ${agent.idn}`);
         const agentFlows = [];
         for (const flow of agent.flows ?? []) {
-            if (verbose)
+            processedFlows++;
+            if (verbose) {
                 console.log(`    📄 Processing flow: ${flow.idn}`);
+            }
+            else {
+                // Simple progress indicator without verbose mode
+                const percent = Math.round((processedFlows / totalFlows) * 100);
+                const progressBar = '█'.repeat(Math.floor(percent / 5)) + '░'.repeat(20 - Math.floor(percent / 5));
+                const progressText = `  [${progressBar}] ${percent}% (${processedFlows}/${totalFlows}) ${flow.idn}`;
+                // Pad the line to clear any leftover text from longer previous lines
+                const padding = ' '.repeat(Math.max(0, 80 - progressText.length));
+                process.stdout.write(`\r${progressText}${padding}`);
+            }
             // Get skills for this flow
             const skills = await listFlowSkills(client, flow.id);
             const skillsData = skills.map(skill => ({
                 idn: skill.idn,
                 title: skill.title || "",
-                prompt_script: `flows/${flow.idn}/${skill.idn}.${skill.runner_type === 'nsl' ? 'jinja' : 'nsl'}`,
+                prompt_script: `flows/${flow.idn}/${skill.idn}.${skill.runner_type === 'nsl' ? 'jinja' : 'guidance'}`,
                 runner_type: `!enum "RunnerType.${skill.runner_type}"`,
                 model: {
                     model_idn: skill.model.model_idn,
@@ -319,6 +354,10 @@ async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
         };
         flowsData.flows.push(agentData);
     }
+    // Clear progress bar and move to new line
+    if (!verbose && totalFlows > 0) {
+        process.stdout.write('\n');
+    }
     // Convert to YAML and write to file with custom enum handling
     let yamlContent = yaml.dump(flowsData, {
         indent: 2,
@@ -330,8 +369,8 @@ async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
     });
     // Post-process to fix enum formatting
     yamlContent = yamlContent.replace(/"(!enum "[^"]+")"/g, '$1');
-    const yamlPath = path.join(projectDir(projectIdn), 'flows.yaml');
-    await writeFileAtomic(yamlPath, yamlContent);
-    console.log(`✓ Generated flows.yaml for ${projectIdn}`);
+    const yamlPath = flowsYamlPath(customer.idn);
+    await writeFileSafe(yamlPath, yamlContent);
+    console.log(`✓ Generated flows.yaml`);
 }
 //# sourceMappingURL=sync.js.map