@reshapr/reshapr-cli 0.0.1

package/dist/commands/secret.js

@@ -0,0 +1,280 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import fs from 'node:fs';
+import { program } from "commander";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { openUpdateEditor } from "../utils/editor.js";
+import { Context } from '../utils/context.js';
+import { CLI_LABEL } from '../constants.js';
+export const secretCommand = program.command('secret')
+    .description(`Manage secrets in ${CLI_LABEL}`);
+/* List all secrets */
+secretCommand.command('list')
+    .description('List all secrets')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async () => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/secrets/refs`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching secrets failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Error parsing secrets response: ' + err.message);
+    });
+    if (data != null) {
+        if (data.length === 0) {
+            Logger.info('No secrets found.');
+        }
+        else {
+            Context.put('secrets', data);
+            const longestName = longestSecretName(data) + 1; // +1 for padding
+            Logger.log(`${'ID'.padEnd(13, ' ')}  ${'NAME'.padEnd(longestName, ' ')} TYPE      DESCRIPTION`);
+            data.forEach((secret) => {
+                Logger.log(`${secret.id}  ${secret.name.padEnd(longestName, ' ')} ${secret.type}  ${secret.description || ''}`);
+            });
+        }
+    }
+});
+function longestSecretName(secrets) {
+    return secrets.reduce((max, secret) => {
+        return Math.max(max, secret.name.length);
+    }, 0);
+}
+/* Get secret by ID */
+secretCommand.command('get <id>')
+    .description('Get details of a secret by ID')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (id) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/secrets/${id}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching secret failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json();
+    Context.put('secret', data);
+    Logger.info('Secret details');
+    Logger.log(`ID          : ${data.id}`);
+    Logger.log(`Name        : ${data.name}`);
+    Logger.log(`Organization: ${data.organizationId}`);
+    Logger.log(`Type        : ${data.type}`);
+    if (data.username) {
+        Logger.log(`Username    : ${data.username}`);
+    }
+    if (data.password) {
+        Logger.log(`Password    : ${data.password}`);
+    }
+    if (data.token) {
+        Logger.log(`Token       : ${data.token}`);
+    }
+    if (!data.useElicitation && data.tokenHeader) {
+        Logger.log(`Token Header: ${data.tokenHeader}`);
+    }
+    if (data.certPem) {
+        Logger.log(`Certificate :`);
+        Logger.log(data.certPem);
+    }
+    Logger.log(`Description : ${data.description || ''}`);
+    if (data.useElicitation) {
+        if (data.tokenHeader) {
+            Logger.bold(`3rd Party Token:`);
+            Logger.log(`  Sensitive Header: ${data.tokenHeader}`);
+        }
+        if (data.thirdPartyOauth2Configuration) {
+            Logger.bold(`3rd Party OAuth2:`);
+            Logger.log(`  OAuth2 Client ID             : ${data.oauth2ClientConfiguration.clientId}`);
+            Logger.log(`  OAuth2 Authorization Endpoint: ${data.oauth2ClientConfiguration.authorizationEndpoint}`);
+            Logger.log(`  OAuth2 Token Endpoint        : ${data.oauth2ClientConfiguration.tokenEndpoint}`);
+        }
+    }
+});
+/* Create a secret with name */
+secretCommand.command('create <name>')
+    .description('Create a new secret')
+    .option('-A, --artifact', 'Secret of ARTIFACT type')
+    .option('-B, --backend', 'Secret of BACKEND type')
+    .option('-d, --description <description>', 'Description for the secret')
+    .option('-u, --username <username>', 'Username for the secret (if applicable)')
+    .option('-p, --password <password>', 'Password for the secret (if applicable)')
+    .option('-t, --token <token>', 'Token for the secret (if applicable)')
+    .option('-h, --tokenHeader <tokenHeader>', 'Token Header for the secret (if not Authorization Bearer)')
+    .option('-c, --certificate <path>', 'Path to the certificate file in PEM format (if applicable)')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (name, options) => {
+    // Initialize the secret object.
+    let secret = {
+        name: name,
+        description: options.description || '',
+    };
+    // Populate the secret object based on the options provided.
+    if (options.artifact) {
+        secret.type = 'ARTIFACT';
+    }
+    else if (options.backend) {
+        secret.type = 'ENDPOINT';
+    }
+    if (options.username) {
+        secret.username = options.username;
+    }
+    if (options.password) {
+        secret.password = options.password;
+    }
+    if (options.token) {
+        secret.token = options.token;
+    }
+    if (options.tokenHeader) {
+        secret.tokenHeader = options.tokenHeader;
+    }
+    if (options.certificate) {
+        // Read the certificate file and put it into a string.
+        if (!fs.existsSync(options.certificate)) {
+            Logger.error(`Certificate file not found: ${options.certificate}`);
+            process.exit(1);
+        }
+        secret.certPem = fs.readFileSync(options.certificate, 'utf8');
+    }
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/secrets`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(secret)
+    });
+    if (!response.ok) {
+        Logger.error('Creating secret failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json();
+    Context.put('secret', data);
+    Logger.success(`Secret ${data.name} created successfully with ID: ${data.id}`);
+});
+/* Create an elicitation secret with name */
+secretCommand.command('create-elicitation <name>')
+    .description('Create a new Elicitation secret')
+    .option('-d, --description <description>', 'Description for the Elicitationsecret')
+    .option('-t, --token <token>', 'Token for the Elicitation secret (if sensitive data access is needed)')
+    .option('--oc, --oauth2ClientID <oauth2ClientID>', 'The ClientID for the backend Authorization service (if OAuth2 is used)')
+    .option('--oae, --oauth2AuthorizationEndpoint <authorizationEndpoint>', 'Authorization Endpoint for the backend authentication (including query parameters without clientID and redirect_uri)')
+    .option('--ote, --oauth2TokenEndpoint <tokenEndpoint>', 'Token exchange Endpoint for backend authentication (if OAuth2 is used)')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (name, options) => {
+    // Initialize the secret object.
+    let secret = {
+        name: name,
+        description: options.description || '',
+        type: 'ENDPOINT',
+        useElicitation: true,
+    };
+    if (options.token) {
+        secret.tokenHeader = options.token;
+    }
+    else {
+        // OAuth2 based elicitation.
+        if (!options.oauth2ClientID || !options.oauth2AuthorizationEndpoint || !options.oauth2TokenEndpoint) {
+            Logger.error('OAuth2 based elicitation requires oauth2ClientID, oauth2AuthorizationEndpoint and oauth2TokenEndpoint to be provided.');
+            process.exit(1);
+        }
+        secret.oauth2ClientConfiguration = {
+            clientId: options.oauth2ClientID,
+            authorizationEndpoint: options.oauth2AuthorizationEndpoint,
+            tokenEndpoint: options.oauth2TokenEndpoint
+        };
+    }
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/secrets`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(secret)
+    });
+    if (!response.ok) {
+        Logger.error('Creating secret failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json();
+    Context.put('secret', data);
+    Logger.success(`Elicitation secret ${data.name} created successfully with ID: ${data.id}`);
+});
+/** Update secret by ID */
+secretCommand.command('update <id>')
+    .description('Update a secret by ID')
+    .action(async (id) => {
+    try {
+        // First, fetch the current secret
+        const response = await fetch(`${ConfigUtil.config.server}/api/v1/secrets/${id}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${ConfigUtil.config.token}`
+            }
+        });
+        if (!response.ok) {
+            Logger.error('Fetching secret failed: ' + response.statusText);
+            process.exit(1);
+        }
+        const secret = await response.json();
+        Logger.info(`Opening editor for secret: ${secret.name}`);
+        await openUpdateEditor(secret, async (modifiedSecret) => {
+            // Enforce properties that are immutable.
+            modifiedSecret.id = secret.id; // Ensure the ID remains the same.
+            modifiedSecret.organizationId = secret.organizationId; // Ensure the organization ID remains the same.
+            const updateResponse = await fetch(`${ConfigUtil.config.server}/api/v1/secrets/${id}`, {
+                method: 'PUT',
+                headers: {
+                    'Authorization': `Bearer ${ConfigUtil.config.token}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(modifiedSecret)
+            });
+            if (!updateResponse.ok) {
+                Logger.error('Updating secret failed: ' + updateResponse.statusText);
+                process.exit(1);
+            }
+            Logger.success(`Secret updated successfully: ${id}`);
+        });
+    }
+    catch (error) {
+        Logger.error('Updating secret failed: ' + error.message);
+        process.exit(1);
+    }
+});
+/** Delete secret by ID */
+secretCommand.command('delete <id>')
+    .description('Delete a secret by ID')
+    .action(async (id) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/secrets/${id}`, {
+        method: 'DELETE',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Deleting secret failed: ' + response.statusText);
+        process.exit(1);
+    }
+    Logger.success(`Secret deleted successfully: ${id}`);
+});

package/dist/commands/service.js

@@ -0,0 +1,145 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import inquirer from "inquirer";
+import { program } from "commander";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { ageFrom } from "../utils/age.js";
+import { Context } from "../utils/context.js";
+import { CLI_LABEL } from '../constants.js';
+export const serviceCommand = program.command('service')
+    .description(`Manage services in ${CLI_LABEL}`);
+/* List all secrets */
+serviceCommand.command('list')
+    .description('List all services')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async () => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/services`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching services failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Failed to parse response: ' + err.message);
+        process.exit(1);
+    });
+    if (data.length === 0) {
+        Logger.info('No services found.');
+    }
+    else {
+        Context.put('services', data);
+        const longestName = longestServiceName(data) + 1; // +1 for padding
+        const longestVersion = longestServiceVersion(data) + 1; // +1 for padding
+        const longestType = longestServiceType(data) + 1; // +1 for padding
+        Logger.log(`${'ID'.padEnd(13, ' ')}  ${'NAME'.padEnd(longestName, ' ')} ${'VERSION'.padEnd(Math.max(longestVersion, 7), ' ')}  ${'TYPE'.padEnd(longestType, ' ')} AGE`);
+        data.forEach((service) => {
+            Logger.log(`${service.id}  ${service.name.padEnd(longestName, ' ')} ${service.version.padEnd(Math.max(longestVersion, 7), ' ')}  ${service.type.padEnd(longestType, ' ')} ${ageFrom(service.createdOn)}`);
+        });
+    }
+});
+function longestServiceName(services) {
+    return services.reduce((max, service) => {
+        return Math.max(max, service.name.length);
+    }, 0);
+}
+function longestServiceVersion(services) {
+    return services.reduce((max, service) => {
+        return Math.max(max, service.version.length);
+    }, 0);
+}
+function longestServiceType(services) {
+    return services.reduce((max, service) => {
+        return Math.max(max, service.type.length);
+    }, 0);
+}
+/** Get service by ID */
+serviceCommand.command('get <id>')
+    .description('Get service by ID')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (id) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/services/${id}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching service failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Error parsing service response: ' + err.message);
+    });
+    if (data != null) {
+        Context.put('service', data);
+        Logger.info('Service details');
+        Logger.log(`ID          : ${data.id}`);
+        Logger.log(`Name        : ${data.name}`);
+        Logger.log(`Version     : ${data.version}`);
+        Logger.log(`Organization: ${data.organizationId}`);
+        Logger.log(`Type        : ${data.type}`);
+        Logger.log(`Created     : ${data.createdOn}`);
+        Logger.bold('Operations :');
+        if (data.operations && data.operations.length > 0) {
+            data.operations.forEach((op) => {
+                Logger.log(`  - Name: ${op.name}`);
+                if (op.inputName) {
+                    Logger.log(`    Input: ${op.inputName}`);
+                }
+                if (op.outputName) {
+                    Logger.log(`    Output ${op.outputName}`);
+                }
+            });
+        }
+        else {
+            Logger.log('  No operations defined for this service.');
+        }
+    }
+});
+/** Delete service by ID */
+serviceCommand.command('delete <id>')
+    .description('Delete service by ID')
+    .option('-f, --force', 'Skip confirmation prompt')
+    .action(async (id, options) => {
+    if (!options.force) {
+        const confirm = await inquirer.prompt({
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Deleting this service will also remove associated artifacts, config plans & expositions. Are you sure you want to proceed?',
+            default: false
+        });
+        if (!confirm.confirm) {
+            Logger.info('Deletion cancelled.');
+            return;
+        }
+    }
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/services/${id}`, {
+        method: 'DELETE',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Deleting service failed: ' + response.statusText);
+        process.exit(1);
+    }
+    Logger.success(`Service ${id} deleted successfully.`);
+});

package/dist/constants.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export const CLI_NAME = "reshapr";
+export const CLI_LABEL = "Reshapr";

package/dist/utils/age.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function ageFrom(value) {
+    const d = new Date(value);
+    const now = new Date();
+    const seconds = Math.round(Math.abs((now.getTime() - d.getTime()) / 1000));
+    const minutes = Math.round(Math.abs(seconds / 60));
+    const hours = Math.round(Math.abs(minutes / 60));
+    const days = Math.round(Math.abs(hours / 24));
+    const months = Math.round(Math.abs(days / 30.416));
+    const years = Math.round(Math.abs(days / 365));
+    if (Number.isNaN(seconds)) {
+        return '';
+    }
+    else if (seconds <= 90) {
+        return `${seconds}s`;
+    }
+    else if (minutes <= 90) {
+        return `${minutes}m`;
+    }
+    else if (hours <= 23) {
+        return `${hours}h`;
+    }
+    else if (days <= 29) {
+        return `${days}d`;
+    }
+    else if (days <= 45) {
+        return `${months}m`;
+    }
+    else if (days <= 545) {
+        return '1y';
+    }
+    else { // (days > 545)
+        return `${years}y`;
+    }
+}

package/dist/utils/config.js

@@ -0,0 +1,80 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+import { Logger } from './logger.js';
+import { CLI_NAME } from '../constants.js';
+export class ConfigUtil {
+    static configPath = `${os.homedir()}/.${CLI_NAME}/config`;
+    static config;
+    static writeConfig(config) {
+        if (!fs.existsSync(ConfigUtil.configPath)) {
+            try {
+                fs.mkdirSync(`${os.homedir()}/.${CLI_NAME}`, { recursive: true });
+            }
+            catch (err) {
+                Logger.error('Failed to create config directory: ' + err);
+                process.exit(1);
+            }
+        }
+        // Extract expiration time and org claim from the token if it exists.
+        if (config.token) {
+            try {
+                const tokenParts = config.token.split('.');
+                if (tokenParts.length === 3) {
+                    const payload = JSON.parse(Buffer.from(tokenParts[1], 'base64').toString('utf-8'));
+                    if (payload.exp) {
+                        config.exp = payload.exp.toString();
+                    }
+                    if (payload.org) {
+                        config.org = payload.org;
+                    }
+                }
+            }
+            catch (err) {
+                Logger.error('Failed to parse token: ' + err);
+            }
+        }
+        fs.writeFileSync(ConfigUtil.configPath, JSON.stringify(config, null, 2));
+        Logger.success(`Configuration saved to ${ConfigUtil.configPath}`);
+        ConfigUtil.config = config;
+    }
+    static readConfig() {
+        if (fs.existsSync(ConfigUtil.configPath)) {
+            try {
+                let configData = fs.readFileSync(ConfigUtil.configPath, 'utf-8');
+                ConfigUtil.config = JSON.parse(configData);
+            }
+            catch (err) {
+                Logger.error('Failed to read config file: ' + err);
+            }
+        }
+    }
+    static deleteConfig() {
+        if (fs.existsSync(ConfigUtil.configPath)) {
+            try {
+                fs.unlinkSync(ConfigUtil.configPath);
+                Logger.success('Configuration deleted successfully.');
+            }
+            catch (err) {
+                Logger.error('Failed to delete config file: ' + err);
+            }
+        }
+        else {
+            Logger.warn('No configuration file found to delete.');
+        }
+    }
+}

package/dist/utils/context.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export class Context {
+    static currentContext = {};
+    static put(key, value) {
+        Context.currentContext[key] = value;
+    }
+    static isEmpty() {
+        return Context.size() === 0;
+    }
+    static size() {
+        return Object.keys(Context.currentContext).length;
+    }
+    static get(key) {
+        return Context.currentContext[key];
+    }
+    static getAll() {
+        return Context.currentContext;
+    }
+    static clear() {
+        Context.currentContext = {};
+    }
+}

package/dist/utils/editor.js

@@ -0,0 +1,70 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as os from 'os';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import { Logger } from "../utils/logger.js";
+import { CLI_NAME } from '../constants.js';
+/** Open a text editor to change initialContent. Execute onChanged() if updated. */
+export async function openUpdateEditor(initialContent, onChanged) {
+    // Create a temporary file with the current configuration
+    const tempDir = os.tmpdir();
+    const tempFile = path.join(tempDir, `${CLI_NAME}-update.json`);
+    const initialData = JSON.stringify(initialContent, null, 2);
+    await fs.writeFile(tempFile, initialData, 'utf8');
+    // Get the initial modification time
+    const statsBefore = await fs.stat(tempFile);
+    const mtimeBefore = statsBefore.mtime.getTime();
+    // Open vi editor with the temporary file
+    const editorProcess = spawn('vi', [tempFile], {
+        stdio: 'inherit', // This allows vi to take control of the terminal
+        shell: false
+    });
+    // Wait for the editor to close
+    await new Promise((resolve, reject) => {
+        editorProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Editor exited with code ${code}`));
+            }
+        });
+        editorProcess.on('error', (error) => {
+            reject(error);
+        });
+    });
+    // Check if the file was modified.
+    const statsAfter = await fs.stat(tempFile);
+    const mtimeAfter = statsAfter.mtime.getTime();
+    if (mtimeAfter !== mtimeBefore) {
+        let modifiedContent;
+        try {
+            modifiedContent = JSON.parse(await fs.readFile(tempFile, 'utf8'));
+        }
+        catch (error) {
+            Logger.error('Error reading modified content: ' + error.message);
+        }
+        // Notify the caller of the changes.
+        await onChanged(modifiedContent);
+    }
+    else {
+        Logger.info('No changes detected. Object not modified.');
+    }
+    // Clean up the temporary file
+    await fs.unlink(tempFile);
+}