@steerable/agent-cli 0.6.73 → 0.7.1

package/dist/approve.d.ts

@@ -1,9 +1,21 @@
 import type { ApprovalDecisionKind } from '@steerable/agent-client';
 export type ApprovePolicy = 'deny' | 'allow-read' | 'allow-all';
+export type ApprovalSurface = 'run' | 'tui';
+export interface ApprovalSpec {
+    policy: ApprovePolicy | 'ask';
+    answerAsk: boolean;
+}
+export declare function resolveApprovalRequest(raw: string | undefined, surface: ApprovalSurface): ApprovalSpec | null;
 export declare function parseApprovePolicy(raw: string | undefined): ApprovePolicy | null;
-/** Headless answer for one approval prompt. Denied read-policy calls still exit 3. */
-export declare function decisionFor(policy: ApprovePolicy, prompt: {
-    toolName?: string;
-    category?: string;
-}): ApprovalDecisionKind;
+/**
+ * `mode` is the declared tool mode. A missing mode is not treated as read.
+ * `prompt` means the TUI should show the card.
+ */
+export declare function decisionFor(spec: ApprovalSpec, prompt: {
+    mode?: string;
+}, surface: ApprovalSurface): ApprovalDecisionKind | 'prompt';
+export declare function unattendedAskText(): string;
+export declare function autoAnswer(questions: {
+    id: string;
+}[], text?: string): Record<string, string>;
 export declare function denied(kind: ApprovalDecisionKind): boolean;

package/dist/approve.js

@@ -1,25 +1,44 @@
-const READ_TOOLS = new Set([
-    'local_read_file',
-    'local_list_scripts',
-    'web_search',
-    'web_fetch',
-]);
-export function parseApprovePolicy(raw) {
-    if (raw === undefined || raw === 'deny' || raw === 'allow-read' || raw === 'allow-all') {
-        return raw ?? 'deny';
+import { cliText } from './copy.js';
+export function resolveApprovalRequest(raw, surface) {
+    if (raw === undefined) {
+        return surface === 'tui'
+            ? { policy: 'ask', answerAsk: false }
+            : { policy: 'deny', answerAsk: false };
     }
-    return null;
+    if (raw !== 'deny' && raw !== 'allow-read' && raw !== 'allow-all')
+        return null;
+    return { policy: raw, answerAsk: raw === 'allow-all' };
+}
+export function parseApprovePolicy(raw) {
+    const spec = resolveApprovalRequest(raw, 'run');
+    if (!spec || spec.policy === 'ask')
+        return null;
+    return spec.policy;
 }
-/** Headless answer for one approval prompt. Denied read-policy calls still exit 3. */
-export function decisionFor(policy, prompt) {
-    if (policy === 'allow-all')
+/**
+ * `mode` is the declared tool mode. A missing mode is not treated as read.
+ * `prompt` means the TUI should show the card.
+ */
+export function decisionFor(spec, prompt, surface) {
+    if (spec.policy === 'allow-all')
         return 'allow_once';
-    const toolName = prompt.toolName ?? '';
-    const category = prompt.category ?? '';
-    if (policy === 'allow-read' && (category === 'read' || READ_TOOLS.has(toolName)))
+    if (spec.policy === 'ask')
+        return 'prompt';
+    if (spec.policy === 'allow-read' && prompt.mode === 'read')
         return 'allow_once';
+    if (spec.policy === 'allow-read' && surface === 'tui')
+        return 'prompt';
     return 'deny_once';
 }
+export function unattendedAskText() {
+    return cliText('ask.unattended');
+}
+export function autoAnswer(questions, text = unattendedAskText()) {
+    const answers = {};
+    for (const question of questions)
+        answers[question.id] = text;
+    return answers;
+}
 export function denied(kind) {
     return kind === 'deny_once' || kind === 'deny_for_session' || kind === 'deny_always' || kind === 'abort';
 }

package/dist/bin.js

@@ -1,3 +1,7 @@
 #!/usr/bin/env node
-import { createCli } from './cli.js';
-process.exit(await createCli({ installSignals: true }));
+import { ensureSupportedNode } from './node-version.js';
+const status = ensureSupportedNode(process.versions.node, process.stderr, 'steerable-cli');
+if (status !== 0)
+    process.exit(status);
+const { createCli } = await import('./cli.js');
+process.exit(await createCli({ installSignals: true, commandName: 'steerable-cli' }));

package/dist/cli.d.ts

@@ -10,5 +10,7 @@ export interface CliOptions {
     createClient?: (options: LocalClientOptions) => Promise<AgentClient>;
     installSignals?: boolean;
     commands?: readonly CliCommandSpec[];
+    /** Bin name written in place of `<product>` in help and protected-directory text. */
+    commandName?: string;
 }
 export declare function createCli(options?: CliOptions): Promise<number>;

package/dist/cli.js

@@ -5,9 +5,11 @@ import { restoreLogConsole, silenceLogConsole } from '@steerable/agent-shell/log
 import { collectPackCliCommands, } from '@steerable/agent-shell/host/pack-cli';
 import { getUserDataDir } from '@steerable/agent-shell/runtime';
 import { applyHostRuntimeEnv, createLocalClient, listBusyChatIds, } from '@steerable/agent-client';
-import { parseApprovePolicy } from './approve.js';
+import { nodeDoctorLine } from './node-version.js';
+import { parseApprovePolicy, resolveApprovalRequest } from './approve.js';
+import { defaultProjectFs, projectStatusLabel, protectedTuiMessage, resolveProjectRequest, } from './project-binding.js';
 import { chatCommand, configCommand, mcpCommand, skillsCommand } from './commands.js';
-import { chatHelp, configHelp, doctorHelp, mcpHelp, rootHelp, runHelp, skillsHelp, tuiHelp } from './help.js';
+import { chatHelp, configHelp, doctorHelp, mcpHelp, renderCommandName, rootHelp, runHelp, skillsHelp, tuiHelp } from './help.js';
 import { runTurn } from './run.js';
 import { runTui } from './tui/run.js';
 export async function createCli(options = {}) {
@@ -47,6 +49,9 @@ async function runCli(options) {
                 json: { type: 'boolean' },
                 'stream-json': { type: 'boolean' },
                 cwd: { type: 'string' },
+                project: { type: 'string' },
+                'no-project': { type: 'boolean', default: false },
+                trust: { type: 'boolean', default: false },
                 timeout: { type: 'string' },
                 'data-dir': { type: 'string' },
                 agent: { type: 'string' },
@@ -56,12 +61,12 @@ async function runCli(options) {
         });
     }
     catch (error) {
-        stderr.write(`${error instanceof Error ? error.message : String(error)}\n${rootHelp(packCommands)}\n`);
+        stderr.write(`${error instanceof Error ? error.message : String(error)}\n${present(options, rootHelp(packCommands))}\n`);
         return 2;
     }
     const command = parsed.positionals[0];
     if (parsed.values.help && !command) {
-        stdout.write(`${rootHelp(packCommands)}\n`);
+        stdout.write(`${present(options, rootHelp(packCommands))}\n`);
         return 0;
     }
     if (!command)
@@ -69,13 +74,13 @@ async function runCli(options) {
     if (command === 'run')
         return runCommand(parsed, options, stdout, stderr);
     if (command === 'chat')
-        return dispatch(parsed, options, stdout, stderr, chatHelp(), chatCommand);
+        return dispatch(parsed, options, stdout, stderr, present(options, chatHelp()), chatCommand);
     if (command === 'skills')
-        return dispatch(parsed, options, stdout, stderr, skillsHelp(), skillsCommand);
+        return dispatch(parsed, options, stdout, stderr, present(options, skillsHelp()), skillsCommand);
     if (command === 'mcp')
-        return dispatch(parsed, options, stdout, stderr, mcpHelp(), mcpCommand);
+        return dispatch(parsed, options, stdout, stderr, present(options, mcpHelp()), mcpCommand);
     if (command === 'config')
-        return dispatch(parsed, options, stdout, stderr, configHelp(), configCommand);
+        return dispatch(parsed, options, stdout, stderr, present(options, configHelp()), configCommand);
     if (command === 'doctor')
         return doctorCommand(parsed, options, stdout, stderr);
     if (command === 'tui')
@@ -83,56 +88,68 @@ async function runCli(options) {
     const pack = packCommands.find((entry) => entry.name === command);
     if (pack)
         return runPackCommand(pack, parsed, options, stdout, stderr);
-    stderr.write(`unknown command: ${command}\n${rootHelp(packCommands)}\n`);
+    stderr.write(`unknown command: ${command}\n${present(options, rootHelp(packCommands))}\n`);
     return 2;
 }
 async function runPackCommand(command, parsed, options, stdout, stderr) {
     if (parsed.values.help) {
-        stdout.write(`<product> ${command.name}\n${command.summary}\n`);
+        stdout.write(present(options, `<product> ${command.name}\n${command.summary}\n`));
         return 0;
     }
     return withClient(parsed, options, async (client) => command.run(parsed.positionals.slice(1), {
-        write: (text) => stdout.write(text),
-        writeError: (text) => stderr.write(text),
+        write: (text) => stdout.write(present(options, text)),
+        writeError: (text) => stderr.write(present(options, text)),
         request: (method, requestPath, body) => client.request(method, requestPath, body),
     }), stderr);
 }
 async function runCommand(parsed, options, stdout, stderr) {
     if (parsed.values.help) {
-        stdout.write(`${runHelp()}\n`);
+        stdout.write(`${present(options, runHelp())}\n`);
         return 0;
     }
     const policy = parseApprovePolicy(parsed.values.approve);
     if (!policy) {
-        stderr.write(`unknown --approve value\n${runHelp()}\n`);
+        stderr.write(`unknown --approve value\n${present(options, runHelp())}\n`);
         return 2;
     }
     let timeoutMs;
     if (typeof parsed.values.timeout === 'string') {
         const parsedTimeout = parseTimeout(parsed.values.timeout);
         if (parsedTimeout === null) {
-            stderr.write(`invalid --timeout\n${runHelp()}\n`);
+            stderr.write(`invalid --timeout\n${present(options, runHelp())}\n`);
             return 2;
         }
         timeoutMs = parsedTimeout;
     }
     const task = await readTask(parsed.positionals.slice(1), options);
     if (!task.trim()) {
-        stderr.write(`missing task\n${runHelp()}\n`);
+        stderr.write(`missing task\n${present(options, runHelp())}\n`);
         return 2;
     }
     const request = {
         task: task.trim(),
         ...(typeof parsed.values.chat === 'string' ? { chatId: parsed.values.chat } : {}),
         ...(typeof parsed.values.agent === 'string' ? { agentId: parsed.values.agent } : {}),
-        ...(typeof parsed.values.cwd === 'string' ? { cwd: parsed.values.cwd } : {}),
         files: parsed.values.file ?? [],
         policy,
         json: parsed.values.json === true,
         streamJson: parsed.values['stream-json'] === true,
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
     };
-    return withClient(parsed, options, async (client, signal) => runTurn(client, request, stdout, stderr, signal));
+    const spec = projectSpec(parsed);
+    if (spec.kind === 'error') {
+        stderr.write(`${present(options, spec.message)}\n`);
+        return spec.code;
+    }
+    return withClient(parsed, options, async (client, signal) => {
+        const bound = await bindAndTrust(client, parsed, spec, stderr);
+        if (typeof bound === 'number')
+            return bound;
+        return runTurn(client, {
+            ...request,
+            ...(bound ? { projectId: bound.id } : {}),
+        }, stdout, stderr, signal);
+    });
 }
 function commandIO(parsed) {
     return {
@@ -147,29 +164,54 @@ async function dispatch(parsed, options, stdout, stderr, help, command) {
 }
 async function tuiCommand(parsed, options, stdout, stderr) {
     if (parsed.values.help) {
-        stdout.write(`${tuiHelp()}\n`);
+        stdout.write(`${present(options, tuiHelp())}\n`);
         return 0;
     }
+    const approval = resolveApprovalRequest(typeof parsed.values.approve === 'string' ? parsed.values.approve : undefined, 'tui');
+    if (!approval) {
+        stderr.write(`unknown --approve value\n${present(options, tuiHelp())}\n`);
+        return 2;
+    }
     const tty = options.stdinIsTTY ?? Boolean(process.stdin.isTTY);
     if (!tty) {
-        stderr.write(`tui needs a terminal. Use run for piped input.\n${tuiHelp()}\n`);
+        stderr.write(`tui needs a terminal. Use run for piped input.\n${present(options, tuiHelp())}\n`);
         return 2;
     }
+    const spec = projectSpec(parsed);
+    if (spec.kind === 'error') {
+        if (spec.reason === 'protected' && spec.protectedKind) {
+            stderr.write(`${present(options, protectedTuiMessage(spec.protectedKind))}\n`);
+            stderr.write('q 退出\n');
+            await waitForQuit(options.stdin ?? process.stdin);
+        }
+        else {
+            stderr.write(`${present(options, spec.message)}\n`);
+        }
+        return spec.code;
+    }
     if ((options.stdout ?? process.stdout) === process.stdout)
         silenceLogConsole('all');
-    return withClient(parsed, options, async (client) => runTui({
-        client,
-        product: getBrand().displayName,
-        dataDir: dataDirFrom(parsed, options.env ?? process.env),
-    }), stderr);
+    return withClient(parsed, options, async (client) => {
+        const bound = await bindAndTrust(client, parsed, spec, stderr);
+        if (typeof bound === 'number')
+            return bound;
+        return runTui({
+            client,
+            product: getBrand().displayName,
+            dataDir: dataDirFrom(parsed, options.env ?? process.env),
+            ...(bound ? { projectId: bound.id, projectLabel: bound.label } : { projectLabel: projectStatusLabel(null) }),
+            approvalPolicy: approval,
+        });
+    }, stderr);
 }
 async function doctorCommand(parsed, options, stdout, stderr) {
     if (parsed.values.help) {
-        stdout.write(`${doctorHelp()}\n`);
+        stdout.write(`${present(options, doctorHelp())}\n`);
         return 0;
     }
     const dataDir = dataDirFrom(parsed, options.env ?? process.env);
     const report = applyHostRuntimeEnv(dataDir, options.env ?? process.env);
+    stdout.write(nodeDoctorLine(process.versions.node));
     stdout.write(`data dir: ${dataDir}\n`);
     stdout.write(`log file: ${path.join(dataDir, 'logs', 'main.log')}\n`);
     stdout.write(`runtime file: ${report.fileFound ? report.filePath : 'missing'}\n`);
@@ -230,6 +272,64 @@ async function withClient(parsed, options, body, stderr = options.stderr ?? proc
         await client?.close();
     }
 }
+function projectSpec(parsed) {
+    const fs = defaultProjectFs();
+    return resolveProjectRequest({
+        cwd: process.cwd(),
+        ...(typeof parsed.values.project === 'string' ? { projectArg: parsed.values.project } : {}),
+        ...(typeof parsed.values.cwd === 'string' ? { cwdArg: parsed.values.cwd } : {}),
+        noProject: parsed.values['no-project'] === true,
+        ...fs,
+    });
+}
+async function bindProject(client, spec, stderr) {
+    if (spec.kind === 'none')
+        return null;
+    if (spec.kind === 'error')
+        return spec.code;
+    const response = await client.request('POST', '/api/v2/projects/resolve', {
+        folderPath: spec.dir,
+        origin: 'cli',
+    });
+    const data = response.data;
+    if (response.status === 403) {
+        stderr.write('该产品未启用项目模式，请使用 --no-project。\n');
+        return 2;
+    }
+    const project = data.project;
+    if (response.status !== 200 || !project?.id || !project.name || !project.folderPath) {
+        stderr.write(`${data.error ?? `failed to bind project (${response.status})`}\n`);
+        return 2;
+    }
+    if (data.created)
+        stderr.write(`已绑定项目 ${project.name}：${project.folderPath}\n`);
+    return {
+        id: project.id,
+        label: projectStatusLabel({ name: project.name, folderPath: project.folderPath }),
+    };
+}
+async function bindAndTrust(client, parsed, spec, stderr) {
+    if (parsed.values.trust === true && spec.kind === 'none') {
+        stderr.write('--trust 需要绑定项目，不能与 --no-project 同用。\n');
+        return 2;
+    }
+    const bound = await bindProject(client, spec, stderr);
+    if (typeof bound === 'number' || !bound || parsed.values.trust !== true)
+        return bound;
+    const trusted = await client.request('PUT', `/api/v2/projects/${encodeURIComponent(bound.id)}/trust`, { trusted: true });
+    if (trusted.status !== 200) {
+        const data = trusted.data;
+        stderr.write(`${data.error ?? `failed to trust project (${trusted.status})`}\n`);
+        return 1;
+    }
+    return bound;
+}
+async function waitForQuit(stdin) {
+    for await (const chunk of stdin) {
+        if (String(chunk).includes('q'))
+            return;
+    }
+}
 function dataDirFrom(parsed, env) {
     if (typeof parsed.values['data-dir'] === 'string')
         return parsed.values['data-dir'];
@@ -237,6 +337,9 @@ function dataDirFrom(parsed, env) {
         return env.DEEPPATH_USER_DATA_DIR;
     return getUserDataDir();
 }
+function present(options, text) {
+    return renderCommandName(text, options.commandName);
+}
 function parseTimeout(raw) {
     const match = /^(\d+)(ms|s|m)?$/.exec(raw.trim());
     if (!match)

package/dist/copy.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Command-line copy. Product packs do not override these strings.
+ */
+export declare const cliCopy: {
+    readonly 'ask.unattended': "无人可答，请按最合理的默认继续。";
+    readonly 'cli.approveAllWarning': "警告：--approve allow-all 会放行本次运行中的全部审批";
+    readonly 'tui.approvalClosed': "审批已关闭";
+    readonly 'tui.approvalRead': "只读自动放行";
+    readonly 'tui.toolAuto': "自动";
+    readonly 'tui.toolAutoAnswer': "自动回答";
+    readonly 'tui.toolSessionAllow': "本会话已允许";
+};
+export type CliCopyKey = keyof typeof cliCopy;
+/** @param key Dictionary key. @returns The command-line string for that key. */
+export declare function cliText(key: CliCopyKey): string;

package/dist/copy.js

@@ -0,0 +1,16 @@
+/**
+ * Command-line copy. Product packs do not override these strings.
+ */
+export const cliCopy = {
+    'ask.unattended': '无人可答，请按最合理的默认继续。',
+    'cli.approveAllWarning': '警告：--approve allow-all 会放行本次运行中的全部审批',
+    'tui.approvalClosed': '审批已关闭',
+    'tui.approvalRead': '只读自动放行',
+    'tui.toolAuto': '自动',
+    'tui.toolAutoAnswer': '自动回答',
+    'tui.toolSessionAllow': '本会话已允许',
+};
+/** @param key Dictionary key. @returns The command-line string for that key. */
+export function cliText(key) {
+    return cliCopy[key];
+}

package/dist/help.d.ts

@@ -9,3 +9,14 @@ export declare function mcpHelp(): string;
 export declare function configHelp(): string;
 export declare function tuiHelp(): string;
 export declare function doctorHelp(): string;
+/** Placeholder left in help text until a product bin supplies its command name. */
+export declare const COMMAND_NAME_TOKEN = "<product>";
+/**
+ * Replaces {@link COMMAND_NAME_TOKEN} with the running bin name.
+ * A blank name, the token itself, or a name that is not a command token is left unchanged.
+ *
+ * @param text Help or protected-directory text.
+ * @param commandName Bin name such as `aroli` or `steerable-cli`.
+ * @returns Text with the placeholder replaced when the name is usable.
+ */
+export declare function renderCommandName(text: string, commandName: string | undefined): string;

package/dist/help.js

@@ -19,8 +19,8 @@ export function rootHelp(commands = []) {
     return `
 Usage:
   <product> run "<task>" [--chat <id>] [--approve deny|allow-read|allow-all]
-                         [--json | --stream-json] [--cwd <dir>] [--timeout <dur>]
-                         [--data-dir <dir>] [--agent <id>] [--file <path>...]
+                         [--json | --stream-json] [--project <dir> | --cwd <dir> | --no-project] [--trust]
+                         [--timeout <dur>] [--data-dir <dir>] [--agent <id>] [--file <path>...]
   <product> chat list | show <id> | rm <id> | export <id> [--format md|json]
   <product> skills list
   <product> mcp list | add <name> -- <cmd...> | rm <name>
@@ -35,9 +35,15 @@ export function runHelp() {
     return `
 Usage:
   <product> run "<task>" [--chat <id>] [--approve deny|allow-read|allow-all]
-                         [--json | --stream-json] [--data-dir <dir>]
+                         [--json | --stream-json] [--project <dir> | --cwd <dir> | --no-project] [--trust]
+                         [--data-dir <dir>]
 
 --approve deny is the default. A denied approval exits 3. A busy chat exits 6.
+run binds the current directory as a project. --project and --cwd name that directory.
+--no-project keeps a workspace per chat.
+--trust marks that project trusted and loads its rule files. It cannot be combined with --no-project.
+STEERABLE_APPROVAL=0 turns the approval layer off for this process. A destructive tool
+is then rejected by the tool router. Use --approve allow-all to allow those tools instead.
 
 ${EXAMPLES}
 `.trim();
@@ -96,9 +102,15 @@ Examples:
 export function tuiHelp() {
     return `
 Usage:
-  <product> tui [--data-dir <dir>]
+  <product> tui [--project <dir> | --cwd <dir> | --no-project] [--trust]
+               [--approve deny|allow-read|allow-all] [--data-dir <dir>]
 
-Starts the terminal interface. When stdin is not a terminal, use run instead.
+Starts the terminal interface in the current directory's project.
+--no-project keeps a workspace per chat.
+--trust marks that project trusted and loads its rule files. It cannot be combined with --no-project.
+STEERABLE_APPROVAL=0 turns the approval layer off for this process. A destructive tool
+is then rejected by the tool router. Use --approve allow-all to allow those tools instead.
+When stdin is not a terminal, use run instead.
 
 /new  /model  /clear  /help
 Ctrl+C interrupts the current turn. Ctrl+L lists chats.
@@ -116,3 +128,21 @@ Examples:
   <product> doctor
 `.trim();
 }
+/** Placeholder left in help text until a product bin supplies its command name. */
+export const COMMAND_NAME_TOKEN = '<product>';
+/**
+ * Replaces {@link COMMAND_NAME_TOKEN} with the running bin name.
+ * A blank name, the token itself, or a name that is not a command token is left unchanged.
+ *
+ * @param text Help or protected-directory text.
+ * @param commandName Bin name such as `aroli` or `steerable-cli`.
+ * @returns Text with the placeholder replaced when the name is usable.
+ */
+export function renderCommandName(text, commandName) {
+    const name = commandName?.trim() ?? '';
+    if (!name || name === COMMAND_NAME_TOKEN)
+        return text;
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name))
+        return text;
+    return text.replaceAll(COMMAND_NAME_TOKEN, name);
+}

package/dist/node-version.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Minimum Node for the command line.
+ *
+ * `@opentui/core` 0.5.12 declares `engines.node` `>=26.4.0`. Its FFI packages
+ * and the rest of the agent-cli dependency tree do not declare a higher
+ * minimum. This module imports nothing: the bin loads it before the CLI.
+ */
+export declare const REQUIRED_NODE = "26.4.0";
+export interface NodeVersionWriter {
+    write(chunk: string): unknown;
+}
+/** @param current Installed version, with or without a leading `v`. @param required `major.minor.patch`. @returns Whether `current` is at least `required`. */
+export declare function satisfies(current: string, required: string): boolean;
+/** @param current Installed version. @param stderr Where the failure text is written. @param product Command name, such as `aroli`. @returns `0` when the version is new enough, otherwise `1`. */
+export declare function ensureSupportedNode(current: string, stderr: NodeVersionWriter, product: string): number;
+/** @param current Installed version. @returns One doctor row, including whether it meets {@link REQUIRED_NODE}. */
+export declare function nodeDoctorLine(current: string): string;

package/dist/node-version.js

@@ -0,0 +1,40 @@
+/**
+ * Minimum Node for the command line.
+ *
+ * `@opentui/core` 0.5.12 declares `engines.node` `>=26.4.0`. Its FFI packages
+ * and the rest of the agent-cli dependency tree do not declare a higher
+ * minimum. This module imports nothing: the bin loads it before the CLI.
+ */
+export const REQUIRED_NODE = '26.4.0';
+/** @param current Installed version, with or without a leading `v`. @param required `major.minor.patch`. @returns Whether `current` is at least `required`. */
+export function satisfies(current, required) {
+    const left = readVersion(current);
+    const right = readVersion(required);
+    if (!left || !right)
+        return false;
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] > right[index];
+    }
+    return true;
+}
+/** @param current Installed version. @param stderr Where the failure text is written. @param product Command name, such as `aroli`. @returns `0` when the version is new enough, otherwise `1`. */
+export function ensureSupportedNode(current, stderr, product) {
+    if (satisfies(current, REQUIRED_NODE))
+        return 0;
+    const shown = current.replace(/^v/, '');
+    stderr.write(`${product} 需要 Node.js ${REQUIRED_NODE} 或更高版本，当前为 ${shown}。\n升级方法：https://nodejs.org/\n`);
+    return 1;
+}
+/** @param current Installed version. @returns One doctor row, including whether it meets {@link REQUIRED_NODE}. */
+export function nodeDoctorLine(current) {
+    const shown = current.replace(/^v/, '');
+    const mark = satisfies(current, REQUIRED_NODE) ? '✓' : '✗';
+    return `Node.js: ${shown}（需要 ≥ ${REQUIRED_NODE}） ${mark}\n`;
+}
+function readVersion(value) {
+    const match = /v?(\d+)\.(\d+)\.(\d+)/.exec(value.trim());
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}

package/dist/project-binding.d.ts

@@ -0,0 +1,35 @@
+export interface ProjectRequest {
+    cwd: string;
+    projectArg?: string;
+    cwdArg?: string;
+    noProject: boolean;
+    home: string;
+    platform: NodeJS.Platform;
+    /** Windows `%SystemRoot%`. Other platforms ignore it. */
+    systemRoot?: string;
+    realpath: (target: string) => string;
+    isDirectory: (target: string) => boolean;
+}
+export type ProtectedDir = 'home' | 'root' | 'system';
+export type ProjectSpec = {
+    kind: 'none';
+} | {
+    kind: 'bind';
+    dir: string;
+    explicit: boolean;
+} | {
+    kind: 'error';
+    code: 2;
+    message: string;
+    reason?: 'protected';
+    protectedKind?: ProtectedDir;
+};
+export declare function resolveProjectRequest(request: ProjectRequest): ProjectSpec;
+export declare function shortenProjectPath(folder: string): string;
+export declare function projectStatusLabel(project: {
+    name: string;
+    folderPath: string;
+} | null): string;
+export declare function protectedRunMessage(kind: ProtectedDir): string;
+export declare function protectedTuiMessage(kind: ProtectedDir): string;
+export declare function defaultProjectFs(): Pick<ProjectRequest, 'realpath' | 'isDirectory' | 'home' | 'platform' | 'systemRoot'>;