feishu-codex-console 1.0.0-beta.6

package/dist/project-registry.js

@@ -0,0 +1,259 @@
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+const SKIP_DIRECTORIES = new Set([
+    ".git",
+    ".idea",
+    ".vscode",
+    ".codex",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "vendor",
+]);
+export class ProjectRegistry {
+    roots;
+    defaultWorkdir;
+    maxDepth;
+    maxProjects;
+    codexStateFile;
+    discovered = [];
+    canonicalRoots = [];
+    canonicalDefaultWorkdir;
+    canonicalHome = homedir();
+    constructor(roots, defaultWorkdir, maxDepth, maxProjects, codexStateFile) {
+        this.roots = roots;
+        this.defaultWorkdir = defaultWorkdir;
+        this.maxDepth = maxDepth;
+        this.maxProjects = maxProjects;
+        this.codexStateFile = codexStateFile;
+        this.canonicalDefaultWorkdir = defaultWorkdir;
+    }
+    async refresh() {
+        const projects = new Map();
+        try {
+            this.canonicalHome = await realpath(homedir());
+        }
+        catch {
+            this.canonicalHome = homedir();
+        }
+        if (this.codexStateFile) {
+            const savedProjects = await this.readCodexSavedProjects();
+            for (const saved of savedProjects) {
+                const project = await this.projectFromPath(saved.path, saved.name, "codex", false);
+                if (project && !projects.has(project.path))
+                    projects.set(project.path, project);
+            }
+        }
+        const scannedPaths = new Set();
+        this.canonicalRoots = [];
+        for (const root of this.roots) {
+            let canonicalRoot;
+            try {
+                canonicalRoot = await realpath(root);
+            }
+            catch {
+                continue;
+            }
+            this.canonicalRoots.push(canonicalRoot);
+            await this.scan(canonicalRoot, canonicalRoot, 0, scannedPaths);
+            if (scannedPaths.size >= this.maxProjects)
+                break;
+        }
+        for (const projectPath of [...scannedPaths].sort((left, right) => left.localeCompare(right))) {
+            const project = await this.projectFromPath(projectPath, undefined, "scan", true);
+            if (project && !projects.has(project.path))
+                projects.set(project.path, project);
+        }
+        const defaultProject = await this.projectFromPath(this.defaultWorkdir, undefined, "default", false);
+        if (!defaultProject) {
+            throw new Error(`Default Codex project is unavailable: ${this.defaultWorkdir}`);
+        }
+        this.canonicalDefaultWorkdir = defaultProject.path;
+        if (!projects.has(defaultProject.path))
+            projects.set(defaultProject.path, defaultProject);
+        const limited = [...projects.values()].slice(0, this.maxProjects);
+        if (!limited.some((project) => project.path === defaultProject.path)) {
+            limited[Math.max(0, limited.length - 1)] = defaultProject;
+        }
+        this.discovered = limited;
+        return limited;
+    }
+    list() {
+        return this.discovered;
+    }
+    defaultProject() {
+        return (this.getByPath(this.canonicalDefaultWorkdir) ?? {
+            name: path.basename(this.canonicalDefaultWorkdir),
+            path: this.canonicalDefaultWorkdir,
+            displayPath: this.displayPath(this.canonicalDefaultWorkdir),
+            isGitRepository: false,
+            source: "default",
+        });
+    }
+    getByPath(projectPath) {
+        return this.discovered.find((project) => project.path === projectPath);
+    }
+    resolve(selector) {
+        const query = selector.trim();
+        if (!query)
+            return { status: "missing" };
+        if (/^\d+$/.test(query)) {
+            const index = Number.parseInt(query, 10) - 1;
+            const project = this.discovered[index];
+            return project ? { status: "found", project } : { status: "missing" };
+        }
+        const normalized = query.toLocaleLowerCase();
+        const exact = this.discovered.filter((project) => project.name.toLocaleLowerCase() === normalized ||
+            project.displayPath.toLocaleLowerCase() === normalized ||
+            project.path.toLocaleLowerCase() === normalized);
+        if (exact.length === 1 && exact[0])
+            return { status: "found", project: exact[0] };
+        if (exact.length > 1)
+            return { status: "ambiguous", projects: exact };
+        const fuzzy = this.discovered.filter((project) => project.name.toLocaleLowerCase().includes(normalized) ||
+            project.displayPath.toLocaleLowerCase().includes(normalized));
+        if (fuzzy.length === 1 && fuzzy[0])
+            return { status: "found", project: fuzzy[0] };
+        if (fuzzy.length > 1)
+            return { status: "ambiguous", projects: fuzzy };
+        return { status: "missing" };
+    }
+    async scan(root, directory, depth, projects) {
+        if (projects.size >= this.maxProjects || depth > this.maxDepth)
+            return;
+        let canonical;
+        try {
+            canonical = await realpath(directory);
+        }
+        catch {
+            return;
+        }
+        if (!isWithin(root, canonical))
+            return;
+        // Additional roots are discovery-only, so arbitrary non-Git directories
+        // under them never become selectable. Non-Git folders are accepted only
+        // when they are exact projects explicitly saved in Codex (or the default).
+        if (await isGitRepository(canonical)) {
+            projects.add(canonical);
+            return;
+        }
+        let entries;
+        try {
+            entries = await readdir(canonical, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink() || SKIP_DIRECTORIES.has(entry.name)) {
+                continue;
+            }
+            await this.scan(root, path.join(canonical, entry.name), depth + 1, projects);
+            if (projects.size >= this.maxProjects)
+                return;
+        }
+    }
+    displayPath(projectPath) {
+        for (const root of this.canonicalRoots) {
+            if (!isWithin(root, projectPath))
+                continue;
+            const relative = path.relative(root, projectPath);
+            return relative || path.basename(projectPath);
+        }
+        if (isWithin(this.canonicalHome, projectPath)) {
+            const relative = path.relative(this.canonicalHome, projectPath);
+            return relative ? `~/${relative}` : "~";
+        }
+        return projectPath;
+    }
+    async projectFromPath(projectPath, name, source, requireGit) {
+        let canonical;
+        try {
+            canonical = await realpath(projectPath);
+            const stats = await lstat(canonical);
+            if (!stats.isDirectory())
+                return null;
+        }
+        catch {
+            return null;
+        }
+        if (source === "codex" && isBroadDirectory(canonical, this.canonicalHome)) {
+            console.warn("[projects] ignored an overly broad Codex project entry");
+            return null;
+        }
+        const git = await isGitRepository(canonical);
+        if (requireGit && !git)
+            return null;
+        return {
+            name: name?.trim() || path.basename(canonical),
+            path: canonical,
+            displayPath: this.displayPath(canonical),
+            isGitRepository: git,
+            source,
+        };
+    }
+    async readCodexSavedProjects() {
+        if (!this.codexStateFile)
+            return [];
+        try {
+            const parsed = JSON.parse(await readFile(this.codexStateFile, "utf8"));
+            if (!isRecord(parsed))
+                return [];
+            const saved = stringArray(parsed["electron-saved-workspace-roots"]);
+            const order = stringArray(parsed["project-order"]);
+            const labels = isRecord(parsed["electron-workspace-root-labels"])
+                ? parsed["electron-workspace-root-labels"]
+                : {};
+            const savedSet = new Set(saved);
+            const ordered = [
+                ...saved.filter((projectPath) => !order.includes(projectPath)),
+                ...order.filter((projectPath) => savedSet.has(projectPath)),
+            ];
+            const seen = new Set();
+            return ordered.flatMap((projectPath) => {
+                if (seen.has(projectPath))
+                    return [];
+                seen.add(projectPath);
+                const label = labels[projectPath];
+                return [
+                    {
+                        path: projectPath,
+                        ...(typeof label === "string" && label.trim() ? { name: label.trim() } : {}),
+                    },
+                ];
+            });
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                console.warn(`[projects] unable to read Codex saved projects: ${error.message}`);
+            }
+            return [];
+        }
+    }
+}
+async function isGitRepository(directory) {
+    try {
+        await lstat(path.join(directory, ".git"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.trim() !== "");
+}
+function isBroadDirectory(candidate, home) {
+    return candidate === path.parse(candidate).root || candidate === home;
+}

package/dist/project-status.js

@@ -0,0 +1,45 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function readProjectGitStatus(projectPath, run = runGitStatus) {
+    try {
+        return parseGitStatus(await run(projectPath));
+    }
+    catch {
+        return null;
+    }
+}
+export function parseGitStatus(output) {
+    const lines = output.split(/\r?\n/).filter(Boolean);
+    const header = lines[0]?.startsWith("## ") ? lines[0].slice(3) : "HEAD (unknown)";
+    const branchPart = (header.split("...")[0] ?? header).trim();
+    const branch = branchPart.replace(/^No commits yet on\s+/i, "").trim() || "HEAD";
+    const detached = /^HEAD(?:\s|$|\()/i.test(branch);
+    const ahead = numberFrom(header, /ahead\s+(\d+)/i);
+    const behind = numberFrom(header, /behind\s+(\d+)/i);
+    const changedFiles = lines[0]?.startsWith("## ") ? Math.max(0, lines.length - 1) : lines.length;
+    return {
+        branch,
+        detached,
+        dirty: changedFiles > 0,
+        changedFiles,
+        ahead,
+        behind,
+    };
+}
+async function runGitStatus(projectPath) {
+    const { stdout } = await execFileAsync("git", ["-C", projectPath, "status", "--short", "--branch", "--untracked-files=normal"], {
+        timeout: 3_000,
+        maxBuffer: 512 * 1024,
+        env: {
+            ...process.env,
+            GIT_OPTIONAL_LOCKS: "0",
+            GIT_TERMINAL_PROMPT: "0",
+        },
+    });
+    return stdout;
+}
+function numberFrom(value, pattern) {
+    const match = value.match(pattern);
+    return match?.[1] ? Number.parseInt(match[1], 10) : 0;
+}

package/dist/project-workspace.js

@@ -0,0 +1,55 @@
+export function rankProjectWorkspace(projects, usage, recentLimit = 8) {
+    const visiblePaths = new Set(projects.map((project) => project.path));
+    const usageByPath = new Map(usage
+        .filter((entry) => visiblePaths.has(entry.projectPath))
+        .map((entry) => [entry.projectPath, entry]));
+    const favoritePaths = usage
+        .filter((entry) => entry.favorite && visiblePaths.has(entry.projectPath))
+        .sort(compareUsage)
+        .map((entry) => entry.projectPath);
+    const recentPaths = usage
+        .filter((entry) => entry.lastUsedAt && visiblePaths.has(entry.projectPath))
+        .sort(compareUsage)
+        .slice(0, recentLimit)
+        .map((entry) => entry.projectPath);
+    const projectsSorted = [...projects].sort((left, right) => {
+        const leftUsage = usageByPath.get(left.path);
+        const rightUsage = usageByPath.get(right.path);
+        const favoriteDifference = Number(rightUsage?.favorite ?? false) - Number(leftUsage?.favorite ?? false);
+        if (favoriteDifference !== 0)
+            return favoriteDifference;
+        const recencyDifference = (rightUsage?.lastUsedAt ?? "").localeCompare(leftUsage?.lastUsedAt ?? "");
+        if (recencyDifference !== 0)
+            return recencyDifference;
+        const nameDifference = left.name.localeCompare(right.name);
+        return nameDifference !== 0 ? nameDifference : left.path.localeCompare(right.path);
+    });
+    return { projects: projectsSorted, favoritePaths, recentPaths };
+}
+export function resolveProjectSelector(projects, selector) {
+    const query = selector.trim();
+    if (!query)
+        return { status: "missing" };
+    if (/^\d+$/.test(query)) {
+        const project = projects[Number.parseInt(query, 10) - 1];
+        return project ? { status: "found", project } : { status: "missing" };
+    }
+    const normalized = query.toLocaleLowerCase();
+    const exact = projects.filter((project) => project.name.toLocaleLowerCase() === normalized ||
+        project.displayPath.toLocaleLowerCase() === normalized ||
+        project.path.toLocaleLowerCase() === normalized);
+    if (exact.length === 1 && exact[0])
+        return { status: "found", project: exact[0] };
+    if (exact.length > 1)
+        return { status: "ambiguous", projects: exact };
+    const fuzzy = projects.filter((project) => project.name.toLocaleLowerCase().includes(normalized) ||
+        project.displayPath.toLocaleLowerCase().includes(normalized));
+    if (fuzzy.length === 1 && fuzzy[0])
+        return { status: "found", project: fuzzy[0] };
+    if (fuzzy.length > 1)
+        return { status: "ambiguous", projects: fuzzy };
+    return { status: "missing" };
+}
+function compareUsage(left, right) {
+    return (right.lastUsedAt ?? "").localeCompare(left.lastUsedAt ?? "");
+}

package/dist/quota-card.js

@@ -0,0 +1,94 @@
+import { renderAccountQuotaPanel } from "./account-quota-card.js";
+export function renderQuotaCard(snapshot) {
+    return {
+        schema: "2.0",
+        config: {
+            update_multi: true,
+            width_mode: "default",
+            enable_forward: false,
+            summary: { content: `Codex 账户额度 · ${safe(snapshot.deviceName)}` },
+        },
+        header: {
+            title: { tag: "plain_text", content: "Codex 账户额度" },
+            subtitle: { tag: "plain_text", content: safe(snapshot.deviceName) },
+            template: snapshot.quota.status === "available" ? "turquoise" : "grey",
+            icon: { tag: "standard_icon", token: "myai_colorful" },
+            text_tag_list: [
+                {
+                    tag: "text_tag",
+                    text: {
+                        tag: "plain_text",
+                        content: snapshot.quota.status === "available" ? "实时读取" : "暂不可用",
+                    },
+                    color: snapshot.quota.status === "available" ? "green" : "neutral",
+                },
+            ],
+        },
+        body: {
+            direction: "vertical",
+            padding: "12px 12px 18px 12px",
+            vertical_spacing: "12px",
+            elements: [
+                ...(snapshot.feedback
+                    ? [
+                        {
+                            tag: "markdown",
+                            element_id: "quota_feedback",
+                            text_size: "notation",
+                            content: `<font color='blue'>${safe(snapshot.feedback)}</font>`,
+                        },
+                    ]
+                    : []),
+                renderAccountQuotaPanel(snapshot.quota, "qq"),
+                {
+                    tag: "column_set",
+                    element_id: "quota_actions",
+                    flex_mode: "none",
+                    horizontal_spacing: "8px",
+                    columns: [
+                        actionColumn("quota_refresh_btn", "刷新额度", "primary_filled", "quota_refresh"),
+                        actionColumn("quota_device_btn", "返回控制台", "default", "quota_device"),
+                    ],
+                },
+                {
+                    tag: "markdown",
+                    element_id: "quota_note",
+                    text_size: "notation",
+                    text_align: "center",
+                    content: "<font color='grey'>数据来自这台设备当前登录的 Codex 账户；不同模型可能使用独立额度窗口。</font>",
+                },
+            ],
+        },
+    };
+}
+function actionColumn(elementId, label, type, action) {
+    return {
+        tag: "column",
+        width: "weighted",
+        weight: 1,
+        elements: [
+            {
+                tag: "button",
+                element_id: elementId,
+                text: { tag: "plain_text", content: label },
+                type,
+                width: "fill",
+                behaviors: [
+                    {
+                        type: "callback",
+                        value: { bridge: "feishu-codex-v4", action },
+                    },
+                ],
+            },
+        ],
+    };
+}
+function safe(value) {
+    return value
+        .replaceAll("&", "＆")
+        .replaceAll("<", "＜")
+        .replaceAll(">", "＞")
+        .replaceAll("*", "＊")
+        .replaceAll("_", "＿")
+        .replaceAll("`", "｀");
+}

package/dist/recovery-policy.js

@@ -0,0 +1,26 @@
+export function assessBridgeRecovery(previous, { currentPid, now = Date.now(), processAlive, liveHeartbeatMs = 45_000, notifyAfterMs = 30_000, }) {
+    if (!previous) {
+        return { blockDuplicate: false, unexpected: false, offlineForMs: 0, notify: false };
+    }
+    const heartbeat = Date.parse(previous.updatedAt);
+    const offlineForMs = Number.isFinite(heartbeat) ? Math.max(0, now - heartbeat) : 0;
+    const validPid = Number.isSafeInteger(previous.pid) && previous.pid > 0;
+    const blockDuplicate = Boolean(validPid &&
+        previous.pid !== currentPid &&
+        offlineForMs < liveHeartbeatMs &&
+        processAlive(previous.pid));
+    const unexpected = !blockDuplicate && ["ready", "degraded", "failed"].includes(previous.status);
+    return {
+        blockDuplicate,
+        unexpected,
+        offlineForMs,
+        notify: unexpected && offlineForMs >= notifyAfterMs,
+        previousHeartbeatAt: previous.updatedAt,
+    };
+}
+export function shouldSendRecoveryNotice(lastNotice, now = Date.now(), minimumIntervalMs = 15 * 60_000) {
+    if (!lastNotice)
+        return true;
+    const previous = Date.parse(lastNotice);
+    return !Number.isFinite(previous) || now - previous >= minimumIntervalMs;
+}

package/dist/redaction.js

@@ -0,0 +1,67 @@
+import path from "node:path";
+const SECRET_NAME = "(?:app|client)[_-]?secret|access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|password|passwd|private[_-]?key|authorization|cookie|session[_-]?(?:id|token|secret)|webhook[_-]?url";
+export function redactSensitiveText(value, maxChars = Number.POSITIVE_INFINITY) {
+    const redacted = value
+        .replace(/-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g, "[REDACTED PRIVATE KEY]")
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer [REDACTED]")
+        .replace(/\bBasic\s+[A-Za-z0-9+/=]{8,}/gi, "Basic [REDACTED]")
+        .replace(/\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|sk-[A-Za-z0-9_-]{20,}|xox[baprs]-[A-Za-z0-9-]{12,})\b/g, "[REDACTED TOKEN]")
+        .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, "[REDACTED JWT]")
+        .replace(new RegExp(`((?:"?(?:${SECRET_NAME})"?)\\s*[:=]\\s*)(?:"[^"]*"|'[^']*'|[^\\s,;]+)`, "gi"), "$1[REDACTED]")
+        .replace(/\b(https?:\/\/)([^\s/:@]+):([^\s/@]+)@/gi, "$1[REDACTED]:[REDACTED]@");
+    return redacted.slice(0, Math.max(0, maxChars));
+}
+export function prepareRemoteMarkdown(value, maxChars = Number.POSITIVE_INFINITY) {
+    const redacted = redactSensitiveText(value);
+    const withoutLocalLinks = redacted.replace(/\[([^\]\r\n]+)\]\(\s*<?(?:(?:file|vscode):\/{2,}|\/(?:Users|home|private|var|tmp)\/|~\/|[A-Za-z]:[\\/])[^)\r\n>]*>?\s*\)/g, (_match, label) => `\`${label.replaceAll("`", "")}\``);
+    return withoutLocalLinks.slice(0, Math.max(0, maxChars));
+}
+export function redactDiagnosticText(value, options = {}) {
+    let redacted = redactSensitiveText(value);
+    if (options.homeDirectory) {
+        const home = path.resolve(options.homeDirectory);
+        redacted = redacted.split(home).join("~");
+    }
+    return redacted.slice(0, options.maxChars ?? Number.POSITIVE_INFINITY);
+}
+export function safeErrorText(error, maxChars = 2_000) {
+    const message = error instanceof Error ? error.message : String(error);
+    return redactSensitiveText(message.replace(/[\r\n]+/g, " "), maxChars);
+}
+let consoleRedactionInstalled = false;
+export function installConsoleRedaction(target = console) {
+    if (consoleRedactionInstalled)
+        return;
+    consoleRedactionInstalled = true;
+    for (const level of ["debug", "info", "warn", "error"]) {
+        const original = target[level].bind(target);
+        target[level] = ((...args) => {
+            original(...args.map((value) => redactLogValue(value)));
+        });
+    }
+}
+function redactLogValue(value, seen = new WeakSet()) {
+    if (typeof value === "string")
+        return redactSensitiveText(value, 8_000);
+    if (value instanceof Error) {
+        const stack = value.stack ? redactSensitiveText(value.stack, 8_000) : "";
+        return stack || `${value.name}: ${safeErrorText(value)}`;
+    }
+    if (Buffer.isBuffer(value))
+        return `[Buffer ${value.length} bytes]`;
+    if (typeof value === "object" && value !== null) {
+        if (seen.has(value))
+            return "[Circular]";
+        seen.add(value);
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, 50).map((entry) => redactLogValue(entry, seen));
+    }
+    if (typeof value === "object" && value !== null) {
+        const entries = Object.entries(value)
+            .slice(0, 50)
+            .map(([key, entry]) => [key, redactLogValue(entry, seen)]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}

package/dist/remote-ready.js

@@ -0,0 +1,112 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export class RemoteReadyController {
+    child = null;
+    enabled = false;
+    lastError;
+    get supported() {
+        return process.platform === "darwin";
+    }
+    async setEnabled(enabled) {
+        this.enabled = enabled;
+        if (!enabled) {
+            this.stopAssertion();
+            return this.getStatus();
+        }
+        if (!this.supported) {
+            this.lastError = "Remote Ready 当前仅支持 macOS caffeinate";
+            return this.getStatus();
+        }
+        if (this.child && this.child.exitCode === null && !this.child.killed)
+            return this.getStatus();
+        await new Promise((resolve, reject) => {
+            const child = execCaffeinate();
+            this.child = child;
+            const onError = (error) => {
+                if (this.child === child)
+                    this.child = null;
+                this.lastError = error.message;
+                reject(error);
+            };
+            child.once("error", onError);
+            child.once("spawn", () => {
+                child.off("error", onError);
+                delete this.lastError;
+                resolve();
+            });
+            child.once("exit", (code, signal) => {
+                if (this.child !== child)
+                    return;
+                this.child = null;
+                if (this.enabled && code !== 0) {
+                    this.lastError = `caffeinate 已退出（${signal ?? code ?? "unknown"}）`;
+                }
+            });
+        });
+        return this.getStatus();
+    }
+    getStatus() {
+        const active = Boolean(this.child && this.child.exitCode === null && !this.child.killed);
+        return {
+            supported: this.supported,
+            enabled: this.enabled,
+            active,
+            ...(active && this.child?.pid !== undefined ? { pid: this.child.pid } : {}),
+            ...(this.lastError ? { lastError: this.lastError } : {}),
+        };
+    }
+    close() {
+        this.enabled = false;
+        this.stopAssertion();
+    }
+    stopAssertion() {
+        const child = this.child;
+        this.child = null;
+        if (child && child.exitCode === null && !child.killed)
+            child.kill("SIGTERM");
+    }
+}
+export async function readPowerStatus() {
+    if (process.platform !== "darwin") {
+        return { source: "unknown", label: "电源状态不可用" };
+    }
+    try {
+        const { stdout } = await execFileAsync("/usr/bin/pmset", ["-g", "batt"], {
+            timeout: 3_000,
+        });
+        return parsePowerStatus(stdout);
+    }
+    catch {
+        return { source: "unknown", label: "电源状态不可用" };
+    }
+}
+export function parsePowerStatus(output) {
+    const source = /AC Power/i.test(output)
+        ? "ac"
+        : /Battery Power/i.test(output)
+            ? "battery"
+            : "unknown";
+    const percentMatch = output.match(/(\d{1,3})%/);
+    const rawPercent = percentMatch?.[1]
+        ? Number.parseInt(percentMatch[1], 10)
+        : undefined;
+    const percent = rawPercent !== undefined
+        ? Math.max(0, Math.min(100, rawPercent))
+        : undefined;
+    return {
+        source,
+        ...(percent !== undefined ? { percent } : {}),
+        label: source === "ac"
+            ? `外接电源${percent !== undefined ? ` · ${percent}%` : ""}`
+            : source === "battery"
+                ? `电池供电${percent !== undefined ? ` · ${percent}%` : ""}`
+                : "电源状态未知",
+    };
+}
+function execCaffeinate() {
+    return spawn("/usr/bin/caffeinate", ["-i", "-w", String(process.pid)], {
+        shell: false,
+        stdio: "ignore",
+    });
+}