shutro-erp 0.2.1 → 0.3.1

package/dist/cli/launch.js

@@ -0,0 +1,138 @@
+/**
+ * After `shutro-erp init`: the project's dependencies installed with the package manager that ran the installer, the API
+ * and the back-office started, each waited for until it answers, and the back-office opened in the default browser.
+ * Both keep running in this terminal until Ctrl+C, which stops them together. Their output is kept, and shown when
+ * one of them fails to start.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+/** The package manager that ran the CLI (`npx`, `pnpm dlx`, `yarn dlx`, `bunx`), from its user agent; npm otherwise. */
+export function packageManager(env = process.env) {
+    const agent = env['npm_config_user_agent'] ?? '';
+    for (const pm of ['pnpm', 'yarn', 'bun'])
+        if (agent.startsWith(`${pm}/`))
+            return pm;
+    return 'npm';
+}
+/** The command that opens `url` in the default browser on `platform`. */
+export function browserCommand(url, platform = process.platform) {
+    if (platform === 'win32')
+        return ['cmd', ['/c', 'start', '""', url]];
+    if (platform === 'darwin')
+        return ['open', [url]];
+    return ['xdg-open', [url]];
+}
+const windows = process.platform === 'win32';
+/** A child process running `pm args` in `cwd`, its output kept (the last 200 lines). */
+function start(pm, args, cwd) {
+    const child = spawn(pm, args, {
+        cwd,
+        env: { ...process.env, FORCE_COLOR: '0' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        // npm, pnpm… are .cmd scripts on Windows; elsewhere a process group, stopped as a whole.
+        shell: windows,
+        detached: !windows,
+    });
+    const lines = [];
+    const keep = (chunk) => {
+        lines.push(...chunk
+            .toString()
+            .split(/\r?\n/)
+            .filter((l) => l.trim() !== ''));
+        lines.splice(0, Math.max(0, lines.length - 200));
+    };
+    child.stdout?.on('data', keep);
+    child.stderr?.on('data', keep);
+    const exited = new Promise((done) => child.on('close', (code) => done(code ?? 1)));
+    return { child, lines, exited };
+}
+/** Stops a started process and what it started. */
+function stop(child) {
+    if (child.pid === undefined || child.exitCode !== null)
+        return;
+    try {
+        if (windows)
+            spawnSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+        else
+            process.kill(-child.pid, 'SIGTERM');
+    }
+    catch {
+        // already gone
+    }
+}
+/** Resolves when `url` answers (any HTTP status below 500); rejects when `exited` settles first or on timeout. */
+async function answers(url, exited, seconds) {
+    let gone = null;
+    void exited.then((code) => {
+        gone = code;
+    });
+    for (let i = 0; i < seconds * 2; i++) {
+        if (gone !== null)
+            throw new Error(`it stopped (exit code ${gone})`);
+        try {
+            const res = await fetch(url, { signal: AbortSignal.timeout(1000) });
+            if (res.status < 500)
+                return;
+        }
+        catch {
+            // not yet
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    throw new Error(`no answer at ${url} within ${seconds}s`);
+}
+/**
+ * Installs, starts and opens the installation; returns when the user stops it (Ctrl+C) or a server stops by itself.
+ */
+export async function launch(o, ui) {
+    const pm = packageManager();
+    await ui.task(`Installing the dependencies (${pm} install)`, async (task) => {
+        task.update('the first run downloads them');
+        const run = start(pm, ['install'], o.dir);
+        const code = await run.exited;
+        if (code !== 0)
+            throw new Error(`${pm} install failed:\n${run.lines.slice(-15).join('\n')}`);
+    });
+    const api = start(pm, ['run', 'start'], o.dir);
+    const web = start(pm, ['run', 'web'], o.dir);
+    const stopAll = () => {
+        stop(api.child);
+        stop(web.child);
+    };
+    process.once('exit', stopAll);
+    const failed = (name, run) => (error) => {
+        stopAll();
+        const tail = run.lines.slice(-15).join('\n');
+        throw new Error(`The ${name} did not start: ${error instanceof Error ? error.message : String(error)}${tail === '' ? '' : `\n${tail}`}`);
+    };
+    const apiUrl = `http://localhost:${o.port}`;
+    const webUrl = `http://localhost:${o.webPort}`;
+    await ui
+        .task(`Starting the API on ${apiUrl}`, () => answers(`${apiUrl}/health/ready`, api.exited, 90))
+        .catch(failed('API', api));
+    await ui
+        .task(`Starting the back-office on ${webUrl}`, () => answers(webUrl, web.exited, 90))
+        .catch(failed('back-office', web));
+    const [command, args] = browserCommand(webUrl);
+    const opened = spawn(command, args, { stdio: 'ignore', detached: true, shell: false });
+    opened.on('error', () => ui.info(`Open ${webUrl} in your browser.`));
+    opened.unref();
+    ui.ok(`Opened ${ui.style('cyan', webUrl)} in your browser · sign in as "${o.login}"`);
+    ui.outro(`${ui.style('green', 'Shutro ERP is running')}  ${ui.style('gray', `back-office ${webUrl} · API ${apiUrl} · Ctrl+C stops both`)}`);
+    // Until Ctrl+C, or until one of them stops by itself (its last lines are shown).
+    const which = await Promise.race([
+        new Promise((done) => {
+            process.once('SIGINT', () => done('stopped'));
+            process.once('SIGTERM', () => done('stopped'));
+        }),
+        api.exited.then(() => 'api'),
+        web.exited.then(() => 'web'),
+    ]);
+    stopAll();
+    if (which === 'stopped') {
+        ui.write(`\n  ${ui.style('gray', `Stopped. Start again with: ${pm} start  and  ${pm} run web`)}\n`);
+        return;
+    }
+    const run = which === 'api' ? api : web;
+    ui.fail(`The ${which === 'api' ? 'API' : 'back-office'} stopped:`);
+    ui.write(`${run.lines.slice(-15).join('\n')}\n`);
+}

package/dist/cli/project.d.ts

@@ -1,13 +1,13 @@
 import type { KoshModule } from '../modules-sdk/index.js';
 import { type KoshServer } from '../server/index.js';
-/** The Kosh modules a file or package exports: `modules`, the default export, or every module export. */
+/** The Shutro ERP modules a file or package exports: `modules`, the default export, or every module export. */
 export declare function modulesOf(specifier: string, cwd: string): Promise<KoshModule[]>;
 /** Opens the installation in `cwd`: `.env`, the modules, a server (not listening). */
 export declare function openProject(cwd: string, modulesFile: string, options?: {
     /** `schema`: installed and disabled modules (what migrations keep); default: the installed ones (what is served). */
     readonly set?: 'served' | 'schema';
 }): Promise<KoshServer>;
-/** What seed data is loaded with: a server's, or an app change's transaction (`kosh apps`). */
+/** What seed data is loaded with: a server's, or an app change's transaction (`shutro-erp apps`). */
 export interface SeedContext {
     readonly shutro: KoshServer['shutro'];
     readonly driver: Pick<KoshServer['driver'], 'query'>;
@@ -24,13 +24,13 @@ export declare function migrateProject(server: KoshServer, dir: string, write: (
     allowDestructive?: boolean;
     seed?: boolean;
 }): Promise<number>;
-/** `kosh migrate [status] …` */
+/** `shutro-erp migrate [status] …` */
 export declare function runMigrate(argv: readonly string[], write: (t: string) => void, cwd: string): Promise<number>;
-/** `kosh seed [module …]` */
+/** `shutro-erp seed [module …]` */
 export declare function runSeed(argv: readonly string[], write: (t: string) => void, cwd: string): Promise<number>;
-/** The files of a new module (`kosh module create <name>`). */
+/** The files of a new module (`shutro-erp module create <name>`). */
 export declare function moduleFiles(name: string): Record<string, string>;
-/** `kosh module create <name>`: scaffolds src/modules/<name>/ and lists it in src/modules.ts. */
+/** `shutro-erp module create <name>`: scaffolds src/modules/<name>/ and lists it in src/modules.ts. */
 export declare function runModule(argv: readonly string[], write: (t: string) => void, cwd: string): Promise<number>;
-/** `kosh user create <login> …` and `kosh user password <login>`. */
+/** `shutro-erp user create <login> …` and `shutro-erp user password <login>`. */
 export declare function runUser(argv: readonly string[], write: (t: string) => void, cwd: string, prompter?: import('./prompt.js').Prompter): Promise<number>;

package/dist/cli/project.js

@@ -1,6 +1,6 @@
 /**
- * Commands that work on an installation (a folder made by `kosh init`): `kosh migrate`, `kosh seed`,
- * `kosh module create`. They read `.env` (DATABASE_URL, storage, ...) and the module list in `src/modules.ts`.
+ * Commands that work on an installation (a folder made by `shutro-erp init`): `shutro-erp migrate`, `shutro-erp seed`,
+ * `shutro-erp module create`. They read `.env` (DATABASE_URL, storage, ...) and the module list in `src/modules.ts`.
  *
  * - Schema migrations are versioned SQL files in `migrations/`, planned from the modules against the live database
  *   (Shutro migrate) and applied in order; each module's data migrations (`migrations` in its Shutro module) run
@@ -21,7 +21,7 @@ function isModule(value) {
         'accessLevels' in value &&
         'name' in value);
 }
-/** The Kosh modules a file or package exports: `modules`, the default export, or every module export. */
+/** The Shutro ERP modules a file or package exports: `modules`, the default export, or every module export. */
 export async function modulesOf(specifier, cwd) {
     const target = specifier.startsWith('.') ||
         specifier.startsWith('/') ||
@@ -39,7 +39,7 @@ export async function modulesOf(specifier, cwd) {
     }
     const all = Object.values(exported).filter(isModule);
     if (all.length === 0)
-        throw new Error(`${specifier} exports no Kosh modules (defineModule from shutro-erp/modules-sdk).`);
+        throw new Error(`${specifier} exports no Shutro ERP modules (defineModule from shutro-erp/modules-sdk).`);
     return all;
 }
 /** Opens the installation in `cwd`: `.env`, the modules, a server (not listening). */
@@ -49,9 +49,9 @@ export async function openProject(cwd, modulesFile, options = {}) {
         process.loadEnvFile(envFile);
     const databaseUrl = process.env['DATABASE_URL'];
     if (databaseUrl === undefined || databaseUrl === '')
-        throw new Error('DATABASE_URL is not set: run kosh init, or add it to .env.');
+        throw new Error('DATABASE_URL is not set: run shutro-erp init, or add it to .env.');
     if (!existsSync(resolve(cwd, modulesFile)))
-        throw new Error(`${modulesFile} does not exist: run kosh init, or pass --modules <file>.`);
+        throw new Error(`${modulesFile} does not exist: run shutro-erp init, or pass --modules <file>.`);
     process.env['KOSH_SCHEDULES'] = 'off';
     // The module list is the catalogue; the database says which of them are installed (RFC 0008).
     const modules = await installedModules(databaseUrl, await modulesOf(modulesFile, cwd), options.set === 'schema' ? ['installed', 'disabled'] : ['installed']);
@@ -93,7 +93,7 @@ export async function seedWith(context, write, only) {
         : context.modules.filter((m) => only.includes(m.name));
     for (const d of await installDefaults(context.shutro, context.modules, {
         company: companyId,
-        reason: 'kosh seed',
+        reason: 'shutro-erp seed',
     }))
         if (wanted.some((m) => m.name === d.module))
             write(`  ${d.module.padEnd(16)} ${d.summary}
@@ -117,7 +117,7 @@ async function apply(server, dir, write, allowDestructive) {
     }
     catch (error) {
         if (error instanceof Error && error.name === 'DestructiveMigrationError') {
-            write(`${error.message}\nReview it, then run kosh migrate --allow-destructive.\n`);
+            write(`${error.message}\nReview it, then run shutro-erp migrate --allow-destructive.\n`);
             return 1;
         }
         throw error;
@@ -152,7 +152,7 @@ export async function migrateProject(server, dir, write, options = {}) {
     if (options.planOnly === true)
         return 0;
     if (plan.destructive.length > 0 && options.allowDestructive !== true) {
-        write('It drops or changes existing data: review the file, then run kosh migrate --allow-destructive.\n');
+        write('It drops or changes existing data: review the file, then run shutro-erp migrate --allow-destructive.\n');
         return 1;
     }
     if (plan.statements.length > 0 || pending.length === 0) {
@@ -173,11 +173,11 @@ export async function migrateProject(server, dir, write, options = {}) {
             await seed(server, write, served !== undefined && served.length > 0 ? served : undefined);
         }
         else
-            write('No company yet: seed data waits for kosh init.\n');
+            write('No company yet: seed data waits for shutro-erp init.\n');
     }
     return 0;
 }
-/** `kosh migrate [status] …` */
+/** `shutro-erp migrate [status] …` */
 export async function runMigrate(argv, write, cwd) {
     const { values, positionals } = parseArgs({
         args: [...argv],
@@ -217,7 +217,7 @@ export async function runMigrate(argv, write, cwd) {
         await server.close();
     }
 }
-/** `kosh seed [module …]` */
+/** `shutro-erp seed [module …]` */
 export async function runSeed(argv, write, cwd) {
     const { values, positionals } = parseArgs({
         args: [...argv],
@@ -239,7 +239,7 @@ const title = (name) => name
     .split(/[-_]+/)
     .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
     .join(' ');
-/** The files of a new module (`kosh module create <name>`). */
+/** The files of a new module (`shutro-erp module create <name>`). */
 export function moduleFiles(name) {
     const id = camel(name);
     const label = title(name);
@@ -265,7 +265,7 @@ export const Item = defineModel('${model}', {
 });
 `,
         'data.ts': `/**
- * Seed data of the ${label} module: \`kosh seed\` (and \`kosh migrate\`) create these records, update them when they
+ * Seed data of the ${label} module: \`shutro-erp seed\` (and \`shutro-erp migrate\`) create these records, update them when they
  * change here, and delete records removed from this list. \`noupdate\` records are created once, then left to the users.
  * Refer to other records by external id: orm.ref('res.currency', 'base.currency_bdt').
  */
@@ -277,7 +277,7 @@ export const data = [
 `,
         'migrations.ts': `/**
  * Data migrations of the ${label} module: each runs once, when an installed module is upgraded past its version
- * (raise \`version\` in index.ts, then \`kosh migrate\`). Schema changes need none: \`kosh migrate\` plans them.
+ * (raise \`version\` in index.ts, then \`shutro-erp migrate\`). Schema changes need none: \`shutro-erp migrate\` plans them.
  */
 import type { DataMigration } from 'shutro-erp/orm';
 
@@ -293,7 +293,7 @@ export const migrations: DataMigration[] = [
 `,
         'index.ts': `/**
  * The ${label} module: its Shutro models, groups, seed data and data migrations, plus access levels, an app,
- * menus, actions and views. Installed by listing it in src/modules.ts, then \`kosh migrate\`.
+ * menus, actions and views. Installed by listing it in src/modules.ts, then \`shutro-erp migrate\`.
  */
 import { base, baseShutro } from 'shutro-erp';
 import { defineModule } from 'shutro-erp/modules-sdk';
@@ -340,11 +340,11 @@ export const ${id} = defineModule({
 `,
     };
 }
-/** `kosh module create <name>`: scaffolds src/modules/<name>/ and lists it in src/modules.ts. */
+/** `shutro-erp module create <name>`: scaffolds src/modules/<name>/ and lists it in src/modules.ts. */
 export async function runModule(argv, write, cwd) {
     const [action, name] = argv;
     if (action !== 'create' || name === undefined) {
-        write('Usage: kosh module create <name>   (lower-case letters, digits and -, e.g. library)\n');
+        write('Usage: shutro-erp module create <name>   (lower-case letters, digits and -, e.g. library)\n');
         return 2;
     }
     if (!/^[a-z][a-z0-9-]{1,40}$/.test(name) ||
@@ -379,7 +379,7 @@ export async function runModule(argv, write, cwd) {
         else
             write(`  add ${id} to the modules list in src/modules.ts\n`);
     }
-    write(`\nNext: kosh apps install ${name}   (creates its tables and loads its seed data, in one transaction)\n`);
+    write(`\nNext: shutro-erp apps install ${name}   (creates its tables and loads its seed data, in one transaction)\n`);
     return 0;
 }
 /** The access levels a role list names: `reporting.user`, `messaging.user`, … (groups of installed modules). */
@@ -396,7 +396,7 @@ function groupsOf(server, roles) {
         throw new Error(`Unknown role(s): ${unknown.join(', ')}. Known: ${[...known].sort().join(', ')}.`);
     return list;
 }
-/** `kosh user create <login> …` and `kosh user password <login>`. */
+/** `shutro-erp user create <login> …` and `shutro-erp user password <login>`. */
 export async function runUser(argv, write, cwd, prompter) {
     const { values, positionals } = parseArgs({
         args: [...argv],
@@ -411,8 +411,8 @@ export async function runUser(argv, write, cwd, prompter) {
     });
     const [action, login] = positionals;
     if ((action !== 'create' && action !== 'password') || login === undefined) {
-        write('Usage: kosh user create <login> [--name <name>] [--email <email>] [--roles a.user,b.manager] [--password <pw>]\n' +
-            '       kosh user password <login> [--password <pw>]\n');
+        write('Usage: shutro-erp user create <login> [--name <name>] [--email <email>] [--roles a.user,b.manager] [--password <pw>]\n' +
+            '       shutro-erp user password <login> [--password <pw>]\n');
         return 2;
     }
     const { terminalPrompter } = await import('./prompt.js');
@@ -436,7 +436,7 @@ export async function runUser(argv, write, cwd, prompter) {
             params: [],
         });
         if (company === undefined)
-            throw new Error('No company yet: run kosh init first.');
+            throw new Error('No company yet: run shutro-erp init first.');
         const [user] = await server.driver.query({
             text: 'SELECT id::text AS id FROM res_users WHERE login = $1',
             params: [login],
@@ -444,7 +444,7 @@ export async function runUser(argv, write, cwd, prompter) {
         if (action === 'password') {
             if (user === undefined)
                 throw new Error(`No user "${login}".`);
-            await server.shutro.bootstrap({ reason: `kosh user password ${login}` }, (env) => auth.setPassword(env, Number(user.id), password));
+            await server.shutro.bootstrap({ reason: `shutro-erp user password ${login}` }, (env) => auth.setPassword(env, Number(user.id), password));
             write(`Password of "${login}" changed.\n`);
             return 0;
         }
@@ -459,7 +459,7 @@ export async function runUser(argv, write, cwd, prompter) {
             groups: groupsOf(server, values.roles),
         });
         if (values.email !== undefined)
-            await server.shutro.bootstrap({ reason: `kosh user create ${login}` }, async (env) => {
+            await server.shutro.bootstrap({ reason: `shutro-erp user create ${login}` }, async (env) => {
                 await env.model('res.users')
                     .browse([id])
                     .write({ email: values.email });

package/dist/cli/prompt.d.ts

@@ -7,11 +7,46 @@ export interface Question {
     /** An error message for an invalid answer (asked again), or `null`. */
     readonly validate?: (value: string) => string | null;
 }
+/** One option of a choice: what is answered, what is shown, an optional hint beside it. */
+export interface Choice {
+    readonly value: string;
+    readonly label: string;
+    readonly hint?: string;
+}
+export interface SelectQuestion {
+    readonly message: string;
+    readonly choices: readonly Choice[];
+    /** The value chosen when Enter is pressed at once. */
+    readonly default?: string;
+}
+export interface MultiQuestion {
+    readonly message: string;
+    readonly choices: readonly Choice[];
+    /** The values ticked to begin with. */
+    readonly defaults?: readonly string[];
+    /** At least one. */
+    readonly required?: boolean;
+}
 export interface Prompter {
     ask(question: Question): Promise<string>;
     confirm(message: string, fallback: boolean): Promise<boolean>;
+    /** One of several (a list chosen with the keyboard); without it, {@link choose} asks a question instead. */
+    select?(question: SelectQuestion): Promise<string>;
+    /** Several of several; without it, {@link chooseMany} asks for a comma-separated list. */
+    multiselect?(question: MultiQuestion): Promise<string[]>;
     close(): void;
 }
+/**
+ * One of `choices`: the prompter's list when it has one, otherwise the question `fallback` (pipes, scripts, tests),
+ * answered with an option's number, value or label.
+ */
+export declare function choose(prompter: Prompter, q: SelectQuestion & {
+    readonly fallback: string;
+}): Promise<string>;
+/** Several of `choices`: the prompter's list, or a comma-separated answer to `fallback`. */
+export declare function chooseMany(prompter: Prompter, q: MultiQuestion & {
+    readonly fallback: string;
+}): Promise<string[]>;
 /** Thrown when the input ends before every question is answered (piped answers ran out, Ctrl+D). */
 export declare class InputEndedError extends Error {
     constructor(question: string);

package/dist/cli/prompt.js

@@ -1,8 +1,54 @@
 /**
- * Terminal questions for `kosh init`, on `node:readline` (no dependency). Answers can be scripted for tests and
+ * Terminal questions for `shutro-erp init`, on `node:readline` (no dependency). Answers can be scripted for tests and
  * non-interactive installs (`--yes` with flags): every question goes through {@link Prompter}.
  */
 import { createInterface } from 'node:readline';
+/**
+ * One of `choices`: the prompter's list when it has one, otherwise the question `fallback` (pipes, scripts, tests),
+ * answered with an option's number, value or label.
+ */
+export async function choose(prompter, q) {
+    if (prompter.select !== undefined)
+        return prompter.select(q);
+    const find = (answer) => {
+        const a = answer.trim().toLowerCase();
+        if (/^\d+$/.test(a))
+            return q.choices[Number(a) - 1];
+        return q.choices.find((c) => c.value.toLowerCase() === a || c.label.toLowerCase() === a);
+    };
+    const answer = await prompter.ask({
+        message: q.fallback,
+        ...(q.default === undefined ? {} : { default: q.default }),
+        validate: (v) => find(v) === undefined ? `One of ${q.choices.map((c) => c.value).join(', ')}` : null,
+    });
+    return find(answer).value;
+}
+/** Several of `choices`: the prompter's list, or a comma-separated answer to `fallback`. */
+export async function chooseMany(prompter, q) {
+    if (prompter.multiselect !== undefined)
+        return prompter.multiselect(q);
+    const known = new Set(q.choices.map((c) => c.value));
+    const answer = await prompter.ask({
+        message: q.fallback,
+        default: (q.defaults ?? []).join(','),
+        validate: (v) => {
+            const items = v
+                .split(',')
+                .map((x) => x.trim())
+                .filter((x) => x !== '');
+            const unknown = items.filter((x) => !known.has(x));
+            if (unknown.length > 0)
+                return `Unknown: ${unknown.join(', ')}`;
+            return q.required === true && items.length === 0 ? 'Choose at least one.' : null;
+        },
+    });
+    return [
+        ...new Set(answer
+            .split(',')
+            .map((x) => x.trim())
+            .filter((x) => x !== '')),
+    ];
+}
 /** Thrown when the input ends before every question is answered (piped answers ran out, Ctrl+D). */
 export class InputEndedError extends Error {
     constructor(question) {
@@ -104,7 +150,7 @@ export function defaultsPrompter() {
     return {
         async ask(q) {
             if (q.default === undefined)
-                throw new Error(`"${q.message}" has no default: pass it as a flag (kosh init --help).`);
+                throw new Error(`"${q.message}" has no default: pass it as a flag (shutro-erp init --help).`);
             const problem = q.validate?.(q.default) ?? null;
             if (problem !== null)
                 throw new Error(`${q.message}: ${problem}`);

package/dist/cli/templates.d.ts

@@ -1,8 +1,8 @@
 /**
- * The starter project `kosh init` writes: an API server and the back-office app, both importing `shutro-erp`.
+ * The starter project `shutro-erp init` writes: an API server and the back-office app, both importing `shutro-erp`.
  * Server files run on Node.js directly (type stripping); the back-office is a Vite app proxying `/api` to the server.
  */
-export type AppName = 'permissions' | 'reporting' | 'messaging' | 'contacts' | 'product' | 'sales' | 'purchase' | 'accounting' | 'sale_account' | 'purchase_account' | 'project' | 'sale_project';
+export type AppName = 'permissions' | 'reporting' | 'messaging' | 'contacts' | 'product' | 'sales' | 'purchase' | 'accounting' | 'sale_account' | 'purchase_account' | 'project' | 'sale_project' | 'l10n_bd' | 'l10n_in';
 export interface AppSpec {
     readonly label: string;
     /** Shown next to the app in the installer (where the terminal shows pictographs). */
@@ -13,17 +13,21 @@ export interface AppSpec {
     readonly web?: string;
     /** A bridge (RFC 0008 §5.1): not offered in the installer; proposed when the apps it connects are installed. */
     readonly bridge?: readonly AppName[];
+    /** A localization (RFC 0016): installed, with its bridged apps, for a company in this country (ISO 3166). */
+    readonly country?: string;
 }
-/** The apps `kosh init` can install (base and Settings are always there), in the order the installer lists them. */
+/** The apps `shutro-erp init` can install (base and Settings are always there), in the order the installer lists them. */
 export declare const APPS: Readonly<Record<AppName, AppSpec>>;
 export interface StarterOptions {
     readonly name: string;
     readonly apps: readonly AppName[];
     readonly port: number;
+    /** The back-office's port in development (default 5173). */
+    readonly webPort?: number;
     readonly koshVersion: string;
     /** The database name of the Docker PostgreSQL service (compose.yaml). */
     readonly dockerDb?: string;
-    /** Attachments in a folder (KOSH_STORAGE_DIR) rather than S3. */
+    /** Attachments in a folder (SHUTRO_ERP_STORAGE_DIR) rather than S3. */
     readonly fileStorage?: boolean;
 }
 /** The project's package.json (merged into an existing one: missing scripts and dependencies are added). */
@@ -52,5 +56,9 @@ export declare function tsconfig(): string;
 export declare function readme(options: StarterOptions): string;
 /** The apps the installer offers (every app but the bridges, which come by themselves). */
 export declare const SELECTABLE_APPS: readonly AppName[];
-/** The bridges whose every connected app is in `apps`. */
-export declare function bridgesFor(apps: readonly AppName[]): AppName[];
+/** The bridges whose every connected app is in `apps`, and the localization of `country` among them. */
+export declare function bridgesFor(apps: readonly AppName[], country?: string): AppName[];
+/** The names of the countries with a localization (the installer's list). */
+export declare const COUNTRY_NAMES: Readonly<Record<string, string>>;
+/** The countries with a localization, for the installer's question. */
+export declare const LOCALIZED_COUNTRIES: readonly string[];