@logto/cli 1.1.0 → 1.2.0

package/lib/commands/install/utils.js

@@ -10,7 +10,7 @@ import * as semver from 'semver';
 import tar from 'tar';
 import { createPoolAndDatabaseIfNeeded } from '../../database.js';
 import { packageJson } from '../../package-json.js';
-import { cliConfig, ConfigKey, downloadFile, isTty, log, oraPromise, safeExecSync, } from '../../utils.js';
+import { cliConfig, ConfigKey, consoleLog, downloadFile, isTty, oraPromise, safeExecSync, } from '../../utils.js';
 import { seedByPool } from '../database/seed/index.js';
 export const defaultPath = path.join(os.homedir(), 'logto');
 const pgRequired = new semver.SemVer('14.0.0');
@@ -19,10 +19,10 @@ export const validateNodeVersion = () => {
     const requiredVersionString = required.map((version) => '^' + version.version).join(' || ');
     const current = new semver.SemVer(execSync('node -v', { encoding: 'utf8', stdio: 'pipe' }));
     if (required.every((version) => version.major !== current.major)) {
-        log.error(`Logto requires NodeJS ${requiredVersionString}, but ${current.version} found.`);
+        consoleLog.fatal(`Logto requires NodeJS ${requiredVersionString}, but ${current.version} found.`);
     }
     if (required.some((version) => version.major === current.major && version.compare(current) > 0)) {
-        log.warn(`Logto is tested under NodeJS ${requiredVersionString}, but version ${current.version} found.`);
+        consoleLog.warn(`Logto is tested under NodeJS ${requiredVersionString}, but version ${current.version} found.`);
     }
 };
 const validatePath = (value) => existsSync(path.resolve(value))
@@ -44,7 +44,7 @@ export const inquireInstancePath = async (initialPath) => {
     // Validate for initialPath
     const validated = validatePath(instancePath);
     if (validated !== true) {
-        log.error(validated);
+        consoleLog.fatal(validated);
     }
     return instancePath;
 };
@@ -65,15 +65,15 @@ export const validateDatabase = async () => {
         },
     });
     if (hasPostgresUrl === false) {
-        log.error('Logto requires a Postgres instance to run.');
+        consoleLog.fatal('Logto requires a Postgres instance to run.');
     }
 };
 export const downloadRelease = async (url) => {
     const tarFilePath = path.resolve(os.tmpdir(), './logto.tar.gz');
     const from = url ??
         `https://github.com/logto-io/logto/releases/download/v${packageJson.version}/logto.tar.gz`;
-    log.info(`Download Logto from ${from}`);
-    log.info(`Target ${tarFilePath}`);
+    consoleLog.info(`Download Logto from ${from}`);
+    consoleLog.info(`Target ${tarFilePath}`);
     await downloadFile(from, tarFilePath);
     return tarFilePath;
 };
@@ -84,7 +84,7 @@ export const decompress = async (toPath, tarPath) => {
             await tar.extract({ file: tarPath, cwd: toPath, strip: 1 });
         }
         catch (error) {
-            log.error(error);
+            consoleLog.fatal(error);
         }
     };
     return oraPromise(run(), {
@@ -99,23 +99,23 @@ export const seedDatabase = async (instancePath, cloud) => {
         await pool.end();
     }
     catch (error) {
-        console.error(error);
+        consoleLog.error(error);
         await oraPromise(fs.rm(instancePath, { force: true, recursive: true }), {
             text: 'Clean up',
             prefixText: chalk.blue('[info]'),
         });
-        log.error('Error occurred during seeding your Logto database. Nothing has changed since the seeding process was in a transaction.\n\n' +
+        consoleLog.fatal('Error occurred during seeding your Logto database. Nothing has changed since the seeding process was in a transaction.\n\n' +
             `  To skip the database seeding, append ${chalk.green('--skip-seed')} to the command options.`);
     }
 };
 export const createEnv = async (instancePath, databaseUrl) => {
     const dotEnvPath = path.resolve(instancePath, '.env');
     await fs.writeFile(dotEnvPath, `DB_URL=${databaseUrl}`, 'utf8');
-    log.info(`Saved database URL to ${chalk.blue(dotEnvPath)}`);
+    consoleLog.info(`Saved database URL to ${chalk.blue(dotEnvPath)}`);
 };
 export const logFinale = (instancePath) => {
     const startCommand = `cd ${instancePath} && npm start`;
-    log.info(`Use the command below to start Logto. Happy hacking!\n\n  ${chalk.green(startCommand)}`);
+    consoleLog.info(`Use the command below to start Logto. Happy hacking!\n\n  ${chalk.green(startCommand)}`);
 };
 export const isUrl = (string) => {
     try {

package/lib/commands/translate/create.js

@@ -1,58 +1,12 @@
-import { existsSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import { isLanguageTag } from '@logto/language-kit';
 import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
 import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-ui';
-import { conditionalString } from '@silverhand/essentials';
-import { log } from '../../utils.js';
+import { consoleLog } from '../../utils.js';
 import { inquireInstancePath } from '../connector/utils.js';
-import { createOpenaiApi, translate } from './openai.js';
-import { baseLanguage, readBaseLocaleFiles } from './utils.js';
-const createFullTranslation = async (instancePath, packageName, languageTag) => {
-    const directory = path.join(await inquireInstancePath(instancePath), 'packages', packageName, 'src/locales');
-    const files = await readBaseLocaleFiles(directory);
-    log.info('Found ' +
-        String(files.length) +
-        ' file' +
-        conditionalString(files.length !== 1 && 's') +
-        ' in ' +
-        packageName +
-        ' to translate');
-    const openai = createOpenaiApi();
-    /* eslint-disable no-await-in-loop */
-    for (const file of files) {
-        const relativePath = path.relative(path.join(directory, baseLanguage.toLowerCase()), file);
-        const targetPath = path.join(directory, languageTag.toLowerCase(), relativePath);
-        const getTranslationPath = async () => {
-            if (existsSync(targetPath)) {
-                const currentContent = await fs.readFile(targetPath, 'utf8');
-                if (currentContent.includes('// UNTRANSLATED')) {
-                    return targetPath;
-                }
-                log.info(`Target path ${targetPath} exists and has no untranslated mark, skipping`);
-                return;
-            }
-            return file;
-        };
-        const translationPath = await getTranslationPath();
-        if (!translationPath) {
-            continue;
-        }
-        log.info(`Translating ${translationPath}`);
-        const result = await translate(openai, languageTag, translationPath);
-        if (!result) {
-            log.error(`Unable to translate ${translationPath}`);
-        }
-        await fs.mkdir(path.parse(targetPath).dir, { recursive: true });
-        await fs.writeFile(targetPath, result);
-        log.succeed(`Translated ${targetPath}`);
-    }
-    /* eslint-enable no-await-in-loop */
-};
+import { createFullTranslation } from './utils.js';
 const create = {
     command: ['create <language-tag>', 'c'],
-    describe: 'Create a new language translation',
+    describe: 'Create a new language translation using ChatGPT. Note the environment variable `OPENAI_API_KEY` is required to work.',
     builder: (yargs) => yargs.positional('language-tag', {
         describe: 'The language tag to create, e.g. `af-ZA`.',
         type: 'string',
@@ -60,16 +14,25 @@ const create = {
     }),
     handler: async ({ path: inputPath, languageTag }) => {
         if (!isLanguageTag(languageTag)) {
-            log.error('Invalid language tag. Run `logto translate list-tags` to see available list.');
+            consoleLog.fatal('Invalid language tag. Run `logto translate list-tags` to see available list.');
         }
+        const instancePath = await inquireInstancePath(inputPath);
         if (isPhrasesBuiltInLanguageTag(languageTag)) {
-            log.info(languageTag + ' is a built-in tag of phrases, updating untranslated phrases');
+            consoleLog.info(languageTag + ' is a built-in tag of phrases, updating untranslated phrases');
         }
-        await createFullTranslation(inputPath, 'phrases', languageTag);
+        await createFullTranslation({
+            instancePath,
+            packageName: 'phrases',
+            languageTag,
+        });
         if (isPhrasesUiBuiltInLanguageTag(languageTag)) {
-            log.info(languageTag + ' is a built-in tag of phrases-ui, updating untranslated phrases');
+            consoleLog.info(languageTag + ' is a built-in tag of phrases-ui, updating untranslated phrases');
         }
-        await createFullTranslation(inputPath, 'phrases-ui', languageTag);
+        await createFullTranslation({
+            instancePath,
+            packageName: 'phrases-ui',
+            languageTag,
+        });
     },
 };
 export default create;

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 sync from './sync.js';
 const translate = {
     command: ['translate', 't'],
     describe: 'Commands for Logto translation',
@@ -12,6 +13,7 @@ const translate = {
     })
         .command(create)
         .command(listTags)
+        .command(sync)
         .demandCommand(1),
     handler: noop,
 };

package/lib/commands/translate/list-tags.js

@@ -2,12 +2,13 @@ import { languages } from '@logto/language-kit';
 import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
 import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-ui';
 import chalk from 'chalk';
+import { consoleLog } from '../../utils.js';
 const listTags = {
     command: ['list-tags', 'list'],
     describe: 'List all available language tags',
     handler: async () => {
         for (const tag of Object.keys(languages)) {
-            console.log(...[
+            consoleLog.plain(...[
                 tag,
                 isPhrasesBuiltInLanguageTag(tag) && chalk.blue('phrases'),
                 isPhrasesUiBuiltInLanguageTag(tag) && chalk.blue('phrases-ui'),

package/lib/commands/translate/openai.d.ts

@@ -1,4 +1,11 @@
 import { type LanguageTag } from '@logto/language-kit';
 import { type Got } from 'got';
 export declare const createOpenaiApi: () => Got;
-export declare const translate: (api: Got, languageTag: LanguageTag, filePath: string) => Promise<string | undefined>;
+type TranslateConfig = {
+    api: Got;
+    sourceFilePath: string;
+    targetLanguage: LanguageTag;
+    extraPrompt?: string;
+};
+export declare const translate: ({ api, targetLanguage, sourceFilePath, extraPrompt, }: TranslateConfig) => Promise<string | undefined>;
+export {};

package/lib/commands/translate/openai.js

@@ -1,10 +1,10 @@
 import fs from 'node:fs/promises';
-import { languages } from '@logto/language-kit';
 import { trySafe } from '@silverhand/essentials';
 import { got, HTTPError } from 'got';
 import { HttpsProxyAgent } from 'hpagent';
 import { z } from 'zod';
-import { getProxy, log } from '../../utils.js';
+import { consoleLog, getProxy } from '../../utils.js';
+import { getTranslationPrompt } from './prompts.js';
 export const createOpenaiApi = () => {
     const proxy = getProxy();
     return got.extend({
@@ -24,8 +24,8 @@ const gptResponseGuard = z.object({
     })
         .array(),
 });
-export const translate = async (api, languageTag, filePath) => {
-    const fileContent = await fs.readFile(filePath, 'utf8');
+export const translate = async ({ api, targetLanguage, sourceFilePath, extraPrompt, }) => {
+    const sourceFileContent = await fs.readFile(sourceFilePath, 'utf8');
     const response = await trySafe(api
         .post('chat/completions', {
         json: {
@@ -33,15 +33,19 @@ export const translate = async (api, languageTag, filePath) => {
             messages: [
                 {
                     role: 'user',
-                    content: `Given the following code snippet, only translate object values to ${languages[languageTag]}, keep all object keys original, output ts code only: \n \`\`\`ts\n${fileContent}\n\`\`\``,
+                    content: getTranslationPrompt({
+                        sourceFileContent,
+                        targetLanguage,
+                        extraPrompt,
+                    }),
                 },
             ],
         },
     })
         .json(), (error) => {
-        log.warn(`Error while translating ${filePath}:`, String(error));
+        consoleLog.warn(`Error while translating ${sourceFilePath}:`, String(error));
         if (error instanceof HTTPError) {
-            log.warn(error.response.body);
+            consoleLog.warn(error.response.body);
         }
     });
     if (!response) {
@@ -49,16 +53,16 @@ export const translate = async (api, languageTag, filePath) => {
     }
     const guarded = gptResponseGuard.safeParse(response);
     if (!guarded.success) {
-        log.warn(`Error while guarding response for ${filePath}:`, response);
+        consoleLog.warn(`Error while guarding response for ${sourceFilePath}:`, response);
         return;
     }
     const [entity] = guarded.data.choices;
     if (!entity) {
-        log.warn(`No choice found in response when translating ${filePath}`);
+        consoleLog.warn(`No choice found in response when translating ${sourceFilePath}`);
         return;
     }
     if (entity.finish_reason !== 'stop') {
-        log.warn(`Unexpected finish reason ${entity.finish_reason} for ${filePath}`);
+        consoleLog.warn(`Unexpected finish reason ${entity.finish_reason} for ${sourceFilePath}`);
     }
     const { content } = entity.message;
     const matched = /```(?:ts)?\n(.*)```/s.exec(content)?.[1];
@@ -67,7 +71,7 @@ export const translate = async (api, languageTag, filePath) => {
         if (['const ', 'import '].some((prefix) => content.startsWith(prefix))) {
             return content;
         }
-        log.warn('No matching code snippet from response:', content);
+        consoleLog.warn('No matching code snippet from response:', content);
     }
     return matched;
 };

package/lib/commands/translate/prompts.d.ts

@@ -0,0 +1,14 @@
+import { type LanguageTag } from '@logto/language-kit';
+type GetTranslationPromptProperties = {
+    sourceFileContent: string;
+    targetLanguage: LanguageTag;
+    extraPrompt?: string;
+};
+/**
+ * Note:
+ * The input token limit of GPT 3.5 is 2048, the following prompt tokens with sourceFileContent is about 1200.
+ * Remember to check the token limit before adding more prompt.
+ * Tokens can be counted in https://platform.openai.com/tokenizer
+ */
+export declare const getTranslationPrompt: ({ sourceFileContent, targetLanguage, extraPrompt, }: GetTranslationPromptProperties) => string;
+export {};

package/lib/commands/translate/prompts.js

@@ -0,0 +1,39 @@
+import { languages } from '@logto/language-kit';
+import { conditionalString } from '@silverhand/essentials';
+/**
+ * Note:
+ * The input token limit of GPT 3.5 is 2048, the following prompt tokens with sourceFileContent is about 1200.
+ * Remember to check the token limit before adding more prompt.
+ * Tokens can be counted in https://platform.openai.com/tokenizer
+ */
+export const getTranslationPrompt = ({ sourceFileContent, targetLanguage, extraPrompt, }) => `Given the following code snippet:
+\`\`\`ts
+${sourceFileContent}
+\`\`\`
+only translate object values to ${languages[targetLanguage]}, keep all object keys original, output ts code only, the code format should be strictly consistent, and should not contains the given code snippet.
+
+Take zh-cn as an example, if the input is:
+\`\`\`ts
+import others from './others.js';
+
+const translation = {
+  hello: '你好',
+  world: 'world', // UNTRANSLATED
+  others,
+};
+
+export default translation;
+\`\`\`
+the output should be:
+\`\`\`ts
+import others from './others.js';
+
+const translation = {
+  hello: '你好',
+  world: '世界',
+  others,
+};
+
+export default translation;
+\`\`\`
+${conditionalString(extraPrompt)}`;

package/lib/commands/translate/sync.d.ts

@@ -0,0 +1,7 @@
+import type { CommandModule } from 'yargs';
+declare const sync: CommandModule<{
+    path?: string;
+}, {
+    path?: string;
+}>;
+export default sync;

package/lib/commands/translate/sync.js

@@ -0,0 +1,40 @@
+import { languages } from '@logto/language-kit';
+import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
+import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-ui';
+import PQueue from 'p-queue';
+import { inquireInstancePath } from '../connector/utils.js';
+import { baseLanguage, syncTranslation } from './utils.js';
+const sync = {
+    command: ['sync'],
+    describe: 'Translate all untranslated phrases using ChatGPT. Note the environment variable `OPENAI_API_KEY` is required to work.',
+    handler: async ({ path: inputPath }) => {
+        const queue = new PQueue({ concurrency: 5 });
+        const instancePath = await inquireInstancePath(inputPath);
+        for (const languageTag of Object.keys(languages)) {
+            if (languageTag === baseLanguage) {
+                continue;
+            }
+            const baseOptions = {
+                instancePath,
+                verbose: false,
+                queue,
+            };
+            if (isPhrasesBuiltInLanguageTag(languageTag)) {
+                void syncTranslation({
+                    ...baseOptions,
+                    packageName: 'phrases',
+                    languageTag,
+                });
+            }
+            if (isPhrasesUiBuiltInLanguageTag(languageTag)) {
+                void syncTranslation({
+                    ...baseOptions,
+                    packageName: 'phrases-ui',
+                    languageTag,
+                });
+            }
+        }
+        await queue.onIdle();
+    },
+};
+export default sync;

package/lib/commands/translate/utils.d.ts

@@ -1,3 +1,14 @@
+import { type LanguageTag } from '@logto/language-kit';
+import PQueue from 'p-queue';
 export declare const baseLanguage = "en";
 export declare const readLocaleFiles: (directory: string) => Promise<string[]>;
 export declare const readBaseLocaleFiles: (directory: string) => Promise<string[]>;
+export type TranslationOptions = {
+    instancePath: string;
+    packageName: 'phrases' | 'phrases-ui';
+    languageTag: LanguageTag;
+    verbose?: boolean;
+    queue?: PQueue;
+};
+export declare const createFullTranslation: ({ instancePath, packageName, languageTag, verbose, queue, }: TranslationOptions) => Promise<void>;
+export declare const syncTranslation: ({ instancePath, packageName, languageTag, verbose, queue, }: TranslationOptions) => Promise<void>;

package/lib/commands/translate/utils.js

@@ -1,7 +1,12 @@
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { log } from '../../utils.js';
+import { conditionalString } from '@silverhand/essentials';
+import PQueue from 'p-queue';
+import { consoleLog } from '../../utils.js';
+import { createOpenaiApi, translate } from './openai.js';
 export const baseLanguage = 'en';
+const untranslatedMark = '// UNTRANSLATED';
 export const readLocaleFiles = async (directory) => {
     const entities = await fs.readdir(directory, { withFileTypes: true });
     const result = await Promise.all(entities.map(async (entity) => {
@@ -16,7 +21,111 @@ export const readBaseLocaleFiles = async (directory) => {
     const enDirectory = path.join(directory, baseLanguage.toLowerCase());
     const stat = await fs.stat(enDirectory);
     if (!stat.isDirectory()) {
-        log.error(directory, 'has no `' + baseLanguage.toLowerCase() + '` directory');
+        consoleLog.fatal(directory, 'has no `' + baseLanguage.toLowerCase() + '` directory');
     }
     return readLocaleFiles(enDirectory);
 };
+export const createFullTranslation = async ({ instancePath, packageName, languageTag, verbose = true, queue = new PQueue({ concurrency: 5 }), }) => {
+    const localeFiles = await getBaseAndTargetLocaleFiles(instancePath, packageName, languageTag);
+    if (verbose) {
+        consoleLog.info('Found ' +
+            String(localeFiles.length) +
+            ' file' +
+            conditionalString(localeFiles.length !== 1 && 's') +
+            ' in ' +
+            packageName +
+            ' to create');
+    }
+    const openai = createOpenaiApi();
+    for (const { baseLocaleFile, targetLocaleFile } of localeFiles) {
+        if (existsSync(targetLocaleFile)) {
+            if (verbose) {
+                consoleLog.info(`Target locale file ${targetLocaleFile} exists, skipping`);
+            }
+            continue;
+        }
+        void createLocaleFile({
+            api: openai,
+            baseLocaleFile,
+            targetPath: targetLocaleFile,
+            targetLanguage: languageTag,
+            queue,
+        });
+    }
+    return queue.onIdle();
+};
+export const syncTranslation = async ({ instancePath, packageName, languageTag, verbose = true, queue = new PQueue({ concurrency: 5 }), }) => {
+    const localeFiles = await getBaseAndTargetLocaleFiles(instancePath, packageName, languageTag);
+    if (verbose) {
+        consoleLog.info('Found ' +
+            String(localeFiles.length) +
+            ' file' +
+            conditionalString(localeFiles.length !== 1 && 's') +
+            ' in ' +
+            packageName +
+            ' to translate');
+    }
+    const openai = createOpenaiApi();
+    /* eslint-disable no-await-in-loop */
+    for (const { baseLocaleFile, targetLocaleFile } of localeFiles) {
+        if (!existsSync(targetLocaleFile)) {
+            void createLocaleFile({
+                api: openai,
+                baseLocaleFile,
+                targetPath: targetLocaleFile,
+                targetLanguage: languageTag,
+                queue,
+            });
+            continue;
+        }
+        const currentContent = await fs.readFile(targetLocaleFile, 'utf8');
+        if (!currentContent.includes(untranslatedMark)) {
+            if (verbose) {
+                consoleLog.info(`Target path ${targetLocaleFile} exists and has no untranslated mark, skipping`);
+            }
+            continue;
+        }
+        void queue.add(async () => {
+            consoleLog.info(`Translating ${targetLocaleFile}`);
+            const result = await translate({
+                api: openai,
+                sourceFilePath: targetLocaleFile,
+                targetLanguage: languageTag,
+                extraPrompt: `Object values without an "${untranslatedMark}" mark should be skipped and keep its original value. Remember to remove the "${untranslatedMark}" mark with the spaces before and after it in the output content.`,
+            });
+            if (!result) {
+                consoleLog.fatal(`Unable to translate ${targetLocaleFile}`);
+            }
+            await fs.unlink(targetLocaleFile);
+            await fs.writeFile(targetLocaleFile, result);
+            consoleLog.succeed(`Translated ${targetLocaleFile}`);
+        });
+    }
+    /* eslint-enable no-await-in-loop */
+    return queue.onIdle();
+};
+const getBaseAndTargetLocaleFiles = async (instancePath, packageName, languageTag) => {
+    const directory = path.join(instancePath, 'packages', packageName, 'src/locales');
+    const baseLocaleFiles = await readBaseLocaleFiles(directory);
+    return baseLocaleFiles.map((baseLocaleFile) => {
+        const basePath = path.relative(path.join(directory, baseLanguage.toLowerCase()), baseLocaleFile);
+        return {
+            baseLocaleFile,
+            targetLocaleFile: path.join(directory, languageTag.toLowerCase(), basePath),
+        };
+    });
+};
+const createLocaleFile = async ({ api, baseLocaleFile, targetPath, targetLanguage, queue, }) => queue.add(async () => {
+    consoleLog.info(`Creating the translation for ${targetPath}`);
+    const result = await translate({
+        api,
+        sourceFilePath: baseLocaleFile,
+        targetLanguage,
+    });
+    if (!result) {
+        consoleLog.fatal(`Unable to create the translation for ${targetPath}`);
+    }
+    await fs.mkdir(path.parse(targetPath).dir, { recursive: true });
+    await fs.writeFile(targetPath, result);
+    consoleLog.succeed(`The translation for ${targetPath} created`);
+});

package/lib/connector/factories.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { consoleLog } from '../utils.js';
 import { notImplemented } from './consts.js';
 import { loadConnector } from './loader.js';
 import { parseMetadata, validateConnectorModule } from './utils.js';
@@ -22,7 +23,7 @@ export const loadConnectorFactories = async (connectorPackages, ignoreVersionMis
         }
         catch (error) {
             if (error instanceof Error) {
-                console.log(`${chalk.red(`[load-connector] skip ${chalk.bold(name)} due to error: ${error.message}`)}`);
+                consoleLog.error(`[load-connector] skip ${chalk.bold(name)} due to error: ${error.message}`);
                 return;
             }
             throw error;

package/lib/connector/loader.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import connectorKitMeta from '@logto/connector-kit/package.json' assert { type: 'json' };
 import { satisfies } from 'semver';
+import { consoleLog } from '../utils.js';
 import { isKeyInObject } from './utils.js';
 const connectorKit = '@logto/connector-kit';
 const { version: currentVersion } = connectorKitMeta;
@@ -8,12 +9,12 @@ const checkConnectorKitVersion = (dependencies, ignoreVersionMismatch) => {
     if (isKeyInObject(dependencies, connectorKit)) {
         const value = dependencies[connectorKit];
         if (typeof value === 'string') {
-            if (satisfies(currentVersion, value)) {
+            if (value.startsWith('workspace:') || satisfies(currentVersion, value)) {
                 return;
             }
             const message = `Connector requires ${connectorKit} to be ${value}, but the version here is ${currentVersion}.`;
             if (ignoreVersionMismatch) {
-                console.warn(`[warn] ${message}\n\nThis is highly discouraged in production.`);
+                consoleLog.warn(`${message}\n\nThis is highly discouraged in production.`);
                 return;
             }
             throw new Error(message);
@@ -33,7 +34,7 @@ export const loadConnector = async (connectorPath, ignoreVersionMismatch) => {
         // CJS pattern
         if (isKeyInObject(loaded.default, 'default')) {
             if (typeof loaded.default.default === 'function') {
-                console.log(`[warn] Load connector ${connectorPath} in CJS mode`);
+                consoleLog.warn(`Load connector ${connectorPath} in CJS mode`);
                 // eslint-disable-next-line no-restricted-syntax
                 return loaded.default.default;
             }

package/lib/database.js

@@ -4,7 +4,7 @@ import decamelize from 'decamelize';
 import { DatabaseError } from 'pg-protocol';
 import { createPool, parseDsn, sql, stringifyDsn } from 'slonik';
 import { createInterceptors } from 'slonik-interceptor-preset';
-import { ConfigKey, getCliConfigWithPrompt, log } from './utils.js';
+import { ConfigKey, consoleLog, getCliConfigWithPrompt } from './utils.js';
 export const defaultDatabaseUrl = 'postgresql://localhost:5432/logto';
 export const getDatabaseUrlFromConfig = async () => (await getCliConfigWithPrompt({
     key: ConfigKey.DatabaseUrl,
@@ -32,7 +32,7 @@ export const createPoolAndDatabaseIfNeeded = async () => {
         // Database does not exist, try to create one
         // https://www.postgresql.org/docs/14/errcodes-appendix.html
         if (!(error instanceof DatabaseError && error.code === '3D000')) {
-            log.error(error);
+            consoleLog.fatal(error);
         }
         const databaseUrl = await getDatabaseUrlFromConfig();
         const dsn = parseDsn(databaseUrl);
@@ -50,7 +50,7 @@ export const createPoolAndDatabaseIfNeeded = async () => {
         connection_limit = -1;
     `);
         await maintenancePool.end();
-        log.succeed(`Created database ${databaseName}`);
+        consoleLog.succeed(`Created database ${databaseName}`);
         return createPoolFromConfig();
     }
 };

package/lib/index.js

@@ -7,7 +7,7 @@ import database from './commands/database/index.js';
 import install from './commands/install/index.js';
 import translate from './commands/translate/index.js';
 import { packageJson } from './package-json.js';
-import { cliConfig, ConfigKey } from './utils.js';
+import { cliConfig, ConfigKey, consoleLog } from './utils.js';
 void yargs(hideBin(process.argv))
     .version(false)
     .option('env', {
@@ -28,7 +28,7 @@ void yargs(hideBin(process.argv))
 })
     .middleware(({ version }) => {
     if (version) {
-        console.log(packageJson.name + ' v' + packageJson.version);
+        consoleLog.plain(packageJson.name + ' v' + packageJson.version);
         // eslint-disable-next-line unicorn/no-process-exit
         process.exit(0);
     }

package/lib/package-json.d.ts

@@ -57,6 +57,7 @@ export declare const packageJson: {
         nanoid: string;
         ora: string;
         "p-limit": string;
+        "p-queue": string;
         "p-retry": string;
         "pg-protocol": string;
         roarr: string;
@@ -87,6 +88,9 @@ export declare const packageJson: {
     };
     eslintConfig: {
         extends: string;
+        rules: {
+            "no-console": string;
+        };
         ignorePatterns: string[];
     };
     prettier: string;