@logto/cli 1.6.0 → 1.7.0

package/LICENSE

@@ -1,9 +1,3 @@
-Portions of this software are licensed as follows:
-
-* All content that resides under the "packages/cloud" directory of this repository, if that directory exists, is licensed under the license defined in "packages/cloud/LICENSE" (Elastic-2.0).
-* All third party components incorporated into this software are licensed under the original license provided by the owner of the applicable component.
-* Content outside of the above mentioned directories or restrictions above is available under the "MPL-2.0" license as defined below.
-
 Mozilla Public License Version 2.0
 ==================================
 

package/lib/commands/connector/utils.js

@@ -109,9 +109,9 @@ export const addConnectorsToPath = async (cwd, packageNames) => {
                 throw new Error(`Unable to execute ${chalk.green('npm pack')} on package ${chalk.green(packageName)}`);
             }
             const { filename, name, version } = result[0];
-            const escapedFilename = filename.replace(/\//g, '-').replace(/@/g, '');
+            const escapedFilename = filename.replaceAll('/', '-').replaceAll('@', '');
             const tarPath = path.join(cwd, escapedFilename);
-            const packageDirectory = path.join(cwd, name.replace(/\//g, '-'));
+            const packageDirectory = path.join(cwd, name.replaceAll('/', '-'));
             await fs.rm(packageDirectory, { force: true, recursive: true });
             await fs.mkdir(packageDirectory, { recursive: true });
             await tar.extract({ cwd: packageDirectory, file: tarPath, strip: 1 });

package/lib/commands/database/alteration/index.js

@@ -13,7 +13,7 @@ const importAlterationScript = async (filePath) => {
 };
 export const getLatestAlterationTimestamp = async () => {
     const files = await getAlterationFiles();
-    const lastFile = files[files.length - 1];
+    const lastFile = files.at(-1);
     if (!lastFile) {
         return 0;
     }

package/lib/commands/database/seed/tables.js

@@ -1,6 +1,6 @@
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { createDefaultAdminConsoleConfig, defaultTenantId, adminTenantId, defaultManagementApi, createAdminDataInAdminTenant, createMeApiInAdminTenant, createDefaultSignInExperience, createAdminTenantSignInExperience, createDefaultAdminConsoleApplication, createCloudApi, createTenantApplicationRole, createTenantMachineToMachineApplication, createAdminTenantApplicationRole, CloudScope, } from '@logto/schemas';
+import { createDefaultAdminConsoleConfig, createCloudConnectionConfig, defaultTenantId, adminTenantId, defaultManagementApi, createAdminDataInAdminTenant, createMeApiInAdminTenant, createDefaultSignInExperience, createAdminTenantSignInExperience, createDefaultAdminConsoleApplication, createCloudApi, createTenantApplicationRole, createTenantMachineToMachineApplication, createAdminTenantApplicationRole, CloudScope, } from '@logto/schemas';
 import { Tenants } from '@logto/schemas/models';
 import { sql } from 'slonik';
 import { raw } from 'slonik-sql-tag-raw';
@@ -96,6 +96,7 @@ export const seedTables = async (connection, latestTimestamp, isCloud) => {
     await assignScopesToRole(connection, adminTenantId, adminAdminData.role.id, ...cloudAdditionalScopes.map(({ id }) => id));
     await Promise.all([
         connection.query(insertInto(createDefaultAdminConsoleConfig(defaultTenantId), 'logto_configs')),
+        connection.query(insertInto(createCloudConnectionConfig(defaultTenantId, defaultTenantApplication.id, defaultTenantApplication.secret), 'logto_configs')),
         connection.query(insertInto(createDefaultSignInExperience(defaultTenantId, isCloud), 'sign_in_experiences')),
         connection.query(insertInto(createDefaultAdminConsoleConfig(adminTenantId), 'logto_configs')),
         connection.query(insertInto(createAdminTenantSignInExperience(), 'sign_in_experiences')),

package/lib/commands/install/utils.js

@@ -61,7 +61,7 @@ export const validateDatabase = async () => {
             const pgOutput = safeExecSync('postgres --version') ?? '';
             // Filter out all brackets in the output since Homebrew will append `(Homebrew)`.
             const pgArray = pgOutput.split(' ').filter((value) => !value.startsWith('('));
-            const pgCurrent = semver.coerce(pgArray[pgArray.length - 1]);
+            const pgCurrent = semver.coerce(pgArray.at(-1));
             return !pgCurrent || pgCurrent.compare(pgRequired) < 0;
         },
     });

package/lib/commands/translate/index.js

@@ -1,6 +1,7 @@
 import { noop } from '@silverhand/essentials';
 import create from './create.js';
 import listTags from './list-tags.js';
+import syncKeys from './sync-keys/index.js';
 import sync from './sync.js';
 const translate = {
     command: ['translate', 't'],
@@ -14,6 +15,7 @@ const translate = {
         .command(create)
         .command(listTags)
         .command(sync)
+        .command(syncKeys)
         .demandCommand(1),
     handler: noop,
 };

package/lib/commands/translate/sync-keys/index.d.ts

@@ -0,0 +1,11 @@
+import { type CommandModule } from 'yargs';
+declare const syncKeys: CommandModule<{
+    path?: string;
+}, {
+    path?: string;
+    baseline: string;
+    target: string;
+    skipLint?: boolean;
+    package: string;
+}>;
+export default syncKeys;

package/lib/commands/translate/sync-keys/index.js

@@ -0,0 +1,84 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { isLanguageTag } from '@logto/language-kit';
+import ora from 'ora';
+import { consoleLog } from '../../../utils.js';
+import { inquireInstancePath } from '../../connector/utils.js';
+import { praseLocaleFiles, syncPhraseKeysAndFileStructure } from './utils.js';
+const execPromise = promisify(execFile);
+const syncKeys = {
+    command: ['sync-keys', 'sk'],
+    describe: [
+        'Sync nested object keys and the file structure from baseline to target.',
+        'If a key is missing in the target, it will be added with a comment to indicate that the phrase is untranslated;',
+        'If a key is missing in the baseline, it will be removed from the target;',
+        'If a key exists in both the baseline and the target, the value of the target will be used.',
+    ].join(' '),
+    builder: (yargs) => yargs
+        .option('baseline', {
+        alias: 'b',
+        type: 'string',
+        describe: 'The baseline language tag',
+        default: 'en',
+    })
+        .option('package', {
+        alias: 'pkg',
+        type: 'string',
+        describe: 'The package name of the phrases, one of `phrases` or `phrases-ui`',
+        default: 'phrases',
+    })
+        .option('target', {
+        alias: 't',
+        type: 'string',
+        describe: 'The target language tag, or `all` to sync all languages',
+    })
+        .option('skip-lint', {
+        alias: 's',
+        type: 'boolean',
+        describe: 'Skip running `eslint --fix` for locales after syncing',
+    })
+        .demandOption(['baseline', 'target']),
+    handler: async ({ path: inputPath, baseline: baselineTag, target: targetTag, skipLint, package: packageName, }) => {
+        if (!isLanguageTag(baselineTag)) {
+            consoleLog.fatal('Invalid baseline language tag');
+        }
+        if (targetTag !== 'all' && !isLanguageTag(targetTag)) {
+            consoleLog.fatal('Invalid target language tag');
+        }
+        if (baselineTag === targetTag) {
+            consoleLog.fatal('Baseline and target cannot be the same');
+        }
+        if (packageName !== 'phrases' && packageName !== 'phrases-ui') {
+            consoleLog.fatal('Invalid package name, expected `phrases` or `phrases-ui`');
+        }
+        const instancePath = await inquireInstancePath(inputPath);
+        const phrasesPath = path.join(instancePath, 'packages', packageName);
+        const localesPath = path.join(phrasesPath, 'src/locales');
+        const entrypoint = path.join(localesPath, baselineTag.toLowerCase(), 'index.ts');
+        const baseline = praseLocaleFiles(entrypoint);
+        const targetLocales = targetTag === 'all' ? fs.readdirSync(localesPath) : [targetTag.toLowerCase()];
+        /* eslint-disable no-await-in-loop */
+        for (const target of targetLocales) {
+            if (target === baselineTag) {
+                continue;
+            }
+            const spinner = ora({
+                text: `Syncing object keys and file structure from ${baselineTag} to ${target}`,
+            }).start();
+            const targetDirectory = path.join(localesPath, target);
+            await syncPhraseKeysAndFileStructure(baseline, target, targetDirectory);
+            spinner.succeed(`Synced object keys and file structure from ${baselineTag} to ${target}`);
+        }
+        /* eslint-enable no-await-in-loop */
+        if (!skipLint) {
+            const spinner = ora({
+                text: 'Running `eslint --fix` for locales',
+            }).start();
+            await execPromise('pnpm', ['eslint', '--ext', '.ts', path.relative(phrasesPath, localesPath), '--fix'], { cwd: phrasesPath });
+            spinner.succeed('Ran `eslint --fix` for locales');
+        }
+    },
+};
+export default syncKeys;

package/lib/commands/translate/sync-keys/utils.d.ts

@@ -0,0 +1,56 @@
+type FileStructure = {
+    [key: string]: {
+        filePath?: string;
+        structure: FileStructure;
+    };
+};
+type NestedPhraseObject = {
+    [key: string]: string | NestedPhraseObject;
+};
+type ParsedTuple = readonly [NestedPhraseObject, FileStructure];
+/**
+ * Given a entrypoint file path of a language, parse the nested object of
+ * phrases and the file structure.
+ *
+ * @example
+ * Given the following file:
+ *
+ * ```ts
+ * import errors from './errors/index.js';
+ *
+ * const translation = {
+ *   page_title: 'Anwendungen',
+ *   errors,
+ * };
+ * ```
+ *
+ * The returned object will be:
+ *
+ * ```ts
+ * {
+ *   page_title: 'Anwendungen',
+ *   errors: {
+ *     page_not_found: 'Seite nicht gefunden',
+ *   },
+ * }
+ * ```
+ *
+ * And the file structure will be:
+ *
+ * ```ts
+ * {
+ *   errors: {
+ *     filePath: './errors/index.js',
+ *     structure: {},
+ *   },
+ * }
+ * ```
+ *
+ * @param filePath The entrypoint file path of a language
+ *
+ * @returns A tuple of the nested object of phrases and the file structure
+ *
+ */
+export declare const praseLocaleFiles: (filePath: string) => ParsedTuple;
+export declare const syncPhraseKeysAndFileStructure: (baseline: ParsedTuple, targetLocale: string, targetDirectory: string) => Promise<void>;
+export {};

package/lib/commands/translate/sync-keys/utils.js

@@ -0,0 +1,249 @@
+import { readFileSync, existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { tryThat } from '@silverhand/essentials';
+import ts from 'typescript';
+import { consoleLog } from '../../../utils.js';
+/**
+ * Given a entrypoint file path of a language, parse the nested object of
+ * phrases and the file structure.
+ *
+ * @example
+ * Given the following file:
+ *
+ * ```ts
+ * import errors from './errors/index.js';
+ *
+ * const translation = {
+ *   page_title: 'Anwendungen',
+ *   errors,
+ * };
+ * ```
+ *
+ * The returned object will be:
+ *
+ * ```ts
+ * {
+ *   page_title: 'Anwendungen',
+ *   errors: {
+ *     page_not_found: 'Seite nicht gefunden',
+ *   },
+ * }
+ * ```
+ *
+ * And the file structure will be:
+ *
+ * ```ts
+ * {
+ *   errors: {
+ *     filePath: './errors/index.js',
+ *     structure: {},
+ *   },
+ * }
+ * ```
+ *
+ * @param filePath The entrypoint file path of a language
+ *
+ * @returns A tuple of the nested object of phrases and the file structure
+ *
+ */
+export const praseLocaleFiles = (filePath) => {
+    const content = readFileSync(filePath, 'utf8');
+    const ast = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const importIdentifierPath = new Map();
+    const traverseNode = (node, nestedObject, fileStructure) => {
+        /**
+         * Handle property assignment in object literal expression:
+         *
+         * - Shorthand property assignments (e.g. `{ errors }`) are treated as import
+         * - Property assignments will be categorized per its initializer:
+         *   - Object literal expressions (e.g. `{ errors: { page_not_found: 'Page not found' } }`)
+         *     will be treated as nested object
+         *   - String literals (e.g. `{ page_title: 'Applications' }`) or no substitution template
+         *     literals (e.g. `{ page_title: `Applications` }`) will be treated as string
+         *   - Others are not supported, and will exit with error
+         */
+        const handleProperty = (property) => {
+            // Treat shorthand property assignment as import
+            if (ts.isShorthandPropertyAssignment(property)) {
+                const key = property.name.getText();
+                const importPath = importIdentifierPath.get(key);
+                if (!importPath) {
+                    consoleLog.fatal(`Cannot find import path for ${key} in ${filePath}`);
+                }
+                const resolvedPath = path.resolve(path.dirname(filePath), importPath);
+                // Recursively parse the nested object from the imported file
+                const [phrases, structure] = praseLocaleFiles(resolvedPath);
+                // eslint-disable-next-line @silverhand/fp/no-mutation
+                nestedObject[key] = phrases;
+                // eslint-disable-next-line @silverhand/fp/no-mutation
+                fileStructure[key] = {
+                    filePath: importPath,
+                    structure,
+                };
+            }
+            if (ts.isPropertyAssignment(property)) {
+                const key = property.name.getText();
+                // Nested object, recursively parse it
+                if (ts.isObjectLiteralExpression(property.initializer)) {
+                    const [phrases, structure] = traverseNode(property.initializer, {}, {});
+                    // eslint-disable-next-line @silverhand/fp/no-mutation
+                    nestedObject[key] = phrases;
+                    // eslint-disable-next-line @silverhand/fp/no-mutation
+                    fileStructure[key] = { structure };
+                }
+                else if (ts.isStringLiteral(property.initializer) ||
+                    ts.isNoSubstitutionTemplateLiteral(property.initializer)) {
+                    const value = property.initializer.getText();
+                    // eslint-disable-next-line @silverhand/fp/no-mutation
+                    nestedObject[key] = value;
+                }
+                else {
+                    consoleLog.fatal('Unsupported property:', property);
+                }
+            }
+        };
+        if (ts.isImportDeclaration(node)) {
+            const importPath = node.moduleSpecifier.getText().slice(1, -1).replace('.js', '.ts');
+            const importIdentifier = node.importClause?.getText();
+            // Assuming only default import is used
+            if (importIdentifier) {
+                importIdentifierPath.set(importIdentifier, importPath);
+            }
+        }
+        else if (ts.isObjectLiteralExpression(node)) {
+            for (const property of node.properties) {
+                handleProperty(property);
+            }
+        }
+        else {
+            node.forEachChild((child) => {
+                traverseNode(child, nestedObject, fileStructure);
+            });
+        }
+        return [nestedObject, fileStructure];
+    };
+    return traverseNode(ast, {}, {});
+};
+const getIdentifier = (filePath) => {
+    const filename = path.basename(filePath, '.ts');
+    return (filename === 'index' ? path.basename(path.dirname(filePath)) : filename).replaceAll('-', '_');
+};
+/** Traverse the file structure and return an array of imports in the current file. */
+const getCurrentFileImports = (fileStructure) => {
+    const imports = new Set();
+    for (const [key, value] of Object.entries(fileStructure)) {
+        // If the key has a file path, treat it as an import and stop traversing
+        // since it's pointing to another file
+        if (value.filePath) {
+            imports.add([key, value.filePath]);
+        }
+        // Otherwise, recursively traverse the nested object
+        else {
+            for (const importEntry of getCurrentFileImports(value.structure)) {
+                imports.add(importEntry);
+            }
+        }
+    }
+    return [...imports];
+};
+/**
+ * Recursively traverse the nested object of phrases and the file structure of
+ * the baseline language, and generate the target language directory with the
+ * same file structure.
+ *
+ * Values of the nested object will be replaced with the values of the target
+ * language if the key exists; otherwise, the value of the baseline language
+ * will be used.
+ *
+ * @param baseline The baseline language tuple
+ * @param targetObject The target language nested object
+ * @param targetFilePath The target language entrypoint file path
+ * @param isRoot Whether the target file is the root entrypoint
+ */
+/* eslint-disable no-await-in-loop */
+const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = false) => {
+    const [, baselineStructure] = baseline;
+    const targetDirectory = path.dirname(targetFilePath);
+    await fs.mkdir(targetDirectory, { recursive: true });
+    await fs.writeFile(targetFilePath, '', { flag: 'w+' });
+    if (isRoot) {
+        await fs.appendFile(targetFilePath, "import type { LocalePhrase } from '../../types.js';\n\n");
+    }
+    // Write imports first
+    const baselineEntries = getCurrentFileImports(baselineStructure);
+    for (const [key, value] of baselineEntries
+        .slice()
+        .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))) {
+        const importPath = path.join(targetDirectory, value);
+        await fs.appendFile(targetFilePath, `import ${key} from './${path
+            .relative(targetDirectory, importPath)
+            .replace('.ts', '.js')}';\n`);
+    }
+    // Add a newline between imports and the object
+    if (baselineEntries.length > 0) {
+        await fs.appendFile(targetFilePath, '\n');
+    }
+    // Write the object
+    const identifier = getIdentifier(targetFilePath);
+    await fs.appendFile(targetFilePath, `const ${identifier} = {\n`);
+    // Recursively traverse the nested object of phrases and the file structure
+    // of the baseline language
+    const traverseObject = async (baseline, targetObject, tabSize) => {
+        const [baselineObject, baselineStructure] = baseline;
+        for (const [key, value] of Object.entries(baselineObject)) {
+            const existingValue = targetObject[key];
+            if (typeof value === 'string') {
+                // If the key exists in the target language and the value is a string, use
+                // the value of the target language; otherwise, use the value of the
+                // baseline language and add a comment to indicate that the phrase is
+                // untranslated to help identify missing translations.
+                await (typeof existingValue === 'string'
+                    ? fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: ${existingValue},\n`)
+                    : fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: ${value}, // UNTRANSLATED\n`));
+            }
+            // Not a string, treat it as a nested object or an import
+            else {
+                const keyStructure = baselineStructure[key];
+                // If the key has a file structure, treat it as an import
+                if (keyStructure?.filePath) {
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key},\n`);
+                    await traverseNode([value, keyStructure.structure], typeof existingValue === 'object' ? existingValue : {}, path.join(targetDirectory, keyStructure.filePath));
+                }
+                // Otherwise, treat it as a nested object.
+                else {
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: {\n`);
+                    await traverseObject([value, keyStructure?.structure ?? {}], typeof existingValue === 'object' ? existingValue : {}, tabSize + 2);
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}},\n`);
+                }
+            }
+        }
+    };
+    await traverseObject(baseline, targetObject, 2);
+    await (isRoot
+        ? fs.appendFile(targetFilePath, '} satisfies LocalePhrase;\n\n')
+        : fs.appendFile(targetFilePath, '};\n\n'));
+    await fs.appendFile(targetFilePath, `export default Object.freeze(${identifier});\n`);
+};
+/* eslint-enable no-await-in-loop */
+export const syncPhraseKeysAndFileStructure = async (baseline, targetLocale, targetDirectory) => {
+    const targetEntrypoint = path.join(targetDirectory, 'index.ts');
+    const isTargetLocaleExist = existsSync(targetEntrypoint);
+    const targetObject = isTargetLocaleExist ? praseLocaleFiles(targetEntrypoint)[0] : {};
+    const backupDirectory = targetDirectory + '.bak';
+    if (isTargetLocaleExist) {
+        await fs.rename(targetDirectory, backupDirectory);
+    }
+    else {
+        consoleLog.warn(`Cannot find ${targetLocale} entrypoint, creating one`);
+    }
+    await tryThat(traverseNode(baseline, targetObject, path.join(targetDirectory, 'index.ts'), true), (error) => {
+        consoleLog.plain();
+        consoleLog.error(error);
+        consoleLog.plain();
+        consoleLog.fatal(`Failed to sync keys for ${targetLocale}, the backup is at ${backupDirectory} for recovery`);
+    });
+    if (isTargetLocaleExist) {
+        await fs.rm(backupDirectory, { recursive: true });
+    }
+};

package/lib/package-json.d.ts

@@ -66,6 +66,7 @@ export declare const packageJson: {
         "slonik-interceptor-preset": string;
         "slonik-sql-tag-raw": string;
         tar: string;
+        typescript: string;
         yargs: string;
         zod: string;
     };
@@ -84,7 +85,6 @@ export declare const packageJson: {
         "lint-staged": string;
         prettier: string;
         sinon: string;
-        typescript: string;
     };
     eslintConfig: {
         extends: string;

package/lib/package-json.js

@@ -1,6 +1,6 @@
 export const packageJson = {
     "name": "@logto/cli",
-    "version": "1.6.0",
+    "version": "1.7.0",
     "description": "Logto CLI.",
     "author": "Silverhand Inc. <contact@silverhand.io>",
     "homepage": "https://github.com/logto-io/logto#readme",
@@ -48,7 +48,7 @@ export const packageJson = {
         "@logto/language-kit": "workspace:^1.0.0",
         "@logto/phrases": "workspace:^1.4.1",
         "@logto/phrases-ui": "workspace:^1.2.0",
-        "@logto/schemas": "workspace:1.6.0",
+        "@logto/schemas": "workspace:1.7.0",
         "@logto/shared": "workspace:^2.0.0",
         "@silverhand/essentials": "^2.5.0",
         "chalk": "^5.0.0",
@@ -69,12 +69,13 @@ export const packageJson = {
         "slonik-interceptor-preset": "^1.2.10",
         "slonik-sql-tag-raw": "^1.1.4",
         "tar": "^6.1.11",
+        "typescript": "^5.0.0",
         "yargs": "^17.6.0",
         "zod": "^3.20.2"
     },
     "devDependencies": {
-        "@silverhand/eslint-config": "3.0.1",
-        "@silverhand/ts-config": "3.0.0",
+        "@silverhand/eslint-config": "4.0.1",
+        "@silverhand/ts-config": "4.0.0",
         "@types/inquirer": "^9.0.0",
         "@types/jest": "^29.4.0",
         "@types/node": "^18.11.18",
@@ -82,12 +83,11 @@ export const packageJson = {
         "@types/sinon": "^10.0.13",
         "@types/tar": "^6.1.2",
         "@types/yargs": "^17.0.13",
-        "eslint": "^8.34.0",
+        "eslint": "^8.44.0",
         "jest": "^29.5.0",
         "lint-staged": "^13.0.0",
-        "prettier": "^2.8.2",
-        "sinon": "^15.0.0",
-        "typescript": "^5.0.0"
+        "prettier": "^3.0.0",
+        "sinon": "^15.0.0"
     },
     "eslintConfig": {
         "extends": "@silverhand",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logto/cli",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Logto CLI.",
   "author": "Silverhand Inc. <contact@silverhand.io>",
   "homepage": "https://github.com/logto-io/logto#readme",
@@ -33,7 +33,7 @@
     "@logto/language-kit": "^1.0.0",
     "@logto/phrases": "^1.4.1",
     "@logto/phrases-ui": "^1.2.0",
-    "@logto/schemas": "1.6.0",
+    "@logto/schemas": "1.7.0",
     "@logto/shared": "^2.0.0",
     "@silverhand/essentials": "^2.5.0",
     "chalk": "^5.0.0",
@@ -54,12 +54,13 @@
     "slonik-interceptor-preset": "^1.2.10",
     "slonik-sql-tag-raw": "^1.1.4",
     "tar": "^6.1.11",
+    "typescript": "^5.0.0",
     "yargs": "^17.6.0",
     "zod": "^3.20.2"
   },
   "devDependencies": {
-    "@silverhand/eslint-config": "3.0.1",
-    "@silverhand/ts-config": "3.0.0",
+    "@silverhand/eslint-config": "4.0.1",
+    "@silverhand/ts-config": "4.0.0",
     "@types/inquirer": "^9.0.0",
     "@types/jest": "^29.4.0",
     "@types/node": "^18.11.18",
@@ -67,12 +68,11 @@
     "@types/sinon": "^10.0.13",
     "@types/tar": "^6.1.2",
     "@types/yargs": "^17.0.13",
-    "eslint": "^8.34.0",
+    "eslint": "^8.44.0",
     "jest": "^29.5.0",
     "lint-staged": "^13.0.0",
-    "prettier": "^2.8.2",
-    "sinon": "^15.0.0",
-    "typescript": "^5.0.0"
+    "prettier": "^3.0.0",
+    "sinon": "^15.0.0"
   },
   "eslintConfig": {
     "extends": "@silverhand",