mocode-ai 1.6.5 → 1.6.6

package/dist/jobs/attach.js

@@ -0,0 +1,61 @@
+// C4 Reattach：`mocode attach [id前缀]`——从头回放 job 日志，并实时跟随新输出，
+// 直到 job 进入终态（succeeded/failed/killed）且日志排空后退出。
+//
+// 纯 stdout 流式（与 headless 同性质），故不嵌进全屏 TUI：TUI 内 /jobs attach
+// 只提示在另一终端运行。轮询而非持久句柄——跨平台、且 job 文件由别的进程写入。
+import fs from 'node:fs';
+import { getJob, listJobs } from './store.js';
+const TERMINAL = new Set(['succeeded', 'failed', 'killed']);
+const POLL_MS = 500;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function resolveJob(idPrefix) {
+    if (!idPrefix) {
+        const running = listJobs().filter((j) => !TERMINAL.has(j.status));
+        return running.length === 1 ? running[0] : (listJobs()[0] ?? null);
+    }
+    const matches = listJobs().filter((j) => j.id.startsWith(idPrefix));
+    return matches.length === 1 ? matches[0] : null;
+}
+export async function runAttachCli(rawArgs) {
+    const idPrefix = rawArgs[0];
+    const initial = resolveJob(idPrefix);
+    if (!initial) {
+        process.stderr.write('mocode: no unique matching job to attach\n');
+        return 1;
+    }
+    process.stdout.write(`── attach ${initial.id} ──\n`);
+    let offset = 0;
+    let stableRounds = 0;
+    for (;;) {
+        // 1) 排空当前新增日志。
+        try {
+            const stat = fs.statSync(initial.logPath);
+            if (stat.size > offset) {
+                const buf = Buffer.alloc(stat.size - offset);
+                const fd = fs.openSync(initial.logPath, 'r');
+                fs.readSync(fd, buf, 0, buf.length, offset);
+                fs.closeSync(fd);
+                offset = stat.size;
+                process.stdout.write(buf);
+                stableRounds = 0;
+            }
+        }
+        catch {
+            // 日志暂时不可读（尚未创建/被锁），下轮再试。
+        }
+        // 2) 查最新状态。
+        const job = getJob(initial.id) ?? initial;
+        if (TERMINAL.has(job.status)) {
+            // 终态后再多等两轮，确保末尾输出已落盘并排空，避免丢最后几行。
+            stableRounds += 1;
+            if (stableRounds >= 2) {
+                if (!process.stdout.isTTY)
+                    process.stdout.write(`\n[${job.status}]`);
+                else
+                    process.stdout.write(`\n${job.status}\n`);
+                return job.status === 'succeeded' ? 0 : 1;
+            }
+        }
+        await sleep(POLL_MS);
+    }
+}

package/dist/jobs/checkpoint.js

@@ -0,0 +1,33 @@
+// D3 checkpoint 存储：每个 bg job 在工具批次提交后把完整 history 快照
+// 原子写到 <id>.checkpoint.json。崩溃 / 机器重启后可用
+// `mocode resume-job <id>` 从最后一个 checkpoint 在新进程断点续跑。
+import fs from 'node:fs';
+import path from 'node:path';
+import { jobsRoot } from './store.js';
+function checkpointPath(jobId) {
+    return path.join(jobsRoot(), `${jobId}.checkpoint.json`);
+}
+export function writeCheckpoint(jobId, history) {
+    fs.mkdirSync(jobsRoot(), { recursive: true });
+    const target = checkpointPath(jobId);
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(history)}\n`, 'utf8');
+    fs.renameSync(tmp, target);
+}
+export function readCheckpoint(jobId) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(checkpointPath(jobId), 'utf8'));
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteCheckpoint(jobId) {
+    try {
+        fs.rmSync(checkpointPath(jobId));
+    }
+    catch {
+        // already gone
+    }
+}

package/dist/jobs/launch.js

@@ -0,0 +1,107 @@
+// 后台任务 launcher / kill：spawn 一个 detached 子进程，父进程退出不影响它
+//（detached + 独立进程组），stdio 重定向到日志文件。
+//
+// 形态自适应：编译产物 src/index.js 存在 → node 直跑；否则（开发态）用 node 加载
+// tsx loader 单进程跑 src/index.ts（不用 tsx CLI：它会 respawn 一个不 hide 的弹窗 node）。
+//
+// 通用件 buildEntryArgs / spawnDetached 也供 schedule 守护进程复用（src/schedule/daemon.ts）。
+import { spawn, spawnSync } from 'node:child_process';
+import { openSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
+import { createJobId, saveJob, updateJob, logPathFor, getJob } from './store.js';
+const jobsDir = path.dirname(fileURLToPath(import.meta.url));
+const srcDir = path.resolve(jobsDir, '..');
+const projectRoot = path.resolve(srcDir, '..');
+const compiledEntry = path.join(srcDir, 'index.js');
+const sourceEntry = path.join(srcDir, 'index.ts');
+const tsxLoader = path.join(projectRoot, 'node_modules', 'tsx', 'dist', 'loader.mjs');
+const tsxPreflight = path.join(projectRoot, 'node_modules', 'tsx', 'dist', 'preflight.cjs');
+/**
+ * 构造「node …入口… internalArgs」的完整参数。
+ * 生产/开发形态自动选择，调用方只需给入口之后的内部参数（如 ['--job-runner', id]）。
+ */
+export function buildEntryArgs(internalArgs) {
+    if (existsSync(compiledEntry))
+        return [compiledEntry, ...internalArgs];
+    return ['--require', tsxPreflight, '--import', pathToFileURL(tsxLoader).href, sourceEntry, ...internalArgs];
+}
+/**
+ * detached spawn 一个 node 子进程。stdio 重定向到 logPath（stdout+stderr 同一 fd）。
+ * 调用方负责后续 saveJob 等状态回写。
+ */
+export function spawnDetached(internalArgs, logPath, cwd = process.cwd()) {
+    const outFd = openSync(logPath, 'a');
+    const child = spawn(process.execPath, buildEntryArgs(internalArgs), {
+        detached: true,
+        stdio: ['ignore', outFd, outFd],
+        cwd,
+        env: process.env,
+        windowsHide: true,
+    });
+    child.unref();
+    return child;
+}
+/** 创建记录并启动 detached job。spawn 失败时记录置 failed。 */
+export function launchBackgroundJob(prompt, opts = {}) {
+    const id = createJobId();
+    const logPath = logPathFor(id);
+    const record = {
+        id,
+        prompt,
+        status: 'running',
+        cwd: process.cwd(),
+        logPath,
+        startedAt: new Date().toISOString(),
+        ...(opts.sessionDir ? { sessionDir: opts.sessionDir } : {}),
+        ...(opts.worktree ? { worktree: true } : {}),
+        ...(opts.botName ? { botName: opts.botName } : {}),
+    };
+    saveJob(record);
+    const child = spawnDetached(['--job-runner', id], logPath);
+    if (child.pid)
+        saveJob({ ...record, pid: child.pid });
+    child.on('error', () => {
+        updateJob(id, { status: 'failed', finishedAt: new Date().toISOString() }, { force: true });
+    });
+    return { record: { ...record, pid: child.pid }, child };
+}
+/**
+ * 树杀进程并置 killed。
+ * Windows：taskkill /T /F 杀整棵进程树；POSIX：负 pid 杀整个进程组。
+ */
+export function killTree(pid) {
+    if (process.platform === 'win32') {
+        const r = spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+        return r.status === 0;
+    }
+    try {
+        process.kill(-pid, 'SIGTERM');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 树杀 job 并置 killed。 */
+export function killBackgroundJob(record) {
+    if (typeof record.pid !== 'number')
+        return false;
+    if (!killTree(record.pid))
+        return false;
+    updateJob(record.id, { status: 'killed', finishedAt: new Date().toISOString() }, { force: true });
+    return true;
+}
+/** D3: 从最后 checkpoint 在新 detached 进程中断点续跑同一 job。 */
+export function resumeBackgroundJob(id) {
+    const record = getJob(id);
+    if (!record)
+        return null;
+    updateJob(id, { status: 'running', finishedAt: undefined, exitCode: undefined }, { force: true });
+    const child = spawnDetached(['--job-runner', id, '--resume'], record.logPath);
+    // 续跑是新 detached 进程，必须回写新 PID，否则后续 /jobs kill 会指向已死的旧 PID。
+    if (child.pid)
+        updateJob(id, { pid: child.pid }, { force: true });
+    return getJob(id);
+}

package/dist/jobs/runner.js

@@ -0,0 +1,59 @@
+// Job runner：detached 子进程的内部入口（`mocode --job-runner <id>`）。
+// 复用 runHeadless 跑任务（输出已被 launcher 重定向到 <id>.log），
+// 结束后按退出码回写 job 终态，并 best-effort 发结束通知（MOCODE_NOTIFY_WEBHOOK）。
+import { getJob, updateJob } from './store.js';
+import { deleteCheckpoint } from './checkpoint.js';
+import { runHeadless } from '../headless.js';
+import { sendNotification } from '../notify/index.js';
+import { config } from '../config/index.js';
+export async function runJobRunner(jobId, resume = false) {
+    const record = getJob(jobId);
+    if (!record) {
+        process.stderr.write(`job runner: unknown job ${jobId}\n`);
+        return 1;
+    }
+    const startedAt = Date.now();
+    let exitCode;
+    try {
+        exitCode = await runHeadless({
+            prompt: record.prompt,
+            json: false,
+            verbose: false,
+            skipPermissions: false,
+            ...(record.sessionDir ? { sessionDir: record.sessionDir } : {}),
+            ...(record.worktree ? { worktree: true } : {}),
+            ...(record.botName ? { botName: record.botName } : {}),
+            jobId,
+            ...(resume ? { resumeFromCheckpoint: true } : {}),
+        });
+    }
+    catch (e) {
+        updateJob(jobId, { status: 'failed', finishedAt: new Date().toISOString(), exitCode: 1 }, { force: true });
+        process.stderr.write(`job runner crashed: ${e instanceof Error ? e.message : String(e)}\n`);
+        await sendNotification(config.notifyWebhook, {
+            status: 'failed',
+            prompt: record.prompt,
+            sessionId: jobId,
+            elapsedMs: Date.now() - startedAt,
+            model: config.model,
+        });
+        return 1;
+    }
+    const status = exitCode === 0 ? 'succeeded' : 'failed';
+    // force：被手动 kill 后进程仍可能在此回写，killed 状态由 killBackgroundJob 强制保留。
+    updateJob(jobId, { status, finishedAt: new Date().toISOString(), exitCode }, { force: false });
+    if (status === 'succeeded')
+        deleteCheckpoint(jobId);
+    // 被 kill 的 job（记录仍是 killed）不发常规成功/失败通知，避免与用户意图冲突。
+    const after = getJob(jobId);
+    if (after?.status !== 'killed') {
+        await sendNotification(config.notifyWebhook, {
+            status,
+            prompt: record.prompt,
+            sessionId: jobId,
+            elapsedMs: Date.now() - startedAt,
+            model: config.model,
+        });
+    }
+    return exitCode;
+}

package/dist/jobs/store.js

@@ -0,0 +1,101 @@
+// 后台任务存储：每个 job 一个 <id>.json 记录 + <id>.log 日志（detached 子进程的
+// stdout/stderr 直接重定向到该文件）。
+//
+// 根目录：<sandboxRoot>/.mocode/jobs/。sandboxRoot 与 headless / REPL 同源
+// （入口先 setSandboxRoot，store 动态读取，不缓存）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { getSandboxRoot } from '../sandbox/index.js';
+/** 与 session 同风格的时间戳 id：YYYYMMDD-HHMMSS-rand。 */
+export function createJobId(now = new Date()) {
+    const p = (n, l = 2) => String(n).padStart(l, '0');
+    const stamp = `${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}` +
+        `-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+    return `${stamp}-${randomBytes(2).toString('hex')}`;
+}
+export function jobsRoot() {
+    return path.join(getSandboxRoot() ?? process.cwd(), '.mocode', 'jobs');
+}
+function recordPath(id) {
+    return path.join(jobsRoot(), `${id}.json`);
+}
+export function logPathFor(id) {
+    return path.join(jobsRoot(), `${id}.log`);
+}
+export function saveJob(record) {
+    fs.mkdirSync(jobsRoot(), { recursive: true });
+    // per-file 原子写：先写 tmp 再 rename，避免读侧看到半截 JSON。
+    const target = recordPath(record.id);
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+    fs.renameSync(tmp, target);
+}
+export function getJob(id) {
+    try {
+        return JSON.parse(fs.readFileSync(recordPath(id), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 更新 job 状态。默认保护：记录已是终态 killed 时不被覆盖
+ * （runner 退出回写与手动 kill 存在竞态）。force 可绕过。
+ */
+export function updateJob(id, patch, opts = {}) {
+    const current = getJob(id);
+    if (!current)
+        return null;
+    if (!opts.force && current.status === 'killed' && patch.status !== 'killed')
+        return current;
+    const next = { ...current, ...patch };
+    saveJob(next);
+    return next;
+}
+/** 列出全部 job，新的在前。 */
+export function listJobs() {
+    let files;
+    try {
+        files = fs.readdirSync(jobsRoot());
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const file of files) {
+        if (!file.endsWith('.json'))
+            continue;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(jobsRoot(), file), 'utf8'));
+            // 只认完整 JobRecord，排除 <id>.approval.json / <id>.checkpoint.json 等附属文件。
+            if (typeof parsed.id === 'string' &&
+                typeof parsed.status === 'string' &&
+                typeof parsed.logPath === 'string' &&
+                typeof parsed.prompt === 'string') {
+                records.push(parsed);
+            }
+        }
+        catch {
+            // 跳过损坏记录
+        }
+    }
+    return records.sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
+}
+/** 读日志尾部，默认最多 4KB。 */
+export function readJobLog(id, maxBytes = 4096) {
+    const logPath = logPathFor(id);
+    try {
+        const stat = fs.statSync(logPath);
+        const size = stat.size;
+        const start = Math.max(0, size - maxBytes);
+        const fd = fs.openSync(logPath, 'r');
+        const buf = Buffer.alloc(size - start);
+        fs.readSync(fd, buf, 0, buf.length, start);
+        fs.closeSync(fd);
+        return buf.toString('utf8');
+    }
+    catch {
+        return '(no logs yet)';
+    }
+}

package/dist/jobs/worktree.js

@@ -0,0 +1,63 @@
+// Git worktree 隔离：为一次性任务创建 detached worktree（独立工作树 + 独立
+// sandboxRoot），结束后销毁。任务写盘全部落在 worktree，主工作区零污染。
+//
+// 附带 node_modules 链接：新 worktree 没有依赖，跑不了构建/测试；junction(Win)/
+// symlink(POSIX) 指向原仓库 node_modules，删链接不影响目标。
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, rmdirSync, existsSync, symlinkSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { randomBytes } from 'node:crypto';
+function git(args, cwd) {
+    const r = spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true });
+    return { ok: r.status === 0, output: `${r.stdout ?? ''}${r.stderr ?? ''}`.trim() };
+}
+/** 当前 git 仓库根；不是 git 仓库时返回 null。 */
+export function gitTopLevel(cwd = process.cwd()) {
+    const r = git(['rev-parse', '--show-toplevel'], cwd);
+    return r.ok ? resolve(r.output.split('\n')[0] ?? '') : null;
+}
+/**
+ * 创建 detached worktree（基于 HEAD）。
+ * 失败（非 git 仓库 / 有未跟踪冲突）抛错，由调用方决定是否回退普通模式。
+ */
+export function createWorktree() {
+    const repoRoot = gitTopLevel();
+    if (!repoRoot)
+        throw new Error('not a git repository (worktree isolation requires git)');
+    const id = `${Date.now()}-${randomBytes(2).toString('hex')}`;
+    const wtPath = join(repoRoot, '.mocode', 'worktrees', `wt-${id}`);
+    mkdirSync(join(repoRoot, '.mocode', 'worktrees'), { recursive: true });
+    const added = git(['worktree', 'add', '--detach', wtPath, 'HEAD'], repoRoot);
+    if (!added.ok)
+        throw new Error(`git worktree add failed: ${added.output}`);
+    // 链接 node_modules（若主仓库有），否则 worktree 内无法构建。
+    const sourceModules = join(repoRoot, 'node_modules');
+    if (existsSync(sourceModules)) {
+        const link = join(wtPath, 'node_modules');
+        if (process.platform === 'win32') {
+            // directory junction：不需要管理员；rmdir 删链接不动目标。
+            spawnSync('cmd', ['/c', 'mklink', '/J', link, sourceModules], { windowsHide: true });
+        }
+        else {
+            symlinkSync(sourceModules, link, 'dir');
+        }
+    }
+    return { path: wtPath, repoRoot };
+}
+/** 先删 node_modules 链接（防误伤目标），再移除 worktree + prune。 */
+export function removeWorktree(wt) {
+    const link = join(wt.path, 'node_modules');
+    if (existsSync(link)) {
+        try {
+            if (process.platform === 'win32')
+                rmdirSync(link); // junction：仅删链接
+            else
+                rmdirSync(link);
+        }
+        catch {
+            // 链接删不掉仍尝试 worktree remove
+        }
+    }
+    git(['worktree', 'remove', '--force', wt.path], wt.repoRoot);
+    git(['worktree', 'prune'], wt.repoRoot);
+}

package/dist/notify/index.js

@@ -0,0 +1,144 @@
+// 任务结束通知：POST 到用户自配的 webhook，按 URL 自动识别格式：
+// - ntfy：https://ntfy.sh/<topic>（POST 正文，Title header）
+// - Bark：https://api.day.app/<key>（POST JSON {title, body}）
+// - Telegram：https://api.telegram.org/bot<token>/sendMessage[?chat_id=...]
+// - 其他：generic JSON webhook
+//
+// 刻意 best-effort：通知失败永不影响任务结果、不重试（webhook 是副作用通道，
+// 不该因为通知服务挂了让 job 变 failed）。
+//
+// 回环地址（localhost/127.0.0.1）走 node:http 直连：Node 24 的 fetch 默认使用
+// HTTP_PROXY 环境代理，而 NO_PROXY 对 localhost 的绕过不可靠，带代理的机器上
+// 本地 webhook 会被转发失败。公网地址仍走 fetch（保留代理穿透）。
+function firstLine(prompt) {
+    const line = prompt.split('\n')[0] ?? '';
+    return line.length > 80 ? `${line.slice(0, 80)}…` : line;
+}
+function buildTitle(ev) {
+    if (ev.status === 'succeeded')
+        return 'mocode OK';
+    if (ev.status === 'failed')
+        return 'mocode FAILED';
+    return 'mocode APPROVAL NEEDED';
+}
+function buildBody(ev) {
+    if (ev.status === 'waiting') {
+        return (`Tool: ${ev.tool ?? '?'}\n\n${firstLine(ev.prompt)}\n\nsession: ${ev.sessionId}\nmodel: ${ev.model}` +
+            `\n\nApprove: mocode approve ${ev.sessionId}\nDeny:    mocode deny ${ev.sessionId}`);
+    }
+    const secs = (ev.elapsedMs / 1000).toFixed(1);
+    return `${firstLine(ev.prompt)}\n\nsession: ${ev.sessionId}\nmodel: ${ev.model}\ntime: ${secs}s`;
+}
+/**
+ * 按 URL 构造请求（纯函数）。
+ * 返回 null 表示 URL 无法识别（调用方静默跳过）。
+ */
+export function buildNotifyRequest(webhookUrl, ev) {
+    let url;
+    try {
+        url = new URL(webhookUrl);
+    }
+    catch {
+        return null;
+    }
+    const title = buildTitle(ev);
+    const body = buildBody(ev);
+    // Telegram：query 中的 chat_id 合并进 JSON body。
+    if (url.hostname === 'api.telegram.org' && url.pathname.includes('/sendMessage')) {
+        const chatId = url.searchParams.get('chat_id') ?? process.env.MOCODE_NOTIFY_CHAT_ID;
+        if (!chatId)
+            return null;
+        url.search = '';
+        return {
+            init: {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ chat_id: chatId, text: `${title}\n${body}` }),
+            },
+        };
+    }
+    // Bark：{title, body}。
+    if (url.hostname === 'api.day.app' || url.hostname.endsWith('.day.app')) {
+        return {
+            init: {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ title, body }),
+            },
+        };
+    }
+    // ntfy 风格（含自建实例）：裸文本正文 + Title/Priority header。
+    if (url.hostname === 'ntfy.sh' || url.pathname.split('/').filter(Boolean).length === 1) {
+        return {
+            init: {
+                method: 'POST',
+                headers: { Title: title, Priority: ev.status === 'failed' ? 'high' : 'default' },
+                body,
+            },
+        };
+    }
+    // Generic JSON webhook。
+    return {
+        init: {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ ...ev, title, body }),
+        },
+    };
+}
+/** 是否回环地址（localhost/127.0.0.1/[::1]）。 */
+function isLoopback(hostname) {
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]' || hostname === '::1';
+}
+/**
+ * 回环地址直连 POST（node:http）。
+ */
+function postLoopback(url, init) {
+    return new Promise((resolvePromise) => {
+        void (async () => {
+            const mod = url.protocol === 'https:' ? await import('node:https') : await import('node:http');
+            const headers = {};
+            const headersInit = init.headers;
+            if (headersInit) {
+                for (const [k, v] of Object.entries(headersInit))
+                    headers[k] = v;
+            }
+            const body = typeof init.body === 'string' ? init.body : '';
+            headers['Content-Length'] = String(Buffer.byteLength(body));
+            const req = mod.request(url, { method: init.method, headers, timeout: 10000 }, (res) => {
+                res.resume();
+                resolvePromise((res.statusCode ?? 500) < 400);
+            });
+            req.on('error', () => resolvePromise(false));
+            req.on('timeout', () => {
+                req.destroy();
+                resolvePromise(false);
+            });
+            req.end(body);
+        })();
+    });
+}
+/** 发送通知。best-effort：成功返回 true，任何失败静默 false。 */
+export async function sendNotification(webhookUrl, ev) {
+    if (!webhookUrl)
+        return false;
+    const spec = buildNotifyRequest(webhookUrl, ev);
+    if (!spec)
+        return false;
+    let url;
+    try {
+        url = new URL(webhookUrl);
+    }
+    catch {
+        return false;
+    }
+    try {
+        if (isLoopback(url.hostname))
+            return await postLoopback(url, spec.init);
+        const res = await fetch(url, { ...spec.init, signal: AbortSignal.timeout(10000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/repl/commands/bots.js

@@ -0,0 +1,32 @@
+/**
+ * 具名 Bot 命令:/bots
+ * 只读列出 bots；增删改/查看详情走 CLI `mocode bots …`，按名运行用 --bot <name>。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { listBots } from '../../bots/store.js';
+import { unhandled, next } from './types.js';
+function oneLine(text) {
+    const line = text.split('\n')[0] ?? '';
+    return line.length > 50 ? `${line.slice(0, 50)}…` : line;
+}
+export const botsCommands = [
+    (ctx) => {
+        if (ctx.line !== '/bots')
+            return unhandled();
+        const all = listBots();
+        if (all.length === 0) {
+            layout.contentWrite(`${ui.dim}(no bots; mocode bots add --name <n> --prompt "…")${ui.reset}\n`);
+            return next();
+        }
+        for (const b of all) {
+            const scopeTag = b.scope === 'global' ? `${ui.dim}g${ui.reset}` : `${ui.cyan}p${ui.reset}`;
+            layout.contentWrite(`  ${scopeTag} ${ui.bold}${b.name}${ui.reset}` +
+                `${b.tools && b.tools.length ? ` ${ui.dim}tools:${b.tools.length}${ui.reset}` : ''}` +
+                `  ${ui.dim}${b.description}${ui.reset}\n` +
+                `      ${ui.dim}${oneLine(b.systemPrompt)}${ui.reset}\n`);
+        }
+        layout.contentWrite(`${ui.dim}  run: mocode run --bot ${all[0]?.name ?? '<name>'} "task" · details: mocode bots show <name>${ui.reset}\n`);
+        return next();
+    },
+];