personal-bot 0.2.3 → 0.2.5

package/lib/common/files.d.ts

@@ -0,0 +1,2 @@
+export declare function atomicFile(path: string, content: string, exclusive?: boolean): Promise<void>;
+export declare function mutationTarget(path: string): Promise<string>;

package/lib/common/files.js

@@ -0,0 +1,44 @@
+import { open, realpath, rename, unlink, link } from "node:fs/promises";
+import { join, dirname, basename } from "node:path";
+import { randomUUID } from "node:crypto";
+import { requireThat } from "./validation.js";
+export async function atomicFile(path, content, exclusive = false) {
+    const temp = path + "." + randomUUID();
+    const handle = await open(temp, "wx", 0o600);
+    try {
+        await handle.writeFile(content);
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        if (exclusive)
+            await link(temp, path);
+        else
+            await rename(temp, path);
+        const directory = await open(dirname(path), "r");
+        try {
+            await directory.sync();
+        }
+        finally {
+            await directory.close();
+        }
+    }
+    finally {
+        await unlink(temp).catch(error => { if (error.code !== "ENOENT")
+            throw error; });
+    }
+}
+export async function mutationTarget(path) {
+    try {
+        return await realpath(path);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        const parent = dirname(path);
+        requireThat(parent !== path, "无法定位目标路径。");
+        return join(await mutationTarget(parent), basename(path));
+    }
+}

package/lib/common/json.d.ts

@@ -0,0 +1,6 @@
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+export declare function object(value: unknown): value is Record<string, unknown>;
+export declare function canonical(value: unknown): string;
+export declare function json(value: unknown): Json;

package/lib/common/json.js

@@ -0,0 +1,16 @@
+export function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function canonical(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" && Number.isFinite(value))
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return "[" + value.map(canonical).join(",") + "]";
+    if (object(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) {
+        return "{" + Object.keys(value).sort().map(key => JSON.stringify(key) + ":" + canonical(value[key])).join(",") + "}";
+    }
+    throw new Error("需要有限、可序列化的 JSON 值。");
+}
+export function json(value) { return JSON.parse(canonical(value)); }

package/lib/common/markdown.d.ts

@@ -0,0 +1,5 @@
+import type { Json } from "./json.js";
+/** Preserve original text, including embedded Markdown fences. */
+export declare function markdownBlock(text: string): string;
+/** Render structured result fields without changing their machine-readable values. */
+export declare function markdownFields(value: Json, level?: number): string;

package/lib/common/markdown.js

@@ -0,0 +1,26 @@
+/** Preserve original text, including embedded Markdown fences. */
+export function markdownBlock(text) {
+    let fenceLength = 3;
+    for (const match of text.matchAll(/`+/g))
+        fenceLength = Math.max(fenceLength, match[0].length + 1);
+    const fence = "`".repeat(fenceLength);
+    return fence + "text\n" + text + "\n" + fence;
+}
+/** Render structured result fields without changing their machine-readable values. */
+export function markdownFields(value, level = 2) {
+    if (value === null || typeof value !== "object")
+        return typeof value === "string" ? markdownBlock(value) : String(value);
+    if (Array.isArray(value))
+        return value.length ? value.map((item, index) => "#".repeat(level) + " " + (index + 1) + "\n\n" + markdownFields(item, level + 1)).join("\n\n") : "（空）";
+    const fields = [], sections = [];
+    for (const [key, item] of Object.entries(value)) {
+        if ((item !== null && typeof item === "object") || (typeof item === "string" && (item.includes("\n") || key === "report" || key === "text"))) {
+            sections.push("#".repeat(level) + " " + key + "\n\n" + markdownFields(item, level + 1));
+        }
+        else {
+            const text = String(item).replace(/[\\`*_{}\[\]<>#!|]/g, "\\$&");
+            fields.push("- " + key + ": " + text);
+        }
+    }
+    return [fields.join("\n"), ...sections].filter(Boolean).join("\n\n");
+}

package/lib/common/package-source.js

@@ -0,0 +1,16 @@
+import { prerelease, satisfies, valid } from "semver";
+export function npmName(source) {
+    return /^npm:((?:@[a-z0-9._-]+\/)?[a-z0-9._-]+)(?:@[^\s]+)?$/.exec(source)?.[1];
+}
+export function ordinaryNpm(source) {
+    const name = npmName(source);
+    return name !== undefined && (source === `npm:${name}` || source === `npm:${name}@latest`);
+}
+export function checkStableVersion(version, nodeRange) {
+    if (!valid(version) || prerelease(version))
+        throw new Error(`latest 不是稳定版本：${version}`);
+    if (nodeRange && !satisfies(process.versions.node, nodeRange)) {
+        throw new Error(`目标版本要求 Node.js ${nodeRange}，当前为 ${process.versions.node}。请先升级 Node.js。`);
+    }
+    return version;
+}

package/lib/common/paths.d.ts

@@ -0,0 +1 @@
+export declare const resourceRoot: string;

package/lib/common/paths.js

@@ -0,0 +1,2 @@
+import { fileURLToPath } from "node:url";
+export const resourceRoot = fileURLToPath(new URL("../../resources/", import.meta.url));

package/lib/common/validation.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateFunction } from "ajv";
+export declare function schema(value: unknown): ValidateFunction;
+export declare function requireThat(condition: unknown, message: string): asserts condition;

package/lib/common/validation.js

@@ -0,0 +1,14 @@
+import { Ajv } from "ajv";
+import addFormats from "ajv-formats";
+import { object } from "./json.js";
+export function schema(value) {
+    if (!object(value))
+        throw new Error("需要对象形式的 JSON Schema。");
+    const ajv = new Ajv({ strict: false, allErrors: false, validateFormats: true, coerceTypes: false, useDefaults: false, removeAdditional: false });
+    addFormats.default(ajv);
+    return ajv.compile(value);
+}
+export function requireThat(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}

package/lib/common/version.d.ts

@@ -0,0 +1,3 @@
+/** Before 1.0, the minor release defines compatibility; afterwards, the major does. */
+export declare function releaseLine(version: string): string;
+export declare const packageVersion: string;

package/lib/common/version.js

@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { object } from "./json.js";
+import { requireThat } from "./validation.js";
+/** Before 1.0, the minor release defines compatibility; afterwards, the major does. */
+export function releaseLine(version) {
+    const parts = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+    requireThat(parts, "pbot 发布版本必须使用 MAJOR.MINOR.PATCH。");
+    return parts[1] === "0" ? `0.${parts[2]}` : parts[1];
+}
+const manifest = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+requireThat(object(manifest) && typeof manifest.version === "string", "pbot 包缺少发布版本。");
+export const packageVersion = manifest.version;
+releaseLine(packageVersion);

package/lib/dsh.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "@deepseek-ai/cordis";
+export declare const name = "personal-bot";
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;

package/lib/dsh.js

@@ -0,0 +1,22 @@
+import { registerDshCommand } from "./extension/dsh/command.js";
+import { registerDshManagement } from "./extension/dsh/management.js";
+import { DshWorkspaces, dshDependencies } from "./extension/dsh/workspace.js";
+import { requireThat } from "./common/validation.js";
+export const name = "personal-bot";
+export const inject = ["commands", "typert", ...dshDependencies];
+export async function apply(ctx) {
+    const [major, minor] = process.versions.node.split(".").map(Number);
+    requireThat(major > 24 || (major === 24 && minor >= 9), "dsh 接入需要 Node.js 24.9.0 或更新版本。");
+    const workspaces = new DshWorkspaces(ctx);
+    ctx.effect(() => () => workspaces.close());
+    const management = registerDshManagement(ctx, workspaces);
+    registerDshCommand(ctx, workspaces, management);
+    ctx.on("agent/created", async ({ agent }) => {
+        if (ctx.agents.roots().includes(agent) && agent.session.header.origin !== "subagent")
+            await workspaces.open(agent);
+    });
+    for (const agent of ctx.agents.roots())
+        if (agent.session.header.origin !== "subagent")
+            await workspaces.open(agent);
+    void workspaces.preparePython().catch(error => ctx.logger.warn(String(error)));
+}

package/lib/extension/dsh/agent-events.d.ts

@@ -0,0 +1,24 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { AgentService } from "../../services/agents/agent-service.js";
+import type { TeamService } from "../../services/agents/team-service.js";
+import type { AgentOwner } from "../../model/agent.js";
+/** Server-owned scheduling survives browser disconnects; native cancellation pauses dispatch. */
+export declare class DshAgentEvents {
+    #private;
+    readonly ctx: Context;
+    readonly agent: Agent;
+    readonly agents: AgentService;
+    readonly teams: TeamService;
+    readonly owner: AgentOwner;
+    readonly check: () => void;
+    constructor(ctx: Context, agent: Agent, agents: AgentService, teams: TeamService, owner: AgentOwner, check: () => void);
+    get error(): string | undefined;
+    start(): void;
+    private pauseTeams;
+    private recordError;
+    private notice;
+    refresh(): Promise<void>;
+    private scan;
+    close(): Promise<void>;
+}

package/lib/extension/dsh/agent-events.js

@@ -0,0 +1,242 @@
+import { randomUUID } from "node:crypto";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { agentNotice, teamNotice } from "../../services/agents/agent-notices.js";
+import { deliveredDshNotices, pendingDshNotices } from "../../integrations/dsh/notifications.js";
+import { flushDshAgent } from "../../integrations/dsh/session.js";
+/** Server-owned scheduling survives browser disconnects; native cancellation pauses dispatch. */
+export class DshAgentEvents {
+    ctx;
+    agent;
+    agents;
+    teams;
+    owner;
+    check;
+    #dispatching = new Map();
+    #signals = new Map();
+    #timer;
+    #scan;
+    #closed = false;
+    #pausePending = false;
+    #paused = false;
+    #error;
+    #errorKey;
+    #busySince;
+    #recovery;
+    #completed = [];
+    #autoWake = false;
+    constructor(ctx, agent, agents, teams, owner, check) {
+        this.ctx = ctx;
+        this.agent = agent;
+        this.agents = agents;
+        this.teams = teams;
+        this.owner = owner;
+        this.check = check;
+    }
+    get error() { return this.#error; }
+    start() {
+        this.teams.recover(this.owner);
+        this.ctx.on("agent/pre-step", async ({ signal }, next) => {
+            if (!this.#signals.has(signal)) {
+                const cancel = () => {
+                    if (!this.#closed) {
+                        this.#paused = true;
+                        this.#autoWake = false;
+                        this.#pausePending = true;
+                        try {
+                            this.pauseTeams();
+                        }
+                        catch (error) {
+                            this.recordError(error);
+                        }
+                        void this.refresh();
+                    }
+                };
+                this.#signals.set(signal, cancel);
+                signal.addEventListener("abort", cancel, { once: true });
+                if (signal.aborted)
+                    cancel();
+            }
+            await this.refresh();
+            this.check();
+            const decision = await next();
+            this.check();
+            if (decision.kind !== "enter" || this.#paused)
+                return decision;
+            const note = this.notice(decision.messages);
+            return note ? { ...decision, messages: [...decision.messages, note] } : decision;
+        });
+        this.ctx.on("session/event", (session, event) => {
+            if (session !== this.agent.session || this.#closed)
+                return;
+            if (event.type === "agent/inbox/spliced" && event.data.inserted.some(message => message.source.kind === "user")) {
+                this.#paused = false;
+                this.#autoWake = true;
+            }
+            if (event.type === "user/message" && event.data.source.kind === "pbot-results")
+                this.#autoWake = true;
+            if (event.type === "turn/end") {
+                for (const [signal, cancel] of this.#signals)
+                    signal.removeEventListener("abort", cancel);
+                this.#signals.clear();
+                if (event.data.reason.kind === "aborted") {
+                    this.#paused = true;
+                    this.#autoWake = false;
+                    this.#pausePending = true;
+                    try {
+                        this.pauseTeams();
+                    }
+                    catch (error) {
+                        this.recordError(error);
+                    }
+                }
+                void this.refresh();
+            }
+        });
+        this.#timer = setInterval(() => { void this.refresh(); }, 1000);
+        this.#timer.unref();
+        this.ctx.effect(() => () => this.close());
+    }
+    pauseTeams() {
+        if (!this.#pausePending)
+            return;
+        try {
+            this.teams.pauseAll(this.owner, "主会话中断");
+            this.#pausePending = false;
+            this.#dispatching.clear();
+        }
+        catch (error) {
+            if (error.code !== "PBOT_CONTROL_BUSY") {
+                this.teams.fail(error);
+                this.#dispatching.clear();
+            }
+            throw error;
+        }
+    }
+    recordError(error) {
+        if (this.#closed || error.name === "AbortError")
+            return;
+        if (error.code === "PBOT_CONTROL_BUSY") {
+            this.#busySince ??= Date.now();
+            if (Date.now() - this.#busySince < 5000)
+                return;
+        }
+        else
+            this.#busySince = undefined;
+        const message = String(error);
+        let recovery = error.code === "PBOT_CONTROL_BUSY" ? "retry" : "repair";
+        try {
+            this.teams.check();
+        }
+        catch {
+            recovery = "reload";
+        }
+        if (message !== this.#error || recovery !== this.#recovery) {
+            this.ctx.logger.warn("pbot 协作扫描失败：" + message);
+            this.#errorKey = "agent-error:" + randomUUID();
+        }
+        this.#error = message;
+        this.#recovery = recovery;
+    }
+    notice(proposed = []) {
+        const known = new Set([...deliveredDshNotices(this.agent.session.snapshotEvents()),
+            ...pendingDshNotices([...this.agent.inbox.nextTurn, ...this.agent.inbox.nextStep, ...proposed])]);
+        let value;
+        if (this.#error && this.#errorKey) {
+            if (!known.has(this.#errorKey))
+                value = { keys: [this.#errorKey], content: "# 协作扫描故障\n\n" + this.#error +
+                        "\n\n先核对控制记录和原生报告；结果未知不是重跑许可。" +
+                        (this.#recovery === "reload" ? "团队服务已停用；修复文件后还需重载服务端 personal-bot 插件。" :
+                            this.#recovery === "retry" ? "控制锁持续占用，后台会继续重试；不会自动删除锁或重新提交任务。" : "报告或控制记录读取失败，修复后后台会重试扫描。") +
+                        (this.#pausePending ? "\n\n团队暂停尚未确认，不能据此开始成员私人任务。" : "") };
+        }
+        else {
+            value = teamNotice(this.teams.notifications(this.owner, this.agents.list(this.owner)), known) ??
+                agentNotice(this.#completed, this.teams.links(), known);
+        }
+        return value ? createUserMessage({ content: [{ type: "text", text: value.content }],
+            source: { kind: "pbot-results", form: "notice", summary: "Personal Bot 协作更新", keys: value.keys } }) : undefined;
+    }
+    refresh() {
+        if (this.#closed || this.#scan)
+            return this.#scan ?? Promise.resolve();
+        this.#scan = (async () => {
+            try {
+                await this.scan();
+            }
+            catch (error) {
+                this.recordError(error);
+            }
+            if (this.#closed || this.#paused || !this.#autoWake || this.agent.status !== "idle")
+                return;
+            try {
+                this.check();
+                const note = this.notice();
+                if (note) {
+                    // A failed admission cannot start an automatic retry loop. Actual receipt or new human input re-arms wakeup.
+                    this.#autoWake = false;
+                    this.agent.followup(note);
+                    await flushDshAgent(this.agent);
+                }
+            }
+            catch (error) {
+                this.recordError(error);
+            }
+        })().finally(() => { this.#scan = undefined; });
+        return this.#scan;
+    }
+    async scan() {
+        this.check();
+        this.pauseTeams();
+        await this.agents.refresh(this.owner);
+        if (this.#closed)
+            return;
+        this.check();
+        const completed = await this.agents.completions(this.owner);
+        if (this.#closed)
+            return;
+        this.check();
+        this.#completed = completed;
+        try {
+            this.pauseTeams();
+            for (const input of this.teams.advance(this.owner, this.agents.list(this.owner), completed))
+                this.#dispatching.set(input.requestId, input);
+            for (const [id, input] of this.#dispatching) {
+                try {
+                    this.agents.enqueueTeam(input, this.owner);
+                    this.#dispatching.delete(id);
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (code === "PBOT_CONTROL_BUSY")
+                        throw error;
+                    if (code !== "TEAM_INPUT_STALE")
+                        throw error;
+                    this.teams.pauseMember(input.agentId, "安排失效；未自动重发");
+                    this.#dispatching.delete(id);
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== "PBOT_CONTROL_BUSY") {
+                this.teams.fail(error);
+                this.#dispatching.clear();
+            }
+            throw error;
+        }
+        this.#error = undefined;
+        this.#errorKey = undefined;
+        this.#busySince = undefined;
+        this.#recovery = undefined;
+    }
+    async close() {
+        this.#closed = true;
+        if (this.#timer)
+            clearInterval(this.#timer);
+        this.#timer = undefined;
+        for (const [signal, cancel] of this.#signals)
+            signal.removeEventListener("abort", cancel);
+        this.#signals.clear();
+        await this.#scan;
+        this.#dispatching.clear();
+    }
+}

package/lib/extension/dsh/agent-runtime.d.ts

@@ -0,0 +1,49 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { type FileBlock, type ImageBlock } from "@deepseek-ai/dsh-llm";
+import { AgentRun } from "../../services/agents/agent-run.js";
+import type { TeamService } from "../../services/agents/team-service.js";
+import { AgentFiles } from "../../storage/agent-files.js";
+import type { AgentDescriptor } from "../../model/agent.js";
+/** One expert's native event adapter. AgentRun and TeamService own durable business state. */
+export declare class DshAgentRuntime {
+    #private;
+    readonly ctx: Context;
+    readonly agent: Agent;
+    readonly d: AgentDescriptor;
+    readonly generation: string;
+    readonly files: AgentFiles;
+    readonly teams: TeamService;
+    readonly owner: {
+        check(): void;
+        release(): Promise<void>;
+    };
+    readonly execution: AgentRun;
+    constructor(ctx: Context, agent: Agent, d: AgentDescriptor, generation: string, files: AgentFiles, teams: TeamService, owner: {
+        check(): void;
+        release(): Promise<void>;
+    });
+    check: () => void;
+    actor: () => {
+        requestId?: string;
+        kind: "member";
+        agentId: string;
+        generation: string;
+    };
+    private current;
+    private pause;
+    private enqueue;
+    private fail;
+    initialize(teamTool: boolean): void;
+    /** Called only after native Agent creation has resolved, never from setup. */
+    start(): void;
+    interact(text: string, delivery?: "steer" | "followUp", files?: readonly string[], attachments?: readonly (ImageBlock | FileBlock)[], caller?: AbortSignal): Promise<{
+        status: "queued";
+        messageId: import("@deepseek-ai/dsh-llm").MessageId;
+    }>;
+    private event;
+    private humanPending;
+    private pump;
+    private deliver;
+    stop(): Promise<void>;
+}