@constructive-io/cli 6.0.4 → 6.1.0

package/config/config-manager.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Configuration manager for the CNC execution engine
+ * Uses appstash for directory resolution
+ */
+import type { ContextConfig, GlobalSettings, Credentials, ContextCredentials } from './types';
+/**
+ * Get the appstash directories for cnc
+ */
+export declare function getAppDirs(): import("appstash").AppStashResult;
+/**
+ * Load global settings
+ */
+export declare function loadSettings(): GlobalSettings;
+/**
+ * Save global settings
+ */
+export declare function saveSettings(settings: GlobalSettings): void;
+/**
+ * Load credentials
+ */
+export declare function loadCredentials(): Credentials;
+/**
+ * Save credentials
+ */
+export declare function saveCredentials(credentials: Credentials): void;
+/**
+ * Load a context configuration
+ */
+export declare function loadContext(contextName: string): ContextConfig | null;
+/**
+ * Save a context configuration
+ */
+export declare function saveContext(context: ContextConfig): void;
+/**
+ * Delete a context configuration
+ */
+export declare function deleteContext(contextName: string): boolean;
+/**
+ * List all context configurations
+ */
+export declare function listContexts(): ContextConfig[];
+/**
+ * Get the current active context
+ */
+export declare function getCurrentContext(): ContextConfig | null;
+/**
+ * Set the current active context
+ */
+export declare function setCurrentContext(contextName: string): boolean;
+/**
+ * Create a new context configuration
+ */
+export declare function createContext(name: string, endpoint: string): ContextConfig;
+/**
+ * Get credentials for a context
+ */
+export declare function getContextCredentials(contextName: string): ContextCredentials | null;
+/**
+ * Set credentials for a context
+ */
+export declare function setContextCredentials(contextName: string, token: string, options?: {
+    expiresAt?: string;
+    refreshToken?: string;
+}): void;
+/**
+ * Remove credentials for a context
+ */
+export declare function removeContextCredentials(contextName: string): boolean;
+/**
+ * Check if a context has valid credentials
+ */
+export declare function hasValidCredentials(contextName: string): boolean;

package/config/config-manager.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Configuration manager for the CNC execution engine
+ * Uses appstash for directory resolution
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppDirs = getAppDirs;
+exports.loadSettings = loadSettings;
+exports.saveSettings = saveSettings;
+exports.loadCredentials = loadCredentials;
+exports.saveCredentials = saveCredentials;
+exports.loadContext = loadContext;
+exports.saveContext = saveContext;
+exports.deleteContext = deleteContext;
+exports.listContexts = listContexts;
+exports.getCurrentContext = getCurrentContext;
+exports.setCurrentContext = setCurrentContext;
+exports.createContext = createContext;
+exports.getContextCredentials = getContextCredentials;
+exports.setContextCredentials = setContextCredentials;
+exports.removeContextCredentials = removeContextCredentials;
+exports.hasValidCredentials = hasValidCredentials;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const appstash_1 = require("appstash");
+const types_1 = require("./types");
+const TOOL_NAME = 'cnc';
+/**
+ * Get the appstash directories for cnc
+ */
+function getAppDirs() {
+    return (0, appstash_1.appstash)(TOOL_NAME, { ensure: true });
+}
+/**
+ * Get path to a config file
+ */
+function getConfigPath(filename) {
+    const dirs = getAppDirs();
+    return (0, appstash_1.resolve)(dirs, 'config', filename);
+}
+/**
+ * Get path to a context config file
+ */
+function getContextConfigPath(contextName) {
+    const dirs = getAppDirs();
+    const contextsDir = (0, appstash_1.resolve)(dirs, 'config', 'contexts');
+    if (!fs.existsSync(contextsDir)) {
+        fs.mkdirSync(contextsDir, { recursive: true });
+    }
+    return path.join(contextsDir, `${contextName}.json`);
+}
+/**
+ * Load global settings
+ */
+function loadSettings() {
+    const settingsPath = getConfigPath('settings.json');
+    if (fs.existsSync(settingsPath)) {
+        try {
+            const content = fs.readFileSync(settingsPath, 'utf8');
+            return { ...types_1.DEFAULT_SETTINGS, ...JSON.parse(content) };
+        }
+        catch {
+            return types_1.DEFAULT_SETTINGS;
+        }
+    }
+    return types_1.DEFAULT_SETTINGS;
+}
+/**
+ * Save global settings
+ */
+function saveSettings(settings) {
+    const settingsPath = getConfigPath('settings.json');
+    const configDir = path.dirname(settingsPath);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+/**
+ * Load credentials
+ */
+function loadCredentials() {
+    const credentialsPath = getConfigPath('credentials.json');
+    if (fs.existsSync(credentialsPath)) {
+        try {
+            const content = fs.readFileSync(credentialsPath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch {
+            return { tokens: {} };
+        }
+    }
+    return { tokens: {} };
+}
+/**
+ * Save credentials
+ */
+function saveCredentials(credentials) {
+    const credentialsPath = getConfigPath('credentials.json');
+    const configDir = path.dirname(credentialsPath);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+        mode: 0o600, // Read/write for owner only
+    });
+}
+/**
+ * Load a context configuration
+ */
+function loadContext(contextName) {
+    const contextPath = getContextConfigPath(contextName);
+    if (fs.existsSync(contextPath)) {
+        try {
+            const content = fs.readFileSync(contextPath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Save a context configuration
+ */
+function saveContext(context) {
+    const contextPath = getContextConfigPath(context.name);
+    fs.writeFileSync(contextPath, JSON.stringify(context, null, 2));
+}
+/**
+ * Delete a context configuration
+ */
+function deleteContext(contextName) {
+    const contextPath = getContextConfigPath(contextName);
+    if (fs.existsSync(contextPath)) {
+        fs.unlinkSync(contextPath);
+        return true;
+    }
+    return false;
+}
+/**
+ * List all context configurations
+ */
+function listContexts() {
+    const dirs = getAppDirs();
+    const contextsDir = (0, appstash_1.resolve)(dirs, 'config', 'contexts');
+    if (!fs.existsSync(contextsDir)) {
+        return [];
+    }
+    const files = fs.readdirSync(contextsDir).filter(f => f.endsWith('.json'));
+    const contexts = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(contextsDir, file), 'utf8');
+            contexts.push(JSON.parse(content));
+        }
+        catch {
+            // Skip invalid files
+        }
+    }
+    return contexts;
+}
+/**
+ * Get the current active context
+ */
+function getCurrentContext() {
+    const settings = loadSettings();
+    if (settings.currentContext) {
+        return loadContext(settings.currentContext);
+    }
+    return null;
+}
+/**
+ * Set the current active context
+ */
+function setCurrentContext(contextName) {
+    const context = loadContext(contextName);
+    if (!context) {
+        return false;
+    }
+    const settings = loadSettings();
+    settings.currentContext = contextName;
+    saveSettings(settings);
+    return true;
+}
+/**
+ * Create a new context configuration
+ */
+function createContext(name, endpoint) {
+    const now = new Date().toISOString();
+    const context = {
+        name,
+        endpoint,
+        createdAt: now,
+        updatedAt: now,
+    };
+    saveContext(context);
+    return context;
+}
+/**
+ * Get credentials for a context
+ */
+function getContextCredentials(contextName) {
+    const credentials = loadCredentials();
+    return credentials.tokens[contextName] || null;
+}
+/**
+ * Set credentials for a context
+ */
+function setContextCredentials(contextName, token, options) {
+    const credentials = loadCredentials();
+    credentials.tokens[contextName] = {
+        token,
+        expiresAt: options?.expiresAt,
+        refreshToken: options?.refreshToken,
+    };
+    saveCredentials(credentials);
+}
+/**
+ * Remove credentials for a context
+ */
+function removeContextCredentials(contextName) {
+    const credentials = loadCredentials();
+    if (credentials.tokens[contextName]) {
+        delete credentials.tokens[contextName];
+        saveCredentials(credentials);
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if a context has valid credentials
+ */
+function hasValidCredentials(contextName) {
+    const creds = getContextCredentials(contextName);
+    if (!creds || !creds.token) {
+        return false;
+    }
+    if (creds.expiresAt) {
+        const expiresAt = new Date(creds.expiresAt);
+        if (expiresAt <= new Date()) {
+            return false;
+        }
+    }
+    return true;
+}

package/config/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Config module exports
+ */
+export * from './types';
+export * from './config-manager';

package/config/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Config module exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./config-manager"), exports);

package/config/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Configuration types for the CNC execution engine
+ */
+/**
+ * Context configuration stored in ~/.cnc/config/contexts/{name}.json
+ * Similar to kubectl contexts - bundles endpoint + credentials
+ */
+export interface ContextConfig {
+    /** Context name (used as identifier) */
+    name: string;
+    /** GraphQL endpoint URL */
+    endpoint: string;
+    /** Created timestamp */
+    createdAt: string;
+    /** Last updated timestamp */
+    updatedAt: string;
+}
+/**
+ * Global settings stored in ~/.cnc/config/settings.json
+ */
+export interface GlobalSettings {
+    /** Currently active context name */
+    currentContext?: string;
+}
+/**
+ * Credentials stored in ~/.cnc/config/credentials.json
+ */
+export interface Credentials {
+    /** API tokens per context */
+    tokens: Record<string, ContextCredentials>;
+}
+/**
+ * Per-context credentials
+ */
+export interface ContextCredentials {
+    /** Bearer token for API authentication */
+    token: string;
+    /** Token expiration timestamp (ISO string) */
+    expiresAt?: string;
+    /** Refresh token if available */
+    refreshToken?: string;
+}
+/**
+ * Default global settings
+ */
+export declare const DEFAULT_SETTINGS: GlobalSettings;

package/config/types.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Configuration types for the CNC execution engine
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SETTINGS = void 0;
+/**
+ * Default global settings
+ */
+exports.DEFAULT_SETTINGS = {};

package/esm/commands/auth.js

@@ -0,0 +1,202 @@
+/**
+ * Authentication commands for the CNC execution engine
+ */
+import { extractFirst } from 'inquirerer';
+import chalk from 'yanse';
+import { getCurrentContext, loadContext, listContexts, getContextCredentials, setContextCredentials, removeContextCredentials, hasValidCredentials, loadSettings, } from '../config';
+const usage = `
+Constructive Authentication:
+
+  cnc auth <command> [OPTIONS]
+
+Commands:
+  set-token <token>     Set API token for the current context
+  status                Show authentication status
+  logout                Remove credentials for the current context
+
+Options:
+  --context <name>      Specify context (defaults to current context)
+  --expires <date>      Token expiration date (ISO format)
+
+Examples:
+  cnc auth set-token eyJhbGciOiJIUzI1NiIs...
+  cnc auth status
+  cnc auth logout
+  cnc auth set-token <token> --context my-api
+
+  --help, -h            Show this help message
+`;
+export default async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(usage);
+        process.exit(0);
+    }
+    const { first: subcommand, newArgv } = extractFirst(argv);
+    if (!subcommand) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'subcommand',
+                message: 'What do you want to do?',
+                options: ['set-token', 'status', 'logout'],
+            },
+        ]);
+        return handleSubcommand(answer.subcommand, newArgv, prompter);
+    }
+    return handleSubcommand(subcommand, newArgv, prompter);
+};
+async function handleSubcommand(subcommand, argv, prompter) {
+    switch (subcommand) {
+        case 'set-token':
+            return handleSetToken(argv, prompter);
+        case 'status':
+            return handleStatus(argv);
+        case 'logout':
+            return handleLogout(argv, prompter);
+        default:
+            console.log(usage);
+            console.error(chalk.red(`Unknown subcommand: ${subcommand}`));
+            process.exit(1);
+    }
+}
+async function getTargetContext(argv, prompter) {
+    if (argv.context && typeof argv.context === 'string') {
+        const context = loadContext(argv.context);
+        if (!context) {
+            console.error(chalk.red(`Context "${argv.context}" not found.`));
+            process.exit(1);
+        }
+        return argv.context;
+    }
+    const current = getCurrentContext();
+    if (current) {
+        return current.name;
+    }
+    const contexts = listContexts();
+    if (contexts.length === 0) {
+        console.error(chalk.red('No contexts configured.'));
+        console.log(chalk.gray('Run "cnc context create <name>" to create one first.'));
+        process.exit(1);
+    }
+    const answer = await prompter.prompt(argv, [
+        {
+            type: 'autocomplete',
+            name: 'context',
+            message: 'Select context',
+            options: contexts.map(c => c.name),
+        },
+    ]);
+    return answer.context;
+}
+async function handleSetToken(argv, prompter) {
+    const contextName = await getTargetContext(argv, prompter);
+    const { first: token, newArgv } = extractFirst(argv);
+    let tokenValue = token;
+    if (!tokenValue) {
+        const answer = await prompter.prompt(newArgv, [
+            {
+                type: 'password',
+                name: 'token',
+                message: 'API Token',
+                required: true,
+            },
+        ]);
+        tokenValue = answer.token;
+    }
+    if (!tokenValue || tokenValue.trim() === '') {
+        console.error(chalk.red('Token cannot be empty.'));
+        process.exit(1);
+    }
+    const expiresAt = argv.expires;
+    setContextCredentials(contextName, tokenValue.trim(), { expiresAt });
+    console.log(chalk.green(`Token saved for context: ${contextName}`));
+    if (expiresAt) {
+        console.log(chalk.gray(`Expires: ${expiresAt}`));
+    }
+}
+function handleStatus(argv) {
+    const settings = loadSettings();
+    const contexts = listContexts();
+    if (contexts.length === 0) {
+        console.log(chalk.gray('No contexts configured.'));
+        return;
+    }
+    if (argv.context && typeof argv.context === 'string') {
+        const context = loadContext(argv.context);
+        if (!context) {
+            console.error(chalk.red(`Context "${argv.context}" not found.`));
+            process.exit(1);
+        }
+        showContextAuthStatus(context.name, settings.currentContext === context.name);
+        return;
+    }
+    console.log(chalk.bold('Authentication Status:'));
+    console.log();
+    for (const context of contexts) {
+        const isCurrent = context.name === settings.currentContext;
+        showContextAuthStatus(context.name, isCurrent);
+    }
+}
+function showContextAuthStatus(contextName, isCurrent) {
+    const creds = getContextCredentials(contextName);
+    const hasAuth = hasValidCredentials(contextName);
+    const marker = isCurrent ? chalk.green('*') : ' ';
+    console.log(`${marker} ${chalk.bold(contextName)}`);
+    if (hasAuth && creds) {
+        console.log(`    Status: ${chalk.green('Authenticated')}`);
+        console.log(`    Token:  ${maskToken(creds.token)}`);
+        if (creds.expiresAt) {
+            const expiresAt = new Date(creds.expiresAt);
+            const now = new Date();
+            if (expiresAt <= now) {
+                console.log(`    Expires: ${chalk.red(creds.expiresAt + ' (expired)')}`);
+            }
+            else {
+                console.log(`    Expires: ${creds.expiresAt}`);
+            }
+        }
+    }
+    else if (creds && creds.token) {
+        console.log(`    Status: ${chalk.red('Expired')}`);
+        console.log(`    Token:  ${maskToken(creds.token)}`);
+        if (creds.expiresAt) {
+            console.log(`    Expired: ${creds.expiresAt}`);
+        }
+    }
+    else {
+        console.log(`    Status: ${chalk.yellow('Not authenticated')}`);
+    }
+    console.log();
+}
+function maskToken(token) {
+    if (token.length <= 10) {
+        return '****';
+    }
+    return token.substring(0, 6) + '...' + token.substring(token.length - 4);
+}
+async function handleLogout(argv, prompter) {
+    const contextName = await getTargetContext(argv, prompter);
+    const creds = getContextCredentials(contextName);
+    if (!creds) {
+        console.log(chalk.gray(`No credentials found for context: ${contextName}`));
+        return;
+    }
+    const confirm = await prompter.prompt(argv, [
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remove credentials for context "${contextName}"?`,
+            default: false,
+        },
+    ]);
+    if (!confirm.confirm) {
+        console.log(chalk.gray('Cancelled.'));
+        return;
+    }
+    if (removeContextCredentials(contextName)) {
+        console.log(chalk.green(`Credentials removed for context: ${contextName}`));
+    }
+    else {
+        console.log(chalk.gray(`No credentials found for context: ${contextName}`));
+    }
+}

package/esm/commands/codegen.js

@@ -18,6 +18,8 @@ Generator Options:
   --orm                      Generate ORM client
   --output <dir>             Output directory (default: codegen)
   --authorization <token>    Authorization header value
+  --browserCompatible        Generate browser-compatible code (default: true)
+                             Set to false for Node.js with localhost DNS fix
   --dryRun                   Preview without writing files
   --verbose                  Verbose output
 
@@ -51,6 +53,7 @@ export default async (argv, prompter, _options) => {
         authorization: answers.authorization,
         reactQuery: answers.reactQuery,
         orm: answers.orm,
+        browserCompatible: answers.browserCompatible,
         dryRun: answers.dryRun,
         verbose: answers.verbose,
     });