@logto/cli 1.7.0 → 1.9.0

package/lib/commands/translate/prompts.js

@@ -1,34 +1,37 @@
 import { languages } from '@logto/language-kit';
 import { conditionalString } from '@silverhand/essentials';
+export const untranslatedMark = '/** UNTRANSLATED */';
 /**
  * Note:
- * The input token limit of GPT 3.5 is 2048, the following prompt tokens with sourceFileContent is about 1200.
+ * The input token limit of GPT 3.5 is 2048, the following prompt tokens with sourceFileContent is about 1600.
  * Remember to check the token limit before adding more prompt.
  * Tokens can be counted in https://platform.openai.com/tokenizer
  */
 export const getTranslationPromptMessages = ({ sourceFileContent, targetLanguage, extraPrompt, }) => [
     {
         role: 'assistant',
-        content: `You are a translate assistant of a Typescript engineer, when you receive a code snippet that contains an object, translate and ONLY translate those values that are marked with comment "// UNTRANSLATED" into the language ${languages[targetLanguage]}, remove the "// UNTRANSLATED" mark, keep all object keys original, output ts code only, the code format should be strictly consistent, and should not contain the given code snippet. ${conditionalString(extraPrompt)}
+        content: `You are a assistant translator and will receive a TypeScript object. Traverse and find object values with "${untranslatedMark}" annotation on the top, then translate these values to target locale "${languages[targetLanguage]}". Remove the "${untranslatedMark}" annotations from output. Escape the single quotes (if any) in translated results by prepending a backslash. Keep the interpolation double curly brackets and their inner values intact. Make sure there is a space between the CJK and non-CJK characters. Prefer using "你" instead of "您" in Chinese. Do not include sample code snippet below in the final output. ${conditionalString(extraPrompt)}
 
-Take Chinese as an example, if the input is:
+Take translating to zh-CN as an example, if the input is:
 \`\`\`ts
 import others from './others.js';
 
 const translation = {
-  hello: '你好',
-  world: 'world', // UNTRANSLATED
+  hello: 'Hello',
+  ${untranslatedMark}
+  world: 'world',
   others,
 };
 
 export default translation;
 \`\`\`
-the output should be:
+
+Then the output should be:
 \`\`\`ts
 import others from './others.js';
 
 const translation = {
-  hello: '你好',
+  hello: 'Hello',
   world: '世界',
   others,
 };

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

@@ -1,13 +1,9 @@
-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);
+import { consoleLog, inquireInstancePath, lintLocaleFiles } from '../../../utils.js';
+import { parseLocaleFiles, syncPhraseKeysAndFileStructure } from './utils.js';
 const syncKeys = {
     command: ['sync-keys', 'sk'],
     describe: [
@@ -26,7 +22,7 @@ const syncKeys = {
         .option('package', {
         alias: 'pkg',
         type: 'string',
-        describe: 'The package name of the phrases, one of `phrases` or `phrases-ui`',
+        describe: 'The package name of the phrases, one of `phrases` or `phrases-experience`',
         default: 'phrases',
     })
         .option('target', {
@@ -50,14 +46,14 @@ const syncKeys = {
         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`');
+        if (packageName !== 'phrases' && packageName !== 'phrases-experience') {
+            consoleLog.fatal('Invalid package name, expected `phrases` or `phrases-experience`');
         }
         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 baseline = parseLocaleFiles(entrypoint);
         const targetLocales = targetTag === 'all' ? fs.readdirSync(localesPath) : [targetTag.toLowerCase()];
         /* eslint-disable no-await-in-loop */
         for (const target of targetLocales) {
@@ -73,11 +69,7 @@ const syncKeys = {
         }
         /* 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');
+            void lintLocaleFiles(instancePath, packageName);
         }
     },
 };

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

@@ -5,7 +5,7 @@ type FileStructure = {
     };
 };
 type NestedPhraseObject = {
-    [key: string]: string | NestedPhraseObject;
+    [key: string]: [phrase: string, isTranslated: boolean] | NestedPhraseObject;
 };
 type ParsedTuple = readonly [NestedPhraseObject, FileStructure];
 /**
@@ -19,7 +19,8 @@ type ParsedTuple = readonly [NestedPhraseObject, FileStructure];
  * import errors from './errors/index.js';
  *
  * const translation = {
- *   page_title: 'Anwendungen',
+ *   // UNTRANSLATED
+ *   page_title: 'Applications',
  *   errors,
  * };
  * ```
@@ -28,9 +29,9 @@ type ParsedTuple = readonly [NestedPhraseObject, FileStructure];
  *
  * ```ts
  * {
- *   page_title: 'Anwendungen',
+ *   page_title: ['Anwendungen', false],
  *   errors: {
- *     page_not_found: 'Seite nicht gefunden',
+ *     page_not_found: ['Seite nicht gefunden', true],
  *   },
  * }
  * ```
@@ -51,6 +52,6 @@ type ParsedTuple = readonly [NestedPhraseObject, FileStructure];
  * @returns A tuple of the nested object of phrases and the file structure
  *
  */
-export declare const praseLocaleFiles: (filePath: string) => ParsedTuple;
+export declare const parseLocaleFiles: (filePath: string) => ParsedTuple;
 export declare const syncPhraseKeysAndFileStructure: (baseline: ParsedTuple, targetLocale: string, targetDirectory: string) => Promise<void>;
 export {};

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

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { tryThat } from '@silverhand/essentials';
 import ts from 'typescript';
 import { consoleLog } from '../../../utils.js';
+const untranslatedMark = 'UNTRANSLATED';
 /**
  * Given a entrypoint file path of a language, parse the nested object of
  * phrases and the file structure.
@@ -15,7 +16,8 @@ import { consoleLog } from '../../../utils.js';
  * import errors from './errors/index.js';
  *
  * const translation = {
- *   page_title: 'Anwendungen',
+ *   // UNTRANSLATED
+ *   page_title: 'Applications',
  *   errors,
  * };
  * ```
@@ -24,9 +26,9 @@ import { consoleLog } from '../../../utils.js';
  *
  * ```ts
  * {
- *   page_title: 'Anwendungen',
+ *   page_title: ['Anwendungen', false],
  *   errors: {
- *     page_not_found: 'Seite nicht gefunden',
+ *     page_not_found: ['Seite nicht gefunden', true],
  *   },
  * }
  * ```
@@ -47,7 +49,7 @@ import { consoleLog } from '../../../utils.js';
  * @returns A tuple of the nested object of phrases and the file structure
  *
  */
-export const praseLocaleFiles = (filePath) => {
+export const parseLocaleFiles = (filePath) => {
     const content = readFileSync(filePath, 'utf8');
     const ast = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const importIdentifierPath = new Map();
@@ -73,30 +75,47 @@ export const praseLocaleFiles = (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
+                const [phrases, structure] = parseLocaleFiles(resolvedPath);
+                /* eslint-disable @silverhand/fp/no-mutation */
                 nestedObject[key] = phrases;
-                // eslint-disable-next-line @silverhand/fp/no-mutation
                 fileStructure[key] = {
                     filePath: importPath,
                     structure,
                 };
+                /* eslint-enable @silverhand/fp/no-mutation */
             }
             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
+                    /* eslint-disable @silverhand/fp/no-mutation */
                     nestedObject[key] = phrases;
-                    // eslint-disable-next-line @silverhand/fp/no-mutation
                     fileStructure[key] = { structure };
+                    /* eslint-enable @silverhand/fp/no-mutation */
                 }
                 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;
+                    const commentRanges = ts.getLeadingCommentRanges(property.getFullText(), 0);
+                    if (commentRanges?.[0]) {
+                        if (commentRanges.length > 1) {
+                            consoleLog.fatal('Multiple comments found for property:', property);
+                        }
+                        const commentRange = commentRanges[0];
+                        const comment = property.getFullText().slice(commentRange.pos, commentRange.end);
+                        if (comment.includes(untranslatedMark)) {
+                            // eslint-disable-next-line @silverhand/fp/no-mutation
+                            nestedObject[key] = [value, false];
+                        }
+                        else {
+                            consoleLog.fatal('Unsupported comment:', comment);
+                        }
+                    }
+                    else {
+                        // eslint-disable-next-line @silverhand/fp/no-mutation
+                        nestedObject[key] = [value, true];
+                    }
                 }
                 else {
                     consoleLog.fatal('Unsupported property:', property);
@@ -193,14 +212,19 @@ const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = fal
         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`));
+            if (Array.isArray(value)) {
+                const [phrase] = value;
+                // If the key exists in the target language and the value is a translated
+                // 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.
+                if (Array.isArray(existingValue) && existingValue[1]) {
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: ${existingValue[0]},\n`);
+                }
+                else {
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}/** ${untranslatedMark} */\n`);
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: ${phrase},\n`);
+                }
             }
             // Not a string, treat it as a nested object or an import
             else {
@@ -208,12 +232,12 @@ const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = fal
                 // 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));
+                    await traverseNode([value, keyStructure.structure], Array.isArray(existingValue) ? {} : 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 traverseObject([value, keyStructure?.structure ?? {}], Array.isArray(existingValue) ? {} : existingValue ?? {}, tabSize + 2);
                     await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}},\n`);
                 }
             }
@@ -229,7 +253,7 @@ const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = fal
 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 targetObject = isTargetLocaleExist ? parseLocaleFiles(targetEntrypoint)[0] : {};
     const backupDirectory = targetDirectory + '.bak';
     if (isTargetLocaleExist) {
         await fs.rename(targetDirectory, backupDirectory);

package/lib/commands/translate/sync.js

@@ -1,8 +1,8 @@
 import { languages } from '@logto/language-kit';
 import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
-import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-ui';
+import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-experience';
 import PQueue from 'p-queue';
-import { inquireInstancePath } from '../connector/utils.js';
+import { inquireInstancePath, lintLocaleFiles } from '../../utils.js';
 import { baseLanguage, syncTranslation } from './utils.js';
 const sync = {
     command: ['sync'],
@@ -19,22 +19,25 @@ const sync = {
                 verbose: false,
                 queue,
             };
+            /* eslint-disable no-await-in-loop */
             if (isPhrasesBuiltInLanguageTag(languageTag)) {
-                void syncTranslation({
+                await syncTranslation({
                     ...baseOptions,
                     packageName: 'phrases',
                     languageTag,
                 });
             }
             if (isPhrasesUiBuiltInLanguageTag(languageTag)) {
-                void syncTranslation({
+                await syncTranslation({
                     ...baseOptions,
-                    packageName: 'phrases-ui',
+                    packageName: 'phrases-experience',
                     languageTag,
                 });
             }
+            /* eslint-enable no-await-in-loop */
         }
         await queue.onIdle();
+        void lintLocaleFiles(instancePath);
     },
 };
 export default sync;

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

@@ -5,7 +5,7 @@ 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';
+    packageName: 'phrases' | 'phrases-experience';
     languageTag: LanguageTag;
     verbose?: boolean;
     queue?: PQueue;

package/lib/commands/translate/utils.js

@@ -5,8 +5,8 @@ import { conditionalString } from '@silverhand/essentials';
 import PQueue from 'p-queue';
 import { consoleLog } from '../../utils.js';
 import { createOpenaiApi, translate } from './openai.js';
+import { untranslatedMark } from './prompts.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) => {
@@ -91,7 +91,6 @@ export const syncTranslation = async ({ instancePath, packageName, languageTag,
                 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}`);

package/lib/connector/utils.d.ts

@@ -1,10 +1,10 @@
-import type { AllConnector, BaseConnector, ConnectorMetadata, GetConnectorConfig } from '@logto/connector-kit';
+import type { AllConnector, BaseConnector, ConnectorMetadata, GetConnectorConfig, GetCloudServiceClient } from '@logto/connector-kit';
 import { ConnectorType } from '@logto/connector-kit';
 import type { ConnectorFactory } from './types.js';
 export declare function validateConnectorModule(connector: Partial<BaseConnector<ConnectorType>>): asserts connector is BaseConnector<ConnectorType>;
-export declare const readUrl: (url: string, baseUrl: string, type: 'text' | 'svg') => Promise<string>;
+export declare const readUrl: (url: string, baseUrl: string, type: 'text' | 'image') => Promise<string>;
 export declare const parseMetadata: (metadata: AllConnector['metadata'], packagePath: string) => Promise<AllConnector['metadata']>;
-export declare const buildRawConnector: <T extends AllConnector = AllConnector>(connectorFactory: ConnectorFactory<T>, getConnectorConfig?: GetConnectorConfig) => Promise<{
+export declare const buildRawConnector: <T extends AllConnector = AllConnector>(connectorFactory: ConnectorFactory<T>, getConnectorConfig?: GetConnectorConfig, getCloudServiceClient?: GetCloudServiceClient) => Promise<{
     rawConnector: T;
     rawMetadata: ConnectorMetadata;
 }>;

package/lib/connector/utils.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { ConnectorError, ConnectorErrorCodes, ConnectorType } from '@logto/connector-kit';
+import { consoleLog } from '../utils.js';
 import { notImplemented } from './consts.js';
 export function validateConnectorModule(connector) {
     if (!connector.metadata) {
@@ -14,6 +15,11 @@ export function validateConnectorModule(connector) {
         throw new ConnectorError(ConnectorErrorCodes.UnexpectedType);
     }
 }
+const supportedImageTypes = Object.freeze({
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+});
+const isSupportedImageType = (extension) => Object.keys(supportedImageTypes).includes(extension);
 export const readUrl = async (url, baseUrl, type) => {
     if (!url) {
         return url;
@@ -24,25 +30,32 @@ export const readUrl = async (url, baseUrl, type) => {
     if (!existsSync(path.join(baseUrl, url))) {
         return url;
     }
-    if (type === 'svg') {
-        const data = await readFile(path.join(baseUrl, url));
-        return `data:image/svg+xml;base64,${data.toString('base64')}`;
+    if (type === 'image') {
+        const filePath = path.join(baseUrl, url);
+        const extension = path.extname(filePath);
+        if (!isSupportedImageType(extension)) {
+            consoleLog.warn(`[readUrl] unexpected image type: ${filePath}, only support ".svg" and ".png". Falling back to empty string.`);
+            return '';
+        }
+        const data = await readFile(filePath);
+        return `data:${supportedImageTypes[extension]};base64,${data.toString('base64')}`;
     }
     return readFile(path.join(baseUrl, url), 'utf8');
 };
 export const parseMetadata = async (metadata, packagePath) => {
     return {
         ...metadata,
-        logo: await readUrl(metadata.logo, packagePath, 'svg'),
-        logoDark: metadata.logoDark && (await readUrl(metadata.logoDark, packagePath, 'svg')),
+        logo: await readUrl(metadata.logo, packagePath, 'image'),
+        logoDark: metadata.logoDark && (await readUrl(metadata.logoDark, packagePath, 'image')),
         readme: await readUrl(metadata.readme, packagePath, 'text'),
         configTemplate: metadata.configTemplate && (await readUrl(metadata.configTemplate, packagePath, 'text')),
     };
 };
-export const buildRawConnector = async (connectorFactory, getConnectorConfig) => {
+export const buildRawConnector = async (connectorFactory, getConnectorConfig, getCloudServiceClient) => {
     const { createConnector, path: packagePath } = connectorFactory;
     const rawConnector = await createConnector({
         getConfig: getConnectorConfig ?? notImplemented,
+        getCloudServiceClient,
     });
     validateConnectorModule(rawConnector);
     const rawMetadata = await parseMetadata(rawConnector.metadata, packagePath);

package/lib/constants.d.ts

@@ -1 +1,3 @@
+export declare const defaultPath: string;
+export declare const coreDirectory = "packages/core";
 export declare const connectorDirectory = "connectors";

package/lib/constants.js

@@ -1 +1,5 @@
+import os from 'node:os';
+import path from 'node:path';
+export const defaultPath = path.join(os.homedir(), 'logto');
+export const coreDirectory = 'packages/core';
 export const connectorDirectory = 'connectors';

package/lib/package-json.d.ts

@@ -44,7 +44,7 @@ export declare const packageJson: {
         "@logto/core-kit": string;
         "@logto/language-kit": string;
         "@logto/phrases": string;
-        "@logto/phrases-ui": string;
+        "@logto/phrases-experience": string;
         "@logto/schemas": string;
         "@logto/shared": string;
         "@silverhand/essentials": string;

package/lib/package-json.js

@@ -1,6 +1,6 @@
 export const packageJson = {
     "name": "@logto/cli",
-    "version": "1.7.0",
+    "version": "1.9.0",
     "description": "Logto CLI.",
     "author": "Silverhand Inc. <contact@silverhand.io>",
     "homepage": "https://github.com/logto-io/logto#readme",
@@ -44,13 +44,13 @@ export const packageJson = {
     },
     "dependencies": {
         "@logto/connector-kit": "workspace:^1.1.1",
-        "@logto/core-kit": "workspace:^2.0.1",
+        "@logto/core-kit": "workspace:^2.1.0",
         "@logto/language-kit": "workspace:^1.0.0",
-        "@logto/phrases": "workspace:^1.4.1",
-        "@logto/phrases-ui": "workspace:^1.2.0",
-        "@logto/schemas": "workspace:1.7.0",
-        "@logto/shared": "workspace:^2.0.0",
-        "@silverhand/essentials": "^2.5.0",
+        "@logto/phrases": "workspace:^1.5.0",
+        "@logto/phrases-experience": "workspace:^1.3.0",
+        "@logto/schemas": "workspace:1.9.0",
+        "@logto/shared": "workspace:^2.0.1",
+        "@silverhand/essentials": "^2.8.4",
         "chalk": "^5.0.0",
         "decamelize": "^6.0.0",
         "dotenv": "^16.0.0",
@@ -61,7 +61,7 @@ export const packageJson = {
         "ora": "^6.1.2",
         "p-limit": "^4.0.0",
         "p-queue": "^7.3.4",
-        "p-retry": "^5.1.2",
+        "p-retry": "^6.0.0",
         "pg-protocol": "^1.6.0",
         "roarr": "^7.11.0",
         "semver": "^7.3.8",
@@ -85,7 +85,7 @@ export const packageJson = {
         "@types/yargs": "^17.0.13",
         "eslint": "^8.44.0",
         "jest": "^29.5.0",
-        "lint-staged": "^13.0.0",
+        "lint-staged": "^14.0.0",
         "prettier": "^3.0.0",
         "sinon": "^15.0.0"
     },

package/lib/utils.d.ts

@@ -28,8 +28,10 @@ export declare const getCliConfigWithPrompt: ({ key, readableKey, comments, defa
  * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
  */
 export declare function findLastIndex<T>(array: readonly T[], predicate: (value: T, index: number, object: readonly T[]) => boolean): number;
+export declare const inquireInstancePath: (initialPath?: string) => Promise<string>;
 export type ConnectorPackage = {
     name: string;
     path: string;
 };
 export declare const getConnectorPackagesFromDirectory: (directory: string) => Promise<ConnectorPackage[]>;
+export declare const lintLocaleFiles: (instancePath: string, packageName?: 'phrases' | 'phrases-experience') => Promise<void>;

package/lib/utils.js

@@ -1,16 +1,18 @@
-import { execSync } from 'node:child_process';
+import { execSync, execFile } from 'node:child_process';
 import { createWriteStream, existsSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import path from 'node:path';
+import { promisify } from 'node:util';
 import { ConsoleLog } from '@logto/shared';
-import { conditionalString } from '@silverhand/essentials';
+import { assert, conditionalString } from '@silverhand/essentials';
 import chalk from 'chalk';
 import { got } from 'got';
 import { HttpsProxyAgent } from 'hpagent';
 import inquirer from 'inquirer';
 import ora from 'ora';
 import { z } from 'zod';
+import { coreDirectory, defaultPath } from './constants.js';
 export const safeExecSync = (command) => {
     try {
         return execSync(command, { encoding: 'utf8', stdio: 'pipe' });
@@ -40,7 +42,7 @@ export const downloadFile = async (url, destination) => {
     });
     const spinner = ora({
         text: 'Connecting',
-        prefixText: chalk.blue('[info]'),
+        prefixText: ConsoleLog.prefixes.info,
     }).start();
     stream.pipe(file);
     return new Promise((resolve, reject) => {
@@ -66,7 +68,7 @@ export const getPathInModule = (moduleName, relativePath = '/') =>
 // https://stackoverflow.com/a/49455609/12514940
 path.join(path.dirname(createRequire(import.meta.url).resolve(`${moduleName}/package.json`)), relativePath);
 export const oraPromise = async (promise, options, exitOnError = false) => {
-    const spinner = ora(options).start();
+    const spinner = ora({ prefixText: ConsoleLog.prefixes.info, ...options }).start();
     try {
         const result = await promise;
         spinner.succeed();
@@ -120,6 +122,49 @@ export function findLastIndex(array, predicate) {
     }
     return -1;
 }
+const buildPathErrorMessage = (value) => `The path ${chalk.green(value)} does not contain a Logto instance. Please try another.`;
+const validatePath = async (value) => {
+    const corePackageJsonPath = path.resolve(path.join(value, coreDirectory, 'package.json'));
+    if (!existsSync(corePackageJsonPath)) {
+        return buildPathErrorMessage(value);
+    }
+    const packageJson = await readFile(corePackageJsonPath, { encoding: 'utf8' });
+    const packageName = await z
+        .object({ name: z.string() })
+        .parseAsync(JSON.parse(packageJson))
+        .then(({ name }) => name)
+        .catch(() => '');
+    if (packageName !== '@logto/core') {
+        return buildPathErrorMessage(value);
+    }
+    return true;
+};
+export const inquireInstancePath = async (initialPath) => {
+    const inquire = async () => {
+        if (!initialPath && (await validatePath('.')) === true) {
+            return path.resolve('.');
+        }
+        if (!isTty()) {
+            assert(initialPath, new Error('Path is missing'));
+            return initialPath;
+        }
+        const { instancePath } = await inquirer.prompt({
+            name: 'instancePath',
+            message: 'Where is your Logto instance?',
+            type: 'input',
+            default: defaultPath,
+            filter: (value) => value.trim(),
+            validate: validatePath,
+        }, { instancePath: initialPath });
+        return instancePath;
+    };
+    const instancePath = await inquire();
+    const validated = await validatePath(instancePath);
+    if (validated !== true) {
+        consoleLog.fatal(validated);
+    }
+    return instancePath;
+};
 const getConnectorPackageName = async (directory) => {
     const filePath = path.join(directory, 'package.json');
     if (!existsSync(filePath)) {
@@ -139,3 +184,20 @@ export const getConnectorPackagesFromDirectory = async (directory) => {
     }));
     return rawPackages.filter((packageInfo) => typeof packageInfo.name === 'string');
 };
+const execPromise = promisify(execFile);
+export const lintLocaleFiles = async (
+/** Logto instance path */
+instancePath, 
+/** Target package name, ignore to lint both packages */
+packageName) => {
+    const spinner = ora({
+        text: 'Running `eslint --fix` for locales',
+    }).start();
+    const targetPackages = packageName ? [packageName] : ['phrases', 'phrases-experience'];
+    await Promise.all(targetPackages.map(async (packageName) => {
+        const phrasesPath = path.join(instancePath, 'packages', packageName);
+        const localesPath = path.join(phrasesPath, 'src/locales');
+        await execPromise('pnpm', ['eslint', '--ext', '.ts', path.relative(phrasesPath, localesPath), '--fix'], { cwd: phrasesPath });
+    }));
+    spinner.succeed('Ran `eslint --fix` for locales');
+};