@xopcai/xopc 0.0.231 → 0.0.233

package/dist/src/support/redact-support-report.d.ts

@@ -0,0 +1,16 @@
+export declare class SupportRedactor {
+    private replacementCount;
+    private readonly pathAliases;
+    private readonly identifierAliases;
+    constructor(paths?: {
+        homeDir?: string;
+        stateDir?: string;
+        workspaceDir?: string;
+    });
+    get replacements(): number;
+    addIdentifier(raw: string | undefined, namespace: string): void;
+    text(raw: string | undefined, maxLength?: number): string | undefined;
+    identifier(raw: string | undefined, namespace: string): string | undefined;
+    private identifierValue;
+    private replace;
+}

package/dist/src/support/redact-support-report.js

@@ -0,0 +1,89 @@
+import { createHash } from "node:crypto";
+//#region src/support/redact-support-report.ts
+const SECRET_PATTERNS = [
+	/(\b[A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|AUTHORIZATION)\b["']?\s*[=:]\s*)(["']?)[^\s,"'}]+\2/gi,
+	/(Authorization\s*[:=]\s*Bearer\s+)[A-Za-z0-9._\-+=]+/gi,
+	/\b(?:sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]+|\d+:[A-Za-z0-9_-]{35,})\b/gi,
+	/(-----BEGIN\s+\w+\s+PRIVATE KEY-----)[\s\S]*?(-----END\s+\w+\s+PRIVATE KEY-----)/g
+];
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizedRoots(roots) {
+	return [...new Set(roots.map((root) => root.trim()).filter(Boolean))].sort((left, right) => right.length - left.length);
+}
+var SupportRedactor = class {
+	replacementCount = 0;
+	pathAliases;
+	identifierAliases = [];
+	constructor(paths = {}) {
+		const aliases = [
+			{
+				value: paths.workspaceDir,
+				alias: "<WORKSPACE>"
+			},
+			{
+				value: paths.stateDir,
+				alias: "<STATE_DIR>"
+			},
+			{
+				value: paths.homeDir,
+				alias: "<HOME>"
+			}
+		].filter((item) => Boolean(item.value?.trim()));
+		this.pathAliases = normalizedRoots(aliases.map((item) => item.value)).map((root) => ({
+			pattern: new RegExp(escapeRegExp(root), "g"),
+			alias: aliases.find((item) => item.value === root)?.alias ?? "<PATH>"
+		}));
+	}
+	get replacements() {
+		return this.replacementCount;
+	}
+	addIdentifier(raw, namespace) {
+		if (!raw) return;
+		const source = escapeRegExp(raw);
+		if (this.identifierAliases.some((item) => item.pattern.source === source)) return;
+		this.identifierAliases.push({
+			pattern: new RegExp(source, "g"),
+			alias: this.identifierValue(raw, namespace)
+		});
+	}
+	text(raw, maxLength = 8e3) {
+		if (!raw) return void 0;
+		let value = raw.slice(0, maxLength);
+		for (const { pattern, alias } of this.pathAliases) value = this.replace(value, pattern, alias);
+		for (const { pattern, alias } of this.identifierAliases) value = this.replace(value, pattern, alias);
+		value = this.replace(value, /\/(?:Users|home)\/[^/\s]+/g, "<HOME>");
+		value = this.replace(value, /[A-Za-z]:\\Users\\[^\\\s]+/g, "<HOME>");
+		value = this.replace(value, /https?:\/\/[^\s<>{}"']+/g, (match) => {
+			const rawUrl = String(match);
+			try {
+				const url = new URL(rawUrl);
+				return `${url.origin}${url.pathname}`;
+			} catch {
+				return rawUrl;
+			}
+		});
+		for (const pattern of SECRET_PATTERNS) value = this.replace(value, pattern, (...args) => {
+			if (String(args[0]).includes("PRIVATE KEY-----")) return `${typeof args[1] === "string" ? args[1] : "-----BEGIN PRIVATE KEY-----"}\n[REDACTED]\n${typeof args[2] === "string" ? args[2] : "-----END PRIVATE KEY-----"}`;
+			return `${typeof args[1] === "string" && args[1] ? args[1] : ""}[REDACTED]`;
+		});
+		return value;
+	}
+	identifier(raw, namespace) {
+		if (!raw) return void 0;
+		this.replacementCount += 1;
+		return this.identifierValue(raw, namespace);
+	}
+	identifierValue(raw, namespace) {
+		return `${namespace}_${createHash("sha256").update(`${namespace}:${raw}`).digest("hex").slice(0, 12)}`;
+	}
+	replace(value, pattern, replacement) {
+		return value.replace(pattern, (...args) => {
+			this.replacementCount += 1;
+			return typeof replacement === "string" ? replacement : replacement(...args);
+		});
+	}
+};
+//#endregion
+export { SupportRedactor };

package/dist/src/support/types.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export declare const SupportReportInputSchema: z.ZodObject<{
+    problem: z.ZodString;
+    expected: z.ZodOptional<z.ZodString>;
+    reproduction: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodString>;
+    sessionKey: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+    clientContext: z.ZodOptional<z.ZodObject<{
+        currentPage: z.ZodOptional<z.ZodString>;
+        rendererError: z.ZodOptional<z.ZodString>;
+        surface: z.ZodOptional<z.ZodEnum<{
+            electron: "electron";
+            web: "web";
+        }>>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SupportReportInput = z.infer<typeof SupportReportInputSchema>;
+export type SupportDoctorCheck = {
+    id: string;
+    label: string;
+    status: 'pass' | 'warn' | 'fail' | 'skip';
+    message: string;
+    hints: string[];
+};
+export type SupportLogEntry = {
+    timestamp: string;
+    level: string;
+    message: string;
+    module?: string;
+    phase?: string;
+    requestId?: string;
+    sessionId?: string;
+    error?: {
+        name?: string;
+        message?: string;
+        stack?: string;
+    };
+};
+export type SupportRuntimeSnapshot = {
+    gatewayStatus?: string;
+    gatewayVersion?: string;
+    gatewayUptimeMs?: number;
+    channels?: Record<string, string>;
+};
+export type SupportReport = {
+    schemaVersion: 1;
+    title: string;
+    capturedAt: string;
+    occurredAt: string;
+    problem: string;
+    expected?: string;
+    reproduction?: string;
+    environment: {
+        xopcVersion: string;
+        nodeVersion: string;
+        platform: NodeJS.Platform;
+        arch: string;
+        surface?: 'web' | 'electron';
+        currentPage?: string;
+        userAgent?: string;
+    };
+    runtime?: SupportRuntimeSnapshot;
+    rendererError?: string;
+    doctor: SupportDoctorCheck[];
+    logs: SupportLogEntry[];
+    logWindow: {
+        from: string;
+        to: string;
+    };
+    redaction: {
+        replacements: number;
+    };
+    markdown: string;
+};

package/dist/src/support/types.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+//#region src/support/types.ts
+const SupportReportInputSchema = z.object({
+	problem: z.string().trim().min(1).max(1e4),
+	expected: z.string().trim().max(5e3).optional(),
+	reproduction: z.string().trim().max(1e4).optional(),
+	occurredAt: z.string().datetime().optional(),
+	sessionKey: z.string().trim().max(1e3).optional(),
+	requestId: z.string().trim().max(1e3).optional(),
+	clientContext: z.object({
+		currentPage: z.string().trim().max(2e3).optional(),
+		rendererError: z.string().trim().max(2e4).optional(),
+		surface: z.enum(["web", "electron"]).optional(),
+		userAgent: z.string().trim().max(2e3).optional()
+	}).strict().optional()
+}).strict();
+//#endregion
+export { SupportReportInputSchema };

package/dist/src/tunnel/consent.d.ts

@@ -28,4 +28,4 @@ export declare function assertTunnelMayStart(config: Config): void;
 export declare function assertTunnelAutoStartAllowed(config: Config): void;
 export declare function buildTunnelConsentRecord(): NonNullable<Config['tunnel']>['consent'];
 /** Short risk summary for CLI (keep in sync with web i18n). */
-export declare const TUNNEL_RISK_SUMMARY_LINES: readonly ["Starting remote access exposes your gateway on the public internet via frp.xopc.ai.", "Anyone with the public URL or pairing QR may use your gateway Bearer token.", "Traffic is proxied through third-party infrastructure; use a strong token and stop the tunnel when not needed."];
+export declare const TUNNEL_RISK_SUMMARY_LINES: readonly ["Starting remote access exposes your gateway on the public internet via frp.xopc.ai.", "A public URL exposes the gateway authentication surface to the internet.", "Traffic is proxied through third-party infrastructure; use a strong token and stop the tunnel when not needed."];

package/dist/src/tunnel/consent.js

@@ -57,7 +57,7 @@ function buildTunnelConsentRecord() {
 /** Short risk summary for CLI (keep in sync with web i18n). */
 const TUNNEL_RISK_SUMMARY_LINES = [
 	"Starting remote access exposes your gateway on the public internet via frp.xopc.ai.",
-	"Anyone with the public URL or pairing QR may use your gateway Bearer token.",
+	"A public URL exposes the gateway authentication surface to the internet.",
 	"Traffic is proxied through third-party infrastructure; use a strong token and stop the tunnel when not needed."
 ];
 //#endregion

package/dist/src/tunnel/gateway-lifecycle.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { resolveGatewayEffectiveHost } from "../config/gateway-bind.js";
-import { hasValidTunnelConsent } from "./consent.js";
 import { resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl } from "./env.js";
 import { getTunnelService } from "./tunnel-service.js";
+import { hasValidTunnelConsent } from "./consent.js";
 import { resolveFrpSubdomainHost } from "./frp-subdomain-host.js";
 import { fetchTunnelWellKnown } from "./well-known.js";
 //#region src/tunnel/gateway-lifecycle.ts

package/dist/src/tunnel/index.d.ts

@@ -14,8 +14,5 @@ export { consumeTunnelMutationLimit, resetTunnelMutationLimitsForTests } from '.
 export { getTunnelService, hashGatewayToken, TunnelService } from './tunnel-service.js';
 export type { TunnelServiceConfig } from './tunnel-service.js';
 export { resolveFrpSubdomainHost } from './frp-subdomain-host.js';
-export { createPairingSecret, consumePairingSecret, resetPairingSessionsForTests } from './pairing.js';
-export type { PairingSecretResult } from './pairing.js';
-export { buildMobileConnectQrPayload, resolveLanGatewayUrl } from './tunnel-qr.js';
 export { loadTunnelState, saveTunnelState, resolveTunnelStatePath } from './tunnel-state.js';
-export type { PersistedTunnelState, TunnelQrPayload, TunnelStatus, TunnelRegistration } from './tunnel-types.js';
+export type { PersistedTunnelState, TunnelStatus, TunnelRegistration } from './tunnel-types.js';

package/dist/src/tunnel/index.js

@@ -1,15 +1,13 @@
 import { loadTunnelState, resolveTunnelStatePath, saveTunnelState } from "./tunnel-state.js";
-import { buildMobileConnectQrPayload, resolveLanGatewayUrl } from "./tunnel-qr.js";
-import { CURRENT_TUNNEL_CONSENT_VERSION, TUNNEL_CONSENT_REQUIRED_CODE, TUNNEL_RISK_SUMMARY_LINES, TunnelConsentError, assertTunnelMayStart, getTunnelConsentState, hasValidTunnelConsent } from "./consent.js";
-import { TUNNEL_REGISTRATION_SECRET_REQUIRED_CODE, TunnelRegistrationSecretError, getTunnelRegistrationSecretMeta, isLocalDevelopmentTunnelBroker, isMaskedTunnelSecretPatchValue, resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret, tunnelRegistrationSecretRequiredMessage } from "./env.js";
 import { TunnelBrokerClient, resolveBrokerApiBase } from "./broker-client.js";
 import { FRPC_VERSION, clearFrpcPathForProcess, ensureFrpcBinary, publishFrpcPathForProcess } from "./frpc-binary.js";
-import { consumePairingSecret, createPairingSecret, resetPairingSessionsForTests } from "./pairing.js";
+import { TUNNEL_REGISTRATION_SECRET_REQUIRED_CODE, TunnelRegistrationSecretError, getTunnelRegistrationSecretMeta, isLocalDevelopmentTunnelBroker, isMaskedTunnelSecretPatchValue, resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret, tunnelRegistrationSecretRequiredMessage } from "./env.js";
 import { logTunnelAudit } from "./tunnel-audit.js";
 import { TunnelService, getTunnelService, hashGatewayToken } from "./tunnel-service.js";
+import { CURRENT_TUNNEL_CONSENT_VERSION, TUNNEL_CONSENT_REQUIRED_CODE, TUNNEL_RISK_SUMMARY_LINES, TunnelConsentError, assertTunnelMayStart, getTunnelConsentState, hasValidTunnelConsent } from "./consent.js";
 import { resolveFrpSubdomainHost } from "./frp-subdomain-host.js";
 import { clearTunnelWellKnownCache, fetchTunnelWellKnown } from "./well-known.js";
 import { configureTunnelFromGatewayConfig, maybeAutoStartTunnelFromConfig, wireTunnelEventsToGateway } from "./gateway-lifecycle.js";
 import { applyTunnelConsentToConfig, mergeTunnelConfigPatch, sanitizeTunnelConfig, setTunnelEnabledInConfig } from "./tunnel-config.js";
 import { consumeTunnelMutationLimit, resetTunnelMutationLimitsForTests } from "./tunnel-rate-limit.js";
-export { CURRENT_TUNNEL_CONSENT_VERSION, FRPC_VERSION, TUNNEL_CONSENT_REQUIRED_CODE, TUNNEL_REGISTRATION_SECRET_REQUIRED_CODE, TUNNEL_RISK_SUMMARY_LINES, TunnelBrokerClient, TunnelConsentError, TunnelRegistrationSecretError, TunnelService, applyTunnelConsentToConfig, assertTunnelMayStart, buildMobileConnectQrPayload, clearFrpcPathForProcess, clearTunnelWellKnownCache, configureTunnelFromGatewayConfig, consumePairingSecret, consumeTunnelMutationLimit, createPairingSecret, ensureFrpcBinary, fetchTunnelWellKnown, getTunnelConsentState, getTunnelRegistrationSecretMeta, getTunnelService, hasValidTunnelConsent, hashGatewayToken, isLocalDevelopmentTunnelBroker, isMaskedTunnelSecretPatchValue, loadTunnelState, logTunnelAudit, maybeAutoStartTunnelFromConfig, mergeTunnelConfigPatch, publishFrpcPathForProcess, resetPairingSessionsForTests, resetTunnelMutationLimitsForTests, resolveBrokerApiBase, resolveFrpSubdomainHost, resolveLanGatewayUrl, resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret, resolveTunnelStatePath, sanitizeTunnelConfig, saveTunnelState, setTunnelEnabledInConfig, tunnelRegistrationSecretRequiredMessage, wireTunnelEventsToGateway };
+export { CURRENT_TUNNEL_CONSENT_VERSION, FRPC_VERSION, TUNNEL_CONSENT_REQUIRED_CODE, TUNNEL_REGISTRATION_SECRET_REQUIRED_CODE, TUNNEL_RISK_SUMMARY_LINES, TunnelBrokerClient, TunnelConsentError, TunnelRegistrationSecretError, TunnelService, applyTunnelConsentToConfig, assertTunnelMayStart, clearFrpcPathForProcess, clearTunnelWellKnownCache, configureTunnelFromGatewayConfig, consumeTunnelMutationLimit, ensureFrpcBinary, fetchTunnelWellKnown, getTunnelConsentState, getTunnelRegistrationSecretMeta, getTunnelService, hasValidTunnelConsent, hashGatewayToken, isLocalDevelopmentTunnelBroker, isMaskedTunnelSecretPatchValue, loadTunnelState, logTunnelAudit, maybeAutoStartTunnelFromConfig, mergeTunnelConfigPatch, publishFrpcPathForProcess, resetTunnelMutationLimitsForTests, resolveBrokerApiBase, resolveFrpSubdomainHost, resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret, resolveTunnelStatePath, sanitizeTunnelConfig, saveTunnelState, setTunnelEnabledInConfig, tunnelRegistrationSecretRequiredMessage, wireTunnelEventsToGateway };

package/dist/src/tunnel/tunnel-audit.d.ts

@@ -1,2 +1,2 @@
-export type TunnelAuditEvent = 'tunnel.consent' | 'tunnel.start' | 'tunnel.stop' | 'tunnel.release' | 'tunnel.start_denied' | 'tunnel.pair' | 'tunnel.exchange_token' | 'tunnel.registration_authorized' | 'tunnel.enable_lan_pairing';
+export type TunnelAuditEvent = 'tunnel.consent' | 'tunnel.start' | 'tunnel.stop' | 'tunnel.release' | 'tunnel.start_denied' | 'tunnel.registration_authorized';
 export declare function logTunnelAudit(event: TunnelAuditEvent, fields: Record<string, unknown>, message: string): void;

package/dist/src/tunnel/tunnel-config.js

@@ -1,6 +1,6 @@
 import { TunnelConfigSchema, TunnelConsentSchema, init_schema } from "../config/schema.js";
-import { assertTunnelAutoStartAllowed, buildTunnelConsentRecord, hasValidTunnelConsent } from "./consent.js";
 import { getTunnelRegistrationSecretMeta, isMaskedTunnelSecretPatchValue } from "./env.js";
+import { assertTunnelAutoStartAllowed, buildTunnelConsentRecord, hasValidTunnelConsent } from "./consent.js";
 import { z } from "zod";
 //#region src/tunnel/tunnel-config.ts
 init_schema();

package/dist/src/tunnel/tunnel-service.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'node:events';
-import type { TunnelQrPayload, TunnelStatus } from './tunnel-types.js';
+import type { TunnelStatus } from './tunnel-types.js';
 export type TunnelServiceConfig = {
     brokerUrl: string;
     registrationSecret?: string;
@@ -27,8 +27,7 @@ export declare class TunnelService extends EventEmitter {
     getStatus(): TunnelStatus;
     private setStartPhase;
     private clearStartProgress;
-    buildQr(gatewayPort: number, gatewayHost: string): Promise<TunnelQrPayload>;
-    start(gatewayPort: number, gatewayToken: string): Promise<TunnelQrPayload>;
+    start(gatewayPort: number, gatewayToken: string): Promise<void>;
     stop(opts?: {
         release?: boolean;
     }): Promise<{

package/dist/src/tunnel/tunnel-service.js

@@ -2,13 +2,11 @@ import { PACKAGE_VERSION, init_package_version } from "../package-version.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { clearTunnelState, loadTunnelState, saveTunnelState, updateTunnelState } from "./tunnel-state.js";
-import { buildMobileConnectQrPayload, resolveLanGatewayUrl } from "./tunnel-qr.js";
-import { TunnelRegistrationSecretError } from "./env.js";
 import { TunnelBrokerClient, resolveBrokerApiBase } from "./broker-client.js";
 import { clearFrpcPathForProcess, ensureFrpcBinary, publishFrpcPathForProcess } from "./frpc-binary.js";
 import { writeFrpcConfig } from "./frpc-config.js";
 import { spawnFrpcProcess } from "./frpc-process.js";
-import { createPairingSecret } from "./pairing.js";
+import { TunnelRegistrationSecretError } from "./env.js";
 import { canResumePersistedTunnel, persistedFromRegistration, registrationFromPersisted } from "./tunnel-persist.js";
 import { logTunnelAudit } from "./tunnel-audit.js";
 import { createHash } from "node:crypto";
@@ -81,21 +79,6 @@ var TunnelService = class extends EventEmitter {
 		this.startProgress = null;
 		this.emit("tunnel:progress");
 	}
-	async buildQr(gatewayPort, gatewayHost) {
-		const publicUrl = loadTunnelState()?.publicUrl ?? null;
-		if (!publicUrl) return {
-			qrPayload: "",
-			publicUrl: null,
-			lanUrl: null
-		};
-		const { secret, expiresAt } = createPairingSecret();
-		return buildMobileConnectQrPayload({
-			publicUrl,
-			lanUrl: resolveLanGatewayUrl(gatewayHost, gatewayPort),
-			pairingSecret: secret,
-			expiresAt: expiresAt.toISOString()
-		});
-	}
 	async start(gatewayPort, gatewayToken) {
 		const cfg = this.serviceConfig;
 		if (!cfg) throw new Error("Tunnel service not configured");
@@ -159,14 +142,12 @@ var TunnelService = class extends EventEmitter {
 		this.connectedSince = (/* @__PURE__ */ new Date()).toISOString();
 		this.reconnectAttempt = 0;
 		this.emit("tunnel:connected");
-		const qr = await this.buildQr(gatewayPort, cfg.gatewayHost);
 		logTunnelAudit("tunnel.start", {
 			subdomain: registration.subdomain,
 			publicUrl: registration.publicUrl,
 			tunnelId: registration.tunnelId,
 			gatewayTokenHash: hashGatewayToken(gatewayToken).slice(0, 12)
 		}, "Remote access tunnel started");
-		return qr;
 	}
 	async stop(opts) {
 		const release = opts?.release === true;

package/dist/src/tunnel/tunnel-types.d.ts

@@ -58,9 +58,3 @@ export type TunnelStatus = {
         };
     };
 };
-export type TunnelQrPayload = {
-    qrPayload: string;
-    publicUrl: string | null;
-    lanUrl: string | null;
-    expiresAt?: string;
-};

package/dist/src/user-context/user-avatar.d.ts

@@ -0,0 +1,17 @@
+export declare const USER_AVATAR_MAX_BYTES: number;
+type UserAvatarMime = 'image/png' | 'image/jpeg' | 'image/webp';
+export type UserAvatarResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+    status: 400 | 404;
+};
+export declare function readUserAvatar(): Promise<UserAvatarResult<{
+    buffer: Buffer;
+    contentType: UserAvatarMime;
+}>>;
+export declare function writeUserAvatar(base64: string, mimeType: string): Promise<UserAvatarResult<{}>>;
+export declare function deleteUserAvatar(): Promise<UserAvatarResult<{}>>;
+export {};

package/dist/src/user-context/user-avatar.js

@@ -0,0 +1,116 @@
+import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
+import { join } from "node:path";
+import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+//#region src/user-context/user-avatar.ts
+init_paths_state();
+const USER_AVATAR_MAX_BYTES = 2 * 1024 * 1024;
+const USER_AVATAR_DIR = "profile";
+const USER_AVATAR_BASENAME = "user-avatar";
+const USER_AVATAR_EXTENSIONS = [
+	".png",
+	".jpg",
+	".webp"
+];
+function avatarRoot() {
+	return join(resolveStateDir(), USER_AVATAR_DIR);
+}
+function avatarFilenames() {
+	return USER_AVATAR_EXTENSIONS.map((extension) => `${USER_AVATAR_BASENAME}${extension}`);
+}
+function mimeToExtension(mimeType) {
+	const normalized = mimeType.toLowerCase().trim();
+	if (normalized === "image/png") return ".png";
+	if (normalized === "image/jpeg" || normalized === "image/jpg") return ".jpg";
+	if (normalized === "image/webp") return ".webp";
+	return null;
+}
+function extensionToMime(extension) {
+	if (extension === ".png") return "image/png";
+	if (extension === ".webp") return "image/webp";
+	return "image/jpeg";
+}
+function detectImageMime(buffer) {
+	if (buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) return "image/png";
+	if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) return "image/jpeg";
+	if (buffer.length >= 12 && buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70 && buffer[8] === 87 && buffer[9] === 69 && buffer[10] === 66 && buffer[11] === 80) return "image/webp";
+	return null;
+}
+async function readUserAvatar() {
+	const root = avatarRoot();
+	for (const filename of avatarFilenames()) {
+		const path = join(root, filename);
+		try {
+			const metadata = await stat(path);
+			if (!metadata.isFile() || metadata.size <= 0 || metadata.size > 2097152) continue;
+			const buffer = await readFile(path);
+			const contentType = detectImageMime(buffer);
+			if (!contentType) continue;
+			return {
+				ok: true,
+				data: {
+					buffer,
+					contentType
+				}
+			};
+		} catch {}
+	}
+	return {
+		ok: false,
+		error: "avatar not found",
+		status: 404
+	};
+}
+async function writeUserAvatar(base64, mimeType) {
+	const extension = mimeToExtension(mimeType);
+	if (!extension) return {
+		ok: false,
+		error: "unsupported mimeType (use image/png, image/jpeg, or image/webp)",
+		status: 400
+	};
+	if (!base64 || !/^[A-Za-z0-9+/]*={0,2}$/.test(base64)) return {
+		ok: false,
+		error: "invalid base64",
+		status: 400
+	};
+	const buffer = Buffer.from(base64, "base64");
+	if (buffer.length === 0 || buffer.length > 2097152) return {
+		ok: false,
+		error: `avatar must be non-empty and at most ${USER_AVATAR_MAX_BYTES} bytes`,
+		status: 400
+	};
+	const detectedMime = detectImageMime(buffer);
+	if (!detectedMime || detectedMime !== extensionToMime(extension)) return {
+		ok: false,
+		error: "file content does not match declared image type",
+		status: 400
+	};
+	const root = avatarRoot();
+	await mkdir(root, {
+		recursive: true,
+		mode: 448
+	});
+	const targetFilename = `${USER_AVATAR_BASENAME}${extension}`;
+	for (const filename of avatarFilenames()) {
+		if (filename === targetFilename) continue;
+		try {
+			await unlink(join(root, filename));
+		} catch {}
+	}
+	await writeFile(join(root, targetFilename), buffer, { mode: 384 });
+	return {
+		ok: true,
+		data: {}
+	};
+}
+async function deleteUserAvatar() {
+	const root = avatarRoot();
+	for (const filename of avatarFilenames()) try {
+		await unlink(join(root, filename));
+	} catch {}
+	return {
+		ok: true,
+		data: {}
+	};
+}
+//#endregion
+export { USER_AVATAR_MAX_BYTES, deleteUserAvatar, readUserAvatar, writeUserAvatar };

package/dist/src/workflows/draft/workflow-draft-service.js

@@ -3,7 +3,7 @@ import { init_logger } from "../../utils/logger.js";
 import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../../providers/index.js";
 import { completeWithResolvedCredentials } from "../../providers/model-call.js";
-import { resolveModelRef } from "../../config/agent-typed-models.js";
+import { resolveModelSelector } from "../../config/agent-model-intents.js";
 import { buildWorkflowDraftPrompt, buildWorkflowDraftRepairPrompt } from "./workflow-draft-prompt.js";
 import { buildWorkflowDraftResponse, parseGeneratedWorkflowDraft } from "./workflow-draft-validator.js";
 //#region src/workflows/draft/workflow-draft-service.ts
@@ -83,7 +83,7 @@ var WorkflowDraftService = class {
 };
 function resolveDraftModelRef(config, agentId) {
 	try {
-		return resolveModelRef(config, agentId, "large");
+		return resolveModelSelector(config, agentId, "reasoning");
 	} catch {
 		return getAgentDefaultModelRef(config) ?? getDefaultModelSync(config);
 	}

package/dist/src/workflows/service/workflow-run-service.js

@@ -6,9 +6,9 @@ import { TaskConversationRepository } from "../../tasks/task-conversation-reposi
 import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { getProjectWorkspacePathForSession } from "../../projects/workspace.js";
 import { publishAutomationProductEvent } from "../../automations/product-events.js";
-import { resolveModelRef } from "../../config/agent-typed-models.js";
 import { TaskContextRepository } from "../../tasks/task-context-repository.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
+import { resolveModelSelector } from "../../config/agent-model-intents.js";
 import { DelegateSubagentRunner } from "../../agent/workflow/subagent-runner.js";
 import { preflightWorkflowConnectors } from "../../connectors/workflow-preflight.js";
 import { CatalogWorkflowDefinitionRegistry } from "../registry/catalog-workflow-definition-registry.js";
@@ -90,7 +90,7 @@ var WorkflowRunService = class {
 	}
 	async startWorkflowRun(params) {
 		const config = this.options.service.currentConfig;
-		const workflowPolicy = config.agents?.list ? resolveEffectiveAgentProfileForSession(config, params.parentSessionKey ?? `agent:${params.agentId}`).manifest.workflows : void 0;
+		const workflowPolicy = config.agents?.list ? resolveEffectiveAgentProfileForSession(config, params.parentSessionKey ?? `agent:${params.agentId}`).config.workflows : void 0;
 		if (workflowPolicy?.allowed && !workflowPolicy.allowed.includes(params.definitionId)) return {
 			ok: false,
 			code: "policy_denied",
@@ -568,7 +568,7 @@ var WorkflowRunService = class {
 			runner,
 			hooks: [{ afterRun: ({ runId, status }) => new WorkflowWritebackService().apply(params.runStore, runId, status) }],
 			resolveModelId: (modelId) => {
-				return resolveModel(resolveModelRef(gatewayService.currentConfig, profileAgentId, modelId));
+				return resolveModel(resolveModelSelector(gatewayService.currentConfig, profileAgentId, modelId));
 			},
 			parentSessionKey: params.sessionKey,
 			subagentSessionKeyFactory: ({ runId, agentId }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.231",
+  "version": "0.0.233",
   "description": "Local-first personal AI assistant with reviewable user understanding, durable tasks, workflows, automations, and local or cloud models.",
   "type": "module",
   "main": "dist/src/index.js",
@@ -163,10 +163,10 @@
     "vitepress": "^1.6.4",
     "vitest": "4.1.5",
     "vue": "^3.5.35",
-    "@xopcai/endpoint-tools-protocol": "0.0.0",
     "@xopcai/gateway-contract": "0.0.0",
-    "@xopcai/realtime-client": "0.0.0",
-    "@xopcai/realtime-protocol": "0.0.0"
+    "@xopcai/realtime-protocol": "0.0.0",
+    "@xopcai/endpoint-tools-protocol": "0.0.0",
+    "@xopcai/realtime-client": "0.0.0"
   },
   "scripts": {
     "assets:brand": "node scripts/generate-brand-assets.mjs",