team-anya-cli 0.1.0

package/apps/server/dist/broker/cc-broker.js

@@ -0,0 +1,257 @@
+import { EventEmitter } from 'node:events';
+import { ClaudeCodeBackend } from '@team-anya/cc-client';
+import { ConnectionState, ScopeChecker, } from '@team-anya/core';
+// ── CCBroker ──
+/**
+ * CCBroker：统一 CC 进程管理器
+ *
+ * 管理所有 ClaudeCodeBackend 实例（Loid + Yor），提供：
+ * - 生命周期管理（spawn / dispose / shutdown）
+ * - 消息路由（sendPrompt）
+ * - 事件通知（result / crash / progress）
+ * - 并发控制（按角色分开限制）
+ */
+export class CCBroker extends EventEmitter {
+    instances = new Map();
+    maxLoidInstances;
+    maxYorInstances;
+    logger;
+    shuttingDown = false;
+    constructor(config) {
+        super();
+        this.maxLoidInstances = config.maxLoidInstances;
+        this.maxYorInstances = config.maxYorInstances;
+        this.logger = config.logger ?? { info: console.log, error: console.error };
+    }
+    // ── 生命周期 ──
+    /**
+     * 启动一个新的 CC 实例
+     */
+    async spawn(options) {
+        if (this.shuttingDown) {
+            throw new Error('CCBroker 正在关闭，无法 spawn 新实例');
+        }
+        // 并发检查
+        const currentCount = this.countByRole(options.role);
+        const maxCount = options.role === 'loid' ? this.maxLoidInstances : this.maxYorInstances;
+        if (currentCount >= maxCount) {
+            throw new Error(`${options.role} 实例已满（${currentCount}/${maxCount}）`);
+        }
+        // 重复 ID 检查
+        if (this.instances.has(options.id)) {
+            throw new Error(`实例 ${options.id} 已存在`);
+        }
+        const backend = new ClaudeCodeBackend({
+            logFile: options.logFile,
+        });
+        const instance = {
+            id: options.id,
+            role: options.role,
+            backend,
+            state: 'connecting',
+            config: options.backendConfig,
+            mcpServer: options.mcpServer,
+            taskId: options.taskId,
+            createdAt: new Date(),
+            lastActivityAt: new Date(),
+        };
+        // 注册 Scope 检查器（Yor 实例）
+        if (options.scope) {
+            instance.scopeChecker = new ScopeChecker(options.scope);
+            backend.onToolRequest(instance.scopeChecker.createHandler());
+        }
+        // 注册 session ID 回调
+        backend.onSessionId((sessionId) => {
+            instance.cliSessionId = sessionId;
+            this.emit('instance.sessionId', instance.id, sessionId);
+        });
+        // 注册事件回调
+        backend.onResult((result) => {
+            instance.lastActivityAt = new Date();
+            instance.state = 'idle';
+            this.emit('instance.result', instance.id, instance.role, result);
+        });
+        backend.onProgress((event) => {
+            instance.lastActivityAt = new Date();
+            this.emit('instance.progress', instance.id, event);
+        });
+        backend.onStateChange((connState) => {
+            if (connState === ConnectionState.CONNECTED) {
+                if (instance.state === 'connecting') {
+                    instance.state = 'connected';
+                }
+            }
+            else if (connState === ConnectionState.EXECUTING) {
+                instance.state = 'executing';
+            }
+            else if (connState === ConnectionState.ERROR || connState === ConnectionState.DISCONNECTED) {
+                if (instance.state !== 'disposed' && instance.state !== 'connecting') {
+                    instance.state = 'error';
+                    this.emit('instance.crash', instance.id, instance.role, new Error(`CC 实例 ${instance.id} 连接断开 (state=${connState})`));
+                }
+            }
+        });
+        // 存入 Map 后连接（这样事件回调生效）
+        this.instances.set(options.id, instance);
+        try {
+            await backend.connect(options.backendConfig);
+            instance.state = 'connected';
+            this.logger.info(`[CCBroker] 实例 ${options.id} (${options.role}) 已连接`);
+            return instance;
+        }
+        catch (err) {
+            // 连接失败，清理
+            this.instances.delete(options.id);
+            if (options.mcpServer) {
+                await options.mcpServer.close().catch(() => { });
+            }
+            throw err;
+        }
+    }
+    /**
+     * 向指定实例注入 prompt
+     */
+    sendPrompt(instanceId, prompt) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            throw new Error(`实例 ${instanceId} 不存在`);
+        }
+        if (instance.state === 'disposed') {
+            throw new Error(`实例 ${instanceId} 已释放`);
+        }
+        instance.lastActivityAt = new Date();
+        instance.state = 'executing';
+        // sendPrompt 是异步的但不需要等待
+        instance.backend.sendPrompt(prompt).catch((err) => {
+            this.logger.error(`[CCBroker] sendPrompt 失败 (${instanceId}):`, err);
+        });
+    }
+    /**
+     * 注册工具请求拦截器（可用于外部 scope 检查或自定义逻辑）
+     */
+    onToolRequest(instanceId, handler) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            throw new Error(`实例 ${instanceId} 不存在`);
+        }
+        instance.backend.onToolRequest(handler);
+    }
+    /**
+     * 释放指定实例
+     */
+    async dispose(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance)
+            return;
+        instance.state = 'disposed';
+        // 关闭 per-instance MCP server
+        if (instance.mcpServer) {
+            await instance.mcpServer.close().catch((err) => {
+                this.logger.error(`[CCBroker] MCP server 关闭失败 (${instanceId}):`, err);
+            });
+        }
+        // 关闭 CC backend
+        await instance.backend.dispose().catch((err) => {
+            this.logger.error(`[CCBroker] backend dispose 失败 (${instanceId}):`, err);
+        });
+        this.instances.delete(instanceId);
+        this.logger.info(`[CCBroker] 实例 ${instanceId} 已释放`);
+        this.emit('instance.exited', instanceId, instance.role, instance.taskId);
+        // 检查 shutdown 等待
+        this.checkShutdownComplete();
+    }
+    /**
+     * 优雅关闭所有实例
+     */
+    async shutdown(timeoutMs = 30_000) {
+        this.shuttingDown = true;
+        const activeInstances = [...this.instances.values()].filter(i => i.state !== 'disposed');
+        if (activeInstances.length === 0) {
+            return { unfinished: [] };
+        }
+        this.logger.info(`[CCBroker] 开始关闭 ${activeInstances.length} 个实例...`);
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                // 超时：强制关闭剩余实例
+                const unfinished = [];
+                for (const instance of this.instances.values()) {
+                    if (instance.state !== 'disposed') {
+                        unfinished.push(instance.id);
+                        instance.backend.dispose().catch(() => { });
+                        if (instance.mcpServer) {
+                            instance.mcpServer.close().catch(() => { });
+                        }
+                    }
+                }
+                this.instances.clear();
+                resolve({ unfinished });
+            }, timeoutMs);
+            this.shutdownResolve = () => {
+                clearTimeout(timer);
+                resolve({ unfinished: [] });
+            };
+            // 对所有实例发起 dispose
+            for (const instance of activeInstances) {
+                this.dispose(instance.id).catch(() => { });
+            }
+        });
+    }
+    /**
+     * 释放所有实例（不进入 shutdown 模式，允许后续重新 spawn）
+     * 返回被释放的实例 ID 列表
+     */
+    async disposeAll() {
+        const ids = [...this.instances.keys()];
+        if (ids.length === 0)
+            return [];
+        this.logger.info(`[CCBroker] 开始释放全部 ${ids.length} 个实例...`);
+        await Promise.all(ids.map(id => this.dispose(id).catch(() => { })));
+        this.logger.info('[CCBroker] 全部实例已释放');
+        return ids;
+    }
+    // ── 查询 ──
+    getInstance(id) {
+        return this.instances.get(id);
+    }
+    getInstancesByRole(role) {
+        return [...this.instances.values()].filter(i => i.role === role);
+    }
+    getInstanceByTaskId(taskId) {
+        return [...this.instances.values()].find(i => i.taskId === taskId);
+    }
+    status() {
+        return [...this.instances.values()].map(i => ({
+            id: i.id,
+            role: i.role,
+            state: i.state,
+            taskId: i.taskId,
+            cliSessionId: i.cliSessionId,
+            createdAt: i.createdAt.toISOString(),
+            lastActivityAt: i.lastActivityAt.toISOString(),
+        }));
+    }
+    get instanceCount() {
+        return this.instances.size;
+    }
+    // ── 私有 ──
+    shutdownResolve = null;
+    countByRole(role) {
+        let count = 0;
+        for (const instance of this.instances.values()) {
+            if (instance.role === role && instance.state !== 'disposed') {
+                count++;
+            }
+        }
+        return count;
+    }
+    checkShutdownComplete() {
+        if (!this.shuttingDown || !this.shutdownResolve)
+            return;
+        const stillActive = [...this.instances.values()].some(i => i.state !== 'disposed');
+        if (!stillActive) {
+            this.shutdownResolve();
+            this.shutdownResolve = null;
+        }
+    }
+}
+//# sourceMappingURL=cc-broker.js.map

package/apps/server/dist/cli.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+/**
+ * Anya CLI — Team Anya 服务启动/管理入口
+ *
+ * 用法：
+ *   anya start [-p 3000] [--home ~/.anya] [-d]
+ *   anya stop
+ *   anya status
+ *   anya setup
+ */
+import { Command } from 'commander';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { fork } from 'node:child_process';
+import { homedir } from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
+import { writePid, readPid, removePid, isProcessAlive, healthCheck } from './daemon.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// 包根目录：从 apps/server/dist/ 往上 3 层到 monorepo 根
+const PKG_ROOT = resolve(__dirname, '../../..');
+function resolveHome(p) {
+    if (p.startsWith('~/') || p === '~')
+        return join(homedir(), p.slice(2));
+    return p;
+}
+/** 读取版本号 */
+function getVersion() {
+    try {
+        const pkgPath = join(PKG_ROOT, 'package.json');
+        if (existsSync(pkgPath)) {
+            return JSON.parse(readFileSync(pkgPath, 'utf-8')).version ?? '0.1.0';
+        }
+    }
+    catch { /* ignore */ }
+    return '0.1.0';
+}
+/** 设置公共环境变量（.env 先加载，CLI 显式传参再覆盖） */
+function setEnvFromOpts(opts, portExplicit) {
+    const anyaHome = resolveHome(opts.home ?? process.env.ANYA_HOME ?? '~/.anya');
+    process.env.ANYA_HOME = anyaHome;
+    // 先加载 .env（不覆盖已有的环境变量，如系统级 env）
+    const envFile = join(anyaHome, '.env');
+    if (existsSync(envFile)) {
+        const lines = readFileSync(envFile, 'utf-8').split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
+            if (!process.env[key]) {
+                process.env[key] = value;
+            }
+        }
+    }
+    // CLI 显式传参覆盖 .env（只有用户真的传了 -p 才覆盖）
+    if (portExplicit) {
+        process.env.PORT = opts.port;
+    }
+    // 指向包内的模板和协议文件
+    if (!process.env.OFFICE_TEMPLATE_DIR) {
+        process.env.OFFICE_TEMPLATE_DIR = resolve(PKG_ROOT, 'workspace');
+    }
+    if (!process.env.LOID_PROTOCOLS_DIR) {
+        process.env.LOID_PROTOCOLS_DIR = resolve(PKG_ROOT, 'anya/prompts/protocols');
+    }
+    return anyaHome;
+}
+const program = new Command();
+program
+    .name('anya')
+    .description('Team Anya - AI 数字员工系统')
+    .version(getVersion());
+// ── start ──
+program
+    .command('start')
+    .description('启动 Anya 服务（API + Web UI）')
+    .option('-p, --port <port>', '服务端口')
+    .option('--home <path>', 'ANYA_HOME 目录', '~/.anya')
+    .option('-d, --daemon', '后台运行')
+    .action(async (opts, cmd) => {
+    // 检测 -p 是否由用户显式传入（而非 commander 默认值）
+    const portExplicit = cmd.getOptionValueSource('port') === 'cli';
+    const anyaHome = setEnvFromOpts(opts, portExplicit);
+    process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+    // 检查是否已有进程在运行
+    const existingPid = readPid(anyaHome);
+    if (existingPid && isProcessAlive(existingPid)) {
+        console.error(`Anya 已在运行 (PID: ${existingPid})，请先执行 anya stop`);
+        process.exit(1);
+    }
+    if (opts.daemon) {
+        // 后台模式：fork 子进程
+        const child = fork(__filename, ['_start-server'], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env },
+        });
+        child.unref();
+        writePid(anyaHome, child.pid);
+        const port = process.env.PORT || '3000';
+        console.log(`Anya 已在后台启动 (PID: ${child.pid})`);
+        console.log(`  API:    http://localhost:${port}/api/`);
+        console.log(`  Web UI: http://localhost:${port}/`);
+        console.log(`  日志:   ${join(anyaHome, 'data/logs/anya.log')}`);
+        process.exit(0);
+    }
+    // 前台模式
+    writePid(anyaHome, process.pid);
+    process.on('exit', () => removePid(anyaHome));
+    try {
+        const { startServer } = await import('./main.js');
+        const { config } = await startServer();
+        console.log(`\nAnya 服务已启动`);
+        console.log(`  API:    http://localhost:${config.PORT}/api/`);
+        console.log(`  Web UI: http://localhost:${config.PORT}/`);
+        console.log(`  Home:   ${anyaHome}\n`);
+    }
+    catch (err) {
+        removePid(anyaHome);
+        console.error('启动失败:', err);
+        process.exit(1);
+    }
+});
+// ── stop ──
+program
+    .command('stop')
+    .description('停止 Anya 服务')
+    .option('--home <path>', 'ANYA_HOME 目录', '~/.anya')
+    .action(async (opts) => {
+    const anyaHome = resolveHome(opts.home ?? process.env.ANYA_HOME ?? '~/.anya');
+    const pid = readPid(anyaHome);
+    if (!pid) {
+        console.log('未找到运行中的 Anya 进程');
+        process.exit(0);
+    }
+    if (!isProcessAlive(pid)) {
+        console.log(`PID ${pid} 已不存在，清理 PID 文件`);
+        removePid(anyaHome);
+        process.exit(0);
+    }
+    console.log(`正在停止 Anya (PID: ${pid})...`);
+    process.kill(pid, 'SIGTERM');
+    // 等待进程退出（最多 30 秒）
+    const deadline = Date.now() + 30_000;
+    while (Date.now() < deadline && isProcessAlive(pid)) {
+        await new Promise(r => setTimeout(r, 500));
+    }
+    if (isProcessAlive(pid)) {
+        console.log('进程未响应 SIGTERM，发送 SIGKILL...');
+        process.kill(pid, 'SIGKILL');
+    }
+    removePid(anyaHome);
+    console.log('Anya 已停止');
+});
+// ── status ──
+program
+    .command('status')
+    .description('查看 Anya 运行状态')
+    .option('-p, --port <port>', '服务端口')
+    .option('--home <path>', 'ANYA_HOME 目录', '~/.anya')
+    .action(async (opts, cmd) => {
+    const anyaHome = resolveHome(opts.home ?? process.env.ANYA_HOME ?? '~/.anya');
+    // 加载 .env 获取端口
+    const portExplicit = cmd.getOptionValueSource('port') === 'cli';
+    setEnvFromOpts(opts, portExplicit);
+    const port = parseInt(process.env.PORT || '3000', 10);
+    const pid = readPid(anyaHome);
+    console.log(`ANYA_HOME: ${anyaHome}`);
+    console.log(`PORT:  ${port}`);
+    if (!pid) {
+        console.log('状态: 未运行（无 PID 文件）');
+        process.exit(1);
+    }
+    const alive = isProcessAlive(pid);
+    console.log(`PID:   ${pid} (${alive ? '运行中' : '已退出'})`);
+    if (!alive) {
+        removePid(anyaHome);
+        process.exit(1);
+    }
+    const health = await healthCheck(port);
+    console.log(`HTTP:  ${health.ok ? 'healthy' : 'unhealthy'} (status: ${health.status ?? 'N/A'})`);
+    process.exit(health.ok ? 0 : 1);
+});
+// ── setup ──
+program
+    .command('setup')
+    .description('交互式初始化 Anya 配置')
+    .option('--home <path>', 'ANYA_HOME 目录', '~/.anya')
+    .action(async (opts) => {
+    const { createInterface } = await import('node:readline');
+    const { mkdirSync, writeFileSync, readFileSync, existsSync: exists } = await import('node:fs');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q, fallback = '') => new Promise(resolve => {
+        const suffix = fallback ? ` (${fallback})` : '';
+        rl.question(`${q}${suffix}: `, ans => resolve(ans.trim() || fallback));
+    });
+    console.log('\n  Anya Setup - 交互式配置向导\n');
+    // ── 1. ANYA_HOME ──
+    const anyaHome = resolveHome(await ask('数据目录 ANYA_HOME', opts.home ?? '~/.anya'));
+    // 创建目录结构
+    const dirs = ['data', 'data/logs', 'office', 'repos', 'media/feishu'];
+    for (const dir of dirs)
+        mkdirSync(join(anyaHome, dir), { recursive: true });
+    console.log(`  -> 已创建 ${anyaHome}\n`);
+    // 读取已有配置
+    const envFile = join(anyaHome, '.env');
+    const existing = {};
+    if (exists(envFile)) {
+        for (const line of readFileSync(envFile, 'utf-8').split('\n')) {
+            const t = line.trim();
+            if (!t || t.startsWith('#'))
+                continue;
+            const eq = t.indexOf('=');
+            if (eq === -1)
+                continue;
+            existing[t.slice(0, eq).trim()] = t.slice(eq + 1).trim().replace(/^["']|["']$/g, '');
+        }
+    }
+    // ── 2. 基础配置 ──
+    console.log('-- 基础配置 --');
+    const port = await ask('服务端口 PORT', existing.PORT || '3000');
+    // ── 3. Claude Code（核心依赖）──
+    console.log('\n-- Claude Code（核心，Yor 执行引擎）--');
+    console.log('  Anya 通过 Claude Code CLI 驱动 AI Agent 执行任务');
+    console.log('  需要先安装: npm install -g @anthropic-ai/claude-code\n');
+    const ccBinary = await ask('Claude Code 命令路径 CLAUDE_CODE_BINARY', existing.CLAUDE_CODE_BINARY || 'claude');
+    // ── 4. 飞书集成（可选）──
+    console.log('\n-- 飞书集成（可选，留空跳过）--');
+    console.log('  配置后 Anya 可通过飞书群接收任务、推送进度');
+    console.log('  需要在飞书开放平台创建应用并开启机器人能力\n');
+    const feishuAppId = await ask('飞书 App ID FEISHU_APP_ID', existing.FEISHU_APP_ID || '');
+    let feishuAppSecret = '';
+    if (feishuAppId) {
+        feishuAppSecret = await ask('飞书 App Secret FEISHU_APP_SECRET', existing.FEISHU_APP_SECRET || '');
+    }
+    rl.close();
+    // ── 生成 .env ──
+    const lines = [
+        '# Anya 配置文件（由 anya setup 生成）',
+        '',
+        '# 基础配置',
+        `PORT=${port}`,
+        '',
+        '# Claude Code',
+        `CLAUDE_CODE_BINARY=${ccBinary}`,
+    ];
+    lines.push('');
+    if (feishuAppId) {
+        lines.push('# 飞书集成');
+        lines.push(`FEISHU_APP_ID=${feishuAppId}`);
+        lines.push(`FEISHU_APP_SECRET=${feishuAppSecret}`);
+    }
+    else {
+        lines.push('# 飞书集成（未配置）');
+        lines.push('# FEISHU_APP_ID=');
+        lines.push('# FEISHU_APP_SECRET=');
+    }
+    lines.push('');
+    writeFileSync(envFile, lines.join('\n'), 'utf-8');
+    console.log(`\n配置已写入: ${envFile}`);
+    // ── 环境检查 ──
+    console.log('\n-- 环境检查 --');
+    const { execSync: exec } = await import('node:child_process');
+    const checks = [
+        { name: 'Node.js', cmd: 'node --version', required: true },
+        { name: 'git', cmd: 'git --version', required: true },
+        { name: 'Claude Code', cmd: `${ccBinary} --version`, required: true },
+        { name: 'GitHub CLI (gh)', cmd: 'gh --version', required: false },
+        { name: 'Python 3', cmd: 'python3 --version', required: false },
+    ];
+    for (const c of checks) {
+        try {
+            const ver = exec(c.cmd, { encoding: 'utf-8', timeout: 5000 }).trim().split('\n')[0];
+            console.log(`  [OK] ${c.name}: ${ver}`);
+        }
+        catch {
+            const tag = c.required ? 'MISSING' : 'skip';
+            console.log(`  [${tag}] ${c.name}: 未安装${c.required ? '（必需）' : '（可选）'}`);
+        }
+    }
+    console.log('\n配置完成！运行 anya start 启动服务');
+});
+// ── 内部命令：daemon 子进程实际启动 ──
+program
+    .command('_start-server', { hidden: true })
+    .action(async () => {
+    const { startServer } = await import('./main.js');
+    await startServer();
+});
+program.parse();
+//# sourceMappingURL=cli.js.map

package/apps/server/dist/config.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { join, resolve, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+function resolveHome(p) {
+    if (p.startsWith('~/') || p === '~') {
+        return join(homedir(), p.slice(2));
+    }
+    return p;
+}
+const defaultAnyaHome = resolveHome('~/.anya');
+/**
+ * 基于包自身位置推导默认路径（兼容 monorepo 开发 + npm 全局安装）
+ * - npm 包: config.js 在 apps/server/dist/，包根在 ../../..
+ * - monorepo 开发: config.ts 通过 tsx 运行，cwd 是项目根
+ */
+function findPkgRoot() {
+    // 从编译后的 dist/config.js 位置往上找
+    const fromDist = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
+    // 检查是否确实是包根（有 workspace/ 目录）
+    if (existsSync(join(fromDist, 'workspace')))
+        return fromDist;
+    // 开发模式 fallback：从 cwd 推导
+    if (existsSync(join(process.cwd(), 'workspace')))
+        return process.cwd();
+    return fromDist;
+}
+const PKG_ROOT = findPkgRoot();
+const envSchema = z.object({
+    PORT: z.coerce.number().default(3000),
+    SQLITE_PATH: z.string().optional(),
+    ANYA_HOME: z.string().default(defaultAnyaHome).transform(resolveHome),
+    WORKSPACE_PATH: z.string().optional(),
+    MAX_YOR_CONCURRENCY: z.coerce.number().min(1).max(10).default(3),
+    CLAUDE_CODE_BINARY: z.string().default('claude'),
+    LOID_WORK_DIR: z.string().optional(),
+    LOID_PROTOCOLS_DIR: z.string().default(resolve(PKG_ROOT, 'anya/prompts/protocols')),
+    NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+    FEISHU_APP_ID: z.string().optional(),
+    FEISHU_APP_SECRET: z.string().optional(),
+    FEISHU_DAILY_REPORT_CHAT_ID: z.string().optional(),
+    PROJECTS_CONFIG_PATH: z.string().optional(),
+    REPOS_PATH: z.string().optional(),
+    LOG_DIR: z.string().optional(),
+    LOID_USE_CC: z.coerce.boolean().default(true),
+    OFFICE_TEMPLATE_DIR: z.string().default(resolve(PKG_ROOT, 'workspace')),
+}).transform((val) => ({
+    ...val,
+    SQLITE_PATH: val.SQLITE_PATH ?? join(val.ANYA_HOME, 'data', 'anya.db'),
+    WORKSPACE_PATH: val.WORKSPACE_PATH ?? join(val.ANYA_HOME, 'office'),
+    LOID_WORK_DIR: val.LOID_WORK_DIR ?? join(val.ANYA_HOME, 'office', 'loid'),
+    PROJECTS_CONFIG_PATH: val.PROJECTS_CONFIG_PATH ?? join(val.ANYA_HOME, 'office', 'projects.json'),
+    REPOS_PATH: val.REPOS_PATH ?? join(val.ANYA_HOME, 'repos'),
+    MEDIA_PATH: join(val.ANYA_HOME, 'media', 'feishu'),
+    LOG_DIR: val.LOG_DIR ?? join(val.ANYA_HOME, 'data', 'logs'),
+}));
+let _config = null;
+export function loadConfig(env = process.env) {
+    const result = envSchema.safeParse(env);
+    if (!result.success) {
+        const formatted = result.error.issues
+            .map(i => `  ${i.path.join('.')}: ${i.message}`)
+            .join('\n');
+        throw new Error(`配置校验失败:\n${formatted}`);
+    }
+    _config = result.data;
+    return _config;
+}
+export function getConfig() {
+    if (!_config) {
+        throw new Error('配置未初始化，请先调用 loadConfig()');
+    }
+    return _config;
+}
+//# sourceMappingURL=config.js.map

package/apps/server/dist/daemon.js

@@ -0,0 +1,51 @@
+/**
+ * Daemon 管理：PID 文件读写、进程检测、健康检查
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+function resolveHome(p) {
+    if (p.startsWith('~/') || p === '~')
+        return join(homedir(), p.slice(2));
+    return p;
+}
+function getPidFile(anyaHome) {
+    const dataDir = join(resolveHome(anyaHome), 'data');
+    mkdirSync(dataDir, { recursive: true });
+    return join(dataDir, 'anya.pid');
+}
+export function writePid(anyaHome, pid) {
+    writeFileSync(getPidFile(anyaHome), String(pid), 'utf-8');
+}
+export function readPid(anyaHome) {
+    const pidFile = getPidFile(anyaHome);
+    if (!existsSync(pidFile))
+        return null;
+    const raw = readFileSync(pidFile, 'utf-8').trim();
+    const pid = parseInt(raw, 10);
+    return Number.isNaN(pid) ? null : pid;
+}
+export function removePid(anyaHome) {
+    const pidFile = getPidFile(anyaHome);
+    if (existsSync(pidFile))
+        unlinkSync(pidFile);
+}
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function healthCheck(port) {
+    try {
+        const res = await fetch(`http://localhost:${port}/api/dashboard`);
+        return { ok: res.ok, status: res.status };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+//# sourceMappingURL=daemon.js.map