newo 3.4.2 → 3.6.0

package/dist/format/v2-yaml.js

@@ -0,0 +1,222 @@
+/**
+ * V2 YAML parsers and generators
+ *
+ * Handles reading/writing the newo_v2 format YAML files:
+ * - Flow YAML: {FlowIdn}.yaml (inline skill definitions, events, state_fields)
+ * - Project YAML: {project_idn}.yaml
+ * - Agent YAML: agent.yaml
+ * - Library YAML: {library_idn}.yaml
+ */
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import { patchYamlToPyyaml } from './yaml-patch.js';
+// ── Custom YAML tag for !enum values ──
+const enumTag = new yaml.Type('!enum', {
+    kind: 'scalar',
+    resolve: () => true,
+    construct: (data) => data,
+    represent: (data) => String(data),
+});
+const V2_YAML_SCHEMA = yaml.DEFAULT_SCHEMA.extend([enumTag]);
+// ── Shared YAML dump options ──
+const YAML_DUMP_OPTIONS = {
+    indent: 2,
+    quotingType: '"',
+    forceQuotes: false,
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false,
+    flowLevel: -1,
+    schema: V2_YAML_SCHEMA,
+};
+// ── Skill sorting: CamelCase first, then _prefixed, then snake_case ──
+function skillSortKey(idn) {
+    if (idn.startsWith('_')) {
+        return `1_${idn}`; // _prefixed second
+    }
+    if (idn[0] && idn[0] === idn[0].toUpperCase()) {
+        return `0_${idn}`; // CamelCase first
+    }
+    return `2_${idn}`; // snake_case last
+}
+/**
+ * Sort skills in V2 export order (case-sensitive ASCII sort within groups):
+ * 1. CamelCase (public) - case-sensitive alphabetically
+ * 2. _prefixed (private) - case-sensitive alphabetically
+ * 3. snake_case - case-sensitive alphabetically
+ */
+export function sortV2Skills(skills) {
+    return [...skills].sort((a, b) => {
+        const ka = skillSortKey(a.idn);
+        const kb = skillSortKey(b.idn);
+        return ka < kb ? -1 : ka > kb ? 1 : 0;
+    });
+}
+/**
+ * Sort parameters alphabetically by name (case-sensitive, V2 export order)
+ */
+export function sortV2Parameters(params) {
+    return [...params].sort((a, b) => {
+        return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+    });
+}
+// ── Flow YAML ──
+export async function parseV2FlowYaml(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    return yaml.load(content, { schema: V2_YAML_SCHEMA });
+}
+/**
+ * Generate V2 flow YAML content from API data
+ *
+ * Produces the exact format found in the reference V2 export:
+ *   title, idn, description, agent_id, skills[], events[], state_fields[],
+ *   default_runner_type, default_provider_idn, default_model_idn, publication_type
+ */
+export function generateV2FlowYaml(flowIdn, flowTitle, flowDescription, defaultRunnerType, defaultProviderIdn, defaultModelIdn, skills, events, stateFields) {
+    // Sort skills in V2 order and sort parameters within each skill
+    const sortedSkills = sortV2Skills(skills).map(s => ({
+        ...s,
+        parameters: sortV2Parameters(s.parameters),
+    }));
+    // Sort events by idn, then skill_idn, then integration_idn, then connector_idn
+    const sortedEvents = [...events].sort((a, b) => {
+        if (a.idn !== b.idn)
+            return a.idn < b.idn ? -1 : 1;
+        const as = a.skill_idn || '';
+        const bs = b.skill_idn || '';
+        if (as !== bs)
+            return as < bs ? -1 : 1;
+        const ai = a.integration_idn || '';
+        const bi = b.integration_idn || '';
+        if (ai !== bi)
+            return ai < bi ? -1 : 1;
+        const ac = a.connector_idn || '';
+        const bc = b.connector_idn || '';
+        return ac < bc ? -1 : ac > bc ? 1 : 0;
+    });
+    // Sort state_fields alphabetically by idn
+    const sortedStates = [...stateFields].sort((a, b) => a.idn < b.idn ? -1 : a.idn > b.idn ? 1 : 0);
+    const flowDef = {
+        title: flowTitle,
+        idn: flowIdn,
+        description: flowDescription ?? null,
+        agent_id: null,
+        skills: sortedSkills,
+        events: sortedEvents,
+        state_fields: sortedStates,
+        default_runner_type: defaultRunnerType,
+        default_provider_idn: defaultProviderIdn,
+        default_model_idn: defaultModelIdn,
+        publication_type: null,
+    };
+    // Flow YAML uses lineWidth: -1 (no wrapping) to keep prompt_script paths on one line
+    // Then patch to convert double-quoted JSON values to single-quoted
+    return patchYamlToPyyaml(yaml.dump(flowDef, { ...YAML_DUMP_OPTIONS, lineWidth: -1 }));
+}
+// ── Project YAML ──
+export async function parseV2ProjectYaml(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    const parsed = yaml.load(content, { schema: V2_YAML_SCHEMA });
+    return parsed.project;
+}
+/**
+ * Generate V2 project YAML
+ *
+ * Format:
+ *   project:
+ *     idn: naf
+ *     name: naf
+ *     version: 4.1.0
+ *     description: ""
+ *     is_auto_update_enabled: true
+ *     registry: production
+ *     registry_item_idn: naf
+ */
+export function generateV2ProjectYaml(meta) {
+    return yaml.dump({ project: meta }, YAML_DUMP_OPTIONS);
+}
+// ── Agent YAML ──
+export async function parseV2AgentYaml(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    const parsed = yaml.load(content, { schema: V2_YAML_SCHEMA });
+    return parsed.agent;
+}
+/**
+ * Generate V2 agent YAML
+ *
+ * Format:
+ *   agent:
+ *     idn: TaskManager
+ *     title: TaskManager
+ *     description: null
+ *
+ * V2 export preserves description exactly as provided (null stays null, "" stays "")
+ */
+export function generateV2AgentYaml(meta) {
+    return patchYamlToPyyaml(yaml.dump({ agent: meta }, YAML_DUMP_OPTIONS));
+}
+// ── Library YAML ──
+export async function parseV2LibraryYaml(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    return yaml.load(content, { schema: V2_YAML_SCHEMA });
+}
+/**
+ * Generate V2 library YAML
+ *
+ * Format:
+ *   title: Test Library
+ *   idn: testLib
+ *   description: Shared utility library
+ *   skills:
+ *     - idn: utilSkill
+ *       ...
+ */
+export function generateV2LibraryYaml(lib) {
+    return yaml.dump(lib, YAML_DUMP_OPTIONS);
+}
+// ── Conversion helpers ──
+/**
+ * Build a V2InlineSkill entry from API skill data
+ */
+export function buildV2InlineSkill(skillIdn, skillTitle, runnerType, modelIdn, providerIdn, parameters, promptScriptRelPath) {
+    return {
+        title: skillTitle || '',
+        idn: skillIdn,
+        prompt_script: promptScriptRelPath,
+        runner_type: runnerType,
+        model: {
+            model_idn: modelIdn,
+            provider_idn: providerIdn,
+        },
+        parameters: parameters.map(p => ({
+            name: p.name,
+            default_value: p.default_value ?? '',
+        })),
+    };
+}
+/**
+ * Build a V2FlowEvent entry from API event data
+ */
+export function buildV2FlowEvent(eventIdn, skillSelector, skillIdn, stateIdn, integrationIdn, connectorIdn, interruptMode) {
+    return {
+        idn: eventIdn,
+        skill_selector: skillSelector,
+        skill_idn: skillIdn || null,
+        state_idn: stateIdn || null,
+        integration_idn: integrationIdn || null,
+        connector_idn: connectorIdn || null,
+        interrupt_mode: interruptMode,
+    };
+}
+/**
+ * Build a V2StateField entry from API state data
+ */
+export function buildV2StateField(stateIdn, stateTitle, defaultValue, scope) {
+    return {
+        title: stateTitle || '',
+        idn: stateIdn,
+        default_value: defaultValue ?? '',
+        scope,
+    };
+}
+//# sourceMappingURL=v2-yaml.js.map

package/dist/format/yaml-patch.d.ts

@@ -0,0 +1,14 @@
+/**
+ * YAML Post-Processor - Patches js-yaml output to match pyyaml's formatting
+ *
+ * Replicates pyyaml's Emitter wrapping behavior:
+ * - Double-quoted: breaks with `\` when column + pending > best_width (80) at space
+ * - Plain scalar: breaks at space when column > best_width
+ * - Continuation indent: parent indent + best_indent (usually +2)
+ * - Single-quote preference for strings with brackets
+ */
+/**
+ * Patch full YAML document output to match pyyaml formatting
+ */
+export declare function patchYamlToPyyaml(yamlText: string): string;
+//# sourceMappingURL=yaml-patch.d.ts.map

package/dist/format/yaml-patch.js

@@ -0,0 +1,184 @@
+/**
+ * YAML Post-Processor - Patches js-yaml output to match pyyaml's formatting
+ *
+ * Replicates pyyaml's Emitter wrapping behavior:
+ * - Double-quoted: breaks with `\` when column + pending > best_width (80) at space
+ * - Plain scalar: breaks at space when column > best_width
+ * - Continuation indent: parent indent + best_indent (usually +2)
+ * - Single-quote preference for strings with brackets
+ */
+const BEST_WIDTH = 80;
+/**
+ * Patch full YAML document output to match pyyaml formatting
+ */
+export function patchYamlToPyyaml(yamlText) {
+    const lines = yamlText.split('\n');
+    const result = [];
+    let inBlockScalar = false;
+    let blockIndent = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Track block scalar context (|- or >- or | or >)
+        if (inBlockScalar) {
+            const currentIndent = line.length - line.trimStart().length;
+            if (line.trim() === '' || currentIndent > blockIndent) {
+                result.push(line);
+                continue;
+            }
+            inBlockScalar = false;
+        }
+        // Detect start of block scalar
+        if (/^\s*[\w-]+:\s+[|>]-?\s*$/.test(line)) {
+            const keyIndent = line.length - line.trimStart().length;
+            inBlockScalar = true;
+            blockIndent = keyIndent;
+            result.push(line);
+            continue;
+        }
+        result.push(...patchLine(line));
+    }
+    return result.join('\n');
+}
+// Keys that must NEVER be wrapped
+const NO_WRAP_KEYS = new Set([
+    'prompt_script', 'idn', 'runner_type',
+    'model_idn', 'provider_idn', 'skill_idn', 'state_idn',
+    'integration_idn', 'connector_idn', 'interrupt_mode',
+    'skill_selector', 'name', 'scope', 'agent_id',
+    'default_runner_type', 'default_provider_idn', 'default_model_idn',
+    'publication_type', 'is_hidden', 'is_auto_update_enabled',
+    'group', 'registry', 'registry_item_idn', 'version',
+]);
+function patchLine(line) {
+    if (line.trim() === '' || line.trim().startsWith('#')) {
+        return [line];
+    }
+    const kvMatch = line.match(/^(\s*(?:-\s+)?)([\w-]+):\s+(.+)$/);
+    if (!kvMatch) {
+        return [line];
+    }
+    const prefix = kvMatch[1];
+    const key = kvMatch[2];
+    const value = kvMatch[3];
+    // Single-quote fix for JSON-like values (before anything else)
+    const sqFix = tryConvertToSingleQuote(value);
+    const effectiveValue = sqFix ?? value;
+    const effectiveLine = sqFix !== null ? `${prefix}${key}: ${sqFix}` : line;
+    if (NO_WRAP_KEYS.has(key)) {
+        return [effectiveLine];
+    }
+    // Only wrap if line exceeds BEST_WIDTH
+    if (effectiveLine.length <= BEST_WIDTH) {
+        return [effectiveLine];
+    }
+    const keyPart = `${prefix}${key}: `;
+    // pyyaml continuation indent = current mapping indent + best_indent
+    // For "  description: ..." indent is 2, continuation = 2 + 2 = 4 spaces
+    const keyIndent = prefix.replace(/-\s+$/, '').length;
+    const contIndent = ' '.repeat(keyIndent + 2);
+    if (effectiveValue.startsWith('"') && effectiveValue.endsWith('"')) {
+        return wrapDoubleQuoted(keyPart, effectiveValue, contIndent);
+    }
+    if (effectiveValue.startsWith("'") && effectiveValue.endsWith("'")) {
+        return [effectiveLine]; // Single-quoted: don't wrap
+    }
+    return wrapPlainScalar(keyPart, effectiveValue, contIndent);
+}
+/**
+ * Try to convert double-quoted string with escaped chars to single-quoted
+ */
+function tryConvertToSingleQuote(value) {
+    if (!value.startsWith('"') || !value.endsWith('"'))
+        return null;
+    const inner = value.slice(1, -1);
+    if (!inner.includes('\\"'))
+        return null;
+    if (!inner.includes('[') && !inner.includes('{'))
+        return null;
+    const unescaped = inner.replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+    if (unescaped.includes("'")) {
+        return `'${unescaped.replace(/'/g, "''")}'`;
+    }
+    return `'${unescaped}'`;
+}
+/**
+ * Wrap double-quoted scalar matching pyyaml's write_double_quoted algorithm:
+ * - Track column from 0
+ * - At each space, check if column + pending > best_width
+ * - If yes, emit text + `\`, newline, indent, `\ ` (escaped space for continuation)
+ */
+function wrapDoubleQuoted(keyPart, quotedValue, contIndent) {
+    const inner = quotedValue.slice(1, -1);
+    const result = [];
+    let column = keyPart.length + 1; // keyPart + opening "
+    let lineStart = 0;
+    let lastSpace = -1;
+    for (let i = 0; i < inner.length; i++) {
+        column++;
+        if (inner[i] === ' ') {
+            lastSpace = i;
+        }
+        // pyyaml condition: column + remaining_in_word > best_width, at a space or start >= end
+        if (column > BEST_WIDTH && lastSpace > lineStart) {
+            // Break at lastSpace
+            const chunk = inner.slice(lineStart, lastSpace);
+            if (result.length === 0) {
+                result.push(`${keyPart}"${chunk}\\`);
+            }
+            else {
+                result.push(`${contIndent}\\ ${chunk}\\`);
+            }
+            lineStart = lastSpace + 1; // skip the space
+            column = contIndent.length + 2 + (i - lastSpace); // contIndent + "\ " + chars after space
+            lastSpace = -1;
+        }
+    }
+    // Remaining text
+    const remaining = inner.slice(lineStart);
+    if (result.length === 0) {
+        result.push(`${keyPart}"${remaining}"`);
+    }
+    else {
+        result.push(`${contIndent}\\ ${remaining}"`);
+    }
+    return result;
+}
+/**
+ * Wrap plain scalar matching pyyaml's write_plain algorithm:
+ * - At each space, if column > best_width, break
+ * - Continuation is just indented text (no backslash)
+ */
+function wrapPlainScalar(keyPart, value, contIndent) {
+    const result = [];
+    let column = keyPart.length;
+    let lineStart = 0;
+    let lastSpace = -1;
+    for (let i = 0; i < value.length; i++) {
+        column++;
+        if (value[i] === ' ') {
+            // pyyaml breaks at single space when column > best_width
+            if (column > BEST_WIDTH && lastSpace >= lineStart) {
+                const chunk = value.slice(lineStart, i);
+                if (result.length === 0) {
+                    result.push(`${keyPart}${chunk}`);
+                }
+                else {
+                    result.push(`${contIndent}${chunk}`);
+                }
+                lineStart = i + 1; // skip the space
+                column = contIndent.length;
+            }
+            lastSpace = i;
+        }
+    }
+    // Remaining
+    const remaining = value.slice(lineStart);
+    if (result.length === 0) {
+        result.push(`${keyPart}${remaining}`);
+    }
+    else {
+        result.push(`${contIndent}${remaining}`);
+    }
+    return result;
+}
+//# sourceMappingURL=yaml-patch.js.map

package/dist/fsutil.d.ts

@@ -7,6 +7,11 @@ 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>;
+/**
+ * Ensure only the .newo/ state directory exists (no V1 projects/ dir)
+ * Used by newo_v2 format to avoid creating V1 artifacts
+ */
+export declare function ensureStateOnly(customerIdn: string): Promise<void>;
 export declare function projectDir(customerIdn: string, projectIdn: string): string;
 export declare function flowsYamlPath(customerIdn: string): string;
 export declare function customerAttributesPath(customerIdn: string): string;
@@ -19,6 +24,11 @@ export declare function projectMetadataPath(customerIdn: string, projectIdn: str
 export declare function agentMetadataPath(customerIdn: string, projectIdn: string, agentIdn: string): string;
 export declare function flowMetadataPath(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string): string;
 export declare function skillMetadataPath(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string): string;
+export declare function libraryDir(customerIdn: string, projectIdn: string, libraryIdn: string): string;
+export declare function libraryMetadataPath(customerIdn: string, projectIdn: string, libraryIdn: string): string;
+export declare function librarySkillFolderPath(customerIdn: string, projectIdn: string, libraryIdn: string, skillIdn: string): string;
+export declare function librarySkillScriptPath(customerIdn: string, projectIdn: string, libraryIdn: string, skillIdn: string, runnerType?: RunnerType): string;
+export declare function librarySkillMetadataPath(customerIdn: string, projectIdn: string, libraryIdn: string, skillIdn: string): string;
 export declare function metadataPath(customerIdn: string, projectIdn: string): string;
 export declare const ROOT_DIR: string;
 export declare const MAP_PATH: string;

package/dist/fsutil.js

@@ -22,6 +22,14 @@ export async function ensureState(customerIdn) {
     await fs.ensureDir(customerStateDir(customerIdn));
     await fs.ensureDir(customerProjectsDir(customerIdn));
 }
+/**
+ * Ensure only the .newo/ state directory exists (no V1 projects/ dir)
+ * Used by newo_v2 format to avoid creating V1 artifacts
+ */
+export async function ensureStateOnly(customerIdn) {
+    await fs.ensureDir(STATE_DIR);
+    await fs.ensureDir(customerStateDir(customerIdn));
+}
 export function projectDir(customerIdn, projectIdn) {
     return path.posix.join(customerProjectsDir(customerIdn), projectIdn);
 }
@@ -63,6 +71,23 @@ export function flowMetadataPath(customerIdn, projectIdn, agentIdn, flowIdn) {
 export function skillMetadataPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn) {
     return path.posix.join(skillFolderPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn), 'metadata.yaml');
 }
+// Library paths (cli_v1 format)
+export function libraryDir(customerIdn, projectIdn, libraryIdn) {
+    return path.posix.join(customerProjectsDir(customerIdn), projectIdn, 'libraries', libraryIdn);
+}
+export function libraryMetadataPath(customerIdn, projectIdn, libraryIdn) {
+    return path.posix.join(libraryDir(customerIdn, projectIdn, libraryIdn), 'metadata.yaml');
+}
+export function librarySkillFolderPath(customerIdn, projectIdn, libraryIdn, skillIdn) {
+    return path.posix.join(libraryDir(customerIdn, projectIdn, libraryIdn), skillIdn);
+}
+export function librarySkillScriptPath(customerIdn, projectIdn, libraryIdn, skillIdn, runnerType = 'guidance') {
+    const extension = runnerType === 'nsl' ? '.jinja' : '.guidance';
+    return path.posix.join(librarySkillFolderPath(customerIdn, projectIdn, libraryIdn, skillIdn), `${skillIdn}${extension}`);
+}
+export function librarySkillMetadataPath(customerIdn, projectIdn, libraryIdn, skillIdn) {
+    return path.posix.join(librarySkillFolderPath(customerIdn, projectIdn, libraryIdn, skillIdn), 'metadata.yaml');
+}
 // Legacy metadata path - keep for backwards compatibility
 export function metadataPath(customerIdn, projectIdn) {
     return path.posix.join(customerProjectsDir(customerIdn), projectIdn, 'metadata.json');

package/dist/sync/attributes.js

@@ -243,9 +243,9 @@ export async function pushProjectAttributes(client, customer, projectId, project
         }
         // Value type is already parsed (we removed !enum tags above)
         const valueType = localAttr.value_type;
-        // Check if value changed
-        const localValue = String(localAttr.value || '');
-        const remoteValue = String(remoteAttr.value || '');
+        // Check if value changed (use ?? to preserve 0, false, empty string)
+        const localValue = String(localAttr.value ?? '');
+        const remoteValue = String(remoteAttr.value ?? '');
         if (localValue !== remoteValue) {
             if (verbose)
                 console.log(`   🔄 Updating project attribute: ${localAttr.idn}`);

package/dist/sync/skill-files.js

@@ -40,8 +40,8 @@ export async function findSkillScriptFiles(skillFolderPath) {
         const stats = await fs.stat(filePath);
         if (stats.isFile()) {
             const ext = path.extname(fileName).toLowerCase();
-            // Check for script file extensions
-            if (['.jinja', '.guidance', '.nsl'].includes(ext)) {
+            // Check for script file extensions (all formats)
+            if (['.jinja', '.guidance', '.nsl', '.nslg'].includes(ext)) {
                 const content = await fs.readFile(filePath, 'utf8');
                 scriptFiles.push({
                     filePath,

package/dist/types.d.ts

@@ -155,10 +155,15 @@ export interface AgentData {
     id: string;
     flows: Record<string, FlowData>;
 }
+export interface LibraryData {
+    id: string;
+    skills: Record<string, SkillMetadata>;
+}
 export interface ProjectData {
     projectId: string;
     projectIdn: string;
     agents: Record<string, AgentData>;
+    libraries?: Record<string, LibraryData> | undefined;
 }
 export interface ProjectMap {
     projects: Record<string, ProjectData>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newo",
-  "version": "3.4.2",
+  "version": "3.6.0",
   "description": "NEWO CLI: Professional command-line tool with modular architecture for NEWO AI Agent development. Features account migration, integration management, webhook automation, AKB knowledge base, project attributes, sandbox testing, IDN-based file management, real-time progress tracking, intelligent sync operations, and comprehensive multi-customer support.",
   "type": "module",
   "bin": {

package/src/api.ts

@@ -627,4 +627,68 @@ export async function getLogs(
 
   const response = await client.get<LogsResponse>(`/api/v1/analytics/logs?${queryParams.toString()}`);
   return response.data;
+}
+
+// ── Libraries ──
+
+export interface LibraryResponse {
+  id: string;
+  idn: string;
+  project_id: string;
+  skills: Skill[];
+}
+
+export async function listLibraries(client: AxiosInstance, projectId: string): Promise<LibraryResponse[]> {
+  const response = await client.get<LibraryResponse[]>(
+    `/api/v1/designer/projects/${projectId}/libraries`
+  );
+  return response.data;
+}
+
+export async function listLibrarySkills(client: AxiosInstance, libraryId: string): Promise<Skill[]> {
+  const response = await client.get<Skill[]>(
+    `/api/v1/designer/libraries/${libraryId}/skills`
+  );
+  return response.data;
+}
+
+export async function updateLibrarySkill(
+  client: AxiosInstance,
+  libraryId: string,
+  skillId: string,
+  data: { prompt_script: string; [key: string]: unknown }
+): Promise<void> {
+  await client.patch(
+    `/api/v1/designer/libraries/${libraryId}/skills/${skillId}`,
+    data
+  );
+}
+
+// ── V2 Bulk Export/Import ──
+
+export interface V2ExportOptions {
+  export_akb?: boolean;
+  export_customer_attributes?: boolean;
+  exclude_projects_idn?: string[];
+}
+
+export async function exportCustomerV2(
+  client: AxiosInstance,
+  customerId: string,
+  options: V2ExportOptions = {}
+): Promise<Buffer> {
+  const params = new URLSearchParams();
+  params.set('customer_id', customerId);
+  if (options.export_akb !== undefined) params.set('export_akb', String(options.export_akb));
+  if (options.export_customer_attributes !== undefined) params.set('export_customer_attributes', String(options.export_customer_attributes));
+  if (options.exclude_projects_idn && options.exclude_projects_idn.length > 0) {
+    for (const idn of options.exclude_projects_idn) {
+      params.append('exclude_projects_idn', idn);
+    }
+  }
+
+  const response = await client.post(`/api/v2/designer/customer/export?${params.toString()}`, null, {
+    responseType: 'arraybuffer',
+  });
+  return Buffer.from(response.data as ArrayBuffer);
 }

package/src/cli/commands/export.ts

@@ -0,0 +1,78 @@
+/**
+ * Export command handler - downloads V2 bulk export ZIP from platform
+ *
+ * Usage:
+ *   newo export                           # Export to temp/export-{customerIdn}-{timestamp}.zip
+ *   newo export --output my-export.zip    # Export to specific file
+ *   newo export --no-akb                  # Exclude AKB from export
+ *   newo export --no-attributes           # Exclude customer attributes
+ */
+import { makeClient, exportCustomerV2 } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { selectSingleCustomer } from '../customer-selection.js';
+import fs from 'fs-extra';
+import path from 'path';
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+
+export async function handleExportCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean
+): Promise<void> {
+  const { selectedCustomer } = selectSingleCustomer(
+    customerConfig,
+    args.customer as string | undefined
+  );
+
+  if (!selectedCustomer) {
+    console.error('Please specify a customer with --customer');
+    process.exit(1);
+  }
+
+  const accessToken = await getValidAccessToken(selectedCustomer);
+  const client = await makeClient(verbose, accessToken);
+
+  // Get customer ID from token (needed for V2 export API)
+  const customerId = await getCustomerIdFromToken(accessToken);
+  if (!customerId) {
+    console.error('Could not determine customer ID from token');
+    process.exit(1);
+  }
+
+  const exportAkb = !args['no-akb'];
+  const exportAttributes = !args['no-attributes'];
+
+  console.log(`Downloading V2 export for customer ${selectedCustomer.idn}...`);
+
+  const zipBuffer = await exportCustomerV2(client, customerId, {
+    export_akb: exportAkb,
+    export_customer_attributes: exportAttributes,
+  });
+
+  // Determine output path
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const defaultName = `export-${selectedCustomer.idn}-${timestamp}.zip`;
+  const outputPath = (args.output as string | undefined) || (args.o as string | undefined)
+    || path.join(process.cwd(), 'temp', defaultName);
+
+  await fs.ensureDir(path.dirname(outputPath));
+  await fs.writeFile(outputPath, zipBuffer);
+
+  console.log(`Exported ${(zipBuffer.length / 1024 / 1024).toFixed(1)}MB to ${outputPath}`);
+}
+
+/**
+ * Extract customer_id from JWT token payload
+ */
+function getCustomerIdFromToken(token: string): string | null {
+  try {
+    const parts = token.split('.');
+    if (parts.length < 2) return null;
+    const payload = parts[1]!;
+    const padded = payload + '='.repeat(4 - (payload.length % 4));
+    const decoded = JSON.parse(Buffer.from(padded, 'base64').toString('utf8')) as Record<string, unknown>;
+    return (decoded['customer_id'] as string) || (decoded['sub'] as string) || null;
+  } catch {
+    return null;
+  }
+}