@constructive-io/cli 6.0.5 → 6.1.1

package/esm/commands/context.js

@@ -0,0 +1,228 @@
+/**
+ * Context management commands for the CNC execution engine
+ * Similar to kubectl contexts - manages named endpoint + credential configurations
+ */
+import { extractFirst } from 'inquirerer';
+import chalk from 'yanse';
+import { createContext, listContexts, loadContext, deleteContext, getCurrentContext, setCurrentContext, loadSettings, saveSettings, getContextCredentials, hasValidCredentials, } from '../config';
+const usage = `
+Constructive Context Management:
+
+  cnc context <command> [OPTIONS]
+
+Commands:
+  create <name>         Create a new context
+  list                  List all contexts
+  use <name>            Set the active context
+  current               Show current context
+  delete <name>         Delete a context
+
+Create Options:
+  --endpoint <url>      GraphQL endpoint URL
+
+Examples:
+  cnc context create my-api --endpoint https://api.example.com/graphql
+  cnc context list
+  cnc context use my-api
+  cnc context current
+  cnc context delete 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: ['create', 'list', 'use', 'current', 'delete'],
+            },
+        ]);
+        return handleSubcommand(answer.subcommand, newArgv, prompter);
+    }
+    return handleSubcommand(subcommand, newArgv, prompter);
+};
+async function handleSubcommand(subcommand, argv, prompter) {
+    switch (subcommand) {
+        case 'create':
+            return handleCreate(argv, prompter);
+        case 'list':
+            return handleList();
+        case 'use':
+            return handleUse(argv, prompter);
+        case 'current':
+            return handleCurrent();
+        case 'delete':
+            return handleDelete(argv, prompter);
+        default:
+            console.log(usage);
+            console.error(chalk.red(`Unknown subcommand: ${subcommand}`));
+            process.exit(1);
+    }
+}
+async function handleCreate(argv, prompter) {
+    const { first: name, newArgv } = extractFirst(argv);
+    const settings = loadSettings();
+    const answers = await prompter.prompt({ name, ...newArgv }, [
+        {
+            type: 'text',
+            name: 'name',
+            message: 'Context name',
+            required: true,
+        },
+        {
+            type: 'text',
+            name: 'endpoint',
+            message: 'GraphQL endpoint URL',
+            required: true,
+        },
+    ]);
+    const answersRecord = answers;
+    const contextName = answersRecord.name;
+    const endpoint = answersRecord.endpoint;
+    const existing = loadContext(contextName);
+    if (existing) {
+        console.error(chalk.red(`Context "${contextName}" already exists.`));
+        console.log(chalk.gray(`Use "cnc context delete ${contextName}" to remove it first.`));
+        process.exit(1);
+    }
+    const context = createContext(contextName, endpoint);
+    if (!settings.currentContext) {
+        setCurrentContext(contextName);
+        console.log(chalk.green(`Created and activated context: ${contextName}`));
+    }
+    else {
+        console.log(chalk.green(`Created context: ${contextName}`));
+    }
+    console.log();
+    console.log(`  Endpoint: ${context.endpoint}`);
+    console.log();
+    console.log(chalk.gray(`Next: Run "cnc auth set-token <token>" to configure authentication.`));
+}
+function handleList() {
+    const contexts = listContexts();
+    const settings = loadSettings();
+    if (contexts.length === 0) {
+        console.log(chalk.gray('No contexts configured.'));
+        console.log(chalk.gray('Run "cnc context create <name>" to create one.'));
+        return;
+    }
+    console.log(chalk.bold('Contexts:'));
+    console.log();
+    for (const context of contexts) {
+        const isCurrent = context.name === settings.currentContext;
+        const hasAuth = hasValidCredentials(context.name);
+        const marker = isCurrent ? chalk.green('*') : ' ';
+        const authStatus = hasAuth ? chalk.green('[authenticated]') : chalk.yellow('[no token]');
+        console.log(`${marker} ${chalk.bold(context.name)} ${authStatus}`);
+        console.log(`    Endpoint: ${context.endpoint}`);
+        console.log();
+    }
+}
+async function handleUse(argv, prompter) {
+    const { first: name } = extractFirst(argv);
+    const contexts = listContexts();
+    if (contexts.length === 0) {
+        console.log(chalk.gray('No contexts configured.'));
+        console.log(chalk.gray('Run "cnc context create <name>" to create one.'));
+        return;
+    }
+    let contextName = name;
+    if (!contextName) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'name',
+                message: 'Select context',
+                options: contexts.map(c => c.name),
+            },
+        ]);
+        contextName = answer.name;
+    }
+    if (setCurrentContext(contextName)) {
+        console.log(chalk.green(`Switched to context: ${contextName}`));
+    }
+    else {
+        console.error(chalk.red(`Context "${contextName}" not found.`));
+        process.exit(1);
+    }
+}
+function handleCurrent() {
+    const current = getCurrentContext();
+    if (!current) {
+        console.log(chalk.gray('No current context set.'));
+        console.log(chalk.gray('Run "cnc context use <name>" to set one.'));
+        return;
+    }
+    const creds = getContextCredentials(current.name);
+    const hasAuth = hasValidCredentials(current.name);
+    console.log();
+    console.log(chalk.bold(`Current context: ${current.name}`));
+    console.log();
+    console.log(`  Endpoint:   ${current.endpoint}`);
+    console.log(`  Created:    ${current.createdAt}`);
+    console.log(`  Updated:    ${current.updatedAt}`);
+    console.log();
+    console.log(chalk.bold('Authentication:'));
+    if (hasAuth) {
+        console.log(`  Status: ${chalk.green('Authenticated')}`);
+        if (creds?.expiresAt) {
+            console.log(`  Expires: ${creds.expiresAt}`);
+        }
+    }
+    else {
+        console.log(`  Status: ${chalk.yellow('Not authenticated')}`);
+        console.log(chalk.gray(`  Run "cnc auth set-token <token>" to configure.`));
+    }
+    console.log();
+}
+async function handleDelete(argv, prompter) {
+    const { first: name } = extractFirst(argv);
+    const contexts = listContexts();
+    if (contexts.length === 0) {
+        console.log(chalk.gray('No contexts configured.'));
+        return;
+    }
+    let contextName = name;
+    if (!contextName) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'name',
+                message: 'Select context to delete',
+                options: contexts.map(c => c.name),
+            },
+        ]);
+        contextName = answer.name;
+    }
+    const confirm = await prompter.prompt(argv, [
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to delete context "${contextName}"?`,
+            default: false,
+        },
+    ]);
+    if (!confirm.confirm) {
+        console.log(chalk.gray('Cancelled.'));
+        return;
+    }
+    if (deleteContext(contextName)) {
+        const settings = loadSettings();
+        if (settings.currentContext === contextName) {
+            settings.currentContext = undefined;
+            saveSettings(settings);
+        }
+        console.log(chalk.green(`Deleted context: ${contextName}`));
+    }
+    else {
+        console.error(chalk.red(`Context "${contextName}" not found.`));
+        process.exit(1);
+    }
+}

package/esm/commands/execute.js

@@ -0,0 +1,98 @@
+/**
+ * Execute command for running GraphQL queries
+ */
+import * as fs from 'fs';
+import chalk from 'yanse';
+import { execute, getExecutionContext } from '../sdk';
+const usage = `
+Constructive Execute - Run GraphQL Queries:
+
+  cnc execute [OPTIONS]
+
+Options:
+  --query <graphql>     GraphQL query/mutation string
+  --file <path>         Path to file containing GraphQL query
+  --variables <json>    Variables as JSON string
+  --context <name>      Context to use (defaults to current)
+
+Examples:
+  # Execute inline query
+  cnc execute --query 'query { databases { nodes { id name } } }'
+
+  # Execute from file
+  cnc execute --file query.graphql
+
+  # With variables
+  cnc execute --query 'query($id: UUID!) { database(id: $id) { name } }' --variables '{"id":"..."}'
+
+  --help, -h            Show this help message
+`;
+export default async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(usage);
+        process.exit(0);
+    }
+    let query;
+    let variables;
+    if (argv.file) {
+        const filePath = argv.file;
+        if (!fs.existsSync(filePath)) {
+            console.error(chalk.red(`File not found: ${filePath}`));
+            process.exit(1);
+        }
+        query = fs.readFileSync(filePath, 'utf8');
+    }
+    else if (argv.query) {
+        query = argv.query;
+    }
+    else {
+        const answers = await prompter.prompt(argv, [
+            {
+                type: 'text',
+                name: 'query',
+                message: 'GraphQL query',
+                required: true,
+            },
+        ]);
+        query = answers.query;
+    }
+    if (argv.variables) {
+        try {
+            variables = JSON.parse(argv.variables);
+        }
+        catch {
+            console.error(chalk.red('Invalid JSON in --variables'));
+            process.exit(1);
+        }
+    }
+    let execContext;
+    try {
+        execContext = await getExecutionContext(argv.context);
+    }
+    catch (error) {
+        console.error(chalk.red(error instanceof Error ? error.message : 'Failed to get execution context'));
+        process.exit(1);
+    }
+    console.log(chalk.gray(`Context: ${execContext.context.name}`));
+    console.log(chalk.gray(`Endpoint: ${execContext.context.endpoint}`));
+    console.log();
+    const result = await execute(query, variables, execContext);
+    if (result.ok) {
+        console.log(chalk.green('Success!'));
+        console.log();
+        console.log(JSON.stringify(result.data, null, 2));
+    }
+    else {
+        console.error(chalk.red('Failed!'));
+        console.log();
+        if (result.errors) {
+            for (const error of result.errors) {
+                console.error(chalk.red(`  - ${error.message}`));
+                if (error.path) {
+                    console.error(chalk.gray(`    Path: ${error.path.join('.')}`));
+                }
+            }
+        }
+        process.exit(1);
+    }
+};

package/esm/commands.js

@@ -1,6 +1,9 @@
 import { checkForUpdates } from '@inquirerer/utils';
 import { cliExitWithError, extractFirst, getPackageJson } from 'inquirerer';
+import auth from './commands/auth';
 import codegen from './commands/codegen';
+import context from './commands/context';
+import execute from './commands/execute';
 import explorer from './commands/explorer';
 import getGraphqlSchema from './commands/get-graphql-schema';
 import jobs from './commands/jobs';
@@ -13,6 +16,9 @@ const createCommandMap = () => {
         'get-graphql-schema': getGraphqlSchema,
         codegen,
         jobs,
+        context,
+        auth,
+        execute,
     };
 };
 export const commands = async (argv, prompter, options) => {

package/esm/config/config-manager.js

@@ -0,0 +1,229 @@
+/**
+ * Configuration manager for the CNC execution engine
+ * Uses appstash for directory resolution
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { appstash, resolve } from 'appstash';
+import { DEFAULT_SETTINGS } from './types';
+const TOOL_NAME = 'cnc';
+/**
+ * Get the appstash directories for cnc
+ */
+export function getAppDirs() {
+    return appstash(TOOL_NAME, { ensure: true });
+}
+/**
+ * Get path to a config file
+ */
+function getConfigPath(filename) {
+    const dirs = getAppDirs();
+    return resolve(dirs, 'config', filename);
+}
+/**
+ * Get path to a context config file
+ */
+function getContextConfigPath(contextName) {
+    const dirs = getAppDirs();
+    const contextsDir = resolve(dirs, 'config', 'contexts');
+    if (!fs.existsSync(contextsDir)) {
+        fs.mkdirSync(contextsDir, { recursive: true });
+    }
+    return path.join(contextsDir, `${contextName}.json`);
+}
+/**
+ * Load global settings
+ */
+export function loadSettings() {
+    const settingsPath = getConfigPath('settings.json');
+    if (fs.existsSync(settingsPath)) {
+        try {
+            const content = fs.readFileSync(settingsPath, 'utf8');
+            return { ...DEFAULT_SETTINGS, ...JSON.parse(content) };
+        }
+        catch {
+            return DEFAULT_SETTINGS;
+        }
+    }
+    return DEFAULT_SETTINGS;
+}
+/**
+ * Save global settings
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export function saveContext(context) {
+    const contextPath = getContextConfigPath(context.name);
+    fs.writeFileSync(contextPath, JSON.stringify(context, null, 2));
+}
+/**
+ * Delete a context configuration
+ */
+export function deleteContext(contextName) {
+    const contextPath = getContextConfigPath(contextName);
+    if (fs.existsSync(contextPath)) {
+        fs.unlinkSync(contextPath);
+        return true;
+    }
+    return false;
+}
+/**
+ * List all context configurations
+ */
+export function listContexts() {
+    const dirs = getAppDirs();
+    const contextsDir = 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
+ */
+export function getCurrentContext() {
+    const settings = loadSettings();
+    if (settings.currentContext) {
+        return loadContext(settings.currentContext);
+    }
+    return null;
+}
+/**
+ * Set the current active context
+ */
+export 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
+ */
+export 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
+ */
+export function getContextCredentials(contextName) {
+    const credentials = loadCredentials();
+    return credentials.tokens[contextName] || null;
+}
+/**
+ * Set credentials for a context
+ */
+export 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
+ */
+export 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
+ */
+export 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/esm/config/index.js

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

package/esm/config/types.js

@@ -0,0 +1,7 @@
+/**
+ * Configuration types for the CNC execution engine
+ */
+/**
+ * Default global settings
+ */
+export const DEFAULT_SETTINGS = {};

package/esm/sdk/client.js

@@ -0,0 +1,66 @@
+/**
+ * Simple GraphQL client for the CNC execution engine
+ * Uses native fetch - no external dependencies
+ */
+/**
+ * Execute a GraphQL query/mutation against an endpoint
+ */
+export async function executeGraphQL(endpoint, query, variables, headers) {
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                ...headers,
+            },
+            body: JSON.stringify({
+                query,
+                variables: variables ?? {},
+            }),
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                data: null,
+                errors: [
+                    { message: `HTTP ${response.status}: ${response.statusText}` },
+                ],
+            };
+        }
+        const json = (await response.json());
+        if (json.errors && json.errors.length > 0) {
+            return {
+                ok: false,
+                data: json.data ?? null,
+                errors: json.errors,
+            };
+        }
+        return {
+            ok: true,
+            data: json.data,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            data: null,
+            errors: [
+                {
+                    message: error instanceof Error ? error.message : 'Unknown error occurred',
+                },
+            ],
+        };
+    }
+}
+/**
+ * Create a configured client for a specific endpoint
+ */
+export function createClient(config) {
+    return {
+        execute: (query, variables) => {
+            return executeGraphQL(config.endpoint, query, variables, config.headers);
+        },
+        config,
+    };
+}

package/esm/sdk/executor.js

@@ -0,0 +1,44 @@
+/**
+ * Simple GraphQL executor for the CNC execution engine
+ * Executes raw GraphQL queries against configured endpoints
+ */
+import { executeGraphQL } from './client';
+import { getCurrentContext, loadContext, getContextCredentials, hasValidCredentials, } from '../config';
+/**
+ * Get execution context for the current or specified context
+ */
+export async function getExecutionContext(contextName) {
+    let context;
+    if (contextName) {
+        context = loadContext(contextName);
+        if (!context) {
+            throw new Error(`Context "${contextName}" not found.`);
+        }
+    }
+    else {
+        context = getCurrentContext();
+        if (!context) {
+            throw new Error('No active context. Run "cnc context create" or "cnc context use" first.');
+        }
+    }
+    if (!hasValidCredentials(context.name)) {
+        throw new Error(`No valid credentials for context "${context.name}". Run "cnc auth set-token" first.`);
+    }
+    const creds = getContextCredentials(context.name);
+    if (!creds || !creds.token) {
+        throw new Error(`No token found for context "${context.name}". Run "cnc auth set-token" first.`);
+    }
+    return {
+        context,
+        token: creds.token,
+    };
+}
+/**
+ * Execute a raw GraphQL query/mutation
+ */
+export async function execute(query, variables, execContext) {
+    const ctx = execContext || (await getExecutionContext());
+    return executeGraphQL(ctx.context.endpoint, query, variables, {
+        Authorization: `Bearer ${ctx.token}`,
+    });
+}

package/esm/sdk/index.js

@@ -0,0 +1,5 @@
+/**
+ * SDK module exports
+ */
+export * from './client';
+export * from './executor';