@zhin.js/host-http 1.1.0 → 1.1.1

package/lib/console-rpc-extended/inbox-rpc.js

@@ -0,0 +1,292 @@
+import { boundedIntegerField, boolField, errorMessage, numArrayField, optionalNum, strField, withLiveEndpoint, } from './rpc-values.js';
+import { channelFromStoredRow, normalizeParent } from './endpoint-rpc.js';
+export const TABLE_MESSAGE = 'unified_inbox_message';
+export const TABLE_REQUEST = 'unified_inbox_request';
+export const TABLE_NOTICE = 'unified_inbox_notice';
+const MAX_INBOX_OFFSET = 10_000;
+const CONSUMED_NOT_WIRED = '收件箱已读标记未接线：unified_inbox_request/notice 表未注册或 DatabaseHost 未启动';
+function getInboxModel(ctx, table) {
+    const model = ctx.databaseHost?.models?.get(table);
+    if (!model || typeof model.select !== 'function')
+        return undefined;
+    return model;
+}
+async function readInboxRows(ctx, table, where, options) {
+    const model = getInboxModel(ctx, table);
+    if (!model)
+        return { rows: [], enabled: false, offsetApplied: false };
+    try {
+        let selection = model.select().where(where);
+        let orderApplied = options?.orderBy == null;
+        if (options?.orderBy && typeof selection.orderBy === 'function') {
+            selection = selection.orderBy(options.orderBy.field, options.orderBy.direction ?? 'DESC');
+            orderApplied = true;
+        }
+        const offset = options?.offset ?? 0;
+        const offsetSelection = orderApplied ? selection.offset : undefined;
+        const canApplyOffset = typeof offsetSelection === 'function';
+        const offsetApplied = offset === 0 || canApplyOffset;
+        if (offset > 0 && canApplyOffset) {
+            selection = offsetSelection.call(selection, offset);
+        }
+        if (options?.limit != null && orderApplied && typeof selection.limit === 'function') {
+            selection = selection.limit(options.limit + (offsetApplied ? 0 : offset));
+        }
+        const rows = await selection;
+        return { rows: Array.isArray(rows) ? rows : [], enabled: true, offsetApplied };
+    }
+    catch {
+        // 表未创建 / 方言未启动等场景降级为空，不向上抛。
+        return { rows: [], enabled: false, offsetApplied: false };
+    }
+}
+export async function listInbox(d, ctx, table, key, mapRow) {
+    const adapter = strField(d, 'adapter');
+    const endpointKey = strField(d, 'endpointKey');
+    if (!adapter || !endpointKey)
+        return { error: 'adapter and endpointKey are required' };
+    const limit = boundedIntegerField(d, 30, 1, 100, 'limit');
+    const offset = boundedIntegerField(d, 0, 0, MAX_INBOX_OFFSET, 'offset');
+    const unreadOnly = table === TABLE_NOTICE
+        && boolField(d, false, 'unreadOnly');
+    const { rows, enabled, offsetApplied } = await readInboxRows(ctx, table, {
+        adapter,
+        endpoint_id: endpointKey,
+        ...(unreadOnly ? { consumed: 0 } : {}),
+    }, {
+        // sort/limit 下推到 DB 侧（内存 sort/slice 保留，作为无下推能力模型的兜底）
+        orderBy: { field: 'created_at', direction: 'DESC' },
+        limit,
+        offset,
+    });
+    const sorted = rows
+        .slice()
+        .sort((a, b) => Number(b.created_at ?? 0) - Number(a.created_at ?? 0))
+        .slice(offsetApplied ? 0 : offset, (offsetApplied ? 0 : offset) + limit)
+        .map(mapRow);
+    return { data: { [key]: sorted, inboxEnabled: enabled } };
+}
+/** request.list —— 优先 live EndpointManagement.listRequests；否则回退 unified_inbox_request。 */
+export async function listPendingRequests(d, ctx) {
+    const adapter = strField(d, 'adapter');
+    const endpointKey = strField(d, 'endpointKey');
+    if (!adapter || !endpointKey)
+        return { error: 'adapter and endpointKey are required' };
+    if (ctx.withEndpointManagement) {
+        try {
+            const live = await ctx.withEndpointManagement(adapter, endpointKey, async (management) => {
+                if (!management.listRequests)
+                    return undefined;
+                const pending = await management.listRequests();
+                const requests = pending.map((row) => mapRequestRow({
+                    platform_request_id: row.platform_request_id,
+                    type: row.type,
+                    scene_type: row.scene_type ?? null,
+                    scene_id: row.scene_id,
+                    sub_type: row.sub_type ?? null,
+                    actor_id: row.actor_id,
+                    actor_name: row.actor_name ?? null,
+                    comment: row.comment ?? null,
+                    created_at: row.created_at,
+                    resolved: 0,
+                }));
+                return { data: { requests, inboxEnabled: false, source: 'endpoint' } };
+            });
+            if (live)
+                return live;
+        }
+        catch (error) {
+            return { error: errorMessage(error) };
+        }
+    }
+    const { rows, enabled } = await readInboxRows(ctx, TABLE_REQUEST, {
+        adapter,
+        endpoint_id: endpointKey,
+    }, {
+        orderBy: { field: 'created_at', direction: 'ASC' },
+    });
+    const requests = rows
+        .filter((row) => Number(row.resolved ?? 0) === 0)
+        .sort((a, b) => Number(a.created_at ?? 0) - Number(b.created_at ?? 0))
+        .map(mapRequestRow);
+    return { data: { requests, inboxEnabled: enabled, source: 'inbox' } };
+}
+export async function listInboxMessages(d, ctx) {
+    const adapter = strField(d, 'adapter');
+    const endpointKey = strField(d, 'endpointKey');
+    const channelId = strField(d, 'channelId');
+    const channelType = strField(d, 'channelType');
+    if (!adapter || !endpointKey || !channelId || !channelType) {
+        return { error: 'adapter, endpointKey, channelId, and channelType are required' };
+    }
+    const limit = boundedIntegerField(d, 50, 1, 100, 'limit');
+    const beforeTs = optionalNum(d, 'beforeTs');
+    const beforeId = optionalNum(d, 'beforeId');
+    const parent = normalizeParent(d.parent);
+    const where = {
+        adapter,
+        endpoint_id: endpointKey,
+        channel_id: channelId,
+        channel_type: channelType,
+    };
+    if (parent) {
+        where.channel_parent_type = parent.type;
+        where.channel_parent_id = parent.id;
+    }
+    const { rows, enabled } = await readInboxRows(ctx, TABLE_MESSAGE, where, {
+        // before_ts/before_id 过滤保留在内存（涉及双字段比较），排序下推 DB 侧
+        orderBy: { field: 'created_at', direction: 'DESC' },
+    });
+    const messages = rows
+        .filter((row) => (beforeTs == null || Number(row.created_at ?? 0) < beforeTs)
+        && (beforeId == null || Number(row.id ?? 0) < beforeId))
+        .sort((a, b) => Number(b.created_at ?? 0) - Number(a.created_at ?? 0))
+        .slice(0, limit)
+        .map(mapMessageRow);
+    return { data: { messages, inboxEnabled: enabled } };
+}
+/**
+ * Cross-endpoint recent inbox used by paired Mobile Console clients.
+ * Unlike endpoint-detail `inbox.messages`, every row carries its complete
+ * routable address so selecting a conversation can safely call
+ * `endpoint.send_message` through the Device Protocol write allowlist.
+ */
+export async function listRecentInboxMessages(d, ctx) {
+    const limit = boundedIntegerField(d, 50, 1, 100, 'limit');
+    const [messagePage, requestPage] = await Promise.all([
+        readInboxRows(ctx, TABLE_MESSAGE, {}, {
+            orderBy: { field: 'created_at', direction: 'DESC' }, limit,
+        }),
+        readInboxRows(ctx, TABLE_REQUEST, { resolved: 0 }, {
+            orderBy: { field: 'created_at', direction: 'DESC' }, limit,
+        }),
+    ]);
+    const messages = messagePage.rows
+        .slice()
+        .sort((left, right) => Number(right.created_at ?? 0) - Number(left.created_at ?? 0))
+        .slice(0, limit)
+        .map(row => ({
+        ...mapMessageRow(row),
+        adapter: String(row.adapter ?? ''),
+        endpointKey: String(row.endpoint_id ?? ''),
+    }));
+    const requests = requestPage.rows
+        .filter(row => Number(row.resolved ?? 0) === 0)
+        .slice()
+        .sort((left, right) => Number(right.created_at ?? 0) - Number(left.created_at ?? 0))
+        .slice(0, limit)
+        .map(row => ({
+        ...mapRequestRow(row),
+        adapter: String(row.adapter ?? ''),
+        endpointKey: String(row.endpoint_id ?? ''),
+    }));
+    return { data: { messages, requests, inboxEnabled: messagePage.enabled || requestPage.enabled } };
+}
+export function mapRequestRow(row) {
+    return {
+        id: row.id,
+        platformRequestId: row.platform_request_id,
+        type: row.type,
+        subType: row.sub_type ?? undefined,
+        actor: actorFromStoredRow(row, 'actor'),
+        comment: row.comment ?? undefined,
+        channel: {
+            id: String(row.scene_id ?? ''),
+            type: String(row.scene_type ?? ''),
+        },
+        timestamp: row.created_at,
+        resolved: Boolean(row.resolved),
+        resolvedAt: row.resolved_at ?? undefined,
+    };
+}
+export function mapNoticeRow(row) {
+    const actorId = row.actor_id ?? undefined;
+    const actorName = row.actor_name ?? undefined;
+    const sceneId = String(row.scene_id ?? '');
+    const sceneType = row.scene_type == null ? undefined : String(row.scene_type);
+    return {
+        id: row.id,
+        platformNoticeId: row.platform_notice_id,
+        noticeType: row.type,
+        channel: { id: sceneId, type: sceneType ?? '' },
+        subType: row.sub_type ?? undefined,
+        ...(actorId == null ? {} : { operator: { id: String(actorId), ...(actorName == null ? {} : { name: String(actorName) }) } }),
+        ...(row.target_id == null ? {} : { target: {
+                id: String(row.target_id),
+                ...(row.target_name == null ? {} : { name: String(row.target_name) }),
+            } }),
+        payload: row.payload,
+        timestamp: row.created_at,
+        consumed: Boolean(row.consumed),
+        consumedAt: row.consumed_at ?? undefined,
+    };
+}
+function mapMessageRow(row) {
+    return {
+        id: row.id,
+        platformMessageId: row.platform_message_id,
+        sender: actorFromStoredRow(row, 'sender'),
+        content: row.content,
+        raw: row.raw,
+        timestamp: row.created_at,
+        channel: channelFromStoredRow(row),
+    };
+}
+function actorFromStoredRow(row, field) {
+    const id = String(row[`${field}_id`] ?? '');
+    const name = row[`${field}_name`];
+    return name == null ? { id } : { id, name: String(name) };
+}
+// ---------------------------------------------------------------- consumed 标记
+/**
+ * request.consumed / notice.consumed —— 按行 id 置 consumed=1。
+ * 表未注册（或 model 无 update）时保持"未接线"报错。
+ */
+export async function markInboxConsumed(d, ctx, table) {
+    const ids = numArrayField(d, 'rowIds');
+    if (ids.length === 0)
+        return { error: 'rowIds is required' };
+    const model = getInboxModel(ctx, table);
+    if (!model || typeof model.update !== 'function')
+        return { error: CONSUMED_NOT_WIRED };
+    const now = Date.now();
+    try {
+        for (const id of ids) {
+            await model.update({ consumed: 1, consumed_at: now }).where({ id });
+        }
+        return { data: { success: true, updated: ids.length } };
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
+// ---------------------------------------------------------------- 请求审批
+export async function actOnRequest(type, d, ctx) {
+    const adapter = strField(d, 'adapter');
+    const endpointKey = strField(d, 'endpointKey');
+    const requestId = strField(d, 'platformRequestId');
+    if (!adapter || !endpointKey || !requestId) {
+        return { error: 'adapter, endpointKey, and platformRequestId are required' };
+    }
+    return withLiveEndpoint(ctx, adapter, endpointKey, async (management) => {
+        const approve = type === 'request.approve';
+        const method = approve ? management.approveRequest : management.rejectRequest;
+        if (!method) {
+            return {
+                error: `请求审批未接线：当前平台（${adapter}）endpoint 不支持 ${approve ? 'approveRequest' : 'rejectRequest'}，` +
+                    '且新 Runtime 尚未挂载 pending request 注册表',
+            };
+        }
+        const extra = approve
+            ? strField(d, 'remark')
+            : strField(d, 'reason');
+        await method.call(management, requestId, extra || undefined);
+        const model = getInboxModel(ctx, TABLE_REQUEST);
+        if (model && typeof model.update === 'function') {
+            await model.update({ resolved: 1, resolved_at: Date.now() }).where({
+                adapter, endpoint_id: endpointKey, platform_request_id: requestId,
+            });
+        }
+        return { data: { success: true } };
+    });
+}

package/lib/console-rpc-extended/index.d.ts

@@ -0,0 +1,2 @@
+export type { ConsoleRpcExtendedCtx, ConsoleScheduleEngine, ConsoleWorkroomKnowledgeControlPort, ConsoleWorkroomProfileControlPort, ExtendedRpcResult, } from './contracts.js';
+export { dispatchExtendedConsoleRpc } from './dispatcher.js';

package/lib/console-rpc-extended/index.js

@@ -0,0 +1 @@
+export { dispatchExtendedConsoleRpc } from './dispatcher.js';

package/lib/console-rpc-extended/login-rpc.d.ts

@@ -0,0 +1,4 @@
+import type { ConsoleRpcExtendedCtx, ExtendedRpcResult } from './contracts.js';
+export declare function listLoginPending(ctx: ConsoleRpcExtendedCtx): ExtendedRpcResult;
+export declare function submitLogin(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): ExtendedRpcResult;
+export declare function cancelLogin(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): ExtendedRpcResult;

package/lib/console-rpc-extended/login-rpc.js

@@ -0,0 +1,46 @@
+import { strField } from './rpc-values.js';
+export function listLoginPending(ctx) {
+    const assist = ctx.loginAssist;
+    if (!assist)
+        return { error: '登录辅助未接线（LoginAssist 未挂载）' };
+    const tasks = assist.listPending().map((task) => ({
+        id: task.id,
+        adapter: task.adapter,
+        endpointKey: task.endpointKey,
+        type: task.type,
+        payload: task.payload,
+        createdAt: task.createdAt,
+        expiresAt: task.expiresAt,
+    }));
+    return { data: { tasks, count: tasks.length } };
+}
+export function submitLogin(d, ctx) {
+    const assist = ctx.loginAssist;
+    if (!assist)
+        return { error: '登录辅助未接线（LoginAssist 未挂载）' };
+    const id = strField(d, 'taskId');
+    if (!id)
+        return { error: 'taskId is required' };
+    const raw = d.value ?? '';
+    const value = typeof raw === 'string' || (raw && typeof raw === 'object')
+        ? raw
+        : String(raw ?? '');
+    const ok = assist.submit(id, value);
+    if (!ok)
+        return { error: `login task not found: ${id}` };
+    return { data: { success: true } };
+}
+export function cancelLogin(d, ctx) {
+    const assist = ctx.loginAssist;
+    if (!assist)
+        return { error: '登录辅助未接线（LoginAssist 未挂载）' };
+    const id = strField(d, 'taskId');
+    if (!id)
+        return { error: 'taskId is required' };
+    const reason = strField(d, 'reason') || 'cancelled';
+    const ok = assist.cancel(id, reason);
+    if (!ok)
+        return { error: `login task not found: ${id}` };
+    return { data: { success: true } };
+}
+// ---------------------------------------------------------------- 社交读取

package/lib/console-rpc-extended/rpc-values.d.ts

@@ -0,0 +1,16 @@
+import type { ConsoleRpcExtendedCtx, EndpointManagementPort, ExtendedRpcResult } from './contracts.js';
+export declare function requiredRpcValue(value: unknown, name: string): unknown;
+export declare function requiredRpcText(value: unknown, name: string): string;
+export declare function optionalRpcText(value: unknown, name: string): string | undefined;
+export declare function optionalRpcTextArray(value: unknown, name: string): readonly string[] | undefined;
+export declare function requiredRpcInteger(value: unknown, name: string, minimum?: number): number;
+export declare function requiredRpcBoolean(value: unknown, name: string): boolean;
+export declare function strField(d: Record<string, unknown>, key: string): string;
+export declare function numField(d: Record<string, unknown>, fallback: number, key: string): number;
+export declare function boundedIntegerField(d: Record<string, unknown>, fallback: number, minimum: number, maximum: number, key: string): number;
+export declare function boolField(d: Record<string, unknown>, fallback: boolean, key: string): boolean;
+export declare function optionalNum(d: Record<string, unknown>, key: string): number | undefined;
+/** Parse one canonical numeric-array field into finite positive ids. */
+export declare function numArrayField(d: Record<string, unknown>, key: string): number[];
+export declare function withLiveEndpoint(ctx: ConsoleRpcExtendedCtx, adapter: string, endpointKey: string, run: (management: EndpointManagementPort) => ExtendedRpcResult | Promise<ExtendedRpcResult>): Promise<ExtendedRpcResult>;
+export declare function errorMessage(error: unknown): string;

package/lib/console-rpc-extended/rpc-values.js

@@ -0,0 +1,87 @@
+export function requiredRpcValue(value, name) {
+    if (value === undefined || value === null)
+        throw new Error(`${name} is required`);
+    return structuredClone(value);
+}
+export function requiredRpcText(value, name) {
+    if (typeof value !== 'string' || !value.trim() || value !== value.trim()) {
+        throw new Error(`${name} is invalid`);
+    }
+    return value;
+}
+export function optionalRpcText(value, name) {
+    return value === undefined ? undefined : requiredRpcText(value, name);
+}
+export function optionalRpcTextArray(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new Error(`${name} is invalid`);
+    const result = value.map((item, index) => requiredRpcText(item, `${name}.${index}`));
+    if (new Set(result).size !== result.length)
+        throw new Error(`${name} contains duplicates`);
+    return Object.freeze(result);
+}
+export function requiredRpcInteger(value, name, minimum = 1) {
+    if (!Number.isSafeInteger(value) || Number(value) < minimum)
+        throw new Error(`${name} is invalid`);
+    return Number(value);
+}
+export function requiredRpcBoolean(value, name) {
+    if (typeof value !== 'boolean')
+        throw new Error(`${name} is invalid`);
+    return value;
+}
+// ---------------------------------------------------------------- cron
+export function strField(d, key) {
+    const value = d[key];
+    if (typeof value === 'string' && value.trim())
+        return value.trim();
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    return '';
+}
+export function numField(d, fallback, key) {
+    const parsed = Number(d[key]);
+    return d[key] != null && Number.isFinite(parsed) ? parsed : fallback;
+}
+export function boundedIntegerField(d, fallback, minimum, maximum, key) {
+    const value = numField(d, fallback, key);
+    if (!Number.isFinite(value))
+        return fallback;
+    return Math.min(maximum, Math.max(minimum, Math.trunc(value)));
+}
+export function boolField(d, fallback, key) {
+    const value = d[key];
+    return typeof value === 'boolean' ? value : fallback;
+}
+export function optionalNum(d, key) {
+    if (d[key] == null)
+        return undefined;
+    const parsed = Number(d[key]);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+/** Parse one canonical numeric-array field into finite positive ids. */
+export function numArrayField(d, key) {
+    const value = d[key];
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => Number(item))
+        .filter((item) => Number.isFinite(item));
+}
+export async function withLiveEndpoint(ctx, adapter, endpointKey, run) {
+    if (!ctx.withEndpointManagement) {
+        return { error: 'Endpoint registry is not configured' };
+    }
+    try {
+        return await ctx.withEndpointManagement(adapter, endpointKey, run)
+            ?? { error: 'endpoint not found' };
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/console-rpc-extended/schedule-rpc.d.ts

@@ -0,0 +1,6 @@
+import type { ConsoleRpcExtendedCtx, ExtendedRpcResult } from './contracts.js';
+export declare function listSchedule(ctx: ConsoleScheduleListCtx): Promise<ExtendedRpcResult> | ExtendedRpcResult;
+type ConsoleScheduleListCtx = ConsoleRpcExtendedCtx;
+export declare function addCron(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export declare function mutateCron(type: 'cron:remove' | 'cron:pause' | 'cron:resume', d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export {};

package/lib/console-rpc-extended/schedule-rpc.js

@@ -0,0 +1,109 @@
+import { errorMessage } from './rpc-values.js';
+const CRON_NOT_WIRED = '持久化调度未接线：当前 Plugin Runtime ScheduleHost 仅支持插件注册的内存任务（list），' +
+    '不支持 add/remove/pause/resume（需要 @zhin.js/agent 持久化调度引擎）';
+export function listSchedule(ctx) {
+    const host = ctx.scheduleHost;
+    if (!host || typeof host.list !== 'function') {
+        return { error: '调度服务未配置（scheduleHost 未挂载）' };
+    }
+    try {
+        const raw = host.list();
+        const memory = (Array.isArray(raw) ? raw : [])
+            .filter((job) => !!job && typeof job === 'object'
+            && typeof job.id === 'string'
+            && typeof job.cron === 'string')
+            .map((job) => ({
+            id: job.id,
+            cron: job.cron,
+            ...(typeof job.description === 'string' ? { description: job.description } : {}),
+            // console cron 页渲染字段（由 schedule host 提供时透传）
+            expression: job.expression ?? job.cron,
+            running: job.running ?? true,
+            ...(job.plugin ? { plugin: job.plugin } : {}),
+            ...(job.nextExecution
+                ? { nextExecution: job.nextExecution } : {}),
+        }));
+        return listPersistentJobs(ctx).then((persistent) => ({ data: { memory, persistent } }));
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
+/** 持久化任务（Agent Host ScheduleJobEngine）→ 前端 PersistentCron 形状。 */
+async function listPersistentJobs(ctx) {
+    const engine = ctx.resolveScheduleEngine?.();
+    if (!engine)
+        return [];
+    try {
+        const jobs = await engine.listJobs();
+        return jobs.map((job) => ({
+            id: job.id,
+            label: job.label ?? job.id,
+            cronExpression: job.schedule?.cron ?? '',
+            prompt: job.action?.prompt ?? '',
+            enabled: job.enabled !== false,
+            source: job.source ?? 'manual',
+            createdAt: job.createdAt,
+            nextExecution: job.state?.nextRunAtMs,
+            ...(job.notify?.target
+                ? { context: { target: job.notify.target } } : {}),
+            lastExecutedAt: job.state?.lastExecutedAt,
+            lastStatus: job.state?.lastStatus,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function addCron(d, ctx) {
+    const engine = ctx.resolveScheduleEngine?.();
+    if (!engine)
+        return { error: CRON_NOT_WIRED };
+    const cronExpression = String(d.cronExpression ?? '').trim();
+    const prompt = String(d.prompt ?? '').trim();
+    if (!cronExpression)
+        return { error: 'cronExpression is required' };
+    if (!prompt)
+        return { error: 'prompt is required' };
+    const label = typeof d.label === 'string' && d.label.trim() ? d.label.trim() : undefined;
+    const context = (d.context ?? {});
+    const target = context.target ?? context.channel;
+    const job = {
+        id: `console-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`,
+        ...(label ? { label } : {}),
+        enabled: true,
+        schedule: { kind: 'solar', cron: cronExpression },
+        action: { kind: 'agent', prompt },
+        notify: target
+            ? { channel: 'im', target }
+            : { channel: 'silent' },
+        source: 'manual',
+    };
+    try {
+        const created = await engine.addJob(job);
+        return { data: { job: created, success: true } };
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
+export async function mutateCron(type, d, ctx) {
+    const engine = ctx.resolveScheduleEngine?.();
+    if (!engine)
+        return { error: CRON_NOT_WIRED };
+    const id = String(d.id ?? '').trim();
+    if (!id)
+        return { error: 'id is required' };
+    try {
+        const ok = type === 'cron:remove'
+            ? await engine.removeJob(id)
+            : type === 'cron:pause'
+                ? await engine.pauseJob(id)
+                : await engine.resumeJob(id);
+        return ok ? { data: { success: true } } : { error: `任务不存在: ${id}` };
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
+// ---------------------------------------------------------------- inbox

package/lib/console-rpc-extended/workroom-rpc.d.ts

@@ -0,0 +1,3 @@
+import type { ConsoleRpcExtendedCtx, ExtendedRpcResult } from './contracts.js';
+export declare function mutateWorkroomProfile(type: 'workroom.profile.status' | 'workroom.profile.bootstrap' | 'workroom.profile.pack.publish' | 'workroom.profile.publish' | 'workroom.profile.rollback' | 'workroom.profile.policy.publish', data: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export declare function mutateWorkroomKnowledge(type: 'workroom.knowledge.get' | 'workroom.knowledge.publish' | 'workroom.knowledge.rollback', data: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;