larkin 0.5.3 → 0.5.4

package/dist/platform/config.mjs

@@ -8,11 +8,16 @@ import { CURRENT_RUNTIME_MODELS } from "../runtime/runtime-model-catalog.mjs";
 import { fromUserRuntime, isAdapterRuntime, isUserRuntime, toUserRuntime } from "../runtime/user-runtime.mjs";
 import processInspect from "./process-inspect.cjs";
 export { RUNTIME_OPTIONS, fromUserRuntime, isAdapterRuntime, isUserRuntime, runtimeOptionOf, runtimeOptionTarget, toUserRuntime, } from "../runtime/user-runtime.mjs";
+export const DEFAULT_INBOX_AUDIT_INTERVAL_MS = 15 * 60_000;
+export const MIN_INBOX_AUDIT_INTERVAL_MS = 60_000;
+export const MAX_INBOX_AUDIT_INTERVAL_MS = 24 * 60 * 60_000;
 const TOP_FIELDS_V3 = new Set(["version", "serverId", "activeAgent", "agents"]);
 const TOP_FIELDS_V4 = new Set(["version", "serverId", "mentionPolicy", "activeAgent", "agents"]);
+const OPTIONAL_TOP_FIELDS_V4 = new Set(["inboxAudit"]);
 const AGENT_FIELDS_V3 = new Set(["runtime", "model", "effort", "noMentionChats", "createdAt"]);
-const AGENT_FIELDS_V4 = new Set(["runtime", "model", "effort", "mentionPolicy", "chatMentionPolicies", "createdAt"]);
+const AGENT_FIELDS_V4 = new Set(["runtime", "model", "effort", "mentionPolicy", "chatMentionPolicies", "inboxAudit", "createdAt"]);
 const LEGACY_AGENT_FIELDS = new Set(["piDistribution", "runtimeOption"]);
+const INBOX_AUDIT_FIELDS = new Set(["enabled", "intervalMs"]);
 const APP_ID = /^cli_[A-Za-z0-9]+$/;
 const CHAT_ID = /^oc_[A-Za-z0-9_-]+$/;
 const PI_EFFORTS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
@@ -76,6 +81,85 @@ function assertPolicy(value, label) {
     if (value !== "require" && value !== "free")
         throw new Error(`${label} 只允许 require/free`);
 }
+export function assertInboxAuditInterval(value, label = "inbox-audit interval") {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < MIN_INBOX_AUDIT_INTERVAL_MS || value > MAX_INBOX_AUDIT_INTERVAL_MS) {
+        throw new Error(`${label} 必须是 ${MIN_INBOX_AUDIT_INTERVAL_MS}–${MAX_INBOX_AUDIT_INTERVAL_MS} 毫秒`);
+    }
+}
+export function parseInboxAuditInterval(value) {
+    if (typeof value !== "string" || !value)
+        throw new Error("inbox-audit interval 不能为空");
+    let milliseconds;
+    if (/^[1-9]\d*$/.test(value))
+        milliseconds = Number(value);
+    else {
+        const match = /^([1-9]\d*)(m|h)$/.exec(value);
+        if (!match)
+            throw new Error("inbox-audit interval 只允许 15m/1h 或 60000–86400000 毫秒");
+        milliseconds = Number(match[1]) * (match[2] === "h" ? 3_600_000 : 60_000);
+    }
+    assertInboxAuditInterval(milliseconds);
+    return milliseconds;
+}
+export function formatInboxAuditInterval(intervalMs) {
+    if (intervalMs % 3_600_000 === 0)
+        return `${intervalMs / 3_600_000}h`;
+    if (intervalMs % 60_000 === 0)
+        return `${intervalMs / 60_000}m`;
+    return `${intervalMs}ms`;
+}
+function parseStoredInboxAudit(value, label) {
+    if (!isPlainObject(value))
+        throw new Error(`${label} 必须是普通 object`);
+    assertAllowedFields(value, INBOX_AUDIT_FIELDS, label);
+    const settings = {};
+    if (Object.hasOwn(value, "enabled")) {
+        if (typeof value.enabled !== "boolean")
+            throw new Error(`${label}.enabled 必须是 boolean`);
+        settings.enabled = value.enabled;
+    }
+    if (Object.hasOwn(value, "intervalMs")) {
+        assertInboxAuditInterval(value.intervalMs, `${label}.intervalMs`);
+        settings.intervalMs = value.intervalMs;
+    }
+    return settings;
+}
+function resolvedInboxAudit(settings) {
+    return {
+        enabled: settings?.enabled ?? false,
+        intervalMs: settings?.intervalMs ?? DEFAULT_INBOX_AUDIT_INTERVAL_MS,
+    };
+}
+export function inboxAuditMutationFromCli(input) {
+    if (input.scope === "global") {
+        if (input.enabled !== "on" && input.enabled !== "off") {
+            throw new Error("用法: larkin config inbox-audit global <on|off> [--interval <15m|1h>]");
+        }
+        const mutation = {
+            kind: "set-global-inbox-audit", enabled: input.enabled === "on",
+        };
+        if (input.interval !== undefined) {
+            if (input.interval === "inherit")
+                throw new Error("全局 inbox-audit 不支持 interval=inherit");
+            mutation.intervalMs = parseInboxAuditInterval(input.interval);
+        }
+        return mutation;
+    }
+    if (input.scope === "agent") {
+        if (input.enabled !== "on" && input.enabled !== "off" && input.enabled !== "inherit") {
+            throw new Error("用法: larkin config inbox-audit agent <inherit|on|off> [--agent <App ID>] [--interval <15m|inherit>]");
+        }
+        const mutation = {
+            kind: "set-agent-inbox-audit", agentId: input.agentId,
+            enabled: input.enabled === "inherit" ? "inherit" : input.enabled === "on",
+        };
+        if (input.interval !== undefined) {
+            mutation.intervalMs = input.interval === "inherit" ? "inherit" : parseInboxAuditInterval(input.interval);
+        }
+        return mutation;
+    }
+    throw new Error("inbox-audit scope 只支持 global/agent");
+}
 function assertModel(runtime, model) {
     if (model === "default")
         return;
@@ -143,6 +227,8 @@ function validateStoredAgent(key, agent, version) {
     }
     if (version === 4 && Object.hasOwn(agent, "mentionPolicy"))
         assertPolicy(agent.mentionPolicy, `Agent ${key}.mentionPolicy`);
+    if (version === 4 && Object.hasOwn(agent, "inboxAudit"))
+        parseStoredInboxAudit(agent.inboxAudit, `Agent ${key}.inboxAudit`);
     if (version === 4 && Object.hasOwn(agent, "chatMentionPolicies")) {
         if (!isPlainObject(agent.chatMentionPolicies))
             throw new Error(`Agent ${key}.chatMentionPolicies 必须是普通 object`);
@@ -171,6 +257,7 @@ function hydratedStoredAgent(key, agent, version) {
         model: agent.model,
         ...(typeof agent.effort === "string" ? { effort: agent.effort } : {}),
         ...(version === 4 && (agent.mentionPolicy === "require" || agent.mentionPolicy === "free") ? { mentionPolicy: agent.mentionPolicy } : {}),
+        ...(version === 4 && Object.hasOwn(agent, "inboxAudit") ? { inboxAudit: parseStoredInboxAudit(agent.inboxAudit, `Agent ${key}.inboxAudit`) } : {}),
         ...(Object.keys(chatMentionPolicies).length ? { chatMentionPolicies, noMentionChats: Object.entries(chatMentionPolicies).filter(([, policy]) => policy === "free").map(([chatId]) => chatId) } : {}),
         ...(typeof agent.createdAt === "string" ? { createdAt: agent.createdAt } : {}),
     };
@@ -184,6 +271,7 @@ export function hydrateAgent(key, agent, configDir) {
         larkConfigDir: path.join(layout.agentStateDir(key), "lark-cli-config"),
         ...(agent.effort ? { effort: agent.effort } : {}),
         ...(agent.mentionPolicy ? { mentionPolicy: agent.mentionPolicy } : {}),
+        ...(agent.inboxAudit ? { inboxAudit: { ...agent.inboxAudit } } : {}),
         ...(agent.chatMentionPolicies ? { chatMentionPolicies: { ...agent.chatMentionPolicies } } : {}),
         ...(agent.noMentionChats ? { noMentionChats: [...agent.noMentionChats] } : {}),
         ...(agent.createdAt ? { createdAt: agent.createdAt } : {}),
@@ -202,7 +290,7 @@ export function normalizeConfig(raw, configDir, { mint } = {}) {
     if (version !== 3 && version !== 4)
         throw new Error("不支持该配置格式：larkin 只接受 version=3/4");
     const topFields = version === 3 ? TOP_FIELDS_V3 : TOP_FIELDS_V4;
-    assertAllowedFields(raw, topFields, "config");
+    assertAllowedFields(raw, version === 4 ? new Set([...TOP_FIELDS_V4, ...OPTIONAL_TOP_FIELDS_V4]) : topFields, "config");
     for (const field of topFields)
         if (!Object.hasOwn(raw, field))
             throw new Error(`config 缺少必需字段 ${field}`);
@@ -221,8 +309,12 @@ export function normalizeConfig(raw, configDir, { mint } = {}) {
     const agents = {};
     for (const [key, agent] of Object.entries(raw.agents))
         agents[key] = hydrateAgent(key, hydratedStoredAgent(key, agent, version), layout.root);
+    const inboxAudit = version === 4 && Object.hasOwn(raw, "inboxAudit")
+        ? resolvedInboxAudit(parseStoredInboxAudit(raw.inboxAudit, "config.inboxAudit"))
+        : undefined;
     return {
         version: 4, serverId: raw.serverId, mentionPolicy: version === 4 ? raw.mentionPolicy : "require",
+        ...(inboxAudit ? { inboxAudit } : {}),
         configDir: layout.configDir, larkinHome: layout.larkinHome, larkConfigDir: resolveLarkConfigDir({}, layout.root), activeAgent: raw.activeAgent, agents,
     };
 }
@@ -448,7 +540,11 @@ export function selectAgent(config, env = process.env) {
     return agents[config.activeAgent];
 }
 export function toStored(config) {
-    const out = { version: 4, serverId: config.serverId, mentionPolicy: config.mentionPolicy, activeAgent: config.activeAgent, agents: {} };
+    const out = {
+        version: 4, serverId: config.serverId, mentionPolicy: config.mentionPolicy, activeAgent: config.activeAgent, agents: {},
+    };
+    if (config.inboxAudit)
+        out.inboxAudit = { enabled: config.inboxAudit.enabled, intervalMs: config.inboxAudit.intervalMs };
     for (const [key, agent] of Object.entries(config.agents || {})) {
         const stored = { runtime: agent.runtime, model: agent.model };
         if (typeof agent.effort === "string" && agent.effort)
@@ -457,6 +553,9 @@ export function toStored(config) {
             stored.mentionPolicy = agent.mentionPolicy;
         if (agent.chatMentionPolicies && Object.keys(agent.chatMentionPolicies).length)
             stored.chatMentionPolicies = { ...agent.chatMentionPolicies };
+        if (agent.inboxAudit && (agent.inboxAudit.enabled !== undefined || agent.inboxAudit.intervalMs !== undefined)) {
+            stored.inboxAudit = { ...agent.inboxAudit };
+        }
         if (typeof agent.createdAt === "string" && agent.createdAt)
             stored.createdAt = agent.createdAt;
         out.agents[key] = stored;
@@ -483,6 +582,20 @@ export function resolveAgentGlobalMentionPolicy(config, agentId) {
         return { effective: agent.mentionPolicy, source: "agent" };
     return { effective: config.mentionPolicy, source: "global" };
 }
+export function resolveInboxAuditSchedule(config, agentId) {
+    const agent = config.agents[agentId];
+    if (!agent)
+        throw new Error(`Agent 不存在：${agentId}`);
+    const enabled = agent.inboxAudit?.enabled ?? config.inboxAudit?.enabled ?? false;
+    const intervalMs = agent.inboxAudit?.intervalMs ?? config.inboxAudit?.intervalMs ?? DEFAULT_INBOX_AUDIT_INTERVAL_MS;
+    assertInboxAuditInterval(intervalMs);
+    return {
+        enabled,
+        intervalMs,
+        enabledSource: agent.inboxAudit?.enabled !== undefined ? "agent" : config.inboxAudit ? "global" : "default",
+        intervalSource: agent.inboxAudit?.intervalMs !== undefined ? "agent" : config.inboxAudit?.intervalMs !== undefined ? "global" : "default",
+    };
+}
 function revision(bytes) {
     return `sha256:${crypto.createHash("sha256").update(bytes).digest("hex")}`;
 }
@@ -495,6 +608,7 @@ function agentSignature(config, agentId) {
         schema: 2,
         runtime: agent.runtime, model: agent.model, effort: agent.effort ?? null,
         globalMentionPolicy: config.mentionPolicy, agentMentionPolicy: agent.mentionPolicy ?? null, chatMentionPolicies: chats,
+        globalInboxAudit: config.inboxAudit ?? null, agentInboxAudit: agent.inboxAudit ?? null,
     }));
 }
 export function runtimeConfigSignature(config, agentId) {
@@ -632,6 +746,19 @@ function applyMutation(config, mutation) {
         config.mentionPolicy = mutation.value;
         return { scope: "global", runtimeChange: false, affectedAgentIds: Object.keys(config.agents) };
     }
+    if (mutation.kind === "set-global-inbox-audit") {
+        if (mutation.enabled === undefined && mutation.intervalMs === undefined)
+            throw new Error("inbox-audit 全局变更必须包含 enabled 或 interval");
+        const current = resolvedInboxAudit(config.inboxAudit);
+        if (mutation.enabled !== undefined)
+            current.enabled = mutation.enabled;
+        if (mutation.intervalMs !== undefined) {
+            assertInboxAuditInterval(mutation.intervalMs, "全局 inbox-audit interval");
+            current.intervalMs = mutation.intervalMs;
+        }
+        config.inboxAudit = current;
+        return { scope: "global", runtimeChange: false, affectedAgentIds: Object.keys(config.agents) };
+    }
     if (!APP_ID.test(mutation.agentId) || !config.agents[mutation.agentId])
         throw new Error(`Agent 不存在：${mutation.agentId}`);
     const agent = config.agents[mutation.agentId];
@@ -644,6 +771,26 @@ function applyMutation(config, mutation) {
         }
         return { scope: "agent", agentId: mutation.agentId, runtimeChange: false, affectedAgentIds: [mutation.agentId] };
     }
+    if (mutation.kind === "set-agent-inbox-audit") {
+        if (mutation.enabled === undefined && mutation.intervalMs === undefined)
+            throw new Error("inbox-audit Agent 变更必须包含 enabled 或 interval");
+        const current = { ...(agent.inboxAudit || {}) };
+        if (mutation.enabled === "inherit")
+            delete current.enabled;
+        else if (mutation.enabled !== undefined)
+            current.enabled = mutation.enabled;
+        if (mutation.intervalMs === "inherit")
+            delete current.intervalMs;
+        else if (mutation.intervalMs !== undefined) {
+            assertInboxAuditInterval(mutation.intervalMs, "Agent inbox-audit interval");
+            current.intervalMs = mutation.intervalMs;
+        }
+        if (current.enabled === undefined && current.intervalMs === undefined)
+            delete agent.inboxAudit;
+        else
+            agent.inboxAudit = current;
+        return { scope: "agent", agentId: mutation.agentId, runtimeChange: false, affectedAgentIds: [mutation.agentId] };
+    }
     if (mutation.kind === "set-chat-mention") {
         if (!CHAT_ID.test(mutation.chatId))
             throw new Error(`群 ID 格式无效：${mutation.chatId}`);
@@ -1130,8 +1277,24 @@ export function safeConfigView(config, onlyAgentId, chatId, applyState) {
             source: agent.mentionPolicy ? "agent" : "global",
             ...(chatId ? { chat: { chatId, override: agent.chatMentionPolicies?.[chatId] ?? "inherit", ...resolveMentionPolicy(config, agentId, chatId) } } : {}),
         },
+        inboxAudit: (() => {
+            const resolved = resolveInboxAuditSchedule(config, agentId);
+            return {
+                override: {
+                    enabled: agent.inboxAudit?.enabled === undefined ? "inherit" : agent.inboxAudit.enabled ? "on" : "off",
+                    intervalMs: agent.inboxAudit?.intervalMs ?? "inherit",
+                },
+                effective: { enabled: resolved.enabled, intervalMs: resolved.intervalMs },
+                source: { enabled: resolved.enabledSource, intervalMs: resolved.intervalSource },
+            };
+        })(),
         chatMentionPolicies: { ...(agent.chatMentionPolicies || {}) },
         apply: applyState?.agents?.[agentId] ?? { applyState: "unknown" },
     }));
-    return { version: 4, mentionPolicy: config.mentionPolicy, persistedRevision: applyState?.persistedRevision ?? "unknown", agents };
+    const inboxAudit = resolvedInboxAudit(config.inboxAudit);
+    return {
+        version: 4, mentionPolicy: config.mentionPolicy,
+        inboxAudit: { enabled: inboxAudit.enabled, intervalMs: inboxAudit.intervalMs },
+        persistedRevision: applyState?.persistedRevision ?? "unknown", agents,
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkin",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "private": false,
   "larkinPackageRole": "npm-published",
   "files": [