ns-gm 1.0.3

package/src/commands/setup.js

@@ -0,0 +1,179 @@
+const fs = require('fs');
+const path = require('path');
+const prompts = require('prompts');
+const { EXIT_CODES, exitWithCode } = require('../utils/exitCodes');
+const {
+    loadStore,
+    listAliases,
+    saveProfile,
+    setActiveAlias,
+    getActiveProfile,
+    STORE_PATH
+} = require('../utils/profileStore');
+
+function onCancel() {
+    console.log('\nSetup cancelled.');
+    process.exit(EXIT_CODES.SUCCESS);
+}
+
+function maskValue(value) {
+    if (!value) return '(not set)';
+    const text = String(value);
+    if (text.length <= 8) return '***';
+    return `${text.slice(0, 4)}***${text.slice(-4)}`;
+}
+
+function validateAlias(alias, existingAliases) {
+    const cleanAlias = alias.trim();
+    if (!cleanAlias) {
+        return 'Alias is required';
+    }
+
+    if (existingAliases.includes(cleanAlias)) {
+        return `Alias "${cleanAlias}" already exists`;
+    }
+
+    return true;
+}
+
+function validatePrivateKeyPath(privateKeyPathInput) {
+    const resolvedPath = path.resolve(privateKeyPathInput.trim());
+    if (!fs.existsSync(resolvedPath)) {
+        return `File does not exist: ${resolvedPath}`;
+    }
+    return true;
+}
+
+async function selectAlias(aliases, activeAlias) {
+    const choices = aliases.map(alias => ({
+        title: alias === activeAlias ? `${alias} (active)` : alias,
+        value: alias
+    }));
+    choices.push({ title: 'new', value: 'new' });
+
+    const response = await prompts({
+        type: 'select',
+        name: 'selectedAlias',
+        message: 'Select a profile alias:',
+        choices,
+        initial: activeAlias && aliases.includes(activeAlias) ? aliases.indexOf(activeAlias) : choices.length - 1
+    }, { onCancel });
+
+    return response.selectedAlias;
+}
+
+async function createNewAlias(existingAliases) {
+    const answers = await prompts([
+        {
+            type: 'text',
+            name: 'alias',
+            message: 'Profile alias:',
+            validate: value => validateAlias(value, existingAliases)
+        },
+        {
+            type: 'text',
+            name: 'accountId',
+            message: 'NetSuite Account ID:',
+            validate: value => value.trim().length > 0 || 'Account ID is required'
+        },
+        {
+            type: 'text',
+            name: 'clientId',
+            message: 'OAuth 2.0 Client ID:',
+            validate: value => value.trim().length > 0 || 'Client ID is required'
+        },
+        {
+            type: 'text',
+            name: 'certificateId',
+            message: 'Certificate ID (kid):',
+            validate: value => value.trim().length > 0 || 'Certificate ID is required'
+        },
+        {
+            type: 'text',
+            name: 'privateKeyPath',
+            message: 'Private key path (.pem):',
+            validate: validatePrivateKeyPath
+        },
+        {
+            type: 'text',
+            name: 'restletUrl',
+            message: 'RESTlet URL:',
+            validate: value => /^https:\/\/.+\/app\/site\/hosting\/restlet\.nl\?.+/.test(value.trim()) || 'Invalid RESTlet URL'
+        },
+        {
+            type: 'text',
+            name: 'scope',
+            message: 'OAuth scope:',
+            initial: 'restlets',
+            validate: value => value.trim().length > 0 || 'Scope is required'
+        }
+    ], { onCancel });
+
+    const alias = answers.alias.trim();
+    const profile = {
+        accountId: answers.accountId.trim(),
+        clientId: answers.clientId.trim(),
+        certificateId: answers.certificateId.trim(),
+        privateKeyPath: path.resolve(answers.privateKeyPath.trim()),
+        restletUrl: answers.restletUrl.trim(),
+        scope: answers.scope.trim()
+    };
+
+    saveProfile(alias, profile);
+    setActiveAlias(alias);
+
+    console.log(`\nSaved profile "${alias}" and set it as active.`);
+    console.log(`Credentials store: ${STORE_PATH}`);
+}
+
+async function showConfig() {
+    const store = loadStore();
+    const activeProfile = getActiveProfile();
+
+    if (!activeProfile) {
+        console.log('No active profile configured. Run: ns-gm setup');
+        return;
+    }
+
+    console.log('\nCurrent ns-gm profile configuration:\n');
+    console.log(`Credentials store: ${STORE_PATH}`);
+    console.log(`Active alias:      ${store.activeAlias}`);
+    console.log(`Account ID:        ${activeProfile.accountId}`);
+    console.log(`Client ID:         ${maskValue(activeProfile.clientId)}`);
+    console.log(`Certificate ID:    ${maskValue(activeProfile.certificateId)}`);
+    console.log(`Private Key Path:  ${activeProfile.privateKeyPath}`);
+    console.log(`RESTlet URL:       ${activeProfile.restletUrl}`);
+    console.log(`Scope:             ${activeProfile.scope || 'restlets'}`);
+    console.log('');
+}
+
+async function setupCommand(options) {
+    try {
+        if (options.show) {
+            await showConfig();
+            return;
+        }
+
+        const store = loadStore();
+        const aliases = listAliases();
+        console.log('NetSuite GM - Profile Setup\n');
+
+        const selectedAlias = await selectAlias(aliases, store.activeAlias);
+        if (!selectedAlias) {
+            onCancel();
+            return;
+        }
+
+        if (selectedAlias !== 'new') {
+            setActiveAlias(selectedAlias);
+            console.log(`\nActive alias set to "${selectedAlias}".`);
+            return;
+        }
+
+        await createNewAlias(aliases);
+    } catch (error) {
+        exitWithCode(EXIT_CODES.GENERAL_ERROR, `Setup error: ${error.message}`);
+    }
+}
+
+module.exports = setupCommand;

package/src/commands/stop.js

@@ -0,0 +1,98 @@
+const axios = require('axios');
+const { exec } = require('child_process');
+const { EXIT_CODES, exitWithCode } = require('../utils/exitCodes');
+const config = require('../utils/config');
+
+const PORT = config.proxyPort;
+const PROXY_URL = `http://localhost:${PORT}`;
+
+/**
+ * Check if proxy server is running
+ */
+async function checkProxyHealth() {
+    try {
+        const response = await axios.get(`${PROXY_URL}/health`, { timeout: 2000 });
+        return response.data.status === 'ok';
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * Find and kill the process using the proxy port
+ */
+function killProcessOnPort(port) {
+    return new Promise((resolve, reject) => {
+        // Use netstat to find the process ID
+        exec(`netstat -ano | findstr :${port}`, (error, stdout, stderr) => {
+            if (error || !stdout) {
+                reject(new Error('No process found on port ' + port));
+                return;
+            }
+
+            // Parse the PID from netstat output
+            const lines = stdout.split('\n');
+            const listening = lines.find(line => line.includes('LISTENING'));
+
+            if (!listening) {
+                reject(new Error('No listening process found on port ' + port));
+                return;
+            }
+
+            // Extract PID (last column)
+            const parts = listening.trim().split(/\s+/);
+            const pid = parts[parts.length - 1];
+
+            if (!pid || pid === '0') {
+                reject(new Error('Could not determine process ID'));
+                return;
+            }
+
+            // Kill the process (use /F /PID without doubling slashes)
+            exec(`taskkill /F /PID ${pid}`, (killError, killStdout, killStderr) => {
+                if (killError) {
+                    reject(new Error(`Failed to kill process ${pid}: ${killError.message}`));
+                    return;
+                }
+                resolve(pid);
+            });
+        });
+    });
+}
+
+/**
+ * Stop the proxy server
+ */
+async function stopCommand() {
+    try {
+        // Check if proxy is running
+        const isRunning = await checkProxyHealth();
+
+        if (!isRunning) {
+            console.log('Proxy server is not running.');
+            return;
+        }
+
+        console.log('Stopping proxy server...');
+
+        // Kill the process
+        const pid = await killProcessOnPort(PORT);
+
+        // Wait a moment for the process to fully stop
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        // Verify it stopped
+        const stillRunning = await checkProxyHealth();
+
+        if (stillRunning) {
+            exitWithCode(EXIT_CODES.GENERAL_ERROR, 'Failed to stop proxy server. It may still be running.');
+        }
+
+        console.log(`✓ Proxy server stopped successfully (PID: ${pid})`);
+
+    } catch (error) {
+        exitWithCode(EXIT_CODES.GENERAL_ERROR, `Error stopping proxy server: ${error.message}`);
+    }
+}
+
+module.exports = stopCommand;

package/src/utils/config.js

@@ -0,0 +1,39 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Load configuration from config.json
+ * @param {boolean} showWarning - Whether to show warning if config not found
+ * @returns {Object} Configuration object
+ */
+function loadConfig(showWarning = false) {
+    try {
+        const configPath = path.join(__dirname, '../../config.json');
+        const configData = fs.readFileSync(configPath, 'utf8');
+        return JSON.parse(configData);
+    } catch (error) {
+        // Return default configuration if file doesn't exist or is invalid
+        if (showWarning) {
+            console.warn('Warning: Could not load config.json, using defaults');
+        }
+        return {
+            proxyPort: 9292,
+            proxyInactivityTimeout: 900000,
+            defaultLogCount: 20
+        };
+    }
+}
+
+/**
+ * Load configuration with warning (for init command)
+ * @returns {Object} Configuration object
+ */
+function loadConfigWithWarning() {
+    return loadConfig(true);
+}
+
+// Load and cache configuration (without warning)
+const config = loadConfig(false);
+
+module.exports = config;
+module.exports.loadConfigWithWarning = loadConfigWithWarning;

package/src/utils/exitCodes.js

@@ -0,0 +1,37 @@
+/**
+ * Semantic exit codes for CLI commands
+ *
+ * These exit codes provide meaningful information about why the CLI failed,
+ * making it easier for scripts and AI agents to handle errors programmatically.
+ */
+
+const EXIT_CODES = {
+    SUCCESS: 0,              // Command completed successfully
+    GENERAL_ERROR: 1,        // General/unknown error
+    CONFIG_ERROR: 2,         // Configuration error (missing profile/config, invalid config)
+    NETWORK_ERROR: 3,        // Network error (proxy unreachable, NetSuite connection failed)
+    VALIDATION_ERROR: 4,     // Validation error (missing required parameters)
+    EXECUTION_ERROR: 5,      // Execution error (code execution failed in NetSuite)
+    AUTH_ERROR: 6           // Authentication error (OAuth failed)
+};
+
+/**
+ * Exit the process with a semantic exit code
+ * @param {number} code - Exit code from EXIT_CODES
+ * @param {string} message - Optional error message to display
+ */
+function exitWithCode(code, message) {
+    if (message) {
+        if (code === EXIT_CODES.SUCCESS) {
+            console.log(message);
+        } else {
+            console.error(message);
+        }
+    }
+    process.exit(code);
+}
+
+module.exports = {
+    EXIT_CODES,
+    exitWithCode
+};

package/src/utils/profileStore.js

@@ -0,0 +1,107 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const STORE_DIR = path.join(os.homedir(), '.ns-gm');
+const STORE_PATH = path.join(STORE_DIR, 'credentials.json');
+const EMPTY_STORE = { activeAlias: null, profiles: {} };
+
+function normalizeStore(store) {
+    if (!store || typeof store !== 'object') {
+        return { ...EMPTY_STORE };
+    }
+
+    const activeAlias = typeof store.activeAlias === 'string' ? store.activeAlias : null;
+    const profiles = store.profiles && typeof store.profiles === 'object' ? store.profiles : {};
+
+    return { activeAlias, profiles };
+}
+
+function loadStore() {
+    try {
+        if (!fs.existsSync(STORE_PATH)) {
+            return { ...EMPTY_STORE };
+        }
+
+        const raw = fs.readFileSync(STORE_PATH, 'utf8');
+        return normalizeStore(JSON.parse(raw));
+    } catch (error) {
+        return { ...EMPTY_STORE };
+    }
+}
+
+function saveStore(store) {
+    const normalized = normalizeStore(store);
+    fs.mkdirSync(STORE_DIR, { recursive: true });
+    fs.writeFileSync(STORE_PATH, JSON.stringify(normalized, null, 2), 'utf8');
+    return normalized;
+}
+
+function listAliases() {
+    const store = loadStore();
+    return Object.keys(store.profiles).sort();
+}
+
+function saveProfile(alias, profile) {
+    const cleanAlias = typeof alias === 'string' ? alias.trim() : '';
+    if (!cleanAlias) {
+        throw new Error('Alias is required');
+    }
+
+    const requiredFields = ['accountId', 'clientId', 'certificateId', 'privateKeyPath', 'restletUrl'];
+    for (const field of requiredFields) {
+        if (!profile[field] || !String(profile[field]).trim()) {
+            throw new Error(`Missing required profile field: ${field}`);
+        }
+    }
+
+    const store = loadStore();
+    store.profiles[cleanAlias] = {
+        accountId: String(profile.accountId).trim(),
+        clientId: String(profile.clientId).trim(),
+        certificateId: String(profile.certificateId).trim(),
+        privateKeyPath: String(profile.privateKeyPath).trim(),
+        restletUrl: String(profile.restletUrl).trim(),
+        scope: profile.scope && String(profile.scope).trim() ? String(profile.scope).trim() : 'restlets'
+    };
+
+    saveStore(store);
+    return store.profiles[cleanAlias];
+}
+
+function setActiveAlias(alias) {
+    const cleanAlias = typeof alias === 'string' ? alias.trim() : '';
+    if (!cleanAlias) {
+        throw new Error('Alias is required');
+    }
+
+    const store = loadStore();
+    if (!store.profiles[cleanAlias]) {
+        throw new Error(`Alias not found: ${cleanAlias}`);
+    }
+
+    store.activeAlias = cleanAlias;
+    saveStore(store);
+}
+
+function getActiveProfile() {
+    const store = loadStore();
+    if (!store.activeAlias || !store.profiles[store.activeAlias]) {
+        return null;
+    }
+
+    return {
+        alias: store.activeAlias,
+        ...store.profiles[store.activeAlias]
+    };
+}
+
+module.exports = {
+    STORE_PATH,
+    loadStore,
+    saveStore,
+    listAliases,
+    saveProfile,
+    setActiveAlias,
+    getActiveProfile
+};