@zhin.js/host-http 1.2.0 → 1.2.2

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

@@ -1,43 +1,80 @@
+import { CONSOLE_LOGIN_UNSUPPORTED, LOGIN_RPC } from '@zhin.js/console-protocol';
 import { strField } from './rpc-values.js';
-export function listLoginPending(ctx) {
+const NOT_WIRED = '登录辅助未接线（LoginAssist 未挂载）';
+/** `login.submit` with `wait: true` waits at most this long for the login result. */
+export const LOGIN_SUBMIT_WAIT_MS = 15_000;
+export function listLoginPending(d, ctx) {
     const assist = ctx.loginAssist;
     if (!assist)
-        return { error: '登录辅助未接线（LoginAssist 未挂载）' };
-    const tasks = assist.listPending().map((task) => ({
+        return { error: NOT_WIRED };
+    const scope = loginScope(d, ctx);
+    if ('error' in scope)
+        return scope;
+    const tasks = assist.listPending().filter((task) => inScope(scope, task)).map((task) => ({
         id: task.id,
         adapter: task.adapter,
         endpointKey: task.endpointKey,
         ...(task.endpointIdentity ? { endpointIdentity: task.endpointIdentity } : {}),
         type: task.type,
-        payload: task.payload,
+        payload: canOperate(ctx, task) ? task.payload : eventSafeLoginPayload(task.payload),
         createdAt: task.createdAt,
         expiresAt: task.expiresAt,
+        ...(task.flowId ? { flowId: task.flowId } : {}),
+        ...(task.challengeId ? { challengeId: task.challengeId } : {}),
     }));
     return { data: { tasks, count: tasks.length } };
 }
-export function submitLogin(d, ctx) {
+/**
+ * `login.submit { taskId, value, endpointIdentity?, adapter?, endpointKey?, wait? }`.
+ * `value` is a string (legacy) or `{ action, values }`. With `wait: true` the reply carries the login
+ * result (`{ accepted, outcome, flow }`) or `{ accepted, pending: true }` after 15 s; without it the
+ * legacy `{ success: true }` reply is unchanged.
+ */
+export async function submitLogin(d, ctx) {
     const assist = ctx.loginAssist;
     if (!assist)
-        return { error: '登录辅助未接线（LoginAssist 未挂载）' };
+        return { error: NOT_WIRED };
     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 value = readSubmitValue(d.value);
+    if (value === false)
+        return { error: 'value must be a string or { action, values }' };
     const identity = readEndpointIdentity(d.endpointIdentity);
     if (identity === false)
         return { error: 'Invalid login Endpoint identity' };
-    const ok = identity ? assist.submit(id, value, identity) : assist.submit(id, value);
-    if (!ok)
-        return { error: `login task not found: ${id}` };
-    return { data: { success: true } };
+    const target = checkTaskTarget(d, ctx, id);
+    if (target)
+        return target;
+    try {
+        if (d.wait === true && assist.submitAndWait) {
+            const result = await assist.submitAndWait(id, value, {
+                ...(identity ? { endpointIdentity: identity } : {}),
+                timeoutMs: LOGIN_SUBMIT_WAIT_MS,
+            });
+            if (!result.accepted)
+                return { error: `login task not found: ${id}` };
+            if (result.outcome)
+                return { data: { accepted: true, outcome: result.outcome, ...(result.flow ? { flow: result.flow } : {}) } };
+            return { data: { accepted: true, pending: true, ...(result.flow ? { flow: result.flow } : {}) } };
+        }
+        const ok = identity ? assist.submit(id, value, identity) : assist.submit(id, value);
+        if (!ok)
+            return { error: `login task not found: ${id}` };
+        return { data: { success: true } };
+    }
+    catch (error) {
+        // LoginSubmissionError: the challenge stays open; its message never contains the value.
+        if (error instanceof Error && error.name === 'LoginSubmissionError') {
+            return { error: error.message, data: { code: error.code ?? 'input_invalid' } };
+        }
+        throw error;
+    }
 }
 export function cancelLogin(d, ctx) {
     const assist = ctx.loginAssist;
     if (!assist)
-        return { error: '登录辅助未接线（LoginAssist 未挂载）' };
+        return { error: NOT_WIRED };
     const id = strField(d, 'taskId');
     if (!id)
         return { error: 'taskId is required' };
@@ -45,12 +82,235 @@ export function cancelLogin(d, ctx) {
     const identity = readEndpointIdentity(d.endpointIdentity);
     if (identity === false)
         return { error: 'Invalid login Endpoint identity' };
+    const target = checkTaskTarget(d, ctx, id);
+    if (target)
+        return target;
     const ok = identity ? assist.cancel(id, reason, identity) : assist.cancel(id, reason);
     if (!ok)
         return { error: `login task not found: ${id}` };
     return { data: { success: true } };
 }
-// ---------------------------------------------------------------- 社交读取
+/**
+ * `login.flow.list { adapter?, endpointKey? }`: latest flow per Endpoint. Live challenge material
+ * only for Endpoints the caller may operate; the event-safe form otherwise (ADR 0058 §8).
+ */
+export function listLoginFlows(d, ctx) {
+    const assist = ctx.loginAssist;
+    if (!assist)
+        return { error: NOT_WIRED };
+    if (!assist.listFlows)
+        return unsupported('login flows');
+    const scope = loginScope(d, ctx);
+    if ('error' in scope)
+        return scope;
+    const flows = assist.listFlows().filter((flow) => inScope(scope, flow)).map((flow) => visibleFlow(assist, ctx, flow));
+    return { data: { flows, count: flows.length } };
+}
+/** `login.flow.get { flowId } | { adapter, endpointKey }` → `{ flow: … | null }`. */
+export function getLoginFlow(d, ctx) {
+    const assist = ctx.loginAssist;
+    if (!assist)
+        return { error: NOT_WIRED };
+    if (!assist.getFlow || !assist.getFlowById)
+        return unsupported('login flows');
+    const flowId = strField(d, 'flowId');
+    const scope = loginScope(d, ctx);
+    if ('error' in scope)
+        return scope;
+    if (flowId) {
+        const flow = assist.getFlowById(flowId);
+        // A flow id names one Endpoint; a scoped caller cannot read another Endpoint's flow by id.
+        return { data: { flow: flow && inScope(scope, flow) ? visibleFlow(assist, ctx, flow) : null } };
+    }
+    if (!scope.adapter || !scope.endpointKey)
+        return { error: 'flowId or adapter and endpointKey are required' };
+    const flow = assist.getFlow(scope.adapter, scope.endpointKey);
+    return { data: { flow: flow ? visibleFlow(assist, ctx, flow) : null } };
+}
+/** `login.relogin` / `login.refresh { adapter, endpointKey }` through the Endpoint's login port. */
+export async function controlLogin(type, d, ctx) {
+    const scope = loginScope(d, ctx);
+    if ('error' in scope)
+        return scope;
+    const { adapter, endpointKey } = scope;
+    if (!adapter || !endpointKey)
+        return { error: 'adapter and endpointKey are required' };
+    const relogin = type === LOGIN_RPC.RELOGIN;
+    const label = relogin ? 'relogin' : 'refresh challenge';
+    if (!ctx.withEndpointLogin)
+        return unsupported(label);
+    const result = await ctx.withEndpointLogin(adapter, endpointKey, async (login) => {
+        const declared = relogin ? login.declaration?.relogin === true : login.declaration?.refreshQr === true;
+        const run = relogin ? login.control?.relogin : login.control?.refreshChallenge;
+        if (!declared || !run)
+            return unsupported(label, adapter);
+        await run.call(login.control, {});
+        return { data: { accepted: true } };
+    });
+    return result ?? { error: `Endpoint not found: ${adapter}/${endpointKey}` };
+}
+/**
+ * Audit detail of a login RPC reply: the result category only (never values, never messages).
+ * `undefined` for other RPCs.
+ */
+export function loginAuditDetail(type, data) {
+    if (type !== LOGIN_RPC.SUBMIT && type !== LOGIN_RPC.CANCEL && type !== LOGIN_RPC.RELOGIN && type !== LOGIN_RPC.REFRESH)
+        return undefined;
+    if (!data || typeof data !== 'object')
+        return undefined;
+    const record = data;
+    if (typeof record.code === 'string')
+        return Object.freeze({ result: record.code });
+    if (record.outcome && typeof record.outcome.result === 'string') {
+        return Object.freeze({ result: record.outcome.result, ...(typeof record.outcome.code === 'string' ? { code: record.outcome.code } : {}) });
+    }
+    if (record.pending === true)
+        return Object.freeze({ result: 'pending' });
+    if (record.accepted === true || record.success === true)
+        return Object.freeze({ result: 'accepted' });
+    return undefined;
+}
+// ---------------------------------------------------------------- helpers
+function unsupported(what, adapter) {
+    return {
+        error: `${CONSOLE_LOGIN_UNSUPPORTED}: ${adapter ? `${adapter} does not support ${what}` : `${what} not available on this host`}`,
+        data: { code: CONSOLE_LOGIN_UNSUPPORTED },
+    };
+}
+/**
+ * The Endpoint a login RPC is about: `adapter` / `endpointKey` read from `data` and the top level,
+ * exactly the fields the authorization map reads (ADR 0049). Sources that disagree, or a value that
+ * is not a string, are rejected. When the dispatcher admitted the caller only through an adapter /
+ * endpoint-scoped grant (`ctx.authorizedEndpoint`), the scope is that Endpoint and any other named
+ * target is rejected; global callers may omit it (`''` = no filter).
+ */
+function loginScope(d, ctx) {
+    const sources = d.data && typeof d.data === 'object' && !Array.isArray(d.data)
+        ? [d.data, d]
+        : [d];
+    const read = (key) => {
+        let found = '';
+        for (const source of sources) {
+            const value = source[key];
+            if (value === undefined || value === null || value === '')
+                continue;
+            if (typeof value !== 'string')
+                return false;
+            const text = value.trim();
+            if (!text)
+                continue;
+            if (found && found !== text)
+                return false;
+            found = text;
+        }
+        return found;
+    };
+    const adapter = read('adapter');
+    const endpointKey = read('endpointKey');
+    if (adapter === false || endpointKey === false)
+        return { error: 'Conflicting login target (adapter / endpointKey)' };
+    const authorized = ctx.authorizedEndpoint;
+    if (!authorized)
+        return { adapter, endpointKey };
+    if ((adapter && adapter !== authorized.adapter) || (endpointKey && endpointKey !== authorized.endpointKey)) {
+        return { error: 'Login target outside the authorized Endpoint' };
+    }
+    return { adapter: authorized.adapter, endpointKey: authorized.endpointKey };
+}
+/** The caller may handle this Endpoint's challenge (`endpoint.operate` there); no principal = trusted. */
+function canOperate(ctx, item) {
+    return ctx.canOperateEndpoint ? ctx.canOperateEndpoint(item.adapter, item.endpointKey) : true;
+}
+/**
+ * A flow as this caller may see it: live for operators, otherwise the event-safe form (no QR image,
+ * sensitive blocks redacted, verification links dropped). A port without `eventSafeFlow` falls back
+ * to removing every challenge's media and blocks.
+ */
+function visibleFlow(assist, ctx, flow) {
+    if (canOperate(ctx, flow))
+        return flow;
+    return assist.eventSafeFlow ? assist.eventSafeFlow(flow) : withoutChallengeMaterial(flow);
+}
+function withoutChallengeMaterial(flow) {
+    if (!flow.steps.some((step) => step.challenge?.media || step.challenge?.blocks))
+        return flow;
+    return Object.freeze({
+        ...flow,
+        steps: Object.freeze(flow.steps.map((step) => {
+            if (!step.challenge || (!step.challenge.media && !step.challenge.blocks))
+                return step;
+            const { media, blocks: _blocks, ...challenge } = step.challenge;
+            return Object.freeze({
+                ...step,
+                challenge: Object.freeze({
+                    ...challenge,
+                    media: Object.freeze({
+                        ...(media?.expiresAt !== undefined ? { expiresAt: media.expiresAt } : {}),
+                        ...(media?.refreshable !== undefined ? { refreshable: media.refreshable } : {}),
+                        ...(media?.qrImage ? { qrImageOmitted: true } : {}),
+                        ...(media?.link || media?.captcha ? { linkOmitted: true } : {}),
+                    }),
+                }),
+            });
+        })),
+    });
+}
+/**
+ * Legacy task payload without the QR image (`image`) and verification link (`url`, may carry a
+ * session id), marked `imageOmitted` / `urlOmitted` like the `endpoint.login.*` events.
+ */
+function eventSafeLoginPayload(payload) {
+    // Allow-list: only the message survives; legacy adapters may put sid / ticket / device anywhere.
+    const safe = {};
+    if (typeof payload.message === 'string')
+        safe.message = payload.message;
+    if (payload.image !== undefined)
+        safe.imageOmitted = true;
+    if (payload.url !== undefined)
+        safe.urlOmitted = true;
+    if (Object.keys(payload).some((key) => key !== 'message' && key !== 'image' && key !== 'url'))
+        safe.fieldsOmitted = true;
+    return safe;
+}
+function inScope(scope, item) {
+    return (!scope.adapter || item.adapter === scope.adapter) && (!scope.endpointKey || item.endpointKey === scope.endpointKey);
+}
+/** When the caller names an Endpoint, or was authorized for one, the task must belong to it. */
+function checkTaskTarget(d, ctx, id) {
+    const scope = loginScope(d, ctx);
+    if ('error' in scope)
+        return scope;
+    if (!scope.adapter && !scope.endpointKey)
+        return undefined;
+    const task = ctx.loginAssist?.listPending().find((item) => item.id === id);
+    if (!task || !inScope(scope, task))
+        return { error: `login task not found: ${id}` };
+    return undefined;
+}
+function readSubmitValue(raw) {
+    if (raw === undefined || raw === null)
+        return '';
+    if (typeof raw === 'string')
+        return raw;
+    if (typeof raw === 'number' || typeof raw === 'boolean')
+        return String(raw);
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        return false;
+    const record = raw;
+    if (record.action === undefined)
+        return record;
+    if (typeof record.action !== 'string' || !record.action || record.action.length > 64)
+        return false;
+    if (record.values !== undefined && (!record.values || typeof record.values !== 'object' || Array.isArray(record.values)))
+        return false;
+    const values = {};
+    for (const [key, item] of Object.entries((record.values ?? {}))) {
+        if (typeof item !== 'string' && typeof item !== 'number')
+            return false;
+        values[key] = String(item);
+    }
+    return { action: record.action, values };
+}
 function readEndpointIdentity(value) {
     if (value === undefined)
         return undefined;

package/lib/console-rpc-handlers.d.ts

@@ -8,6 +8,8 @@ export declare function wireConversation(channelType: string, channelId: string,
  */
 export declare function invalidProjectPatchOperations(patches: readonly unknown[]): string | undefined;
 export declare function dispatchHostResourceConsoleRpc(type: string, message: RuntimeConsoleRpcMessage, ctx: RuntimeConsoleRpcContext, requestId: number | string | undefined, payloads: RuntimeConsoleRpcReply[]): Promise<boolean>;
+/** Longest statement text the Console SQL editor sends. */
+export declare const MAX_CONSOLE_SQL_LENGTH = 100000;
 export declare function stringField(message: RuntimeConsoleRpcMessage, key: string): string;
 export declare function recordField(value: unknown): Record<string, unknown> | undefined;
 export declare function positiveInteger(value: unknown, fallback: number): number;

package/lib/console-rpc-handlers.js

@@ -250,15 +250,100 @@ export async function dispatchHostResourceConsoleRpc(type, message, ctx, request
             const page = positiveInteger(message.page, 1);
             const pageSize = Math.min(positiveInteger(message.pageSize, 50), 500);
             const where = recordField(message.where);
+            const order = recordField(message.orderBy);
+            if (message.orderBy !== undefined && message.orderBy !== null
+                && (!order || typeof order.column !== 'string' || (order.direction !== 'asc' && order.direction !== 'desc'))) {
+                errorReply(payloads, requestId, 'orderBy must be { column, direction: "asc" | "desc" }');
+                return true;
+            }
             if (!ctx.database) {
                 emit({ requestId, data: { rows: [], total: 0, page, pageSize } });
                 return true;
             }
             try {
-                emit({ requestId, data: await ctx.database.select(table, page, pageSize, where) });
+                const orderBy = order ? { column: order.column, direction: order.direction } : undefined;
+                emit({ requestId, data: await ctx.database.select(table, page, pageSize, where, orderBy) });
+            }
+            catch (error) {
+                emit({ requestId, error: `Failed to select: ${errorMessage(error)}`, ...refusalData(error) });
+            }
+            return true;
+        }
+        case 'db:query': {
+            const sql = sqlField(message);
+            if (!sql) {
+                errorReply(payloads, requestId, `sql is required (at most ${MAX_CONSOLE_SQL_LENGTH} characters)`);
+                return true;
+            }
+            if (!ctx.database?.query) {
+                unsupportedDatabaseFeature(payloads, requestId, 'SQL query');
+                return true;
+            }
+            try {
+                const maxRows = typeof message.maxRows === 'number' ? message.maxRows : undefined;
+                emit({ requestId, data: await ctx.database.query(sql, maxRows ? { maxRows } : undefined) });
             }
             catch (error) {
-                emit({ requestId, error: `Failed to select: ${errorMessage(error)}` });
+                emit({ requestId, error: errorMessage(error), ...refusalData(error) });
+            }
+            return true;
+        }
+        case 'db:execute': {
+            const sql = sqlField(message);
+            if (!sql) {
+                errorReply(payloads, requestId, `sql is required (at most ${MAX_CONSOLE_SQL_LENGTH} characters)`);
+                return true;
+            }
+            if (!ctx.database?.execute) {
+                unsupportedDatabaseFeature(payloads, requestId, 'SQL execution');
+                return true;
+            }
+            try {
+                emit({ requestId, data: await ctx.database.execute(sql, { dryRun: message.dryRun === true }) });
+            }
+            catch (error) {
+                emit({ requestId, error: errorMessage(error), ...refusalData(error) });
+            }
+            return true;
+        }
+        case 'db:schema:describe': {
+            const table = stringField(message, 'table');
+            if (!table) {
+                errorReply(payloads, requestId, 'table is required');
+                return true;
+            }
+            if (!ctx.database?.describe) {
+                unsupportedDatabaseFeature(payloads, requestId, 'Schema inspection');
+                return true;
+            }
+            try {
+                emit({ requestId, data: await ctx.database.describe(table) });
+            }
+            catch (error) {
+                emit({ requestId, error: errorMessage(error), ...refusalData(error) });
+            }
+            return true;
+        }
+        case 'db:schema:preview':
+        case 'db:schema:apply': {
+            const change = recordField(message.change);
+            if (!change) {
+                errorReply(payloads, requestId, 'change is required');
+                return true;
+            }
+            const database = ctx.database;
+            if (!database?.previewSchema || !database.applySchema) {
+                unsupportedDatabaseFeature(payloads, requestId, 'Schema editing');
+                return true;
+            }
+            try {
+                const plan = type === 'db:schema:apply'
+                    ? await database.applySchema(change, typeof message.confirm === 'string' ? message.confirm : undefined)
+                    : await database.previewSchema(change);
+                emit({ requestId, data: plan });
+            }
+            catch (error) {
+                emit({ requestId, error: errorMessage(error), ...refusalData(error) });
             }
             return true;
         }
@@ -577,6 +662,43 @@ export async function dispatchHostResourceConsoleRpc(type, message, ctx, request
             return false;
     }
 }
+/** Longest statement text the Console SQL editor sends. */
+export const MAX_CONSOLE_SQL_LENGTH = 100_000;
+function sqlField(message) {
+    const value = message.sql;
+    return typeof value === 'string' && value.trim() && value.length <= MAX_CONSOLE_SQL_LENGTH ? value : '';
+}
+const REFUSAL_NAMES = new Set(['ConsoleSqlRefusal', 'ConsoleSchemaRefusal', 'ConsoleSelectRefusal', 'SqliteQueryTimeoutError']);
+/**
+ * `data.code` of a refusal by the database port (`read_only`, `protected_table`, …), and the DDL a
+ * failed `db:schema:apply` attempted (`data.statements`, for the audit log).
+ */
+/** SQLSTATE of a driver error (PostgreSQL `code`, mysql2 `sqlState`), e.g. `42501` insufficient privilege. */
+function sqlStateOf(error) {
+    const record = error;
+    for (const candidate of [record.sqlState, record.code]) {
+        if (typeof candidate === 'string' && /^[0-9A-Z]{5}$/u.test(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function refusalData(error) {
+    if (!(error instanceof Error))
+        return {};
+    const attempted = error.statements;
+    const statements = Array.isArray(attempted) && attempted.every(entry => typeof entry === 'string') ? { statements: attempted } : {};
+    if (error.name === 'GatewayOwnedTableError')
+        return { data: { code: 'protected_table', ...statements } };
+    const code = error.code;
+    const refused = REFUSAL_NAMES.has(error.name) && typeof code === 'string';
+    // The server's SQLSTATE lets the Console explain e.g. 42501 from the restricted account (ADR 0059 §4).
+    const sqlState = refused ? undefined : sqlStateOf(error);
+    const data = { ...(refused ? { code } : {}), ...(sqlState ? { sqlState } : {}), ...statements };
+    return Object.keys(data).length ? { data } : {};
+}
+function unsupportedDatabaseFeature(payloads, requestId, feature) {
+    payloads.push({ requestId, error: `${feature} is not supported by this database Host`, data: { code: 'unsupported' } });
+}
 export function stringField(message, key) {
     const value = message[key];
     return typeof value === 'string' ? value.trim() : '';

package/lib/console-rpc.d.ts

@@ -166,10 +166,6 @@ export type RuntimeConsoleRpcContext = {
     /** Full-scope project read (`config:get-project`); masked unless `reveal`. */
     readProjectConfig?(request: import('@zhin.js/console-protocol').ConsoleConfigProjectReadRequest): Promise<import('@zhin.js/console-protocol').ConsoleConfigProjectRead>;
     applyConfig?(expectedRevision: string): Promise<import('@zhin.js/console-protocol').ConsoleConfigApplyResult>;
-    /** Persist a declared child Plugin lifecycle state. Takes effect after restart. */
-    setPluginEnabled?(instanceKey: string, enabled: boolean): Promise<Readonly<{
-        disabled: readonly string[];
-    }>>;
     /** Read-only install planning shared by Console Web and CLI surfaces. */
     pluginManagement?: PluginManagementPort;
     validatePluginConfig?(pluginName: string, data: unknown): Promise<PluginConfigValidation>;

package/lib/console-rpc.js

@@ -1,5 +1,5 @@
-import { CONFIG_PATCH_LIMITS, CONFIG_RPC, } from '@zhin.js/console-protocol';
-import { authorizeConsoleRpc } from './access-control.js';
+import { CONFIG_PATCH_LIMITS, CONFIG_RPC, grantsAllow, } from '@zhin.js/console-protocol';
+import { authorizeConsoleRpc, principalAllows } from './access-control.js';
 import { dispatchExtendedConsoleRpc } from './console-rpc-extended/index.js';
 import { dispatchPluginConsoleRpc } from './console-plugin-rpc.js';
 import { configurationSaveMessage, dispatchHostResourceConsoleRpc, invalidProjectPatchOperations, } from './console-rpc-handlers.js';
@@ -9,6 +9,20 @@ export function pickRpcReply(message, payloads) {
         ?? payloads[payloads.length - 1]
         ?? null);
 }
+/**
+ * The Endpoint a principal was admitted for when only an adapter / endpoint-scoped grant covers the
+ * call (B-1): handlers must then stay inside it. `undefined` when a global grant covers it.
+ */
+function scopedAuthorizedEndpoint(principal, decision) {
+    if (principal.kind === 'bootstrap' || !decision.permission || !decision.rule)
+        return undefined;
+    if (grantsAllow(principal.grants, decision.permission))
+        return undefined;
+    const target = decision.rule.target;
+    if (target.kind !== 'endpoint')
+        return undefined;
+    return Object.freeze({ adapter: target.adapter, endpointKey: target.endpoint });
+}
 export async function dispatchRuntimeConsoleRpc(message, ctx) {
     const payloads = [];
     const emit = (payload) => {
@@ -16,19 +30,30 @@ export async function dispatchRuntimeConsoleRpc(message, ctx) {
     };
     const type = String(message.type ?? '');
     const requestId = message.requestId;
+    let authorizedEndpoint;
+    let canOperateEndpoint;
     if (ctx.principal) {
-        const decision = authorizeConsoleRpc(ctx.principal, message);
+        const principal = ctx.principal;
+        const decision = authorizeConsoleRpc(principal, message);
         if (!decision.allowed) {
             emit({ requestId, error: decision.error, code: decision.code });
             return payloads;
         }
+        authorizedEndpoint = scopedAuthorizedEndpoint(principal, decision);
+        // Same grant check the map applies to `login.submit` for that Endpoint (ADR 0058 §8).
+        canOperateEndpoint = (adapter, endpointKey) => principalAllows(principal, 'endpoint.operate', Object.freeze({ kind: 'endpoint', adapter, endpoint: endpointKey }));
     }
     // Extended RPC surface (cron/schedule、endpoint 社交/inbox)
     if (ctx.extended) {
-        const extended = await dispatchExtendedConsoleRpc(type, message, { ...ctx.extended, fullScope: ctx.authScope === 'full' });
+        const extended = await dispatchExtendedConsoleRpc(type, message, {
+            ...ctx.extended,
+            fullScope: ctx.authScope === 'full',
+            ...(authorizedEndpoint ? { authorizedEndpoint } : {}),
+            ...(canOperateEndpoint ? { canOperateEndpoint } : {}),
+        });
         if (extended !== undefined) {
             emit('error' in extended
-                ? { requestId, error: extended.error }
+                ? { requestId, error: extended.error, ...(extended.data !== undefined ? { data: extended.data } : {}) }
                 : { requestId, data: extended.data });
             return payloads;
         }

package/lib/index.d.ts

@@ -2,7 +2,7 @@ export { createHttpRouter, httpHostToken, normalizePath, REMOTE_CONSOLE_ORIGIN,
 export type { HttpHostAddress, HttpHostOptions, HttpHostTlsOptions } from './host-options.js';
 export { listHttpHostAddresses } from './addresses.js';
 export { TokenRegistry, extractBearerToken, publicConsoleAccess, unrestrictedConsoleAccess, type AuthenticatedTokenPrincipal, type ConsoleAccess, type AuthScope, type TokenRegistryConfig, } from './token-registry.js';
-export { auditActor, authorizeConsoleHttp, authorizeConsoleRpc, authorizeConsoleWebSocket, globalPermissions, isUserPrincipal, isExplicitConsolePrincipal, pluginRpcWriteAllowed, principalAllows, requestMeta, rpcAuditDetail, rpcAuditTarget, type ConsoleAccessProvider, type ConsoleAuditEntry, type ConsoleBootstrapPrincipal, type ConsoleHttpDecision, type ConsolePrincipal, type ConsoleRequestMeta, type ConsoleRpcDecision, type ConsoleUserPrincipal, } from './access-control.js';
+export { auditActor, authorizeConsoleHttp, authorizeConsoleRpc, authorizeConsoleWebSocket, globalPermissions, isUserPrincipal, isExplicitConsolePrincipal, pluginRpcWriteAllowed, principalAllows, requestMeta, rpcAuditDetail, rpcAuditTarget, type RpcAuditOptions, type ConsoleAccessProvider, type ConsoleAuditEntry, type ConsoleBootstrapPrincipal, type ConsoleHttpDecision, type ConsolePrincipal, type ConsoleRequestMeta, type ConsoleRpcDecision, type ConsoleUserPrincipal, } from './access-control.js';
 export { timingSafeEqualString } from './timing-safe-equal.js';
 export { isLoopbackAddress, isLoopbackHost, verifyProtocolAccessToken, type ProtocolAuthRequest } from './protocol-auth.js';
 export { compileTrustProxy, hasForwardingHeaders, parseTrustProxy, resolveClientAddress, TrustProxyConfigError, type TrustProxyPredicate, type TrustProxySetting, } from './trust-proxy.js';
@@ -11,8 +11,8 @@ export { buildOpenApiDocument, patternToOpenApiPath, routeRequiresBearerAuth, ty
 export { HttpBodyError, readBodyBytes, readJsonBody, readTextBody, type HttpBodyReadOptions, } from './json-body.js';
 export { createResponseStream, emptyResponse, jsonResponse, SSE_HEADERS, type HttpResponseStream, type HttpResponseStreamOptions, } from '@zhin.js/host-http-contract';
 export { dispatchRuntimeConsoleRpc, pickRpcReply, type RuntimeConsolePage, type RuntimeConsoleRpcContext, type RuntimeConsoleRpcMessage, type RuntimeConsoleRpcReply, type RuntimeEndpointSendInput, type PluginInstallPlan, type PluginUninstallPlan, type PluginUpdatePlan, type PluginManagementPort, type PluginManagementState, type PluginVerificationResult, type PluginVerificationPlan, type PluginConfigValidation, } from './console-rpc.js';
-export { dispatchPluginConsoleRpc } from './console-plugin-rpc.js';
+export { dispatchPluginConsoleRpc, PLUGIN_SWITCH_REQUIRES_GATEWAY } from './console-plugin-rpc.js';
 export { buildProjectFileTree, FILE_MANAGER_ALLOWED, FILE_MANAGER_BLOCKED, isProjectPathAllowed, listEnvFiles, readProjectFile, saveProjectFile, type FileTreeNode, } from './project-files.js';
 export { registerConsoleRestPages, type ConsoleAgentIntrospection, type ConsoleAgentRuntime, type ConsoleAgentSessionTree, type ConsoleRestCtx, type ConsoleRestPagesOptions, } from './console-rest-pages.js';
-export { dispatchExtendedConsoleRpc, type ConsoleRpcExtendedCtx, type ConsoleScheduleEngine, type ConsoleWorkroomProfileControlPort, type ConsoleWorkroomKnowledgeControlPort, type ExtendedRpcResult, } from './console-rpc-extended/index.js';
+export { dispatchExtendedConsoleRpc, type ConsoleRpcExtendedCtx, type ConsoleScheduleEngine, type ConsoleWorkroomProfileControlPort, type ConsoleWorkroomKnowledgeControlPort, type ExtendedRpcResult, type ConsoleLoginAssistPort, type ConsoleEndpointLoginAccess, loginAuditDetail, LOGIN_SUBMIT_WAIT_MS, } from './console-rpc-extended/index.js';
 export * from './host-installer.js';

package/lib/index.js

@@ -10,8 +10,8 @@ export { buildOpenApiDocument, patternToOpenApiPath, routeRequiresBearerAuth, }
 export { HttpBodyError, readBodyBytes, readJsonBody, readTextBody, } from './json-body.js';
 export { createResponseStream, emptyResponse, jsonResponse, SSE_HEADERS, } from '@zhin.js/host-http-contract';
 export { dispatchRuntimeConsoleRpc, pickRpcReply, } from './console-rpc.js';
-export { dispatchPluginConsoleRpc } from './console-plugin-rpc.js';
+export { dispatchPluginConsoleRpc, PLUGIN_SWITCH_REQUIRES_GATEWAY } from './console-plugin-rpc.js';
 export { buildProjectFileTree, FILE_MANAGER_ALLOWED, FILE_MANAGER_BLOCKED, isProjectPathAllowed, listEnvFiles, readProjectFile, saveProjectFile, } from './project-files.js';
 export { registerConsoleRestPages, } from './console-rest-pages.js';
-export { dispatchExtendedConsoleRpc, } from './console-rpc-extended/index.js';
+export { dispatchExtendedConsoleRpc, loginAuditDetail, LOGIN_SUBMIT_WAIT_MS, } from './console-rpc-extended/index.js';
 export * from './host-installer.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/host-http",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Minimal HTTP and WebSocket host for Plugin Runtime (no Koa)",
   "type": "module",
   "main": "./lib/index.js",
@@ -25,11 +25,11 @@
   ],
   "dependencies": {
     "ws": "^8.21.1",
-    "@zhin.js/console-protocol": "1.2.0",
     "@zhin.js/host-http-contract": "1.2.0",
     "@zhin.js/logger": "1.1.3",
+    "@zhin.js/console-protocol": "1.2.2",
     "@zhin.js/schedule": "1.1.5",
-    "@zhin.js/plugin-runtime": "1.2.0"
+    "@zhin.js/plugin-runtime": "1.2.1"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",