newo 1.4.0 → 1.5.1

package/src/env.ts

@@ -0,0 +1,118 @@
+import type { NewoEnvironment } from './types.js';
+
+/**
+ * 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;
+  // Dynamic customer entries will be detected at runtime
+  readonly [key: string]: string | undefined;
+}
+
+/**
+ * Environment validation errors with clear messaging
+ */
+export class EnvValidationError extends Error {
+  constructor(message: string) {
+    super(`Environment validation failed: ${message}`);
+    this.name = 'EnvValidationError';
+  }
+}
+
+/**
+ * Validates required environment variables and returns typed configuration
+ */
+export function validateEnvironment(): ValidatedEnv {
+  const env = process.env as NewoEnvironment;
+  
+  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: string): boolean {
+  try {
+    new URL(urlString);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validates if a string is a valid UUID (v4 format)
+ */
+function isValidUuid(uuid: string): boolean {
+  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: ValidatedEnv;
+
+/**
+ * Initialize environment validation - must be called at application startup
+ */
+export function initializeEnvironment(): ValidatedEnv {
+  ENV = validateEnvironment();
+  return ENV;
+}

package/src/fsutil.ts

@@ -0,0 +1,73 @@
+import fs from 'fs-extra';
+import path from 'path';
+import type { RunnerType } from './types.js';
+
+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: string): string {
+  return path.posix.join(NEWO_CUSTOMERS_DIR, customerIdn);
+}
+
+export function customerProjectsDir(customerIdn: string): string {
+  return path.posix.join(customerDir(customerIdn), 'projects');
+}
+
+export function customerStateDir(customerIdn: string): string {
+  return path.join(STATE_DIR, customerIdn);
+}
+
+export function mapPath(customerIdn: string): string {
+  return path.join(customerStateDir(customerIdn), 'map.json');
+}
+
+export function hashesPath(customerIdn: string): string {
+  return path.join(customerStateDir(customerIdn), 'hashes.json');
+}
+
+export async function ensureState(customerIdn: string): Promise<void> {
+  await fs.ensureDir(STATE_DIR);
+  await fs.ensureDir(customerStateDir(customerIdn));
+  await fs.ensureDir(customerProjectsDir(customerIdn));
+}
+
+export function projectDir(customerIdn: string, projectIdn: string): string {
+  return path.posix.join(customerProjectsDir(customerIdn), projectIdn);
+}
+
+export function flowsYamlPath(customerIdn: string): string {
+  return path.posix.join(customerProjectsDir(customerIdn), 'flows.yaml');
+}
+
+export function skillPath(
+  customerIdn: string,
+  projectIdn: string, 
+  agentIdn: string, 
+  flowIdn: string, 
+  skillIdn: string, 
+  runnerType: RunnerType = 'guidance'
+): string {
+  const extension = runnerType === 'nsl' ? '.jinja' : '.guidance';
+  return path.posix.join(customerProjectsDir(customerIdn), projectIdn, agentIdn, flowIdn, `${skillIdn}${extension}`);
+}
+
+export function metadataPath(customerIdn: string, projectIdn: string): string {
+  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: string, content: string): Promise<void> {
+  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: string): Promise<string | null> {
+  return (await fs.pathExists(filepath)) ? fs.readFile(filepath, 'utf8') : null;
+}

package/src/hash.ts

@@ -0,0 +1,41 @@
+import crypto from 'crypto';
+import fs from 'fs-extra';
+import { ensureState, hashesPath, HASHES_PATH } from './fsutil.js';
+import type { HashStore } from './types.js';
+
+export function sha256(str: string): string {
+  return crypto.createHash('sha256').update(str, 'utf8').digest('hex');
+}
+
+export async function loadHashes(customerIdn?: string): Promise<HashStore> {
+  if (customerIdn) {
+    await ensureState(customerIdn);
+    try {
+      return await fs.readJson(hashesPath(customerIdn)) as HashStore;
+    } catch (error: unknown) {
+      if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+        return {};
+      }
+      throw error;
+    }
+  }
+  
+  // Legacy support
+  try {
+    return await fs.readJson(HASHES_PATH) as HashStore;
+  } catch (error: unknown) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      return {};
+    }
+    throw error;
+  }
+}
+
+export async function saveHashes(hashes: HashStore, customerIdn?: string): Promise<void> {
+  if (customerIdn) {
+    await fs.writeJson(hashesPath(customerIdn), hashes, { spaces: 2 });
+  } else {
+    // Legacy support
+    await fs.writeJson(HASHES_PATH, hashes, { spaces: 2 });
+  }
+}

package/src/{sync.js → sync.ts}

@@ -1,99 +1,156 @@
-import { listProjects, listAgents, listFlowSkills, updateSkill, listFlowEvents, listFlowStates, getProjectMeta } from './api.js';
-import { ensureState, skillPath, writeFileAtomic, readIfExists, MAP_PATH, projectDir, metadataPath } from './fsutil.js';
+import { 
+  listProjects, 
+  listAgents, 
+  listFlowSkills, 
+  updateSkill, 
+  listFlowEvents, 
+  listFlowStates, 
+  getProjectMeta 
+} from './api.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';
+import pLimit from 'p-limit';
+import type { AxiosInstance } from 'axios';
+import type { 
+  Agent, 
+  ProjectData, 
+  ProjectMap, 
+  LegacyProjectMap,
+  HashStore,
+  FlowsYamlData,
+  FlowsYamlAgent,
+  FlowsYamlFlow,
+  FlowsYamlSkill,
+  FlowsYamlEvent,
+  FlowsYamlState,
+  CustomerConfig
+} from './types.js';
 
-export async function pullSingleProject(client, projectId, projectIdn, verbose = false) {
-  if (verbose) console.log(`🔍 Fetching agents for project ${projectId} (${projectIdn})...`);
+// Concurrency limits for API operations
+const concurrencyLimit = pLimit(5);
+
+// Type guards for better type safety
+function isProjectMap(x: unknown): x is ProjectMap {
+  return !!x && typeof x === 'object' && 'projects' in x;
+}
+
+function isLegacyProjectMap(x: unknown): x is LegacyProjectMap {
+  return !!x && typeof x === 'object' && 'agents' in x;
+}
+
+export async function pullSingleProject(
+  client: AxiosInstance, 
+  customer: CustomerConfig,
+  projectId: string, 
+  projectIdn: string, 
+  verbose: boolean = false
+): Promise<ProjectData> {
+  if (verbose) 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: {} };
+  const projectMap: ProjectData = { projectId, projectIdn, agents: {} };
 
   for (const agent of agents) {
     const aKey = agent.idn;
     projectMap.agents[aKey] = { id: agent.id, flows: {} };
 
     for (const flow of agent.flows ?? []) {
-      projectMap.agents[aKey].flows[flow.idn] = { id: flow.id, skills: {} };
+      projectMap.agents[aKey]!.flows[flow.idn] = { id: flow.id, skills: {} };
 
       const skills = await listFlowSkills(client, flow.id);
-      for (const s of skills) {
-        const file = skillPath(projectIdn, agent.idn, flow.idn, s.idn, s.runner_type);
-        await writeFileAtomic(file, s.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[s.idn] = {
-          id: s.id,
-          title: s.title,
-          idn: s.idn,
-          runner_type: s.runner_type,
-          model: s.model,
-          parameters: s.parameters,
-          path: s.path
+        projectMap.agents[aKey]!.flows[flow.idn]!.skills[skill.idn] = {
+          id: skill.id,
+          title: skill.title,
+          idn: skill.idn,
+          runner_type: skill.runner_type,
+          model: skill.model,
+          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);
+  if (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: AxiosInstance, 
+  customer: CustomerConfig,
+  projectId: string | null = null, 
+  verbose: boolean = false
+): Promise<void> {
+  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 });
+    const idMap: ProjectMap = { projects: { [projectMeta.idn]: projectMap } };
+    await fs.writeJson(mapPath(customer.idn), idMap, { spaces: 2 });
     
     // Generate hash tracking for this project
-    const hashes = {};
+    const hashes: HashStore = {};
     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...`);
+  if (verbose) console.log(`🔍 Fetching all projects for customer ${customer.idn}...`);
   const projects = await listProjects(client);
   if (verbose) console.log(`📦 Found ${projects.length} projects`);
 
-  const idMap = { projects: {} };
-  const allHashes = {};
+  const idMap: ProjectMap = { projects: {} };
+  const allHashes: HashStore = {};
 
   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);
         }
@@ -101,28 +158,32 @@ export async function pullAll(client, projectId = null, verbose = false) {
     }
   }
 
-  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: AxiosInstance, customer: CustomerConfig, verbose: boolean = false): Promise<void> {
+  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);
+  if (verbose) console.log(`📋 Loading project mapping for customer ${customer.idn}...`);
+  const idMapData = await fs.readJson(mapPath(customer.idn)) as unknown;
   if (verbose) console.log('🔍 Loading file hashes...');
-  const oldHashes = await loadHashes();
-  const newHashes = { ...oldHashes };
+  const oldHashes = await loadHashes(customer.idn);
+  const newHashes: HashStore = { ...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 = 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 as ProjectData }
+    : (() => { throw new Error('Invalid project map format'); })();
   
   for (const [projectIdn, projectData] of Object.entries(projects)) {
     if (verbose && projectIdn) console.log(`📁 Scanning project: ${projectIdn}`);
@@ -133,8 +194,8 @@ export async function pushChanged(client, verbose = false) {
         if (verbose) 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}`);
           
@@ -164,7 +225,7 @@ export async function pushChanged(client, verbose = false) {
               runner_type: skillMeta.runner_type,
               model: skillMeta.model,
               parameters: skillMeta.parameters,
-              path: skillMeta.path
+              path: skillMeta.path || undefined
             };
             
             if (verbose) {
@@ -189,24 +250,28 @@ 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: CustomerConfig, verbose: boolean = false): Promise<void> {
+  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();
+  if (verbose) console.log(`📋 Loading project mapping and hashes for customer ${customer.idn}...`);
+  const idMapData = await fs.readJson(mapPath(customer.idn)) as unknown;
+  const hashes = await loadHashes(customer.idn);
   let dirty = 0;
 
-  // Handle both old single-project format and new multi-project format
-  const 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 as ProjectData }
+    : (() => { throw new Error('Invalid project map format'); })();
 
   for (const [projectIdn, projectData] of Object.entries(projects)) {
     if (verbose && projectIdn) console.log(`📁 Checking project: ${projectIdn}`);
@@ -217,8 +282,8 @@ export async function status(verbose = false) {
         if (verbose) 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}`); 
@@ -248,23 +313,49 @@ export async function status(verbose = false) {
   console.log(dirty ? `${dirty} changed file(s).` : 'Clean.');
 }
 
-async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
-  const flowsData = { flows: [] };
+async function generateFlowsYaml(
+  client: AxiosInstance, 
+  customer: CustomerConfig,
+  agents: Agent[], 
+  verbose: boolean = false
+): Promise<void> {
+  const flowsData: FlowsYamlData = { 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 = [];
+    const agentFlows: FlowsYamlFlow[] = [];
     
     for (const flow of agent.flows ?? []) {
-      if (verbose) console.log(`    📄 Processing flow: ${flow.idn}`);
+      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 => ({
+      const skillsData: FlowsYamlSkill[] = 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,
@@ -277,17 +368,17 @@ async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
       }));
 
       // Get events for this flow
-      let eventsData = [];
+      let eventsData: FlowsYamlEvent[] = [];
       try {
         const events = await listFlowEvents(client, flow.id);
         eventsData = events.map(event => ({
           title: event.description,
           idn: event.idn,
           skill_selector: `!enum "SkillSelector.${event.skill_selector}"`,
-          skill_idn: event.skill_idn,
-          state_idn: event.state_idn,
-          integration_idn: event.integration_idn,
-          connector_idn: event.connector_idn,
+          skill_idn: event.skill_idn || undefined,
+          state_idn: event.state_idn || undefined,
+          integration_idn: event.integration_idn || undefined,
+          connector_idn: event.connector_idn || undefined,
           interrupt_mode: `!enum "InterruptMode.${event.interrupt_mode}"`
         }));
         if (verbose) console.log(`      📋 Found ${events.length} events`);
@@ -296,13 +387,13 @@ async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
       }
 
       // Get state fields for this flow
-      let stateFieldsData = [];
+      let stateFieldsData: FlowsYamlState[] = [];
       try {
         const states = await listFlowStates(client, flow.id);
         stateFieldsData = states.map(state => ({
           title: state.title,
           idn: state.idn,
-          default_value: state.default_value,
+          default_value: state.default_value || undefined,
           scope: `!enum "StateFieldScope.${state.scope}"`
         }));
         if (verbose) console.log(`      📊 Found ${states.length} state fields`);
@@ -323,11 +414,18 @@ async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
       });
     }
 
-    flowsData.flows.push({
+    const agentData: FlowsYamlAgent = {
       agent_idn: agent.idn,
-      agent_description: agent.description,
+      agent_description: agent.description || undefined,
       agent_flows: agentFlows
-    });
+    };
+    
+    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
@@ -343,7 +441,7 @@ 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`);
 }