record_safer_pro_mcp 1.0.0

package/dist/api-client.js

@@ -0,0 +1,991 @@
+/**
+ * Record Safer API Client — 统一 HTTP 客户端适配层
+ * 封装与 Backend (record_safer_headless) 的所有 HTTP 通信
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+/** Backend HTTP 错误，包含状态码和响应体 */
+export class ApiError extends Error {
+    statusCode;
+    responseBody;
+    constructor(statusCode, responseBody) {
+        super(buildSafeHttpErrorMessage(statusCode));
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = "ApiError";
+    }
+}
+function buildSafeHttpErrorMessage(statusCode) {
+    if (statusCode === 400) {
+        return "Backend rejected the request as invalid (HTTP 400).";
+    }
+    if (statusCode === 401 || statusCode === 403) {
+        return `Backend authentication or authorization failed (HTTP ${statusCode}).`;
+    }
+    if (statusCode === 404) {
+        return "Backend endpoint was not found (HTTP 404).";
+    }
+    if (statusCode === 409) {
+        return "Backend rejected the request due to a state conflict (HTTP 409).";
+    }
+    if (statusCode === 422) {
+        return "Backend could not validate the request (HTTP 422).";
+    }
+    if (statusCode >= 500) {
+        return `Backend encountered an internal error (HTTP ${statusCode}).`;
+    }
+    return `Backend request failed (HTTP ${statusCode}).`;
+}
+export function normalizeDisplayPath(filePath) {
+    const trimmed = filePath.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    const normalizedPath = path.normalize(trimmed);
+    const normalizedHome = path.normalize(os.homedir());
+    if (normalizedPath === normalizedHome) {
+        return "~";
+    }
+    if (normalizedPath.startsWith(`${normalizedHome}${path.sep}`)) {
+        return `~${normalizedPath.slice(normalizedHome.length)}`;
+    }
+    return normalizedPath;
+}
+function parseTruthyEnv(value) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function normalizeHostEntry(entry) {
+    const trimmed = entry.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const parsed = new URL(trimmed.includes("://") ? trimmed : `http://${trimmed}`);
+        return parsed.hostname.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function getRemoteFileTokenAllowlist() {
+    const allowlistRaw = process.env.RECORD_SAFER_REMOTE_FILE_TOKEN_HOSTS;
+    if (!allowlistRaw) {
+        return new Set();
+    }
+    return new Set(allowlistRaw
+        .split(",")
+        .map((entry) => normalizeHostEntry(entry))
+        .filter((entry) => Boolean(entry)));
+}
+function isLoopbackHost(hostname) {
+    const normalized = hostname.toLowerCase();
+    return (normalized === "localhost" ||
+        normalized === "::1" ||
+        normalized === "[::1]" ||
+        normalized === "127.0.0.1" ||
+        normalized.startsWith("127.") ||
+        normalized.startsWith("::ffff:127."));
+}
+function isLoopbackBaseUrl(rawUrl) {
+    try {
+        const parsed = new URL(rawUrl);
+        return isLoopbackHost(parsed.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function isRemoteFileTokenAllowed(rawUrl) {
+    if (!parseTruthyEnv(process.env.RECORD_SAFER_ALLOW_REMOTE_FILE_TOKEN)) {
+        return false;
+    }
+    const allowlist = getRemoteFileTokenAllowlist();
+    if (allowlist.size === 0) {
+        return false;
+    }
+    try {
+        const parsed = new URL(rawUrl);
+        return allowlist.has(parsed.hostname.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
+function loadAuthTokenWithSource() {
+    if (process.env.RECORD_SAFER_TOKEN) {
+        return { token: process.env.RECORD_SAFER_TOKEN, source: "env" };
+    }
+    const tokenPath = path.join(os.homedir(), ".record_safer", "auth_token");
+    try {
+        const token = fs.readFileSync(tokenPath, "utf-8").trim();
+        if (token.length > 0) {
+            return { token, source: "file" };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return { token: null, source: "none" };
+}
+function isSafePortFile(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+            return false;
+        }
+        // 拒绝 group/world 可写，避免被其他用户篡改
+        if ((stat.mode & 0o022) !== 0) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isProcessAlive(pid) {
+    if (!pid || !Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readPortFromMeta(dir) {
+    const metaPath = path.join(dir, "backend_port.meta.json");
+    if (!fs.existsSync(metaPath)) {
+        return null;
+    }
+    if (!isSafePortFile(metaPath)) {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(metaPath, "utf-8");
+        const meta = JSON.parse(raw);
+        const port = Number(meta?.port);
+        const pid = meta?.pid !== undefined ? Number(meta.pid) : null;
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            return null;
+        }
+        if (typeof pid === "number" && Number.isInteger(pid) && pid > 0 && !isProcessAlive(pid)) {
+            return null;
+        }
+        return port;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 加载 Auth Token：优先环境变量，其次文件
+ * 1. RECORD_SAFER_TOKEN 环境变量
+ * 2. ~/.record_safer/auth_token 文件
+ */
+export function loadAuthToken() {
+    return loadAuthTokenWithSource().token;
+}
+/**
+ * 从端口文件读取后端端口号
+ * 返回有效端口号（1-65535）或 null
+ */
+export function readPortFromFile() {
+    try {
+        const dir = path.join(os.homedir(), ".record_safer");
+        const metaPort = readPortFromMeta(dir);
+        if (metaPort !== null) {
+            return metaPort;
+        }
+        const portPath = path.join(dir, "backend_port");
+        if (!isSafePortFile(portPath)) {
+            return null;
+        }
+        const content = fs.readFileSync(portPath, "utf-8").trim();
+        const port = parseInt(content, 10);
+        if (Number.isInteger(port) && port >= 1 && port <= 65535) {
+            return port;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 按优先级链解析 baseUrl：
+ * 1. 端口文件 → http://127.0.0.1:{port}
+ * 2. RECORD_SAFER_URL 环境变量
+ * 3. 默认 http://127.0.0.1:8080
+ */
+export function resolveBaseUrl() {
+    const port = readPortFromFile();
+    if (port !== null) {
+        return `http://127.0.0.1:${port}`;
+    }
+    return process.env.RECORD_SAFER_URL ?? "http://127.0.0.1:8080";
+}
+/**
+ * 启动 Record Safer Pro 应用并等待后端就绪
+ * 仅在 macOS 上有效，使用 open -a 命令启动 Electron 应用
+ * 启动后轮询 /api/system/info 直到后端响应或超时
+ */
+async function launchAppAndWaitForBackend(getUrl, getAuthHeaders, timeoutMs = 15000) {
+    // 启动应用
+    try {
+        try {
+            execSync('open -a "Record Safer Pro"', { timeout: 5000 });
+        }
+        catch {
+            execSync('open -a "Record Safer"', { timeout: 5000 });
+        }
+    }
+    catch {
+        // open 命令失败（应用未安装等），直接返回
+        return false;
+    }
+    // 轮询等待后端就绪
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        await new Promise(r => setTimeout(r, 500));
+        try {
+            // 重新解析 URL（端口文件可能在启动后才写入）
+            const url = getUrl();
+            const headers = getAuthHeaders(url);
+            const resp = await fetch(`${url}/api/system/info`, { headers, signal: AbortSignal.timeout(2000) });
+            if (resp.ok)
+                return true;
+        }
+        catch {
+            // 后端还没起来，继续等
+        }
+    }
+    return false;
+}
+/**
+ * 快速预检后端连接配置（不发起 HTTP 请求）
+ * 检查端口文件和 token 是否存在，返回诊断信息
+ */
+export function preflightCheck() {
+    const port = readPortFromFile();
+    const loadedToken = loadAuthTokenWithSource();
+    const token = loadedToken.token;
+    const hasPort = port !== null;
+    const hasToken = token !== null && token.length > 0;
+    const baseUrl = hasPort ? `http://127.0.0.1:${port}` : (process.env.RECORD_SAFER_URL ?? "http://127.0.0.1:8080");
+    if (!hasPort && !process.env.RECORD_SAFER_URL) {
+        return {
+            ok: false,
+            baseUrl,
+            hasToken,
+            hasPort,
+            error: `Backend connection failed. Due to the DADAO Engine safety architecture, session initialization and recording start must be performed manually in the Record Safer Pro GUI. Please open Record Safer Pro, complete setup, and enter the recording console before using MCP recording actions.`,
+        };
+    }
+    if (!hasToken) {
+        return {
+            ok: false,
+            baseUrl,
+            hasToken,
+            hasPort,
+            error: `Auth token unavailable. Due to the DADAO Engine safety architecture, session initialization and recording start must be performed manually in the Record Safer Pro GUI. Please open Record Safer Pro, complete setup, and enter the recording console before using MCP recording actions.`,
+        };
+    }
+    if (loadedToken.source === "file" &&
+        !isLoopbackBaseUrl(baseUrl) &&
+        !isRemoteFileTokenAllowed(baseUrl)) {
+        return {
+            ok: false,
+            baseUrl,
+            hasToken,
+            hasPort,
+            error: "Remote backend URL detected. Refusing to send local ~/.record_safer/auth_token to a non-loopback host. Set RECORD_SAFER_TOKEN explicitly for remote use, or set RECORD_SAFER_ALLOW_REMOTE_FILE_TOKEN=1 together with RECORD_SAFER_REMOTE_FILE_TOKEN_HOSTS allowlist.",
+        };
+    }
+    return { ok: true, baseUrl, hasToken, hasPort };
+}
+/** Record Safer Backend HTTP 客户端 */
+export class RecordSaferClient {
+    explicitBaseUrl;
+    authToken;
+    authTokenSource;
+    remoteFileTokenWarningLogged = false;
+    appEnsured = false; // 是否已确认应用在运行
+    backendReady = false; // 后端连接是否已验证可用
+    constructor(config) {
+        this.explicitBaseUrl = config?.baseUrl;
+        if (config && Object.prototype.hasOwnProperty.call(config, "authToken")) {
+            this.authToken = config.authToken ? config.authToken : null;
+            this.authTokenSource = this.authToken ? "config" : "none";
+        }
+        else {
+            const loaded = loadAuthTokenWithSource();
+            this.authToken = loaded.token;
+            this.authTokenSource = loaded.source;
+        }
+    }
+    getBaseUrl() {
+        return this.explicitBaseUrl ?? resolveBaseUrl();
+    }
+    shouldAttachAuthToken(baseUrl) {
+        if (!this.authToken || this.authToken.length === 0) {
+            return false;
+        }
+        if (this.authTokenSource === "config" || this.authTokenSource === "env") {
+            return true;
+        }
+        if (this.authTokenSource !== "file") {
+            return false;
+        }
+        if (isLoopbackBaseUrl(baseUrl)) {
+            return true;
+        }
+        return isRemoteFileTokenAllowed(baseUrl);
+    }
+    buildAuthHeaders(baseUrl) {
+        if (this.shouldAttachAuthToken(baseUrl) && this.authToken) {
+            return { Authorization: `Bearer ${this.authToken}` };
+        }
+        if (this.authToken &&
+            this.authTokenSource === "file" &&
+            !isLoopbackBaseUrl(baseUrl) &&
+            !this.remoteFileTokenWarningLogged) {
+            this.remoteFileTokenWarningLogged = true;
+            console.warn("[RecordSaferClient] Blocked sending local auth_token to remote backend. " +
+                "Use RECORD_SAFER_TOKEN for remote target, or set RECORD_SAFER_ALLOW_REMOTE_FILE_TOKEN=1 together with RECORD_SAFER_REMOTE_FILE_TOKEN_HOSTS.");
+        }
+        return {};
+    }
+    toMonitorChannelId(index) {
+        if (!Number.isInteger(index) || index < 0) {
+            throw new Error(`Invalid channel index: ${index}`);
+        }
+        return index + 1;
+    }
+    /**
+     * 快速预检：检查端口和 token 配置是否就绪
+     * 不发起 HTTP 请求，仅检查本地文件
+     * 返回 null 表示配置就绪，否则返回错误消息
+     */
+    preflight() {
+        if (this.backendReady)
+            return null;
+        if (this.explicitBaseUrl)
+            return null; // 显式配置了 URL，跳过预检
+        const result = preflightCheck();
+        if (!result.ok) {
+            return result.error;
+        }
+        return null;
+    }
+    /**
+     * 确保 Record Safer 应用正在运行
+     * 首次调用时检查后端是否可达，不可达则自动启动应用并等待就绪
+     * @returns true 如果它尝试了启动应用操作，false 如果已经在运行
+     */
+    async ensureAppRunning() {
+        if (this.appEnsured)
+            return false;
+        // 先尝试一次快速请求，看后端是否已经在运行
+        try {
+            const baseUrl = this.getBaseUrl();
+            const headers = this.buildAuthHeaders(baseUrl);
+            const resp = await fetch(`${baseUrl}/api/system/info`, {
+                headers,
+                signal: AbortSignal.timeout(2000),
+            });
+            if (resp.ok) {
+                this.appEnsured = true;
+                this.backendReady = true;
+                return false;
+            }
+        }
+        catch {
+            // 连接失败，需要启动应用
+        }
+        // 后端不可达，尝试启动应用
+        const launched = await launchAppAndWaitForBackend(() => this.getBaseUrl(), (baseUrl) => this.buildAuthHeaders(baseUrl));
+        if (launched) {
+            // 启动后重新加载 auth token（应用启动时可能生成新 token）
+            const loaded = loadAuthTokenWithSource();
+            if (loaded.token) {
+                this.authToken = loaded.token;
+                this.authTokenSource = loaded.source;
+                this.remoteFileTokenWarningLogged = false;
+            }
+            this.backendReady = true;
+        }
+        this.appEnsured = true;
+        return true;
+    }
+    /**
+     * 通用 HTTP 请求方法
+     * - 自动附加 Authorization header（当 token 可用时）
+     * - 自动设置 Content-Type: application/json（当有 body 时）
+     * - HTTP 错误时抛出 ApiError
+     */
+    async request(urlPath, options, requestOptions) {
+        if (requestOptions?.allowAutoLaunch !== false) {
+            await this.ensureAppRunning();
+        }
+        const baseUrl = this.getBaseUrl();
+        const url = `${baseUrl}${urlPath}`;
+        const headers = new Headers(options?.headers);
+        const authHeaders = this.buildAuthHeaders(baseUrl);
+        if (authHeaders.Authorization) {
+            headers.set("Authorization", authHeaders.Authorization);
+        }
+        if (options?.body) {
+            headers.set("Content-Type", "application/json");
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new ApiError(response.status, body);
+        }
+        return (await response.json());
+    }
+    // ===== 设备管理 =====
+    async listDevices(requestOptions) {
+        return this.request("/api/devices", undefined, requestOptions);
+    }
+    async listOutputDevices() {
+        const data = await this.request("/api/devices/outputs");
+        return Array.isArray(data?.devices) ? data.devices : [];
+    }
+    async getBufferSizes(deviceId, sampleRate) {
+        const params = new URLSearchParams();
+        if (typeof sampleRate === "number" && sampleRate > 0) {
+            params.set("sampleRate", String(Math.round(sampleRate)));
+        }
+        const query = params.size > 0 ? `?${params.toString()}` : "";
+        return this.request(`/api/devices/${deviceId}/buffer-sizes${query}`);
+    }
+    async getDeviceSignals(deviceId, sampleRate) {
+        const params = new URLSearchParams();
+        if (typeof sampleRate === "number" && sampleRate > 0) {
+            params.set("sampleRate", String(Math.round(sampleRate)));
+        }
+        const query = params.size > 0 ? `?${params.toString()}` : "";
+        return this.request(`/api/devices/${deviceId}/signals${query}`);
+    }
+    async getDeviceLevels(deviceId, params) {
+        const queryParams = new URLSearchParams();
+        if (typeof params?.sampleRate === "number" && params.sampleRate > 0) {
+            queryParams.set("sampleRate", String(Math.round(params.sampleRate)));
+        }
+        if (typeof params?.bufferSize === "number" && params.bufferSize > 0) {
+            queryParams.set("bufferSize", String(Math.round(params.bufferSize)));
+        }
+        const query = queryParams.size > 0 ? `?${queryParams.toString()}` : "";
+        return this.request(`/api/devices/${deviceId}/levels${query}`);
+    }
+    async stopLevelMonitoring() {
+        await this.request("/api/devices/levels/stop", { method: "POST" });
+    }
+    // ===== 电平监控 =====
+    async subscribeLevels(params) {
+        const body = params && Object.keys(params).length > 0
+            ? JSON.stringify({
+                ...(params.deviceId ? { deviceId: parseInt(params.deviceId, 10) || 0 } : {}),
+                ...(typeof params.channelCount === "number" ? { channelCount: params.channelCount } : {}),
+                ...(typeof params.sampleRate === "number" ? { sampleRate: params.sampleRate } : {}),
+            })
+            : undefined;
+        await this.request("/api/levels/subscribe", { method: "POST", body });
+    }
+    async unsubscribeLevels() {
+        await this.request("/api/levels/unsubscribe", { method: "POST" });
+    }
+    async disableLevelCallback() {
+        await this.request("/api/levels/disable-callback", { method: "POST" });
+    }
+    async enableLevelCallback() {
+        await this.request("/api/levels/enable-callback", { method: "POST" });
+    }
+    // ===== 会话与录音 =====
+    /**
+     * 初始化录音会话
+     * 接收 MCP 工具层的简化参数，转换为后端期望的格式后发送
+     */
+    async initializeSession(params) {
+        // 步骤 1: 先设置输出路径（后端 initialize 不会保存 outputPath，需要单独调用）
+        // 这与前端 GUI 的行为一致
+        await this.setOutputPath(params.outputPath);
+        // 步骤 2: 设置音频格式
+        await this.setAudioFormat({
+            format: params.audioFormat,
+            sampleRate: params.sampleRate,
+            bitDepth: params.bitDepth,
+        });
+        // 步骤 3: 初始化会话
+        const backendPayload = {
+            device: { id: parseInt(params.deviceId, 10) },
+            sampleRate: params.sampleRate,
+            bitDepth: params.bitDepth,
+            channels: params.channels.map(ch => ({
+                id: ch,
+                active: true,
+                name: `Channel ${ch}`,
+            })),
+            outputPath: params.outputPath,
+            audioFormat: params.audioFormat,
+        };
+        return this.request("/api/session/initialize", {
+            method: "POST",
+            body: JSON.stringify(backendPayload),
+        });
+    }
+    async startRecordMcp(params) {
+        if (params.userConfirmed !== true) {
+            throw new Error("start_record_mcp requires explicit user confirmation before execution");
+        }
+        const usedDefaultBitDepth = !params.bitDepth;
+        const bitDepth = params.bitDepth ?? "24-bit";
+        const usedDefaultOutputPath = !params.outputPath || params.outputPath.trim().length === 0;
+        const outputPath = usedDefaultOutputPath
+            ? path.join(os.homedir(), "Desktop")
+            : params.outputPath.trim();
+        const deviceId = parseInt(params.deviceId, 10);
+        if (!Number.isInteger(deviceId) || deviceId <= 0) {
+            throw new Error(`Invalid deviceId: ${params.deviceId}`);
+        }
+        const devices = await this.listDevices({ allowAutoLaunch: false });
+        const deviceInfo = devices.find((device) => device.id === params.deviceId);
+        if (!deviceInfo) {
+            throw new Error(`Input device ${params.deviceId} is not available`);
+        }
+        const deviceDefaultSampleRate = Number.isInteger(deviceInfo.defaultSampleRate) && deviceInfo.defaultSampleRate > 0
+            ? deviceInfo.defaultSampleRate
+            : 48000;
+        const requestedSampleRate = Number.isInteger(params.sampleRate) && params.sampleRate > 0 ? params.sampleRate : null;
+        if (requestedSampleRate !== null && requestedSampleRate !== deviceDefaultSampleRate) {
+            throw new Error(`Requested sample rate ${requestedSampleRate} Hz does not match the selected device default/current rate ${deviceDefaultSampleRate} Hz. Current MCP preparation cannot switch hardware sample rate; confirm the device rate or adjust it in the app first.`);
+        }
+        const sampleRate = requestedSampleRate ?? deviceDefaultSampleRate;
+        const usedDeviceDefaultSampleRate = requestedSampleRate === null;
+        const channelPayload = params.channels.map((channel) => ({
+            id: channel.id,
+            active: channel.armed !== false,
+            name: `Channel ${channel.id}`,
+        }));
+        const requestedChannelRenames = params.channels
+            .map((channel) => ({
+            id: channel.id,
+            name: channel.name?.trim() ?? "",
+        }))
+            .filter((channel) => channel.name.length > 0);
+        const activeChannelCount = channelPayload.filter((channel) => channel.active).length;
+        if (channelPayload.length === 0 || activeChannelCount === 0) {
+            throw new Error("start_record_mcp requires at least one armed channel");
+        }
+        const previousUiState = await this.getUIState().catch(() => null);
+        let sessionInitialized = false;
+        try {
+            await this.setOutputPath(outputPath);
+            await this.setAudioFormat({
+                format: params.audioFormat,
+                sampleRate,
+                bitDepth,
+            });
+            await this.setUIState("RECORDING", 7);
+            const payload = {
+                device: { id: deviceId },
+                sampleRate,
+                bitDepth,
+                channels: channelPayload,
+                outputPath,
+                audioFormat: params.audioFormat,
+            };
+            if (params.sessionName && params.sessionName.trim().length > 0) {
+                payload.sessionName = params.sessionName.trim();
+            }
+            if (typeof params.bufferSize === "number" && params.bufferSize > 0) {
+                payload.bufferSize = params.bufferSize;
+            }
+            await this.request("/api/session/initialize", {
+                method: "POST",
+                body: JSON.stringify(payload),
+            });
+            sessionInitialized = true;
+            for (const channel of requestedChannelRenames) {
+                await this.renameChannel(String(channel.id), channel.name);
+            }
+            const [status, uiState] = await Promise.all([
+                this.getRecordingStatus(),
+                this.getUIState(),
+            ]);
+            const sessionConfig = status.sessionConfig;
+            const fallbackChannels = channelPayload;
+            return {
+                success: true,
+                page: "RECORDING",
+                pageStep: uiState.pageStep,
+                consoleReady: uiState.page === "RECORDING" &&
+                    Array.isArray(sessionConfig?.channels) &&
+                    sessionConfig.channels.length > 0,
+                usedDefaultOutputPath,
+                usedDeviceDefaultSampleRate,
+                usedDefaultBitDepth,
+                appliedChannelRenames: requestedChannelRenames.length,
+                outputPath: normalizeDisplayPath(sessionConfig?.outputPath || outputPath),
+                deviceId: String(sessionConfig?.deviceId ?? params.deviceId),
+                requestedSampleRate,
+                requestedBitDepth: bitDepth,
+                effectiveSampleRate: sessionConfig?.sampleRate ?? sampleRate,
+                effectiveBitDepth: sessionConfig?.bitDepth ?? bitDepth,
+                audioFormat: sessionConfig?.audioFormat ?? params.audioFormat,
+                sessionName: sessionConfig?.sessionName ?? params.sessionName ?? null,
+                channels: (sessionConfig?.channels ?? fallbackChannels).map((channel) => ({
+                    id: channel.id,
+                    name: channel.name,
+                    armed: channel.armed !== undefined ? channel.armed : channel.active !== false,
+                    deviceChannelLabel: channel.deviceChannelLabel,
+                    color: channel.color,
+                })),
+            };
+        }
+        catch (error) {
+            if (!sessionInitialized && previousUiState != null) {
+                await this.setUIState(previousUiState.page, previousUiState.pageStep).catch(() => { });
+            }
+            throw error;
+        }
+    }
+    async resetSession() {
+        await this.request("/api/session/reset", { method: "POST" });
+    }
+    async startRecording(options) {
+        return this.request("/api/recording/start", {
+            method: "POST",
+            body: options ? JSON.stringify(options) : undefined,
+        });
+    }
+    async stopRecording(params) {
+        if (params.userConfirmed !== true) {
+            throw new Error("stop_recording requires explicit user confirmation before execution");
+        }
+        return this.request("/api/recording/stop", { method: "POST" });
+    }
+    async getRecordingStatus(requestOptions) {
+        return this.request("/api/recording/status", undefined, requestOptions);
+    }
+    // ===== 配置 =====
+    async getOutputPath() {
+        return this.request("/api/config/output-path");
+    }
+    async setOutputPath(outputPath) {
+        await this.request("/api/config/output-path", {
+            method: "POST",
+            body: JSON.stringify({ path: outputPath }),
+        });
+    }
+    async getAudioFormat() {
+        return this.request("/api/config/format");
+    }
+    async setAudioFormat(format) {
+        await this.request("/api/config/format", {
+            method: "POST",
+            body: JSON.stringify(format),
+        });
+    }
+    async getSettings() {
+        const data = await this.request("/api/settings");
+        if (!data?.settings || typeof data.settings !== "object") {
+            throw new Error("Backend returned an invalid settings payload");
+        }
+        return data.settings;
+    }
+    async updateSettings(settings) {
+        const currentSettings = await this.getSettings();
+        const mergedSettings = {
+            ...currentSettings,
+            ...settings,
+        };
+        if (mergedSettings.audioFormat !== "wav" && mergedSettings.audioFormat !== "caf") {
+            throw new Error("Settings update requires a valid audioFormat value");
+        }
+        if (typeof mergedSettings.showLevelMeterDuringRecording !== "boolean") {
+            throw new Error("Settings update requires showLevelMeterDuringRecording to be a boolean");
+        }
+        await this.request("/api/settings", {
+            method: "POST",
+            body: JSON.stringify(mergedSettings),
+        });
+        return mergedSettings;
+    }
+    // ===== 监听/DSP =====
+    async getMonitorStatus() {
+        const data = await this.request("/api/monitor/status");
+        return data.status;
+    }
+    async startMonitor(params) {
+        const inputDeviceId = parseInt(params.inputDeviceId, 10) || 0;
+        const outputDeviceId = parseInt(params.outputDeviceId, 10) || 0;
+        await this.request("/api/monitor/start", {
+            method: "POST",
+            body: JSON.stringify({
+                inputDeviceId,
+                outputDeviceId,
+                ...(typeof params.outputLeftChannel === "number" ? { outputLeftChannel: params.outputLeftChannel } : {}),
+                ...(typeof params.outputRightChannel === "number" ? { outputRightChannel: params.outputRightChannel } : {}),
+                ...(typeof params.bufferSize === "number" ? { bufferSize: params.bufferSize } : {}),
+            }),
+        });
+    }
+    async stopMonitor() {
+        await this.request("/api/monitor/stop", { method: "POST" });
+    }
+    async setMasterVolume(volume, pan) {
+        await this.request("/api/monitor/master", {
+            method: "POST",
+            body: JSON.stringify(pan !== undefined ? { volume, pan } : { volume }),
+        });
+    }
+    async getMixLevels() {
+        return this.request("/api/monitor/mix-levels");
+    }
+    async setChannelVolume(index, volume) {
+        const channelId = this.toMonitorChannelId(index);
+        await this.request(`/api/monitor/channel/${channelId}/volume`, {
+            method: "POST",
+            body: JSON.stringify({ volume }),
+        });
+    }
+    async setChannelPan(index, pan) {
+        const channelId = this.toMonitorChannelId(index);
+        await this.request(`/api/monitor/channel/${channelId}/pan`, {
+            method: "POST",
+            body: JSON.stringify({ pan }),
+        });
+    }
+    async setChannelSolo(index, solo) {
+        const channelId = this.toMonitorChannelId(index);
+        await this.request(`/api/monitor/channel/${channelId}/solo`, {
+            method: "POST",
+            body: JSON.stringify({ solo }),
+        });
+    }
+    async setChannelMute(index, mute) {
+        const channelId = this.toMonitorChannelId(index);
+        await this.request(`/api/monitor/channel/${channelId}/mute`, {
+            method: "POST",
+            body: JSON.stringify({ mute }),
+        });
+    }
+    async setChannelMsProcess(index, enabled) {
+        const channelId = this.toMonitorChannelId(index);
+        await this.request(`/api/monitor/channel/${channelId}/ms-process`, {
+            method: "POST",
+            body: JSON.stringify({ enabled }),
+        });
+    }
+    async setChannelPhaseInvert(index, inverted) {
+        const channelId = this.toMonitorChannelId(index);
+        await this.request(`/api/monitor/channel/${channelId}/phase-invert`, {
+            method: "POST",
+            body: JSON.stringify({ inverted }),
+        });
+    }
+    async mergeChannelsStereo(leftIndex, rightIndex) {
+        await this.setChannelPan(leftIndex, -1.0);
+        await this.setChannelPan(rightIndex, 1.0);
+    }
+    async splitStereoChannel(leftIndex, rightIndex) {
+        await this.setChannelPan(leftIndex, 0.0);
+        await this.setChannelPan(rightIndex, 0.0);
+        await this.setChannelMsProcess(leftIndex, false);
+    }
+    // ===== 轨道与标记 =====
+    async listTracks(requestOptions) {
+        return this.request("/api/tracks/available", undefined, requestOptions);
+    }
+    async stopTrack(trackId) {
+        await this.request(`/api/tracks/${trackId}/stop`, { method: "POST" });
+    }
+    async listMarkers(requestOptions) {
+        const data = await this.request("/api/markers", undefined, requestOptions);
+        return data?.markers || [];
+    }
+    async addMarker(label) {
+        const created = await this.request("/api/markers/add", {
+            method: "POST",
+        });
+        if (created.success !== true || !Number.isInteger(created.id) || typeof created.timestamp !== "number") {
+            throw new Error("Backend returned an invalid marker payload");
+        }
+        const markerId = created.id;
+        const markerTimestamp = created.timestamp;
+        const normalizedLabel = label?.trim();
+        if (normalizedLabel) {
+            await this.renameMarker(String(markerId), normalizedLabel);
+        }
+        return {
+            success: true,
+            id: markerId,
+            timestamp: markerTimestamp,
+            label: normalizedLabel || created.label || `Marker ${markerId}`,
+            time: created.time,
+        };
+    }
+    async syncMarkers(markers) {
+        await this.request("/api/markers/sync", {
+            method: "POST",
+            body: JSON.stringify({ markers }),
+        });
+    }
+    async renameMarker(id, name) {
+        await this.request(`/api/markers/${id}/rename`, {
+            method: "POST",
+            body: JSON.stringify({ name }),
+        });
+    }
+    async renameChannel(id, name) {
+        await this.request(`/api/channels/${id}/rename`, {
+            method: "POST",
+            body: JSON.stringify({ name }),
+        });
+    }
+    async setChannelColor(id, color) {
+        await this.request(`/api/channels/${id}/color`, {
+            method: "POST",
+            body: JSON.stringify({ color }),
+        });
+    }
+    // ===== 存储 =====
+    async listVolumes() {
+        const data = await this.request("/api/storage/volumes");
+        return Array.isArray(data?.volumes) ? data.volumes : [];
+    }
+    async listExternalDrives() {
+        const data = await this.request("/api/storage/external");
+        return Array.isArray(data?.volumes) ? data.volumes : [];
+    }
+    async validateStoragePath(storagePath) {
+        return this.request("/api/storage/validate", {
+            method: "POST",
+            body: JSON.stringify({ path: storagePath }),
+        });
+    }
+    async lockStorage(uuid) {
+        await this.request("/api/storage/lock", {
+            method: "POST",
+            body: JSON.stringify({ uuid }),
+        });
+    }
+    async unlockStorage() {
+        await this.request("/api/storage/unlock", { method: "POST" });
+    }
+    // ===== 系统 =====
+    async getUIState(requestOptions) {
+        return this.request("/api/ui/state", undefined, requestOptions);
+    }
+    async setUIState(page, pageStep) {
+        await this.request("/api/ui/state", {
+            method: "POST",
+            body: JSON.stringify({ page, pageStep }),
+        });
+    }
+    // ===== MCP 分场景查询 =====
+    async getMcpChannels(requestOptions) {
+        return this.request("/api/mcp/channels", undefined, requestOptions);
+    }
+    async getMcpMix(requestOptions) {
+        return this.request("/api/mcp/mix", undefined, requestOptions);
+    }
+    async getMcpHealth(requestOptions) {
+        return this.request("/api/mcp/health", undefined, requestOptions);
+    }
+    async getMcpStatus(requestOptions) {
+        return this.request("/api/mcp/status", undefined, requestOptions);
+    }
+    async getSystemInfo() {
+        return this.request("/api/system/info");
+    }
+    async getDiskSpace() {
+        return this.request("/api/system/disk-space");
+    }
+    async checkDiskHealth(params) {
+        const body = params && (params.path || params.deviceId)
+            ? JSON.stringify({
+                ...(params.path ? { path: params.path } : {}),
+                ...(params.deviceId ? { deviceId: parseInt(params.deviceId, 10) || 0 } : {}),
+            })
+            : undefined;
+        return this.request("/api/system/disk-health", { method: "POST", body });
+    }
+    async checkUpdates() {
+        return this.request("/api/system/update");
+    }
+    async getUpdateBadge() {
+        return this.request("/api/system/update-badge");
+    }
+    async installUpdate() {
+        await this.request("/api/system/install-update", { method: "POST" });
+    }
+    async getDownloadProgress() {
+        return this.request("/api/system/download-progress");
+    }
+    // ===== 激活 =====
+    async activateLicense(code) {
+        return this.request("/api/activation/activate", {
+            method: "POST",
+            body: JSON.stringify({ code }),
+        });
+    }
+    async getActivationStatus() {
+        return this.request("/api/activation/status");
+    }
+    async setActivation(data) {
+        try {
+            await this.request("/api/activation/set", {
+                method: "POST",
+                body: JSON.stringify(data),
+            });
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.statusCode === 404) {
+                throw new Error("set_activation is only available on debug backends with RECORD_SAFER_ENABLE_DEBUG_ACTIVATION_API=1.");
+            }
+            throw error;
+        }
+    }
+    async restoreLicense() {
+        return this.request("/api/activation/restore", { method: "POST" });
+    }
+    // ===== 工具 =====
+    async startSplit(params) {
+        return this.request("/api/tools/split", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    async getSplitProgress() {
+        return this.request("/api/tools/split/progress");
+    }
+    async cancelSplit() {
+        await this.request("/api/tools/split/cancel", { method: "POST" });
+    }
+    // ===== 系统控制 =====
+    async sendTelemetry(data) {
+        await this.request("/api/telemetry/recording-start", {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }
+    async shutdown() {
+        await this.request("/api/shutdown", { method: "POST" });
+    }
+}
+//# sourceMappingURL=api-client.js.map