@xopcai/xopc 0.0.231 → 0.0.233

package/dist/src/gateway/global-defaults-admin.js

@@ -1,134 +1,34 @@
-import { CapabilityPresetSchema, init_schema } from "../agent-manifest/schema.js";
-import { DEFAULT_AGENT_MODELS, init_default_model } from "../config/default-model.js";
-import { getAllProviders, getModelsByProvider, getProviderAuthState, getProviderDisplayName, init_providers } from "../providers/index.js";
-import { getRecommendedModelsForProvider } from "../providers/presentation.js";
+import { AgentDefaultsSchema } from "../agent-config/schema.js";
+import { init_agent_config } from "../agent-config/index.js";
+import { GATEWAY_BUILTIN_TOOLS } from "./agent-builtin-tools.js";
 //#region src/gateway/global-defaults-admin.ts
-init_schema();
-init_default_model();
-init_providers();
-function defaultPresetId(cfg) {
-	return cfg.agents.defaultPreset || "default";
-}
-function emptyGlobalDefaultsPreset(id) {
-	return {
-		id,
-		name: "Global defaults",
-		description: "Default capabilities inherited by every agent.",
-		version: 1,
-		models: DEFAULT_AGENT_MODELS
-	};
-}
-function ensureGlobalDefaultsConfig(cfg) {
-	const presetId = defaultPresetId(cfg);
-	const current = cfg.agents.capabilityPresets[presetId];
-	const preset = current ? {
-		...current,
-		id: presetId,
-		name: current.name || "Global defaults",
-		version: current.version || 1,
-		models: current.models ?? DEFAULT_AGENT_MODELS
-	} : emptyGlobalDefaultsPreset(presetId);
-	return {
-		...cfg,
-		agents: {
-			...cfg.agents,
-			defaultPreset: presetId,
-			capabilityPresets: {
-				...cfg.agents.capabilityPresets,
-				[presetId]: preset
-			}
-		}
-	};
-}
-function sourceFromAuthMode(authMode) {
-	if (authMode === "gateway") return "config";
-	if (authMode === "env") return "env";
-	if (authMode === "oauth") return "oauth";
-	if (authMode === "extension") return "extension";
-	if (authMode === "models_json") return "models_json";
-	if (authMode === "agent") return "agent";
-	return null;
-}
-function recommendedModelForProvider(provider) {
-	const recommended = getRecommendedModelsForProvider(provider, 1)[0];
-	if (recommended) return recommended.ref;
-	const model = getModelsByProvider(provider)[0];
-	return model ? `${provider}/${model.id}` : null;
-}
-async function listGlobalDefaults(cfg) {
-	const normalized = ensureGlobalDefaultsConfig(cfg);
-	const presetId = defaultPresetId(normalized);
-	const preset = normalized.agents.capabilityPresets[presetId] ?? emptyGlobalDefaultsPreset(presetId);
-	const providers = [];
-	const recommendations = [];
-	for (const provider of getAllProviders()) {
-		const auth = await getProviderAuthState(provider);
-		const configured = auth.authStatus === "connected";
-		const source = configured ? sourceFromAuthMode(auth.authMode) : null;
-		providers.push({
-			id: provider,
-			name: getProviderDisplayName(provider),
-			configured,
-			source
-		});
-		if (configured) {
-			const model = recommendedModelForProvider(provider);
-			if (model) recommendations.push({
-				provider,
-				model,
-				reason: "configured-provider"
-			});
-		}
-	}
-	providers.sort((a, b) => Number(b.configured) - Number(a.configured) || a.name.localeCompare(b.name));
+init_agent_config();
+function listGlobalDefaults(cfg) {
 	return {
-		presetId,
-		models: preset.models ?? DEFAULT_AGENT_MODELS,
-		providers,
-		recommendations
+		defaults: structuredClone(cfg.agents.defaults),
+		builtinTools: GATEWAY_BUILTIN_TOOLS.map((tool) => ({
+			id: tool.id,
+			description: { ...tool.description }
+		}))
 	};
 }
 function prepareUpdateGlobalDefaults(cfg, body) {
-	const normalized = ensureGlobalDefaultsConfig(cfg);
-	const presetId = defaultPresetId(normalized);
-	let nextPreset = normalized.agents.capabilityPresets[presetId] ?? emptyGlobalDefaultsPreset(presetId);
-	if (body.models !== void 0) {
-		const parsed = CapabilityPresetSchema.pick({ models: true }).safeParse({ models: body.models });
-		if (!parsed.success) return {
-			ok: false,
-			error: `models ${parsed.error.issues[0]?.message ?? "is invalid"}`,
-			status: 400
-		};
-		const models = parsed.data.models ?? DEFAULT_AGENT_MODELS;
-		const roles = models.roles ?? {};
-		const defaultRole = models.defaultRole ?? Object.keys(roles)[0] ?? "deep";
-		if (Object.keys(roles).length > 0 && !roles[defaultRole]) return {
-			ok: false,
-			error: "models.defaultRole must reference models.roles",
-			status: 400
-		};
-		nextPreset = {
-			...nextPreset,
-			models: {
-				...models,
-				defaultRole,
-				roles
-			}
-		};
-	}
+	const parsed = AgentDefaultsSchema.safeParse(body.defaults);
+	if (!parsed.success) return {
+		ok: false,
+		error: `defaults ${parsed.error.issues[0]?.message ?? "is invalid"}`,
+		status: 400
+	};
 	return {
 		ok: true,
 		data: { nextConfig: {
-			...normalized,
+			...cfg,
 			agents: {
-				...normalized.agents,
-				capabilityPresets: {
-					...normalized.agents.capabilityPresets,
-					[presetId]: nextPreset
-				}
+				...cfg.agents,
+				defaults: parsed.data
 			}
 		} }
 	};
 }
 //#endregion
-export { ensureGlobalDefaultsConfig, listGlobalDefaults, prepareUpdateGlobalDefaults };
+export { listGlobalDefaults, prepareUpdateGlobalDefaults };

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/app.js

@@ -9,12 +9,13 @@ import { isLoopbackIpAddress, isTrustedProxyAddress } from "../client-ip.js";
 import { buildGatewayConsoleCspHeader } from "../security/csp.js";
 import { checkBrowserOrigin } from "../security/origin-check.js";
 import { auth } from "./middleware/auth.js";
-import { operatorScopes } from "./middleware/scopes.js";
+import { gatewayScopes } from "./middleware/scopes.js";
 import { createChannelRateLimitMiddleware, createChatRateLimitMiddleware, createMediaRateLimitMiddleware, createStrictRateLimitMiddleware, createTaskRateLimitMiddleware, createXopcCloudPollRateLimitMiddleware } from "./middleware/strict-rate-limit.js";
 import { logContextMiddleware } from "./middleware/log-context.js";
 import { logger } from "./middleware/logger.js";
 import { routeErrorMiddleware } from "./middleware/route-errors.js";
 import { registerPublicExtensionAssetRoutes } from "./routes/auth-registry-extensions.js";
+import { registerDeviceAuthPublicRoutes } from "./routes/devices.js";
 import { registerPublicLocalAppPreviewRoutes } from "./routes/local-apps.js";
 import { resetLazyRouteBundlesForTests } from "./routes/lazy-fallback.js";
 import { registerAuthenticatedRoutes } from "./routes/index.js";
@@ -193,6 +194,7 @@ function createHonoApp(config) {
 		})(c, next);
 	});
 	registerPublicGatewayRoutes(app, service);
+	registerDeviceAuthPublicRoutes(app);
 	registerPublicExtensionAssetRoutes(app, service);
 	registerPublicLocalAppPreviewRoutes(app, service);
 	const authenticated = new Hono();
@@ -205,7 +207,7 @@ function createHonoApp(config) {
 			allowRealIpFallback: service.currentConfig.gateway?.allowRealIpFallback === true
 		})
 	}));
-	authenticated.use(operatorScopes());
+	authenticated.use(gatewayScopes());
 	const strictRateLimitMiddleware = createStrictRateLimitMiddleware({ getTrustedProxyContext: () => ({
 		trustedProxies: service.currentConfig.gateway?.trustedProxies,
 		allowRealIpFallback: service.currentConfig.gateway?.allowRealIpFallback === true

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -29,165 +29,83 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
         defaultId: string;
         list: {
             id: string;
-            identity: {
-                name: string;
-                role: string;
-                language: string;
-                tone: string;
-                description?: string;
-                avatar?: string;
-            };
-            workspace: {
-                root: string;
-            };
+            workspace: string;
             models: {
-                defaultRole?: string;
-                roles?: Record<string, {
-                    model: string;
-                    fallbacks?: string[];
-                    description?: string;
-                }>;
-                imageModel?: {
+                chat?: {
                     primary: string;
-                    fallbacks?: string[];
-                    timeoutMs?: number;
-                    autoProviderFallback?: boolean;
+                    fallbacks: string[];
                 };
-                imageGenerationModel?: {
+                intents?: Partial<Record<"understanding" | "fast" | "reasoning" | "coding" | "review" | "vision", {
                     primary: string;
-                    fallbacks?: string[];
-                    timeoutMs?: number;
-                    autoProviderFallback?: boolean;
-                };
-                policy?: {
-                    allowFallbacks?: boolean;
-                    maxCostTier?: "low" | "high" | "medium";
+                    fallbacks: string[];
+                }>>;
+                imageUnderstanding?: {
+                    primary: string;
+                    fallbacks: string[];
                 };
-            };
-            tools: {
-                builtin?: Record<string, {
-                    mode: "allow" | "deny" | "confirm";
-                    scope?: "workspace" | "readonly" | "unrestricted";
-                    limits?: {
-                        maxCallsPerTurn?: number;
-                        timeoutMs?: number;
-                    };
-                }>;
-                mcp?: {
-                    servers?: Record<string, {
-                        mode: "allow" | "deny" | "confirm";
-                        scope?: "workspace" | "readonly" | "unrestricted";
-                        limits?: {
-                            maxCallsPerTurn?: number;
-                            timeoutMs?: number;
-                        };
-                    }>;
-                    tools?: Record<string, {
-                        mode: "allow" | "deny" | "confirm";
-                        scope?: "workspace" | "readonly" | "unrestricted";
-                        limits?: {
-                            maxCallsPerTurn?: number;
-                            timeoutMs?: number;
-                        };
-                    }>;
+                imageGeneration?: {
+                    primary: string;
+                    fallbacks: string[];
+                    autoProviderFallback: boolean;
+                    timeoutMs?: number;
                 };
             };
+            tools: Record<string, {
+                mode: "allow" | "deny" | "ask";
+                maxCallsPerTurn?: number;
+                timeoutMs?: number;
+            }>;
             skills: {
-                mode: "off" | "all" | "allowlist" | "denylist";
-                allow?: string[];
-                deny?: string[];
+                mode: "merge";
+                add: string[];
+                remove: string[];
+            } | {
+                mode: "replace";
+                include: string[];
             };
             workflows: {
                 default?: string;
                 allowed?: string[];
-                suggested?: {
-                    intent: string;
-                    workflow: string;
-                }[];
-            };
-            boundaries: {
-                requiresConfirmation?: string[];
-                forbidden?: string[];
-                escalation?: string[];
             };
         }[];
-        capabilityPresets: Record<string, {
-            id: string;
-            name: string;
-            version: number;
-            description?: string;
-            extends?: string[];
-            models?: {
-                defaultRole?: string;
-                roles?: Record<string, {
-                    model: string;
-                    fallbacks?: string[];
-                    description?: string;
-                }>;
-                imageModel?: {
+        defaults: {
+            models: {
+                chat: {
                     primary: string;
-                    fallbacks?: string[];
-                    timeoutMs?: number;
-                    autoProviderFallback?: boolean;
+                    fallbacks: string[];
                 };
-                imageGenerationModel?: {
+                intents: Partial<Record<"understanding" | "fast" | "reasoning" | "coding" | "review" | "vision", {
                     primary: string;
-                    fallbacks?: string[];
-                    timeoutMs?: number;
-                    autoProviderFallback?: boolean;
-                };
-                policy?: {
-                    allowFallbacks?: boolean;
-                    maxCostTier?: "low" | "high" | "medium";
+                    fallbacks: string[];
+                }>>;
+                imageUnderstanding?: {
+                    primary: string;
+                    fallbacks: string[];
                 };
-            };
-            tools?: {
-                builtin?: Record<string, {
-                    mode: "allow" | "deny" | "confirm";
-                    scope?: "workspace" | "readonly" | "unrestricted";
-                    limits?: {
-                        maxCallsPerTurn?: number;
-                        timeoutMs?: number;
-                    };
-                }>;
-                mcp?: {
-                    servers?: Record<string, {
-                        mode: "allow" | "deny" | "confirm";
-                        scope?: "workspace" | "readonly" | "unrestricted";
-                        limits?: {
-                            maxCallsPerTurn?: number;
-                            timeoutMs?: number;
-                        };
-                    }>;
-                    tools?: Record<string, {
-                        mode: "allow" | "deny" | "confirm";
-                        scope?: "workspace" | "readonly" | "unrestricted";
-                        limits?: {
-                            maxCallsPerTurn?: number;
-                            timeoutMs?: number;
-                        };
-                    }>;
+                imageGeneration?: {
+                    primary: string;
+                    fallbacks: string[];
+                    autoProviderFallback: boolean;
+                    timeoutMs?: number;
                 };
             };
-            skills?: {
-                mode: "off" | "all" | "allowlist" | "denylist";
-                allow?: string[];
-                deny?: string[];
+            skills: {
+                mode: "all-enabled";
+                exclude: string[];
+            } | {
+                mode: "selected";
+                include: string[];
             };
-            workflows?: {
+            tools: Record<string, {
+                mode: "allow" | "deny" | "ask";
+                maxCallsPerTurn?: number;
+                timeoutMs?: number;
+            }>;
+            workflows: {
                 default?: string;
                 allowed?: string[];
-                suggested?: {
-                    intent: string;
-                    workflow: string;
-                }[];
-            };
-            boundaries?: {
-                requiresConfirmation?: string[];
-                forbidden?: string[];
-                escalation?: string[];
             };
-            runtime?: {
+            runtime: {
                 maxTurns?: number;
                 timeoutMs?: number;
                 maxToolFailuresPerTurn?: number;
@@ -196,8 +114,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                     lifetime: "short" | "long";
                 };
             };
-            locks?: string[];
-        }>;
+        };
     };
     channels: {
         [k: string]: {

package/dist/src/gateway/hono/lib/config-payload.js

@@ -113,15 +113,13 @@ async function buildSafeWebConfigPayload(service, options = {}) {
 			defaultId: resolveDefaultAgentId(config),
 			list: listAgentEntries(config).filter((e) => e.enabled !== false).map((e) => ({
 				id: normalizeAgentId(e.id),
-				identity: e.identity,
 				workspace: e.workspace,
 				models: e.models,
 				tools: e.tools,
 				skills: e.skills,
-				workflows: e.workflows,
-				boundaries: e.boundaries
+				workflows: e.workflows
 			})),
-			capabilityPresets: config.agents?.capabilityPresets ?? {}
+			defaults: config.agents.defaults
 		},
 		channels: channelsPayload,
 		providers: Object.fromEntries(await Promise.all(getAllProviders().map(async (provider) => [provider, await maskLlmProviderApiKeyForWeb(provider)]))),

package/dist/src/gateway/hono/middleware/auth.js

@@ -1,6 +1,7 @@
 import { logAuthEvent } from "../../../utils/logger/audit.js";
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
+import { authenticateDeviceAccessToken } from "../../../storage/sqlite/device-access-repository.js";
 import { safeEqualSecret } from "../../security/secret-equal.js";
 import { resolveClientIpFromRequest } from "../../client-ip.js";
 import { authPolicyConfig, buckets, resolveAuthRateLimit } from "../../rate-limit/buckets.js";
@@ -9,6 +10,7 @@ import { resolveAuthTracking } from "../../rate-limit/auth-policy.js";
 import { isAuthRateLimitGloballyDisabled } from "../../rate-limit/env-flags.js";
 import "../../rate-limit/index.js";
 import { authorizeTrustedProxy } from "../../trusted-proxy.js";
+import { setGatewayPrincipal } from "../../security/gateway-principal.js";
 import { createMiddleware } from "hono/factory";
 import { getConnInfo } from "@hono/node-server/conninfo";
 //#region src/gateway/hono/middleware/auth.ts
@@ -29,7 +31,7 @@ function extractTokenFromHeader(authHeader) {
 }
 /**
 * SECURITY: query-string tokens leak into server logs, Referer headers, and
-* browser history. We accept them only for agent avatar `<img>` loads, where an
+* browser history. We accept them only for avatar `<img>` loads, where an
 * Authorization header cannot be set. Realtime WebSocket authentication uses a
 * one-time ticket acquired over authenticated HTTP.
 */
@@ -37,9 +39,10 @@ function extractTokenFromQuery(url) {
 	return new URL(url).searchParams.get("token");
 }
 const AGENT_AVATAR_GET_PATH = /^\/api\/agents\/[^/]+\/avatar$/;
+const USER_AVATAR_GET_PATH = "/api/you/avatar";
 /** Exported for gateway security tests. */
 function isQueryTokenAllowedPath(path, method) {
-	if (method === "GET" && AGENT_AVATAR_GET_PATH.test(path)) return true;
+	if (method === "GET" && (AGENT_AVATAR_GET_PATH.test(path) || path === USER_AVATAR_GET_PATH)) return true;
 	return false;
 }
 function resolveRemoteAddress(c) {
@@ -165,10 +168,22 @@ function auth(config) {
 				}, 401);
 			}
 			recordSuccess(rl);
+			setGatewayPrincipal(c, {
+				kind: "trusted-proxy",
+				principalId: result.user,
+				scopes: ["gateway.admin"]
+			});
 			await next();
 			return;
 		}
-		if (authMode === "none") return next();
+		if (authMode === "none") {
+			setGatewayPrincipal(c, {
+				kind: "owner",
+				principalId: "gateway-owner",
+				scopes: ["gateway.admin"]
+			});
+			return next();
+		}
 		const expectedCredential = resolveExpectedCredential(resolvedAuth);
 		if (!expectedCredential) {
 			log.error({
@@ -196,6 +211,24 @@ function auth(config) {
 		const providedCredential = authHeader || queryToken;
 		if (providedCredential && validateCredential(providedCredential, expectedCredential)) {
 			recordSuccess(rl);
+			setGatewayPrincipal(c, {
+				kind: "owner",
+				principalId: "gateway-owner",
+				scopes: ["gateway.admin"]
+			});
+			await next();
+			return;
+		}
+		const deviceIdentity = providedCredential?.startsWith("xopc_at_") ? authenticateDeviceAccessToken(providedCredential) : void 0;
+		if (deviceIdentity) {
+			recordSuccess(rl);
+			setGatewayPrincipal(c, {
+				kind: "device",
+				principalId: deviceIdentity.deviceId,
+				deviceId: deviceIdentity.deviceId,
+				accessSessionId: deviceIdentity.accessSessionId,
+				scopes: deviceIdentity.scopes
+			});
 			await next();
 			return;
 		}

package/dist/src/gateway/hono/middleware/scopes.d.ts

@@ -1,15 +1,5 @@
-/**
- * Middleware that enforces operator scope requirements on API routes.
- *
- * This middleware runs AFTER the auth middleware. For authenticated requests,
- * it checks that the declared operator scopes (defaulting to full access for
- * token-authenticated users) satisfy the minimum scope required by the route.
- *
- * The scope system is currently implicit: all authenticated users get
- * DEFAULT_OPERATOR_SCOPES. This lays the groundwork for future per-device
- * or per-token scope restrictions (similar to OpenClaw's device pairing scopes).
- */
-export declare function operatorScopes(): import("hono/dist/types/types.js").MiddlewareHandler<any, string, {}, Response & import("hono/dist/types/types.js").TypedResponse<{
+/** Enforces fail-closed route scopes after authentication establishes a principal. */
+export declare function gatewayScopes(): import("hono/dist/types/types.js").MiddlewareHandler<any, string, {}, Response & import("hono/dist/types/types.js").TypedResponse<{
     error: string;
     message: string;
 }, 403, "json">>;

package/dist/src/gateway/hono/middleware/scopes.js

@@ -1,30 +1,21 @@
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
-import { DEFAULT_OPERATOR_SCOPES, authorizeRouteScope } from "../../security/operator-scopes.js";
+import { hasGatewayScope, requiredGatewayScope } from "../../security/gateway-scopes.js";
+import { getGatewayPrincipal } from "../../security/gateway-principal.js";
 import { createMiddleware } from "hono/factory";
 //#region src/gateway/hono/middleware/scopes.ts
 init_logger();
 const log = createLogger("Hono:Scopes");
-/**
-* Middleware that enforces operator scope requirements on API routes.
-*
-* This middleware runs AFTER the auth middleware. For authenticated requests,
-* it checks that the declared operator scopes (defaulting to full access for
-* token-authenticated users) satisfy the minimum scope required by the route.
-*
-* The scope system is currently implicit: all authenticated users get
-* DEFAULT_OPERATOR_SCOPES. This lays the groundwork for future per-device
-* or per-token scope restrictions (similar to OpenClaw's device pairing scopes).
-*/
-function operatorScopes() {
+/** Enforces fail-closed route scopes after authentication establishes a principal. */
+function gatewayScopes() {
 	return createMiddleware(async (c, next) => {
-		const grantedScopes = [...DEFAULT_OPERATOR_SCOPES];
-		const scopeCheck = authorizeRouteScope(c.req.path, grantedScopes);
-		if (!scopeCheck.allowed && "requiredScope" in scopeCheck) {
-			const { requiredScope } = scopeCheck;
+		const principal = getGatewayPrincipal(c);
+		const requiredScope = requiredGatewayScope(c.req.method, c.req.path);
+		if (!hasGatewayScope(principal.scopes, requiredScope)) {
 			log.warn({
 				path: c.req.path,
 				method: c.req.method,
+				principalId: principal.principalId,
 				requiredScope
 			}, `Scope check failed: missing ${requiredScope}`);
 			return c.json({
@@ -36,4 +27,4 @@ function operatorScopes() {
 	});
 }
 //#endregion
-export { operatorScopes };
+export { gatewayScopes };