@botlearn-course/daemon 0.0.1 → 0.0.3

package/dist/run-dispatcher.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { CourseClientError, isRunTerminal } from "./course-client.js";
 import { reportFileCandidates } from "./file-candidates.js";
 import { log as defaultLog } from "./log.js";
+import { MAX_PROGRESS_EVENTS_PER_ATTEMPT, tryNormalizeProgressReport, } from "./mcp/report-progress.js";
 import { errorInfo, redactSecretString, truncateText } from "./redaction.js";
 import { missingRunCapabilities } from "./runtime-capabilities.js";
 import { RunQueue } from "./run-queue.js";
@@ -35,10 +36,13 @@ export class RunDispatcher {
     runtimes;
     queue = new RunQueue();
     inflight = new Map();
+    scheduledRunIds = new Set();
+    pendingCancellations = new Set();
     defaultRuntimeId;
     log;
     scanLimits;
     now;
+    persistentSession;
     constructor(client, runtimes, opts = {}) {
         this.client = client;
         this.runtimes = runtimes;
@@ -46,22 +50,37 @@ export class RunDispatcher {
         this.log = opts.log ?? defaultLog;
         this.scanLimits = opts.scanLimits;
         this.now = opts.now ?? Date.now;
+        this.persistentSession = opts.persistentSession;
     }
     /** 排队执行一个 run。返回的 Promise 不 reject（失败已归一化回报为 run.failed）。 */
     dispatch(payload) {
         const key = payload.agent_instance_id ?? payload.agent_run_id;
-        return this.queue.enqueue(key, () => this.execute(payload));
+        this.scheduledRunIds.add(payload.agent_run_id);
+        return this.queue
+            .enqueue(key, () => this.execute(payload))
+            .finally(() => {
+            this.scheduledRunIds.delete(payload.agent_run_id);
+            this.pendingCancellations.delete(payload.agent_run_id);
+        });
     }
     cancel(agentRunId) {
         const controller = this.inflight.get(agentRunId);
-        if (!controller)
+        if (controller) {
+            controller.abort();
+            return true;
+        }
+        if (!this.scheduledRunIds.has(agentRunId))
             return false;
-        controller.abort();
+        // dispatch() queues execution on a microtask. A durable cancel may arrive after the
+        // command ACK but before execute() installs its AbortController.
+        this.pendingCancellations.add(agentRunId);
         return true;
     }
     cancelAll() {
         for (const controller of this.inflight.values())
             controller.abort();
+        for (const runId of this.scheduledRunIds)
+            this.pendingCancellations.add(runId);
     }
     get activeCount() {
         return this.inflight.size;
@@ -80,6 +99,8 @@ export class RunDispatcher {
         const runId = payload.agent_run_id;
         const controller = new AbortController();
         this.inflight.set(runId, controller);
+        if (this.pendingCancellations.delete(runId))
+            controller.abort();
         let seq = 0;
         // 服务端已把本 run 判为终态（409）：停止一切后续上报。
         let serverTerminal = false;
@@ -90,6 +111,15 @@ export class RunDispatcher {
         let profileApplied = false;
         let toolCalls = 0;
         let toolLimitExceeded = false;
+        let progressEvents = 0;
+        let lastProgressKey = null;
+        const progressDisposition = {
+            accepted: 0,
+            deduplicated: 0,
+            invalid: 0,
+            over_limit: 0,
+            server_rejected: 0,
+        };
         const startedAt = this.now();
         const usage = () => ({
             wall_time_ms: Math.max(0, this.now() - startedAt),
@@ -163,12 +193,13 @@ export class RunDispatcher {
                     ...runtimeProfileInstructions(payload, applied),
                 ];
             }
-            const { workspaceDir } = ensureRunWorkspace(runId);
+            const persistentTurn = this.persistentSession?.prepareTurn(payload);
+            const { workspaceDir } = persistentTurn ?? ensureRunWorkspace(runId);
             const missingCapabilities = missingRunCapabilities(payload, workspaceDir);
             if (missingCapabilities.length > 0) {
                 throw new RuntimeExecutionError(`runtime is missing required capabilities: ${missingCapabilities.join(", ")}`, "runtime_unavailable");
             }
-            const transcript = new TranscriptWriter(transcriptPath(runId));
+            const transcript = new TranscriptWriter(persistentTurn?.transcriptFile ?? transcriptPath(runId));
             const timeoutSeconds = clampTimeoutSeconds(payload.limits.timeout_seconds);
             timer = setTimeout(() => {
                 timedOut = true;
@@ -178,7 +209,74 @@ export class RunDispatcher {
             // 上一次真正上了 wire 的块 kind：thinking/status 只在 kind 切换时上报一次，避免刷屏。
             let lastReportedKind = null;
             const sink = {
+                progressDispositions: async (dispositions) => {
+                    progressDisposition.invalid += dispositions.invalid;
+                    progressDisposition.deduplicated += dispositions.deduplicated;
+                    progressDisposition.over_limit += dispositions.over_limit;
+                },
                 block: async (block) => {
+                    if (block.kind === "progress") {
+                        const normalized = tryNormalizeProgressReport({
+                            summary: block.summary,
+                            status: block.status,
+                        });
+                        if (!normalized) {
+                            progressDisposition.invalid += 1;
+                            return;
+                        }
+                        // Redact before the local transcript and every reporting client boundary.
+                        const progress = tryNormalizeProgressReport({
+                            summary: redactSecretString(normalized.summary),
+                            status: normalized.status,
+                        });
+                        // Redaction can expand a token marker past 240 code points; never truncate or send it.
+                        if (!progress) {
+                            progressDisposition.invalid += 1;
+                            return;
+                        }
+                        const key = `${progress.status}\0${progress.summary}`;
+                        if (key === lastProgressKey) {
+                            progressDisposition.deduplicated += 1;
+                            return;
+                        }
+                        if (progressEvents >= MAX_PROGRESS_EVENTS_PER_ATTEMPT) {
+                            progressDisposition.over_limit += 1;
+                            return;
+                        }
+                        lastProgressKey = key;
+                        progressEvents += 1;
+                        transcript.writeBlock({
+                            kind: "progress",
+                            runtime: runtime.id,
+                            summary: progress.summary,
+                            status: progress.status,
+                        });
+                        if (serverTerminal)
+                            return;
+                        try {
+                            await send({
+                                type: "run.block",
+                                payload: {
+                                    schema_version: "agent-progress/0.1",
+                                    kind: "progress",
+                                    runtime: runtime.id,
+                                    summary: progress.summary,
+                                    status: progress.status,
+                                },
+                            });
+                            if (!serverTerminal)
+                                progressDisposition.accepted += 1;
+                        }
+                        catch (error) {
+                            if (error instanceof CourseClientError &&
+                                (error.status === 400 || error.status === 422)) {
+                                progressDisposition.server_rejected += 1;
+                                return;
+                            }
+                            throw error;
+                        }
+                        return;
+                    }
                     transcript.writeBlock(block);
                     if (block.kind === "tool_call") {
                         toolCalls += 1;
@@ -212,8 +310,23 @@ export class RunDispatcher {
                 file: async (file) => {
                     await this.client.postFile(runId, file);
                 },
+                runtimeSession: async (sessionId) => {
+                    this.persistentSession?.persistNativeSession(sessionId);
+                },
             };
-            await runtime.run({ payload, workspaceDir }, sink, controller.signal);
+            await runtime.run({
+                payload,
+                workspaceDir,
+                ...(persistentTurn
+                    ? {
+                        nativeSessionId: persistentTurn.nativeSessionId,
+                        contextRevision: persistentTurn.contextRevision,
+                        ...(persistentTurn.runtimeEnv
+                            ? { runtimeEnv: persistentTurn.runtimeEnv }
+                            : {}),
+                    }
+                    : {}),
+            }, sink, controller.signal);
             clearTimeout(timer);
             if (serverTerminal)
                 return;
@@ -288,6 +401,13 @@ export class RunDispatcher {
                 clearTimeout(timer);
             if (profileApplied)
                 cleanupRunRuntimeProfile(runId);
+            if (Object.values(progressDisposition).some((count) => count > 0)) {
+                this.log.info("progress event dispositions", {
+                    agentRunId: runId,
+                    runtime: runtimeId,
+                    ...progressDisposition,
+                });
+            }
             this.inflight.delete(runId);
         }
     }

package/dist/runtime-env.d.ts

@@ -0,0 +1,9 @@
+/** Remove Course control-plane coordinates before any model/runtime child is created. */
+export declare function clearAgentServiceControlEnv(env?: NodeJS.ProcessEnv): void;
+/** Copy an environment for a runtime child without leaking Agent Service control values. */
+export declare function runtimeChildEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** Run model processes as the Template's untrusted runtime UID when configured. */
+export declare function runtimeChildIdentity(env?: NodeJS.ProcessEnv): {
+    uid?: number;
+    gid?: number;
+};

package/dist/runtime-env.js

@@ -0,0 +1,40 @@
+const AGENT_SERVICE_CONTROL_ENV_KEYS = [
+    "BOTLEARN_COURSE_API_URL",
+    "BOTLEARN_AGENT_SERVICE_RUN_ID",
+    "BOTLEARN_AGENT_SERVICE_RUN_TOKEN",
+    "BOTLEARN_AGENT_SERVICE_WORKER_ID",
+    "BOTLEARN_AGENT_SERVICE_WS_URL",
+    "BOTLEARN_AGENT_SERVICE_RUNTIME_SESSION_ID",
+    "BOTLEARN_AGENT_SERVICE_SESSION_TOKEN",
+];
+const AGENT_SERVICE_SUPERVISOR_ENV_KEYS = [
+    "BOTLEARN_RUNTIME_UID",
+    "BOTLEARN_RUNTIME_GID",
+    "BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT",
+    "BOTLEARN_AGENT_SERVICE_PROFILE_ROOT",
+];
+/** Remove Course control-plane coordinates before any model/runtime child is created. */
+export function clearAgentServiceControlEnv(env = process.env) {
+    for (const key of AGENT_SERVICE_CONTROL_ENV_KEYS)
+        delete env[key];
+}
+/** Copy an environment for a runtime child without leaking Agent Service control values. */
+export function runtimeChildEnv(env = process.env) {
+    const childEnv = { ...env };
+    clearAgentServiceControlEnv(childEnv);
+    for (const key of AGENT_SERVICE_SUPERVISOR_ENV_KEYS)
+        delete childEnv[key];
+    return childEnv;
+}
+/** Run model processes as the Template's untrusted runtime UID when configured. */
+export function runtimeChildIdentity(env = process.env) {
+    const uid = Number(env.BOTLEARN_RUNTIME_UID);
+    const gid = Number(env.BOTLEARN_RUNTIME_GID);
+    if (!Number.isInteger(uid) ||
+        uid < 1 ||
+        !Number.isInteger(gid) ||
+        gid < 1) {
+        return {};
+    }
+    return { uid, gid };
+}

package/dist/runtime-profile.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
-import { mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import path from "node:path";
-import { runtimeProfileDir, runRootDir } from "./workspace.js";
+import { runtimeProfileDir, runtimeProfileRunRootDir } from "./workspace.js";
 const SAFE_ASSET_ID = /^[a-z0-9][a-z0-9._-]{0,159}$/;
 const SHA256 = /^sha256:[0-9a-f]{64}$/;
 const MAX_SKILL_PACKAGES = 32;
@@ -20,13 +20,19 @@ export function applyRunRuntimeProfile(payload, raw) {
     if (payload.context.profileHash !== profile.profileHash) {
         throw new RuntimeProfileApplyError("run.start profileHash does not match runtime profile");
     }
-    const runDir = runRootDir(payload.agent_run_id);
+    const runDir = runtimeProfileRunRootDir(payload.agent_run_id);
     const target = runtimeProfileDir(payload.agent_run_id);
-    mkdirSync(runDir, { recursive: true, mode: 0o700 });
+    const managedReadView = Boolean(process.env.BOTLEARN_AGENT_SERVICE_PROFILE_ROOT?.trim());
+    const directoryMode = managedReadView ? 0o750 : 0o700;
+    const fileMode = managedReadView ? 0o640 : 0o600;
+    mkdirSync(runDir, { recursive: true, mode: directoryMode });
+    chmodSync(runDir, directoryMode);
     const staging = mkdtempSync(path.join(runDir, ".runtime-profile-"));
+    chmodSync(staging, directoryMode);
     try {
         const skillsRoot = path.join(staging, "skills");
-        mkdirSync(skillsRoot, { recursive: true, mode: 0o700 });
+        mkdirSync(skillsRoot, { recursive: true, mode: directoryMode });
+        chmodSync(skillsRoot, directoryMode);
         const skillRefs = [];
         const skillIds = new Set();
         for (const skill of profile.skillPackages) {
@@ -34,12 +40,14 @@ export function applyRunRuntimeProfile(payload, raw) {
                 throw new RuntimeProfileApplyError(`duplicate runtime Skill id: ${skill.id}`);
             }
             skillIds.add(skill.id);
-            installSkillPackage(skillsRoot, skill);
+            installSkillPackage(skillsRoot, skill, { directoryMode, fileMode });
             skillRefs.push(`${skill.id}@${skill.version}`);
         }
         const promptPackPath = path.join(staging, "prompt-pack.md");
-        writeFileSync(promptPackPath, profile.promptPack.systemInstructions, { mode: 0o600 });
-        writeFileSync(path.join(staging, "profile.json"), `${JSON.stringify({
+        writeFileSync(promptPackPath, profile.promptPack.systemInstructions, { mode: fileMode });
+        chmodSync(promptPackPath, fileMode);
+        const manifestPath = path.join(staging, "profile.json");
+        writeFileSync(manifestPath, `${JSON.stringify({
             schemaVersion: profile.schemaVersion,
             profileId: profile.profileId,
             profileHash: profile.profileHash,
@@ -51,7 +59,8 @@ export function applyRunRuntimeProfile(payload, raw) {
             },
             skillRefs,
             requiredCapabilities: profile.requiredCapabilities,
-        }, null, 2)}\n`, { mode: 0o600 });
+        }, null, 2)}\n`, { mode: fileMode });
+        chmodSync(manifestPath, fileMode);
         rmSync(target, { recursive: true, force: true });
         renameSync(staging, target);
         return {
@@ -94,7 +103,7 @@ export function runtimeProfileInstructions(payload, applied) {
             : []),
     ];
 }
-function installSkillPackage(skillsRoot, skill) {
+function installSkillPackage(skillsRoot, skill, modes) {
     assertSafeAssetId(skill.id, "Skill id");
     if (!SHA256.test(skill.digest)) {
         throw new RuntimeProfileApplyError(`Skill ${skill.id} has an invalid digest`);
@@ -104,11 +113,14 @@ function installSkillPackage(skillsRoot, skill) {
         throw new RuntimeProfileApplyError(`Skill ${skill.id}@${skill.version} digest mismatch`);
     }
     const skillDir = path.join(skillsRoot, skill.id);
-    mkdirSync(skillDir, { recursive: true, mode: 0o700 });
+    mkdirSync(skillDir, { recursive: true, mode: modes.directoryMode });
+    chmodSync(skillDir, modes.directoryMode);
     for (const entry of entries) {
         const destination = path.join(skillDir, entry.path);
-        mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
-        writeFileSync(destination, entry.content, { mode: 0o600 });
+        mkdirSync(path.dirname(destination), { recursive: true, mode: modes.directoryMode });
+        chmodSync(path.dirname(destination), modes.directoryMode);
+        writeFileSync(destination, entry.content, { mode: modes.fileMode });
+        chmodSync(destination, modes.fileMode);
     }
 }
 function archiveEntries(skill) {

package/dist/runtimes/acp-stream.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { runtimeChildIdentity } from "../runtime-env.js";
 import { sanitizeRuntimeFailureText } from "../redaction.js";
 import { sliceUtf8Bytes, utf8ByteLength } from "./text-cap.js";
 import { consoleLogger, } from "./engine.js";
@@ -206,6 +207,7 @@ export class AcpRuntimeAdapter {
         const child = spawn(binary, args, {
             cwd: opts.cwd,
             env: this.spawnEnv(opts),
+            ...runtimeChildIdentity(),
             stdio: ["pipe", "pipe", "pipe"],
         });
         let killTimer = null;

package/dist/runtimes/codex.d.ts

@@ -38,7 +38,7 @@ export declare class CodexAdapter extends NdjsonStreamAdapter {
      * `--` 隔开 flags 与 positionals，防止以 `-` 开头的 prompt 被解析成选项。
      */
     protected buildArgs(opts: EngineRunOptions): string[];
-    protected spawnEnv(_opts: EngineRunOptions): NodeJS.ProcessEnv;
+    protected spawnEnv(opts: EngineRunOptions): NodeJS.ProcessEnv;
     protected handleEvent(raw: unknown, ctx: NdjsonEventCtx): void;
 }
 export declare const codexModule: RuntimeModule;

package/dist/runtimes/codex.js

@@ -181,9 +181,9 @@ export class CodexAdapter extends NdjsonStreamAdapter {
         }
         return ["exec", ...tail, "--", prompt];
     }
-    spawnEnv(_opts) {
+    spawnEnv(opts) {
         return {
-            ...process.env,
+            ...super.spawnEnv(opts),
             // 保证 JSONL 输出不混入 ANSI 转义。
             FORCE_COLOR: "0",
             NO_COLOR: "1",

package/dist/runtimes/deepseek-tui.d.ts

@@ -2,13 +2,15 @@ import { spawn } from "node:child_process";
 import { type ProbeDeps } from "./probe.js";
 import { type EngineAdapter, type EngineRunOptions, type EngineRunResult } from "./engine.js";
 import type { RuntimeModule, RuntimeProbe } from "../types.js";
-interface DeepseekAdapterDeps {
+export interface DeepseekAdapterDeps {
     binary?: string;
     /** 测试注入：使用现成的兼容 server，不 spawn `deepseek`。 */
     serverUrl?: string;
     authToken?: string;
     fetchFn?: typeof fetch;
     spawnFn?: typeof spawn;
+    /** External servers must explicitly attest compatible progress tool events. */
+    progressEventMapping?: boolean;
 }
 /** 解析 PATH 上的 `deepseek` dispatcher CLI。 */
 export declare function resolveDeepseekCommand(deps?: ProbeDeps): string | null;
@@ -28,6 +30,8 @@ export declare class DeepseekTuiAdapter implements EngineAdapter {
     private readonly explicitAuthToken;
     private readonly fetchFn;
     private readonly spawnFn;
+    readonly progressEventMappingEnabled: boolean;
+    readonly progressPromptInjectionEnabled: boolean;
     private resolvedBinary;
     constructor(deps?: DeepseekAdapterDeps);
     run(opts: EngineRunOptions): Promise<EngineRunResult>;
@@ -41,10 +45,10 @@ export declare class DeepseekTuiAdapter implements EngineAdapter {
     private createThread;
     private patchThreadSystemContext;
     private startTurnAndReadEvents;
+    private interruptTurn;
     private readEvents;
     private requestJson;
 }
 /** 仅测试用：清空进程池。 */
 export declare function __resetDeepseekTuiPoolForTests(): void;
 export declare const deepseekTuiModule: RuntimeModule;
-export {};