@qlingzzy/qling 1.0.0

package/dist/context-report.js

@@ -0,0 +1,172 @@
+import { join } from "path";
+import { homedir } from "os";
+import { formatLocalPanel } from "./output-style.js";
+import { SessionRegistry } from "./session/session-registry.js";
+function resolveStateDir(env, agentLoop) {
+    return env?.QLING_FILE_STATE_DIR
+        || agentLoop.getRuntimeRootDir?.()
+        || join(homedir(), ".qling");
+}
+function resolveCacheDir(env, stateDir) {
+    return env?.QLING_FILE_CACHE_DIR || join(stateDir, "cache");
+}
+function resolveMaxTokens(options, agentLoop) {
+    if (typeof options.maxTokens === "number" && options.maxTokens > 0) {
+        return options.maxTokens;
+    }
+    const fromAgent = agentLoop.getTokenBudget?.()?.maxTokens ?? agentLoop.tokenBudget?.maxTokens;
+    return typeof fromAgent === "number" && fromAgent > 0 ? fromAgent : null;
+}
+export function formatTokenUsage(tokens, maxTokens) {
+    const used = Number(tokens ?? 0);
+    if (!maxTokens || maxTokens <= 0) {
+        return `${used.toLocaleString()} / unknown`;
+    }
+    const pct = Math.round((used / maxTokens) * 100);
+    return `${used.toLocaleString()} / ${maxTokens.toLocaleString()} (${pct}%)`;
+}
+function classifyContextLevel(percent) {
+    if (percent === null)
+        return "unknown";
+    if (percent >= 90)
+        return "critical";
+    if (percent >= 70)
+        return "watch";
+    return "ok";
+}
+function describeContextRecommendation(level) {
+    switch (level) {
+        case "critical":
+            return "立即保存 checkpoint 并执行 /compact，避免后续回复被截断或上下文丢失。";
+        case "watch":
+            return "建议在继续长任务前保存 checkpoint；如输出变长，提前 /compact。";
+        case "ok":
+            return "当前上下文占用正常，可继续推进。";
+        default:
+            return "未配置可用 token 预算，建议设置 max token budget 以获得准确上下文水位。";
+    }
+}
+function describeTokenSource(source) {
+    switch (source) {
+        case "provider":
+            return "provider reported usage; suitable for accurate accounting when the provider returns usage.";
+        case "estimate":
+            return "local estimate; useful for context planning but not exact billing.";
+        default:
+            return "unknown; provider usage and local estimate are unavailable.";
+    }
+}
+export async function buildContextReport(context, options = {}) {
+    const env = options.env ?? process.env;
+    const agentLoop = context.agentLoop;
+    const stats = typeof agentLoop.getSessionStats === "function"
+        ? await agentLoop.getSessionStats()
+        : {
+            sessionId: agentLoop.getSessionId?.() ?? "",
+            turnCount: agentLoop.turnCount ?? 0,
+            tokens: agentLoop.sessionTokens ?? 0,
+            tokenSource: "unknown",
+            compactions: agentLoop.compactionCount ?? 0,
+        };
+    const messages = typeof agentLoop.getMessagesSnapshot === "function"
+        ? await agentLoop.getMessagesSnapshot()
+        : [];
+    const savedSessions = context.listSavedSessions ? await context.listSavedSessions() : [];
+    const stateDir = resolveStateDir(env, agentLoop);
+    const cacheDir = resolveCacheDir(env, stateDir);
+    const maxTokens = resolveMaxTokens(options, agentLoop);
+    const tokens = Number(stats.tokens ?? 0);
+    const tokenUsagePercent = maxTokens ? Math.round((tokens / maxTokens) * 100) : null;
+    const tokenSource = normalizeTokenSource(stats.tokenSource);
+    const contextLevel = classifyContextLevel(tokenUsagePercent);
+    return {
+        sessionId: stats.sessionId || agentLoop.getSessionId?.() || "-",
+        turnCount: Number(stats.turnCount ?? 0),
+        messageCount: Array.isArray(messages) ? messages.length : Number(stats.messageCount ?? 0),
+        tokens,
+        tokenSource,
+        tokenSourceDescription: describeTokenSource(tokenSource),
+        maxTokens,
+        tokenUsagePercent,
+        contextLevel,
+        recommendation: describeContextRecommendation(contextLevel),
+        compactions: Number(stats.compactions ?? stats.compactionCount ?? 0),
+        workspaceDir: context.workspaceDir || agentLoop.getWorkspaceDir?.() || process.cwd(),
+        stateDir,
+        cacheDir,
+        sessionsDir: join(stateDir, "sessions"),
+        savedSessionCount: savedSessions.length,
+        latestSavedSessionAt: savedSessions[0]?.updatedAt ?? null,
+    };
+}
+export async function buildLocalContextReport(options) {
+    const registry = new SessionRegistry({ stateDir: options.stateDir });
+    const savedSessions = await registry.list();
+    const maxTokens = typeof options.maxTokens === "number" && options.maxTokens > 0
+        ? options.maxTokens
+        : null;
+    const tokenUsagePercent = maxTokens ? 0 : null;
+    const tokenSource = "unknown";
+    const contextLevel = classifyContextLevel(tokenUsagePercent);
+    return {
+        sessionId: "-",
+        turnCount: 0,
+        messageCount: 0,
+        tokens: 0,
+        tokenSource,
+        tokenSourceDescription: describeTokenSource(tokenSource),
+        maxTokens,
+        tokenUsagePercent,
+        contextLevel,
+        recommendation: describeContextRecommendation(contextLevel),
+        compactions: 0,
+        workspaceDir: options.workspaceDir,
+        stateDir: options.stateDir,
+        cacheDir: options.cacheDir || join(options.stateDir, "cache"),
+        sessionsDir: join(options.stateDir, "sessions"),
+        savedSessionCount: savedSessions.length,
+        latestSavedSessionAt: savedSessions[0]?.updatedAt ?? null,
+    };
+}
+export function formatContextReport(report) {
+    return formatLocalPanel({
+        icon: "🧭",
+        title: "本地上下文",
+        sections: [
+            {
+                heading: "会话",
+                rows: [
+                    ["Session ID", report.sessionId],
+                    ["轮次", report.turnCount],
+                    ["消息数", report.messageCount],
+                    ["压缩次数", report.compactions],
+                ],
+            },
+            {
+                heading: "Token 与状态",
+                rows: [
+                    ["Token", formatTokenUsage(report.tokens, report.maxTokens)],
+                    ["Token 来源", report.tokenSource],
+                    ["Token 说明", report.tokenSourceDescription],
+                    ["上下文状态", report.contextLevel],
+                    ["建议", report.recommendation],
+                ],
+            },
+            {
+                heading: "本地路径",
+                rows: [
+                    ["Workspace", report.workspaceDir],
+                    ["State dir", report.stateDir],
+                    ["Cache dir", report.cacheDir],
+                    ["Sessions", report.sessionsDir],
+                    ["已存快照", report.savedSessionCount],
+                    ["最近保存", report.latestSavedSessionAt ?? "-"],
+                ],
+            },
+        ],
+        boundary: "/context 只展示本地统计与路径，不输出消息正文，不上传上下文。",
+    });
+}
+function normalizeTokenSource(value) {
+    return value === "provider" || value === "estimate" ? value : "unknown";
+}

package/dist/daemon.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=daemon.d.ts.map

package/dist/daemon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":""}

package/dist/daemon.js

@@ -0,0 +1,316 @@
+// ============================================================
+// qlingd - 轻灵后台守护进程 (v0.5 M3)
+// 负责后台任务执行、队列管理与状态持久化
+// ============================================================
+import * as http from "http";
+import { MissionManager } from "./mission/manager.js";
+import { AgentLoop } from "./agent-loop.js";
+import { loadQlingConfig, applyConfigToProcessEnv } from "./config.js";
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
+import dotenv from "dotenv";
+import { SessionScheduler } from "./session/session-scheduler.js";
+import { SessionGoalController } from "./session/goal-controller.js";
+import { SessionGoalManager } from "./session/session-goal-manager.js";
+import { DurableSessionSupervisor } from "./session/durable-session-supervisor.js";
+import { formatDaemonVersion } from "./package-version.js";
+const HOME_DIR = os.homedir();
+const DEFAULT_STATE_DIR = path.join(HOME_DIR, ".qling");
+function loadEnv() {
+    // 1. 项目配置
+    let dir = process.cwd();
+    while (true) {
+        const envPath = path.join(dir, ".env");
+        if (fs.existsSync(envPath)) {
+            dotenv.config({ path: envPath });
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // 2. 全局配置
+    const globalEnv = path.join(HOME_DIR, ".qling", ".env");
+    if (fs.existsSync(globalEnv)) {
+        dotenv.config({ path: globalEnv });
+    }
+}
+async function main() {
+    loadEnv();
+    const stateDir = process.env.QLING_FILE_STATE_DIR || DEFAULT_STATE_DIR;
+    const manager = new MissionManager(stateDir);
+    await manager.init();
+    const startedAt = Date.now();
+    const supervisor = new DurableSessionSupervisor({
+        stateDir,
+        log: (message) => console.log(`[qlingd] ${message}`),
+    });
+    // 尝试预加载配置并应用到环境变量
+    try {
+        const { config } = await loadQlingConfig({});
+        applyConfigToProcessEnv(config);
+    }
+    catch (err) {
+        console.error(`[qlingd] Warning: Failed to load config: ${err.message}`);
+    }
+    const PORT = Number(process.env.QLING_DAEMON_PORT) || 9998;
+    supervisor.start();
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url || "/", `http://localhost:${PORT}`);
+        res.setHeader("Content-Type", "application/json");
+        try {
+            // 1. 获取所有使命
+            if (url.pathname === "/missions" && req.method === "GET") {
+                const list = manager.listMissions();
+                res.end(JSON.stringify(list));
+                return;
+            }
+            // 2. 提交新使命
+            if (url.pathname === "/missions" && req.method === "POST") {
+                const data = await readJsonBody(req);
+                const mission = await manager.createMission(data.name, data.description, data.sessionId);
+                await manager.appendLog(mission.id, "使命已提交到后台队列", { source: "daemon" });
+                // 异步启动任务执行 (Detach) - 传入全量数据以支持状态恢复
+                executeMissionInBackground(mission.id, manager, stateDir, data);
+                res.end(JSON.stringify({ ok: true, missionId: mission.id }));
+                return;
+            }
+            const missionRoute = matchMissionRoute(url.pathname);
+            if (missionRoute) {
+                const { id, action } = missionRoute;
+                if (!action && req.method === "GET") {
+                    const mission = manager.getMissionOrThrow(id);
+                    res.end(JSON.stringify(mission));
+                    return;
+                }
+                if (action === "logs" && req.method === "GET") {
+                    const logs = await manager.getMissionLogs(id);
+                    res.end(JSON.stringify(logs));
+                    return;
+                }
+                if (req.method === "POST") {
+                    if (action === "pause") {
+                        const mission = await manager.pauseMission(id, "daemon_api");
+                        res.end(JSON.stringify({ ok: true, mission }));
+                        return;
+                    }
+                    if (action === "resume") {
+                        const mission = await manager.resumeMission(id, "daemon_api");
+                        res.end(JSON.stringify({ ok: true, mission }));
+                        return;
+                    }
+                    if (action === "cancel") {
+                        const mission = await manager.cancelMission(id, "daemon_api");
+                        res.end(JSON.stringify({ ok: true, mission }));
+                        return;
+                    }
+                    if (action === "retry") {
+                        const retried = await manager.retryMission(id);
+                        await manager.appendLog(retried.id, "使命由 retry 重新排队", {
+                            source: "daemon",
+                            sourceMissionId: id,
+                        });
+                        executeMissionInBackground(retried.id, manager, stateDir, {
+                            name: retried.name,
+                            description: retried.description,
+                            sessionId: retried.sessionId,
+                        });
+                        res.end(JSON.stringify({ ok: true, missionId: retried.id }));
+                        return;
+                    }
+                }
+            }
+            const sessionRoute = matchSessionRoute(url.pathname);
+            if (sessionRoute) {
+                const { sessionId, resource, itemId, action } = sessionRoute;
+                if (resource === "loop-tasks") {
+                    const scheduler = new SessionScheduler({
+                        stateDir,
+                        sessionId,
+                        runner: "daemon",
+                        onDue: async () => { },
+                    });
+                    await scheduler.init();
+                    if (!itemId && req.method === "GET") {
+                        res.end(JSON.stringify(await scheduler.listTasks()));
+                        return;
+                    }
+                    if (!itemId && req.method === "POST") {
+                        const data = await readJsonBody(req);
+                        const task = await scheduler.createLoopTask({
+                            prompt: data.prompt,
+                            intervalMs: Number(data.intervalMs),
+                            mode: data.mode === "fixed" ? "fixed" : "default",
+                            runner: "daemon",
+                        });
+                        res.end(JSON.stringify(task));
+                        return;
+                    }
+                    if (itemId && action === "cancel" && req.method === "POST") {
+                        const task = await scheduler.cancelTask(itemId);
+                        res.end(JSON.stringify(task));
+                        return;
+                    }
+                }
+                if (resource === "goal") {
+                    const manager = new SessionGoalManager({ stateDir, sessionId });
+                    const controller = new SessionGoalController({
+                        manager,
+                        runner: "daemon",
+                    });
+                    await controller.init();
+                    if (!action && req.method === "GET") {
+                        res.end(JSON.stringify(await controller.getGoalStatus()));
+                        return;
+                    }
+                    if (!action && req.method === "POST") {
+                        const data = await readJsonBody(req);
+                        const goal = await controller.setGoal(data.condition, {
+                            turnCount: Number(data.stats?.turnCount ?? 0),
+                            tokens: Number(data.stats?.tokens ?? 0),
+                        }, {
+                            runner: "daemon",
+                            pending: true,
+                        });
+                        res.end(JSON.stringify(goal));
+                        return;
+                    }
+                    if (action === "clear" && req.method === "POST") {
+                        const goal = await controller.clearGoal("daemon_api_clear");
+                        res.end(JSON.stringify(goal));
+                        return;
+                    }
+                }
+            }
+            // 4. 健康检查
+            if (url.pathname === "/health") {
+                res.end(JSON.stringify({
+                    status: "ok",
+                    version: formatDaemonVersion(),
+                    pid: process.pid,
+                    uptimeMs: Date.now() - startedAt,
+                    missions: manager.listMissions().length,
+                    durableSupervisor: "running",
+                }));
+                return;
+            }
+            res.writeHead(404);
+            res.end(JSON.stringify({ error: "Not Found" }));
+        }
+        catch (err) {
+            const error = err;
+            res.writeHead(error.statusCode ?? 500);
+            res.end(JSON.stringify({ error: error.message, code: error.code ?? "DAEMON_ERROR" }));
+        }
+    });
+    server.listen(PORT, () => {
+        console.log(`[qlingd] 守护进程已启动，监听端口: ${PORT}`);
+    });
+    const shutdown = () => {
+        server.close(() => process.exit(0));
+        setTimeout(() => process.exit(0), 2_000).unref();
+    };
+    process.once("SIGTERM", shutdown);
+    process.once("SIGINT", shutdown);
+}
+/** 后台执行使命逻辑 */
+async function executeMissionInBackground(id, manager, stateDir, data) {
+    const mission = manager.getMission(id);
+    if (!mission)
+        return;
+    try {
+        if (mission.status === "paused" || mission.status === "canceled") {
+            await manager.appendLog(id, `使命未启动，当前状态为 ${mission.status}`, { source: "daemon" });
+            return;
+        }
+        await manager.updateStatus(id, "running");
+        await manager.appendLog(id, "使命开始执行", { source: "daemon" });
+        // 重新加载配置
+        const { config: loadedConfig } = await loadQlingConfig({});
+        const { buildToolRegistry } = await import("./tools/index.js");
+        const staticEnabled = {};
+        for (const [name, cfg] of Object.entries(loadedConfig.tools)) {
+            staticEnabled[name] = cfg.enabled;
+        }
+        const tools = buildToolRegistry({ staticEnabled });
+        const agentConfig = {
+            apiKey: loadedConfig.llm.api_key || process.env.QLING_LLM_API_KEY || "",
+            provider: loadedConfig.llm.provider,
+            endpoint: loadedConfig.llm.endpoint,
+            model: loadedConfig.llm.model,
+            maxIterations: loadedConfig.runtime.max_steps,
+            tools,
+            runtime: {
+                workspaceDir: loadedConfig.runtime.workspace_dir || process.cwd(),
+                fileCacheDir: loadedConfig.runtime.file_cache_dir,
+                fileStateDir: stateDir,
+            },
+        };
+        const agent = new AgentLoop(agentConfig);
+        await agent.waitForInit();
+        // v0.5 M3: 状态恢复 (High-fidelity Resume)
+        if (data.checkpoint) {
+            console.log(`[qlingd] 正在为使命 ${id} 恢复状态机快照...`);
+            await manager.appendLog(id, "正在恢复状态机快照", { source: "daemon" });
+            agent.syncWorkflowState(data.checkpoint);
+            if (data.stats) {
+                agent.sessionTokens = data.stats.sessionTokens || 0;
+            }
+        }
+        else {
+            agent.addUserMessage(mission.description);
+        }
+        const result = await agent.run();
+        await manager.appendLog(id, "使命执行成功", {
+            source: "daemon",
+            resultPreview: typeof result === "string" ? result.slice(0, 120) : String(result),
+        });
+        await manager.updateStatus(id, "succeeded");
+        console.log(`[qlingd] 使命 ${id} 执行成功。`);
+        await agent.shutdown();
+    }
+    catch (err) {
+        await manager.updateStatus(id, "failed", {
+            message: err.message,
+            code: "DAEMON_EXEC_FAILED"
+        });
+        await manager.appendLog(id, `使命执行失败: ${err.message}`, { source: "daemon" });
+        console.error(`[qlingd] 使命 ${id} 执行失败: ${err.message}`);
+    }
+}
+function matchMissionRoute(pathname) {
+    const match = pathname.match(/^\/missions\/([^/]+)(?:\/([^/]+))?$/);
+    if (!match)
+        return null;
+    return {
+        id: decodeURIComponent(match[1]),
+        action: match[2] ? decodeURIComponent(match[2]) : null,
+    };
+}
+function matchSessionRoute(pathname) {
+    const match = pathname.match(/^\/sessions\/([^/]+)\/(loop-tasks|goal)(?:\/([^/]+))?(?:\/([^/]+))?$/);
+    if (!match)
+        return null;
+    const resource = match[2];
+    let itemId = match[3] ? decodeURIComponent(match[3]) : null;
+    let action = match[4] ? decodeURIComponent(match[4]) : null;
+    if (resource === "goal" && itemId && !action) {
+        action = itemId;
+        itemId = null;
+    }
+    return {
+        sessionId: decodeURIComponent(match[1]),
+        resource,
+        itemId,
+        action,
+    };
+}
+async function readJsonBody(req) {
+    let body = "";
+    for await (const chunk of req)
+        body += chunk;
+    return body ? JSON.parse(body) : {};
+}
+main().catch(console.error);

package/dist/dashboard-server.d.ts

@@ -0,0 +1,18 @@
+import { MetricsCollector } from "./metrics/collector.js";
+import { WorkflowRuntime } from "./workflow-runtime.js";
+import { AgentLoop } from "./agent-loop.js";
+export interface DashboardOptions {
+    port: number;
+    collector: MetricsCollector;
+    workflowRuntime: WorkflowRuntime;
+    agentLoop: AgentLoop;
+}
+export declare class DashboardServer {
+    private server;
+    private options;
+    listening: boolean;
+    constructor(options: DashboardOptions);
+    start(): Promise<void>;
+    stop(): void;
+}
+//# sourceMappingURL=dashboard-server.d.ts.map

package/dist/dashboard-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard-server.d.ts","sourceRoot":"","sources":["../src/dashboard-server.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,gBAAgB,CAAC;IAC5B,eAAe,EAAE,eAAe,CAAC;IACjC,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,OAAO,CAAmB;IAC3B,SAAS,UAAS;gBAEb,OAAO,EAAE,gBAAgB;IAIrC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA8TtB,IAAI,IAAI,IAAI;CAIb"}