oh-my-agent-web 0.2.0 → 0.4.0

package/dist/server/approval/read-only.js

@@ -0,0 +1,107 @@
+/**
+ * 「这条命令是不是只读」（ADR-0006 的补充）：不要把读操作也丢给用户确认。
+ *
+ * 真事：`sed -n 425,470p file` + `grep` 这种纯查看也会弹窗，用户被迫点几十次「允许一次」，
+ * 最后养成"闭眼允许"的习惯 —— 那比不问更危险。
+ *
+ * 判定偏保守（宁可多问一次，不要漏放一次写操作）：
+ *   1. 命令里的每个可执行名都必须在白名单里；
+ *   2. 不能有 `>`、`>>`、`tee`、`&>` 这类写文件的重定向（`2>&1` 除外）；
+ *   3. `sed`/`perl` 带 `-i`（原地改写）一律不算只读；
+ *   4. 不能有 `$(...)`、反引号、`rm/mv/cp/chmod/...` 这类明显的写操作。
+ */
+/** 只读可执行名（能看、能过滤、能统计，但不落盘） */
+const READ_ONLY_BINARIES = new Set([
+    "ls",
+    "cat",
+    "head",
+    "tail",
+    "wc",
+    "grep",
+    "egrep",
+    "rg",
+    "ag",
+    "find",
+    "fd",
+    "sed",
+    "awk",
+    "cut",
+    "sort",
+    "uniq",
+    "tr",
+    "echo",
+    "printf",
+    "pwd",
+    "whoami",
+    "date",
+    "which",
+    "type",
+    "file",
+    "stat",
+    "du",
+    "df",
+    "tree",
+    "jq",
+    "basename",
+    "dirname",
+    "realpath",
+    "md5sum",
+    "shasum",
+    "sha256sum",
+    "diff",
+    "comm",
+    "column",
+    "nl",
+    "rev",
+    "seq",
+    "expr",
+    "test",
+    "true",
+    "false",
+]);
+/** 一旦出现这些词，直接判定「不是只读」 */
+const WRITE_HINTS = /\b(rm|rmdir|mv|cp|mkdir|touch|chmod|chown|ln|install|dd|mkfs|truncate|tee|git|npm|pnpm|yarn|pip|brew|docker|kubectl|curl|wget|ssh|scp)\b/;
+/** 把一个 shell 片段按 `&&`、`||`、`;`、`|`、换行拆开（不处理引号里的分隔符 —— 保守起见够了） */
+function splitCommands(command) {
+    return command
+        .split(/\n|&&|\|\||;|\|/)
+        .map((part) => part.trim())
+        .filter((part) => part !== "");
+}
+/** 取一段命令的可执行名（跳过 `FOO=1 cmd` 这种前置赋值与 sudo/env 之类） */
+function executableOf(part) {
+    const tokens = part.split(/\s+/).filter((token) => token !== "");
+    let index = 0;
+    // 跳过环境变量赋值
+    while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[index] ?? ""))
+        index += 1;
+    const name = tokens[index];
+    if (!name)
+        return null;
+    return name.split("/").pop() ?? name;
+}
+export function isReadOnlyCommand(command) {
+    const text = command.trim();
+    if (text === "")
+        return false;
+    // 命令替换、反引号：内容不可预知 → 不算只读
+    if (text.includes("$(") || text.includes("`"))
+        return false;
+    if (WRITE_HINTS.test(text))
+        return false;
+    // 写文件的重定向（`2>&1`、`2> /dev/null` 这类放行）
+    if (/(^|[^0-9])>>?/.test(text.replace(/[0-9]?>&[0-9]/g, "").replace(/2>\s*\/dev\/null/g, "")))
+        return false;
+    // sed -i / perl -i 原地改写
+    if (/\bsed\b[^|;]*\s-i/.test(text) || /\bperl\b[^|;]*\s-i/.test(text))
+        return false;
+    // 逐个片段检查可执行名
+    for (const part of splitCommands(text)) {
+        const name = executableOf(part);
+        if (name === null)
+            return false;
+        if (!READ_ONLY_BINARIES.has(name))
+            return false;
+    }
+    return true;
+}

package/dist/server/approval/rules.js

@@ -0,0 +1,85 @@
+/**
+ * 审批规则落盘：`<dataDir>/approval-rules.json`（ADR-0006）。
+ *
+ * 规则形状刻意保持「人能手工编辑」的程度：
+ *   { "v": 1, "rules": [{ "scopeKey": "bash|npm", "scopeHint": "命令 npm", "createdAt": 1699999999999 }] }
+ *
+ * 三条纪律：
+ *   1. 文件坏了/被删了 → 当作没有规则（**不能**因此拒绝启动；规则只是便利，不是安全边界）；
+ *   2. 写盘原子（temp + rename），避免半截 JSON；
+ *   3. 规则只增不减（v1 没有管理 UI，要删就手工编辑文件）。
+ */
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const RULES_FILE = "approval-rules.json";
+export const RULES_VERSION = 1;
+export function rulesPath(dataDir) {
+    return join(dataDir, RULES_FILE);
+}
+function isRule(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const candidate = value;
+    return typeof candidate.scopeKey === "string" && candidate.scopeKey !== "";
+}
+/** 纯函数：解析规则文件；坏内容一律返回空规则（不抛错） */
+export function parseRules(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return [];
+    const rules = parsed.rules;
+    if (!Array.isArray(rules))
+        return [];
+    return rules.filter(isRule).map((rule) => ({
+        scopeKey: rule.scopeKey,
+        scopeHint: typeof rule.scopeHint === "string" ? rule.scopeHint : rule.scopeKey,
+        createdAt: typeof rule.createdAt === "number" ? rule.createdAt : 0,
+    }));
+}
+export function hasRule(rules, scopeKey) {
+    return rules.some((rule) => rule.scopeKey === scopeKey);
+}
+/** 纯函数：加一条规则（已存在则原样返回，保持幂等） */
+export function withRule(rules, rule) {
+    if (hasRule(rules, rule.scopeKey))
+        return rules;
+    return [...rules, rule];
+}
+export function createFileRuleStore(dataDir) {
+    return {
+        async load() {
+            try {
+                return parseRules(await readFile(rulesPath(dataDir), "utf8"));
+            }
+            catch {
+                return []; // 文件不存在/读不了 = 没有规则
+            }
+        },
+        async save(rules) {
+            const target = rulesPath(dataDir);
+            await mkdir(dirname(target), { recursive: true });
+            const payload = { v: RULES_VERSION, rules };
+            const temporary = `${target}.tmp`;
+            await writeFile(temporary, `${JSON.stringify(payload, null, "\t")}\n`, "utf8");
+            await rename(temporary, target);
+        },
+    };
+}
+/** 内存版（单测 / 不落盘运行） */
+export function createMemoryRuleStore(seed = []) {
+    let rules = [...seed];
+    return {
+        async load() {
+            return [...rules];
+        },
+        async save(next) {
+            rules = [...next];
+        },
+    };
+}

package/dist/server/approval/scope.js

@@ -0,0 +1,150 @@
+/**
+ * 「这类操作」的归类（ADR-0006 审批粒度）。
+ *
+ * ADR-0006 的原话：「这类」= 工具名 + 一个稳定特征：命令类取**可执行名**，文件类取**目标目录**
+ * （不用完整命令行，否则永远命中不了）。
+ *
+ * 全部是纯函数：给定工具名与参数，产出
+ *   - `dangerous`：要不要问（读类不问，写/改/跑命令要问）
+ *   - `scopeHint`：落到规则文件里的稳定键
+ *   - `riskNote`：给人看的一句话（为什么问）
+ */
+import { isAbsolute, join, resolve } from "node:path";
+import { isReadOnlyCommand } from "./read-only.js";
+/** 不问的工具：只读类 */
+export const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls"]);
+const SUMMARY_CHARS = 200;
+const RISK_NOTES = {
+    bash: "跑命令会修改你的机器（装包、删文件、改配置都算），确认后才能执行",
+    write: "写文件会改动磁盘内容，确认后才能执行",
+    edit: "改文件会改动已有内容，确认后才能执行",
+    powershell: "跑 PowerShell 命令会修改你的机器，确认后才能执行",
+};
+function truncate(text, limit = SUMMARY_CHARS) {
+    return text.length > limit ? `${text.slice(0, limit)}…` : text;
+}
+/** 包装命令（跳过它们去找真正的可执行名） */
+const WRAPPERS = new Set(["sudo", "env", "command", "nohup", "time", "nice", "stdbuf"]);
+/** 这些选项后面还跟一个值（`sudo -u root …`）—— 跳选项时要一起跳 */
+const VALUE_OPTIONS = new Set([
+    "-u",
+    "-g",
+    "-p",
+    "-C",
+    "-h",
+    "-U",
+    "-T",
+    "-r",
+    "-t",
+    "--user",
+    "--group",
+    "--prompt",
+    "--host",
+    "--chdir",
+]);
+const ENV_ASSIGNMENT_RE = /^[A-Za-z_][A-Za-z0-9_]*=/;
+/**
+ * 从命令行里取「可执行名」：跳过 `FOO=bar` 环境赋值、`sudo`/`env`/`nohup` 之类包装（含它们的选项与取值）、
+ * 以及路径前缀。
+ * 例：`FOO=1 npm run build` → `npm`；`sudo -u root npm ci` → `npm`；`/usr/bin/git push -f` → `git`
+ */
+export function commandExecutable(command) {
+    const tokens = command.trim().split(/\s+/).filter(Boolean);
+    let index = 0;
+    skipLeading: for (;;) {
+        const token = tokens[index];
+        if (token === undefined)
+            break;
+        if (ENV_ASSIGNMENT_RE.test(token)) {
+            index += 1;
+            continue;
+        }
+        if (WRAPPERS.has(token)) {
+            index += 1;
+            // 跳过包装命令自己的选项与取值（`sudo -u root` 里的 `-u root`）
+            while (index < tokens.length) {
+                const next = tokens[index];
+                if (ENV_ASSIGNMENT_RE.test(next)) {
+                    index += 1;
+                    continue;
+                }
+                if (!next.startsWith("-"))
+                    break;
+                index += VALUE_OPTIONS.has(next) ? 2 : 1;
+            }
+            continue skipLeading;
+        }
+        break;
+    }
+    const token = tokens[index] ?? "";
+    const base = token.split(/[\\/]/).pop() ?? token;
+    return base === "" ? "(空命令)" : base;
+}
+/** 目标路径所在目录（相对路径按工作区根解析） */
+export function targetDirectory(path, workspace) {
+    if (path === "")
+        return workspace;
+    const absolute = isAbsolute(path) ? path : resolve(join(workspace, path));
+    const index = absolute.lastIndexOf("/");
+    return index <= 0 ? absolute : absolute.slice(0, index);
+}
+/** 从工具调用参数里抠出最有信息量的那个字段（不同工具的 schema 不同，这里只做尽力而为） */
+function pickString(args, keys) {
+    if (typeof args !== "object" || args === null)
+        return null;
+    const record = args;
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value !== "")
+            return value;
+    }
+    return null;
+}
+export function classifyScope(input) {
+    const { toolName, args, workspace } = input;
+    const dangerous = !READ_ONLY_TOOLS.has(toolName);
+    const argsSummary = truncate(typeof args === "string" ? args : JSON.stringify(args ?? {}));
+    if (toolName === "bash" || toolName === "powershell") {
+        const command = pickString(args, ["command", "cmd", "script"]) ?? "";
+        const executable = commandExecutable(command);
+        // 纯读命令（sed -n / grep / cat …）不问：把"闭眼允许"的口子关掉
+        if (isReadOnlyCommand(command)) {
+            return {
+                dangerous: false,
+                toolName,
+                scopeKey: `${toolName}|${executable}`,
+                scopeHint: `命令 ${executable}`,
+                riskNote: "",
+                argsSummary: truncate(command),
+            };
+        }
+        return {
+            dangerous,
+            toolName,
+            scopeKey: `${toolName}|${executable}`,
+            scopeHint: `命令 ${executable}`,
+            riskNote: RISK_NOTES[toolName] ?? "这条命令会改动你的机器，确认后才能执行",
+            argsSummary: truncate(command || argsSummary),
+        };
+    }
+    const path = pickString(args, ["path", "file", "filePath", "target"]);
+    if (path) {
+        const directory = targetDirectory(path, workspace);
+        return {
+            dangerous,
+            toolName,
+            scopeKey: `${toolName}|${directory}`,
+            scopeHint: `目录 ${directory}`,
+            riskNote: RISK_NOTES[toolName] ?? "这个操作会改动磁盘内容，确认后才能执行",
+            argsSummary,
+        };
+    }
+    return {
+        dangerous,
+        toolName,
+        scopeKey: `${toolName}|*`,
+        scopeHint: `所有 ${toolName} 调用`,
+        riskNote: RISK_NOTES[toolName] ?? "这个操作有副作用，确认后才能执行",
+        argsSummary,
+    };
+}

package/dist/server/brand.js

@@ -0,0 +1,2 @@
+/** 服务端侧的同一个自称（登录框 realm、推送通知兜底标题）——与 web/src/brand.ts 保持一致 */
+export const BRAND_NAME = "oh-my-agent-web";

package/dist/server/cli-config.js

@@ -0,0 +1,52 @@
+/**
+ * 命令行选项的「持久化兜底」：`<dataDir>/password` 与 `<dataDir>/allowed-hosts`。
+ *
+ * 为什么需要：`restart` 的参数是每次从命令行重新给的，忘了带 `-P` 就会把远程访问关掉
+ * （真实踩过一次：重启后远程立刻 403「未设置 AGENT_WEB_PASSWORD」）。
+ * 这两个文件让「设一次就一直在」，而命令行/环境变量仍然优先级最高。
+ *
+ * 纪律：读不到、读坏了都不致命 —— 没有密码文件就等同于「只允许本机」，和以前一致。
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+export const PASSWORD_FILE = "password";
+export const ALLOWED_HOSTS_FILE = "allowed-hosts";
+const readTrimmed = async (path) => {
+    try {
+        const text = await readFile(path, "utf8");
+        // 只取第一行：顺手忽略编辑器留下的空行/换行，但密码里不允许出现空白
+        const first = (text.split("\n")[0] ?? "").trim();
+        return first === "" ? null : first;
+    }
+    catch {
+        return null;
+    }
+};
+/** 纯读取：把两个文件都试一遍（不存在就给空值） */
+export async function readStoredOptions(dataDir) {
+    const password = await readTrimmed(join(dataDir, PASSWORD_FILE));
+    const rawHosts = await readFile(join(dataDir, ALLOWED_HOSTS_FILE), "utf8").catch(() => "");
+    const allowedHosts = rawHosts
+        .split(/[\n,]/)
+        .map((item) => item.trim())
+        .filter((item) => item !== "");
+    return { password, allowedHosts };
+}
+/**
+ * 把「存起来的选项」补进 env —— **只补缺**，命令行与环境变量优先。
+ * 返回补了哪些（日志/提示用，绝不回显密码本身）。
+ */
+export async function applyStoredOptions(env, dataDir) {
+    const stored = await readStoredOptions(dataDir);
+    let password = false;
+    let allowedHosts = false;
+    if (stored.password && !env.AGENT_WEB_PASSWORD) {
+        env.AGENT_WEB_PASSWORD = stored.password;
+        password = true;
+    }
+    if (stored.allowedHosts.length > 0 && !env.AGENT_WEB_ALLOWED_HOSTS) {
+        env.AGENT_WEB_ALLOWED_HOSTS = stored.allowedHosts.join(",");
+        allowedHosts = true;
+    }
+    return { password, allowedHosts };
+}

package/dist/server/cli-info.js

@@ -0,0 +1,101 @@
+/**
+ * `omaw` 的「查询类命令」：status / version / upgrade。
+ *
+ * 为什么单独成文件：cli.ts 已经要管参数解析、前后台切换、停止/重启，
+ * 再加状态查询就过 400 行护栏了（ADR-0010：一个文件只干一件事）。
+ * 这里只读锁文件、读 package.json、探一次 /api/health —— 不改任何状态。
+ */
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { defaultIsAlive, readLock } from "./session/lock.js";
+import { packageMeta } from "./util/version.js";
+/** 探活：拿服务端自报的引擎 / 会话数 / 工作区；连不上就 null */
+export async function fetchHealth(host, port, timeoutMs = 1500) {
+    try {
+        const url = `http://${host.includes(":") ? `[${host}]` : host}:${port}/api/health`;
+        const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+        return response.ok ? (await response.json()) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 「已运行 2 天 3 小时」这种给人看的时间 */
+function formatUptime(ms) {
+    const total = Math.max(0, Math.floor(ms / 1000));
+    const days = Math.floor(total / 86_400);
+    const hours = Math.floor((total % 86_400) / 3600);
+    const minutes = Math.floor((total % 3600) / 60);
+    if (days > 0)
+        return `${days} 天 ${hours} 小时`;
+    if (hours > 0)
+        return `${hours} 小时 ${minutes} 分`;
+    if (minutes > 0)
+        return `${minutes} 分 ${total % 60} 秒`;
+    return `${total} 秒`;
+}
+/** `omaw status`：进程状态 + 服务端自报的事实（引擎 / 会话数 / 工作区） */
+export async function showStatus(options) {
+    const { dataDir, probeHost } = options;
+    const lock = await readLock(dataDir);
+    console.log(`oh-my-agent-web v${packageMeta().version}  ·  数据目录 ${dataDir}`);
+    if (!lock) {
+        console.log("状态：未运行（没有 server.lock）");
+        console.log("  启动：omaw -d");
+        return;
+    }
+    if (!defaultIsAlive(lock.pid)) {
+        console.log(`状态：未运行（陈旧锁：pid ${lock.pid} 已不在，下次 start 会自动接管）`);
+        return;
+    }
+    const health = await fetchHealth(probeHost, lock.port);
+    const onDisk = packageMeta().version;
+    console.log(`状态：运行中（pid ${lock.pid}，已运行 ${formatUptime(Date.now() - lock.startedAt)}）`);
+    console.log(`  地址 http://${probeHost}:${lock.port}`);
+    if (health) {
+        const running = health.version ?? "unknown";
+        console.log(`  版本 v${running}（磁盘上是 v${onDisk}${running === onDisk ? "" : "，重启后生效：omaw restart -d"}）`);
+        console.log(`  引擎 ${health.engine} · 协议 v${health.protocolVersion} · 会话 ${health.sessions} · 对话 ${health.conversations}`);
+        console.log(`  工作区 ${health.workspace}`);
+    }
+    else {
+        console.log("  ⚠ 进程在，但 /api/health 没通（可能还在启动，或端口没监听成功）");
+    }
+}
+/** `omaw version` */
+export function showVersion() {
+    console.log(`oh-my-agent-web v${packageMeta().version}（node ${process.version} · ${process.platform}/${process.arch}）`);
+}
+/**
+ * `omaw upgrade`：升级**全局安装**的这个包。
+ *
+ * 三条底线：
+ *   1. 只跑 `npm i -g <包名>@latest`，不做别的（不替你重启，重启会打断正在跑的回合）；
+ *   2. `private: true` 的包**拒绝升级** —— 它根本没发布到 npm，照名字去装只会装到
+ *      别人的同名包（npm 上 `oh-my-agent-web` 确实已被别人占用，踩过一次）；
+ *   3. 输出原样透传，成功/失败都给出下一步该做什么。
+ */
+export async function upgrade() {
+    const meta = packageMeta();
+    if (meta.private) {
+        console.error(`这个包是 private（${meta.name}@${meta.version}），没有发布到 npm，无法从 npm 升级。`);
+        console.error("  · 本地 / git 安装：回到源码目录重新 `npm i -g .`，然后 `omaw restart -d`");
+        console.error("  · 想用 npm 升级：先把 package.json 的 name 改成自己 scope 下的名字（如 @you/omaw）并发布");
+        return 1;
+    }
+    console.log(`当前 v${meta.version}，正在安装 npm 上的最新版 ${meta.name} …`);
+    const code = await new Promise((resolve) => {
+        const child = spawn("npm", ["install", "-g", `${meta.name}@latest`], { stdio: "inherit" });
+        child.on("error", (error) => {
+            console.error(`调用 npm 失败：${error.message}`);
+            resolve(1);
+        });
+        child.on("exit", (exitCode) => resolve(exitCode ?? 1));
+    });
+    if (code !== 0) {
+        console.error("升级失败（网络 / 权限 / 包名不存在都可能）。");
+        return code;
+    }
+    console.log(`已升级到 v${packageMeta().version}（新进程才用新版：omaw restart -d）`);
+    return 0;
+}