@steerable/agent-cli 0.6.73 → 0.7.1

package/dist/project-binding.js

@@ -0,0 +1,151 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export function resolveProjectRequest(request) {
+    const projectArg = blankToUndefined(request.projectArg);
+    const cwdArg = blankToUndefined(request.cwdArg);
+    if (request.noProject && (projectArg || cwdArg)) {
+        return error('`--no-project` 不能与 `--project` 或 `--cwd` 同时使用。');
+    }
+    if (request.noProject)
+        return { kind: 'none' };
+    if (projectArg && cwdArg) {
+        const left = canonicalize(projectArg, request);
+        const right = canonicalize(cwdArg, request);
+        if (left.kind === 'error')
+            return left;
+        if (right.kind === 'error')
+            return right;
+        if (left.dir !== right.dir) {
+            return error(`--cwd 与 --project 指向不同目录：${left.dir}、${right.dir}。二者含义相同，请只保留一个。`);
+        }
+    }
+    const explicit = Boolean(projectArg || cwdArg);
+    const target = projectArg ?? cwdArg ?? request.cwd;
+    const canonical = canonicalize(target, request);
+    if (canonical.kind === 'error')
+        return canonical;
+    if (!explicit) {
+        const kind = protectedKind(canonical.dir, request);
+        if (kind) {
+            return {
+                kind: 'error',
+                code: 2,
+                reason: 'protected',
+                protectedKind: kind,
+                message: protectedRunMessage(kind),
+            };
+        }
+    }
+    return { kind: 'bind', dir: canonical.dir, explicit };
+}
+export function shortenProjectPath(folder) {
+    const parts = folder.split(/[/\\]/).filter(Boolean);
+    if (parts.length <= 2)
+        return folder;
+    return `…/${parts.slice(-2).join('/')}`;
+}
+export function projectStatusLabel(project) {
+    if (!project)
+        return '独立工作区';
+    return `项目 ${project.name} · ${shortenProjectPath(project.folderPath)}`;
+}
+export function protectedRunMessage(kind) {
+    return [
+        `不会自动把${kindLabel(kind)}绑定为项目：它包含你的全部文件。`,
+        '请改用：<product> run --project <目录> "…"',
+        '或使用独立工作区：<product> run --no-project "…"',
+    ].join('\n');
+}
+export function protectedTuiMessage(kind) {
+    return [
+        `不会自动把${kindLabel(kind)}绑定为项目：它包含你的全部文件。`,
+        '',
+        '请在项目目录里重新启动，或：',
+        '  <product> tui --project <目录>',
+        '  <product> tui --no-project      使用独立工作区',
+    ].join('\n');
+}
+function pathFor(platform) {
+    return platform === 'win32' ? path.win32 : path.posix;
+}
+function canonicalize(target, request) {
+    const absolute = pathFor(request.platform).resolve(request.cwd, target);
+    let dir;
+    try {
+        dir = request.realpath(absolute);
+    }
+    catch {
+        return error(`目录不存在：${absolute}`);
+    }
+    if (!request.isDirectory(dir))
+        return error(`不是目录：${dir}`);
+    return { kind: 'ok', dir };
+}
+function protectedKind(dir, request) {
+    const platformPath = pathFor(request.platform);
+    if (samePath(request.platform, dir, canonicalHome(request)))
+        return 'home';
+    if (samePath(request.platform, dir, platformPath.parse(dir).root))
+        return 'root';
+    const system = systemDirs(request.platform, request.systemRoot);
+    if (system.some((entry) => samePath(request.platform, entry, dir)))
+        return 'system';
+    return null;
+}
+function canonicalHome(request) {
+    const absolute = pathFor(request.platform).resolve(request.home);
+    try {
+        return request.realpath(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}
+/** Windows paths that differ only by letter case are the same directory. */
+function samePath(platform, left, right) {
+    if (platform === 'win32')
+        return left.toLowerCase() === right.toLowerCase();
+    return left === right;
+}
+function systemDirs(platform, systemRoot) {
+    if (platform === 'darwin')
+        return ['/System', '/usr', '/bin', '/sbin', '/private'];
+    if (platform === 'linux')
+        return ['/usr', '/etc', '/bin', '/sbin', '/var'];
+    if (platform === 'win32') {
+        const root = systemRoot?.trim() || process.env.SystemRoot || 'C:\\Windows';
+        return [path.win32.resolve(root)];
+    }
+    return [];
+}
+function kindLabel(kind) {
+    if (kind === 'home')
+        return '家目录';
+    if (kind === 'root')
+        return '根目录';
+    return '系统目录';
+}
+function error(message) {
+    return { kind: 'error', code: 2, message };
+}
+function blankToUndefined(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function defaultProjectFs() {
+    return {
+        home: os.homedir(),
+        platform: process.platform,
+        ...(process.env.SystemRoot ? { systemRoot: process.env.SystemRoot } : {}),
+        realpath: (target) => fs.realpathSync(target),
+        isDirectory: (target) => {
+            try {
+                return fs.statSync(target).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}

package/dist/rules.d.ts

@@ -0,0 +1,8 @@
+export interface RuleContext {
+    ruleFileCount?: number;
+    rulesActive?: boolean;
+    files?: string[];
+    project?: unknown;
+}
+/** Status line for loaded or unloaded project rule files. */
+export declare function ruleStatusLine(context: RuleContext, surface: 'cli' | 'tui'): string | null;

package/dist/rules.js

@@ -0,0 +1,12 @@
+/** Status line for loaded or unloaded project rule files. */
+export function ruleStatusLine(context, surface) {
+    const count = context.ruleFileCount ?? 0;
+    if (count <= 0)
+        return null;
+    if (!context.rulesActive)
+        return `有 ${count} 个规则文件未加载（--trust 加载）`;
+    if (surface === 'tui')
+        return `已加载 ${count} 个规则文件`;
+    const names = (context.files ?? []).map((file) => file.split(/[/\\]/).pop() || file).filter((name) => name.length > 0);
+    return names.length > 0 ? `已加载 ${count} 个规则文件：${names.join('、')}` : `已加载 ${count} 个规则文件`;
+}

package/dist/run.d.ts

@@ -4,7 +4,7 @@ export interface RunRequest {
     task: string;
     chatId?: string;
     agentId?: string;
-    cwd?: string;
+    projectId?: string;
     files: string[];
     policy: ApprovePolicy;
     json: boolean;

package/dist/run.js

@@ -1,12 +1,15 @@
-import { decisionFor, denied } from './approve.js';
+import { autoAnswer, decisionFor, denied } from './approve.js';
+import { cliText } from './copy.js';
+import { ruleStatusLine } from './rules.js';
 export async function runTurn(client, request, stdout, stderr, signal) {
     if (request.policy === 'allow-all') {
-        stderr.write('warning: --approve allow-all allows every tool call in this run\n');
+        stderr.write(`${cliText('cli.approveAllWarning')}\n`);
     }
     let chatId = request.chatId;
     if (!chatId) {
         const created = await client.request('POST', '/api/v2/chats/new', {
             ...(request.agentId ? { agentId: request.agentId } : {}),
+            ...(request.projectId ? { projectId: request.projectId } : {}),
         });
         if (created.status !== 200) {
             stderr.write(`failed to create chat (${created.status})\n`);
@@ -18,21 +21,28 @@ export async function runTurn(client, request, stdout, stderr, signal) {
             return 1;
         }
     }
+    await reportRules(client, chatId, stderr);
     let exitCode = 0;
     let deniedApproval = false;
     const text = [];
-    const approvals = watchApprovals(client, request.policy, () => {
+    const autoAnswered = [];
+    const printedTools = new Set();
+    const streamOrder = { heldTools: [], pendingAnswers: [] };
+    const spec = { policy: request.policy, answerAsk: request.policy === 'allow-all' };
+    const approvals = watchApprovals(client, spec, request, stdout, stderr, autoAnswered, streamOrder, () => {
         deniedApproval = true;
     });
     try {
         for await (const event of client.stream(`/api/v2/chats/${encodeURIComponent(chatId)}/send`, { message: messageText(request), ...(request.agentId ? { agentId: request.agentId } : {}) }, signal)) {
-            const next = observeEvent(event, request, stdout, stderr, text);
+            const next = observeEvent(event, request, stdout, stderr, text, streamOrder, printedTools);
             if (next !== 0)
                 exitCode = next;
         }
     }
     finally {
         approvals.stop();
+        if (request.streamJson)
+            flushStreamOrder(streamOrder, stdout);
     }
     if (signal.aborted && exitCode === 0)
         exitCode = 1;
@@ -44,16 +54,24 @@ export async function runTurn(client, request, stdout, stderr, signal) {
         stdout.write(`${JSON.stringify({
             ok: exitCode === 0,
             chatId,
+            ...(request.projectId ? { projectId: request.projectId } : {}),
             text: text.join(''),
             exitCode,
+            autoAnswered,
         })}\n`);
     }
     return exitCode;
 }
+async function reportRules(client, chatId, stderr) {
+    const response = await client.request('GET', `/api/v2/chats/${encodeURIComponent(chatId)}/project-context`, undefined);
+    if (response.status !== 200)
+        return;
+    const line = ruleStatusLine(response.data, 'cli');
+    if (line)
+        stderr.write(`${line}\n`);
+}
 function messageText(request) {
     const lines = [request.task];
-    if (request.cwd)
-        lines.push(`Working directory: ${request.cwd}`);
     if (request.files.length > 0) {
         lines.push('Files:');
         for (const file of request.files)
@@ -61,7 +79,155 @@ function messageText(request) {
     }
     return lines.join('\n');
 }
-function watchApprovals(client, policy, onDenied) {
+function answerName(record) {
+    return record.kind === 'ask_user' ? 'ask_user' : record.toolName;
+}
+function writeAnswerBeforeTool(order, record, stdout, streamJson) {
+    if (!streamJson)
+        return;
+    const name = answerName(record);
+    const line = JSON.stringify({ type: 'auto_answered', ...record });
+    const index = order.heldTools.findIndex((tool) => tool.name === name || tool.names?.includes(name));
+    if (index < 0) {
+        order.pendingAnswers.push({ name, id: '', line });
+        return;
+    }
+    const tool = order.heldTools[index];
+    if (!tool)
+        return;
+    const waiting = (tool.names ?? [tool.name]).filter((item) => item !== name);
+    tool.prefix = [...(tool.prefix ?? []), line];
+    if (waiting.length > 0) {
+        tool.names = waiting;
+        tool.name = waiting[0] ?? '';
+        return;
+    }
+    order.heldTools.splice(index, 1);
+    for (const item of tool.prefix)
+        stdout.write(`${item}\n`);
+    stdout.write(`${tool.line}\n`);
+}
+function flushHeldActions(order, stdout) {
+    const kept = [];
+    for (const tool of order.heldTools) {
+        if (tool.kind !== 'actions') {
+            kept.push(tool);
+            continue;
+        }
+        for (const item of tool.prefix ?? [])
+            stdout.write(`${item}\n`);
+        stdout.write(`${tool.line}\n`);
+    }
+    order.heldTools = kept;
+}
+function unsettledToolNames(event) {
+    const actions = event.actions;
+    if (!Array.isArray(actions))
+        return [];
+    const names = [];
+    for (const action of actions) {
+        if (!action || typeof action !== 'object')
+            continue;
+        const row = action;
+        const settled = typeof row.durationMs === 'number' || typeof row.success === 'boolean' || row.error != null;
+        if (settled)
+            continue;
+        names.push(typeof row.tool === 'string' && row.tool ? row.tool : 'tool');
+    }
+    return names;
+}
+function eventField(event, key) {
+    const payload = event.payload;
+    if (!payload || typeof payload !== 'object')
+        return '';
+    const value = payload[key];
+    return typeof value === 'string' ? value : '';
+}
+function writeStreamJsonEvent(order, event, stdout) {
+    const line = JSON.stringify(event);
+    const actions = String(event.type) === 'executed_actions';
+    if (actions || event.type === 'content' || event.type === 'done')
+        flushHeldActions(order, stdout);
+    if (actions) {
+        const names = unsettledToolNames(event);
+        const matched = [];
+        for (const name of names) {
+            const index = order.pendingAnswers.findIndex((answer) => answer.name === name);
+            if (index < 0)
+                continue;
+            const answer = order.pendingAnswers.splice(index, 1)[0];
+            if (answer)
+                matched.push(answer.line);
+        }
+        if (matched.length > 0 || names.length === 0) {
+            for (const answer of matched)
+                stdout.write(`${answer}\n`);
+            stdout.write(`${line}\n`);
+            return;
+        }
+        order.heldTools.push({
+            name: names[0] ?? '',
+            id: '',
+            line,
+            kind: 'actions',
+            names,
+        });
+        return;
+    }
+    if (event.type === 'tool_call') {
+        const name = eventField(event, 'name');
+        const index = order.pendingAnswers.findIndex((answer) => answer.name === name);
+        if (index >= 0) {
+            const answer = order.pendingAnswers.splice(index, 1)[0];
+            stdout.write(`${answer.line}\n${line}\n`);
+            return;
+        }
+        order.heldTools.push({ name, id: eventField(event, 'id'), line, kind: 'call' });
+        return;
+    }
+    if (event.type === 'tool_result') {
+        const name = eventField(event, 'name');
+        const id = eventField(event, 'id');
+        const index = order.heldTools.findIndex((tool) => (id && tool.id === id) || (name && tool.name === name));
+        if (index >= 0) {
+            const tool = order.heldTools.splice(index, 1)[0];
+            stdout.write(`${tool.line}\n`);
+        }
+    }
+    stdout.write(`${line}\n`);
+}
+function writeHeld(tool, stdout, extra) {
+    for (const item of tool.prefix ?? [])
+        stdout.write(`${item}\n`);
+    if (extra)
+        stdout.write(`${extra}\n`);
+    stdout.write(`${tool.line}\n`);
+}
+function flushStreamOrder(order, stdout) {
+    const pending = order.pendingAnswers.splice(0);
+    const held = order.heldTools.splice(0);
+    const used = new Set();
+    for (const answer of pending) {
+        const index = held.findIndex((tool, toolIndex) => {
+            if (used.has(toolIndex))
+                return false;
+            return tool.name === answer.name || (tool.names?.includes(answer.name) ?? false);
+        });
+        if (index < 0) {
+            stdout.write(`${answer.line}\n`);
+            continue;
+        }
+        used.add(index);
+        const tool = held[index];
+        if (tool)
+            writeHeld(tool, stdout, answer.line);
+    }
+    held.forEach((tool, index) => {
+        if (!used.has(index))
+            writeHeld(tool, stdout);
+    });
+}
+function watchApprovals(client, spec, request, stdout, stderr, autoAnswered, streamOrder, onDenied) {
     let stopped = false;
     const loop = (async () => {
         for await (const event of client.events()) {
@@ -71,15 +237,38 @@ function watchApprovals(client, policy, onDenied) {
                 const prompt = event.payload;
                 if (!prompt.requestId)
                     continue;
-                const kind = decisionFor(policy, prompt);
+                const kind = decisionFor(spec, { mode: prompt.mode }, 'run');
+                if (kind === 'prompt')
+                    continue;
                 if (denied(kind))
                     onDenied();
+                const record = {
+                    kind: 'approval',
+                    toolName: prompt.toolName ?? '',
+                    category: prompt.category ?? '',
+                    decision: kind,
+                };
+                autoAnswered.push(record);
+                writeAnswerBeforeTool(streamOrder, record, stdout, request.streamJson);
+                if (!request.json && !request.streamJson && record.toolName === 'network_egress' && kind === 'allow_once') {
+                    stderr.write(`${egressProgressLine(prompt.arguments)}\n`);
+                }
                 await client.decideApproval(prompt.requestId, kind);
             }
             else if (event.channel === 'ask-user:request') {
                 const prompt = event.payload;
-                if (prompt.requestId)
+                if (!prompt.requestId)
+                    continue;
+                if (spec.answerAsk) {
+                    const questions = prompt.questions?.length ? prompt.questions : [{ id: 'answer' }];
+                    const record = { kind: 'ask_user', prompt: prompt.prompt ?? '' };
+                    autoAnswered.push(record);
+                    writeAnswerBeforeTool(streamOrder, record, stdout, request.streamJson);
+                    await client.answerAsk(prompt.requestId, { answers: autoAnswer(questions) });
+                }
+                else {
                     await client.answerAsk(prompt.requestId, {});
+                }
             }
         }
     })();
@@ -90,17 +279,86 @@ function watchApprovals(client, policy, onDenied) {
         },
     };
 }
-function observeEvent(event, request, stdout, stderr, text) {
+function formatRunDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return '';
+    if (ms < 10_000)
+        return `${(Math.round(ms / 100) / 10).toFixed(1)}s`;
+    return `${Math.round(ms / 1000)}s`;
+}
+function progressArgs(value) {
+    if (!value || typeof value !== 'object')
+        return '';
+    const record = value;
+    for (const key of ['command', 'path', 'file', 'url', 'query']) {
+        const field = record[key];
+        if (typeof field === 'string' && field.length > 0)
+            return field;
+    }
+    return '';
+}
+function egressTarget(value) {
+    if (!value || typeof value !== 'object')
+        return '';
+    const record = value;
+    const host = typeof record.host === 'string' ? record.host : '';
+    if (!host)
+        return '';
+    const port = typeof record.port === 'number' ? record.port : null;
+    if (port === null || port === 80 || port === 443)
+        return host;
+    return `${host}:${port}`;
+}
+function egressProgressLine(args) {
+    const target = egressTarget(args);
+    return `▸ network_egress  ${target}  ✓ ${cliText('tui.toolAuto')}`.trimEnd();
+}
+function toolProgressLine(action) {
+    const name = typeof action.tool === 'string' && action.tool ? action.tool : 'tool';
+    const title = typeof action.view?.title === 'string' ? action.view.title : '';
+    const args = title && title !== name ? title : progressArgs(action.arguments);
+    const failed = action.success === false || action.error != null;
+    const duration = typeof action.durationMs === 'number' ? formatRunDuration(action.durationMs) : '';
+    const mark = failed ? '✗' : '✓';
+    const base = duration ? `${mark} ${duration}` : mark;
+    const cached = action.approval?.kind === 'allow_for_session' && action.approval.cached === true;
+    const status = cached ? `${base} 本会话已允许` : base;
+    return `▸ ${name}  ${args}  ${status}`.trimEnd();
+}
+function writeToolProgress(event, stderr, printed) {
+    const actions = event.actions;
+    if (!Array.isArray(actions))
+        return;
+    for (const action of actions) {
+        if (!action || typeof action !== 'object')
+            continue;
+        const row = action;
+        const settled = typeof row.durationMs === 'number' || typeof row.success === 'boolean' || row.error != null;
+        if (!settled)
+            continue;
+        const name = typeof row.tool === 'string' ? row.tool : 'tool';
+        const key = typeof row.id === 'string' && row.id ? row.id : `${name}:${toolProgressLine(row)}`;
+        if (printed.has(key))
+            continue;
+        printed.add(key);
+        stderr.write(`${toolProgressLine(row)}\n`);
+    }
+}
+function observeEvent(event, request, stdout, stderr, text, streamOrder, printedTools) {
     if (request.streamJson)
-        stdout.write(`${JSON.stringify(event)}\n`);
+        writeStreamJsonEvent(streamOrder, event, stdout);
     if (event.type === 'content' && typeof event.content === 'string') {
         text.push(event.content);
         if (!request.json && !request.streamJson)
             stdout.write(event.content);
     }
-    if (event.type === 'tool_call' && !request.json && !request.streamJson) {
-        const name = typeof event.payload?.name === 'string' ? event.payload.name : 'tool';
-        stderr.write(`tool ${name}\n`);
+    if (!request.json && !request.streamJson) {
+        if (String(event.type) === 'executed_actions')
+            writeToolProgress(event, stderr, printedTools);
+        if (event.type === 'tool_call') {
+            const name = typeof event.payload?.name === 'string' ? event.payload.name : 'tool';
+            stderr.write(`tool ${name}\n`);
+        }
     }
     if (event.type === 'error') {
         const message = typeof event.message === 'string' ? event.message : 'error';

package/dist/tui/commands.js

@@ -15,6 +15,7 @@ const COMMANDS = [
     { name: 'tasks', hint: '后台任务' },
     { name: 'fork', hint: '分叉' },
     { name: 'rewind', hint: '回退' },
+    { name: 'rules', hint: '项目规则' },
     { name: 'permissions', hint: '会话权限' },
     { name: 'copy', hint: '复制回答' },
     { name: 'editor', hint: '外部编辑器' },

package/dist/tui/run.d.ts

@@ -1,10 +1,14 @@
 import { type Terminal } from '@earendil-works/pi-tui';
 import type { CliRenderer } from '@opentui/core';
 import type { AgentClient } from '@steerable/agent-client';
+import type { ApprovalSpec } from '../approve.js';
 export interface RunTuiOptions {
     client: AgentClient;
     product: string;
     dataDir?: string;
+    projectId?: string;
+    projectLabel?: string;
+    approvalPolicy?: ApprovalSpec;
     terminal?: Terminal;
     fallbackTerminal?: Terminal;
     openRenderer?: CliRenderer;

package/dist/tui/run.js

@@ -36,15 +36,27 @@ async function runOpenTui(options) {
         const session = new AgentTui(options.client, {
             product: options.product,
             ...(options.dataDir ? { dataDir: options.dataDir } : {}),
+            ...(options.projectId ? { projectId: options.projectId } : {}),
+            ...(options.projectLabel ? { projectLabel: options.projectLabel } : {}),
+            ...(options.approvalPolicy ? { approvalPolicy: options.approvalPolicy } : {}),
             onChange() {
                 view.apply(session.snapshot());
             },
             onExit() {
-                renderer.destroy();
+                stop();
                 resolve(0);
             },
         });
         const view = new OpenTuiView(renderer);
+        const onPaste = (event) => {
+            event.stopPropagation();
+            session.acceptDecodedPaste(new TextDecoder().decode(event.bytes));
+        };
+        renderer.keyInput.on('paste', onPaste);
+        const stop = () => {
+            renderer.keyInput.off('paste', onPaste);
+            renderer.destroy();
+        };
         renderer.prependInputHandler((sequence) => {
             if (yieldsToRenderer(sequence))
                 return false;
@@ -57,7 +69,7 @@ async function runOpenTui(options) {
             return true;
         });
         void session.open().then(() => view.apply(session.snapshot()), (error) => {
-            renderer.destroy();
+            stop();
             reject(error);
         });
     });
@@ -69,6 +81,9 @@ function runPlainTui(options) {
         const session = new AgentTui(options.client, {
             product: options.product,
             ...(options.dataDir ? { dataDir: options.dataDir } : {}),
+            ...(options.projectId ? { projectId: options.projectId } : {}),
+            ...(options.projectLabel ? { projectLabel: options.projectLabel } : {}),
+            ...(options.approvalPolicy ? { approvalPolicy: options.approvalPolicy } : {}),
             onChange() {
                 tui.requestRender();
             },

package/dist/tui/screen.d.ts

@@ -5,6 +5,8 @@ export interface TranscriptLine {
     name?: string;
     args?: string;
     status?: string;
+    /** This row was answered by the unattended policy, so the status keeps the auto mark. */
+    auto?: boolean;
     id?: string;
     output?: string;
     diff?: string;
@@ -16,6 +18,7 @@ export interface ChatRow {
     title: string;
     busy: boolean;
     selected: boolean;
+    projectId?: string | null;
 }
 export interface PickRow {
     label: string;
@@ -39,6 +42,8 @@ export interface TuiScreen {
     draft: string;
     cursor: number;
     status: string;
+    projectLabel?: string;
+    ruleLabel?: string;
     picks?: PickRow[] | null;
     attachments?: string[];
     children?: ChildRow[];
@@ -49,6 +54,7 @@ export interface TuiScreen {
     panel?: string[] | null;
     mode?: 'agent' | 'plan';
     permission?: 'ask' | 'auto' | 'read';
+    approvalPolicy?: 'ask' | 'deny' | 'allow-read' | 'allow-all';
     todos?: Array<{
         content: string;
         status: 'pending' | 'in_progress' | 'completed';
@@ -83,4 +89,6 @@ export declare function draftLine(draft: string, cursor: number): string;
 export declare function composerRows(draft: string, columns: number): number;
 export declare const readOnlyText = "\u53EA\u8BFB \u00B7 \u53E6\u4E00\u4E2A\u8FDB\u7A0B\u6B63\u5728\u8FD0\u884C";
 export declare function visibleText(lines: string[]): string;
+/** 状态行最左侧是无人值守提示，后面用竖线和项目、规则接在同一行。 */
+export declare function projectStatusLine(screen: TuiScreen): string;
 export declare function bannerLines(screen: TuiScreen): string[];