@botlearn-course/daemon 0.0.14 → 0.0.15

package/dist/agent-service-sandbox.d.ts

@@ -56,6 +56,15 @@ export declare class AgentServiceSandboxClient implements RunReportingClient, Pe
     private stopped;
     private permanentFailure;
     private lifecycleChain;
+    private runtimeLogPolicy;
+    private runtimeLogHandshakeReady;
+    private runtimeLogWindowStartedAt;
+    private runtimeLogWindowEvents;
+    private runtimeLogWindowBytes;
+    private runtimeLogSuppressedEvents;
+    private runtimeLogSuppressedBytes;
+    private runtimeLogSendChain;
+    private readonly removeOperationalLogSink;
     constructor(options: AgentServiceSandboxOptions);
     prepareTurn(payload: RunStartPayload): PreparedPersistentTurn;
     persistNativeSession(nativeSessionId: string): void;
@@ -69,6 +78,8 @@ export declare class AgentServiceSandboxClient implements RunReportingClient, Pe
     getRunRuntimeProfile(agentRunId: string): Promise<CourseRuntimeProfile>;
     private connectOnce;
     private handleHello;
+    private forwardOperationalLog;
+    private queueRuntimeLog;
     private assertServerFrame;
     private handleServerFrame;
     /** sandbox.sync 只做对账：重放 spool、关闭待关 session、应用 drain/shutdown。 */

package/dist/agent-service-sandbox.js

@@ -2,7 +2,7 @@ import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readF
 import path from "node:path";
 import { ensureDaemonHome } from "./auth-store.js";
 import { AGENT_SERVICE_WS_SCHEMA, AGENT_SERVICE_WS_SUBPROTOCOL, createSandboxFrame, parseSandboxFrame, UnsupportedSandboxProtocolError, } from "./agent-service-ws-protocol.js";
-import { log as defaultLog } from "./log.js";
+import { log as defaultLog, setOperationalLogSink, } from "./log.js";
 import { availableRunCapabilities, runtimeSupportsCourseSkills, } from "./runtime-capabilities.js";
 import { activationRuntimeEnv, runtimeChildEnv } from "./runtime-env.js";
 import { redactSecretString } from "./redaction.js";
@@ -17,6 +17,70 @@ const MAX_EVENT_ACK_WINDOW = 64;
 const LEGACY_EVENT_ACK_WINDOW = 1;
 /** 出站 seq 基址：seq = connection_epoch * SEQ_EPOCH_BASE + n，跨重连单调（合同 §1.1）。 */
 const SEQ_EPOCH_BASE = 1_000_000_000;
+const RUNTIME_LOG_WINDOW_MS = 60_000;
+const DISABLED_RUNTIME_LOG_POLICY = {
+    enabled: false,
+    maxEventBytes: 4096,
+    maxEventsPerMinute: 1,
+    maxBytesPerMinute: 4096,
+};
+function boundedUtf8(value, maxBytes) {
+    const encoded = Buffer.from(value, "utf8");
+    if (encoded.length <= maxBytes)
+        return value;
+    const suffix = "…[truncated]";
+    const budget = Math.max(0, maxBytes - Buffer.byteLength(suffix, "utf8"));
+    return encoded.subarray(0, budget).toString("utf8").replace(/�$/u, "") + suffix;
+}
+function boundedLogFields(fields, maxBytes) {
+    if (!fields || maxBytes < 2)
+        return { bytes: 0 };
+    const bounded = {};
+    let truncated = false;
+    for (const [key, value] of Object.entries(fields)) {
+        bounded[key] = value;
+        let bytes;
+        try {
+            bytes = Buffer.byteLength(JSON.stringify(bounded), "utf8");
+        }
+        catch {
+            bytes = maxBytes + 1;
+        }
+        if (bytes > maxBytes) {
+            delete bounded[key];
+            truncated = true;
+            break;
+        }
+    }
+    if (truncated) {
+        const marked = { ...bounded, runtime_log_fields_truncated: true };
+        if (Buffer.byteLength(JSON.stringify(marked), "utf8") <= maxBytes) {
+            Object.assign(bounded, { runtime_log_fields_truncated: true });
+        }
+    }
+    if (!Object.keys(bounded).length)
+        return { bytes: 0 };
+    const bytes = Buffer.byteLength(JSON.stringify(bounded), "utf8");
+    return { fields: bounded, bytes };
+}
+function runtimeLogPolicy(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return DISABLED_RUNTIME_LOG_POLICY;
+    }
+    const raw = value;
+    const integer = (key, fallback, min, max) => {
+        const candidate = Number(raw[key]);
+        return Number.isSafeInteger(candidate) && candidate >= min && candidate <= max
+            ? candidate
+            : fallback;
+    };
+    return {
+        enabled: raw.enabled === true,
+        maxEventBytes: integer("max_event_bytes", 4096, 256, 16_384),
+        maxEventsPerMinute: integer("max_events_per_minute", 60, 1, 600),
+        maxBytesPerMinute: integer("max_bytes_per_minute", 131_072, 4096, 1_048_576),
+    };
+}
 function inputAttachmentGrant(value) {
     if (value === undefined || value === null)
         return undefined;
@@ -277,6 +341,15 @@ export class AgentServiceSandboxClient {
     stopped = false;
     permanentFailure = false;
     lifecycleChain = Promise.resolve();
+    runtimeLogPolicy = DISABLED_RUNTIME_LOG_POLICY;
+    runtimeLogHandshakeReady = false;
+    runtimeLogWindowStartedAt = 0;
+    runtimeLogWindowEvents = 0;
+    runtimeLogWindowBytes = 0;
+    runtimeLogSuppressedEvents = 0;
+    runtimeLogSuppressedBytes = 0;
+    runtimeLogSendChain = Promise.resolve();
+    removeOperationalLogSink;
     constructor(options) {
         this.options = options;
         this.log = options.log ?? defaultLog;
@@ -288,6 +361,9 @@ export class AgentServiceSandboxClient {
         this.dispatcher = new RunDispatcher(this, options.runtimes, {
             persistentSession: this,
         });
+        this.removeOperationalLogSink = setOperationalLogSink((entry) => {
+            this.forwardOperationalLog(entry);
+        });
     }
     prepareTurn(payload) {
         const scope = this.turnScopes.get(payload.agent_run_id);
@@ -448,6 +524,7 @@ export class AgentServiceSandboxClient {
                 await this.sleep(delay);
             }
         }
+        this.removeOperationalLogSink();
         if (this.permanentFailure) {
             throw new Error("Agent Service sandbox stopped after a permanent protocol failure");
         }
@@ -464,6 +541,8 @@ export class AgentServiceSandboxClient {
         this.activeSessionId = null;
         this.currentTurnSessionId = null;
         this.persist();
+        this.runtimeLogHandshakeReady = false;
+        this.removeOperationalLogSink();
         this.socket?.close(1000, "daemon_stopping");
     }
     async postEvent(agentRunId, event) {
@@ -639,6 +718,7 @@ export class AgentServiceSandboxClient {
             this.rejectPendingFiles(new Error("Agent Service file transport disconnected"));
             if (this.socket === socket)
                 this.socket = null;
+            this.runtimeLogHandshakeReady = false;
             if (socket.readyState === WebSocketClient.OPEN)
                 socket.close(1000, "reconnecting");
         }
@@ -683,6 +763,7 @@ export class AgentServiceSandboxClient {
             ? advertisedAckWindow
             : LEGACY_EVENT_ACK_WINDOW;
         this.maxUnackedEvents = Math.min(MAX_EVENT_ACK_WINDOW, ackWindow);
+        this.runtimeLogPolicy = runtimeLogPolicy(frame.payload.runtime_log_policy);
         this.persist();
         await this.sendControlFrame("sandbox.ready", {
             protocol_versions: [AGENT_SERVICE_WS_SCHEMA],
@@ -696,6 +777,73 @@ export class AgentServiceSandboxClient {
             resumed_sessions: Object.keys(this.state.sessions),
             spool_frames: this.spoolFrameCount(),
         });
+        this.runtimeLogHandshakeReady = true;
+    }
+    forwardOperationalLog(entry) {
+        const policy = this.runtimeLogPolicy;
+        if (!policy.enabled || !this.runtimeLogHandshakeReady)
+            return;
+        const message = boundedUtf8(entry.message, policy.maxEventBytes);
+        const messageBytes = Buffer.byteLength(message, "utf8");
+        const boundedFields = boundedLogFields(entry.fields, Math.max(0, policy.maxEventBytes - messageBytes));
+        const contentBytes = messageBytes + boundedFields.bytes;
+        const now = Date.now();
+        if (now - this.runtimeLogWindowStartedAt >= RUNTIME_LOG_WINDOW_MS) {
+            if (this.runtimeLogSuppressedEvents > 0) {
+                this.queueRuntimeLog({
+                    level: "warn",
+                    message: "sandbox runtime logs suppressed at daemon source",
+                    fields: {
+                        suppressed_count: this.runtimeLogSuppressedEvents,
+                        suppressed_bytes: this.runtimeLogSuppressedBytes,
+                    },
+                    timestamp: new Date(now).toISOString(),
+                });
+            }
+            this.runtimeLogWindowStartedAt = now;
+            this.runtimeLogWindowEvents = 0;
+            this.runtimeLogWindowBytes = 0;
+            this.runtimeLogSuppressedEvents = 0;
+            this.runtimeLogSuppressedBytes = 0;
+        }
+        if (this.runtimeLogWindowEvents >= policy.maxEventsPerMinute ||
+            this.runtimeLogWindowBytes + contentBytes > policy.maxBytesPerMinute) {
+            this.runtimeLogSuppressedEvents += 1;
+            this.runtimeLogSuppressedBytes += contentBytes;
+            return;
+        }
+        this.runtimeLogWindowEvents += 1;
+        this.runtimeLogWindowBytes += contentBytes;
+        this.queueRuntimeLog({
+            ...entry,
+            message,
+            fields: boundedFields.fields,
+        });
+    }
+    queueRuntimeLog(entry) {
+        this.runtimeLogSendChain = this.runtimeLogSendChain
+            .then(async () => {
+            if (!this.runtimeLogHandshakeReady || this.socket?.readyState !== WebSocketClient.OPEN) {
+                return;
+            }
+            await this.sendFrame(createSandboxFrame({
+                type: "sandbox.log",
+                sandboxId: this.options.sandboxId,
+                sandboxGeneration: this.sandboxGeneration,
+                connectionEpoch: this.connectionEpoch,
+                seq: this.nextOutboundSeq(),
+                payload: {
+                    level: entry.level,
+                    stream: "stderr",
+                    message: entry.message,
+                    emitted_at: entry.timestamp,
+                    ...(entry.fields ? { fields: entry.fields } : {}),
+                },
+            }));
+        })
+            .catch(() => {
+            // Sentry forwarding is best-effort and must not enter the daemon logger.
+        });
     }
     assertServerFrame(frame) {
         if (frame.sandbox_id !== this.options.sandboxId ||
@@ -1092,7 +1240,10 @@ export class AgentServiceSandboxClient {
             await this.sendCommandAck(frame, "rejected", "turn_scope_mismatch");
             return;
         }
-        this.dispatcher.cancel(frame.agent_run_id);
+        if (!this.dispatcher.cancel(frame.agent_run_id)) {
+            await this.sendCommandAck(frame, "rejected", "turn_not_running");
+            return;
+        }
         await this.sendCommandAck(frame, "ok");
     }
     /**

package/dist/agent-service-ws-protocol.d.ts

@@ -1,6 +1,6 @@
 export declare const AGENT_SERVICE_WS_SCHEMA: "botlearn-agent-sandbox-ws/0.2";
 export declare const AGENT_SERVICE_WS_SUBPROTOCOL: "botlearn-agent-sandbox.v2";
-export type SandboxFrameType = "sandbox.hello" | "sandbox.sync" | "session.open" | "session.activate" | "turn.start" | "turn.cancel" | "session.close" | "sandbox.drain" | "sandbox.shutdown" | "event.ack" | "auth.rotate" | "ping" | "sandbox.ready" | "sandbox.heartbeat" | "command.ack" | "session.opened" | "session.closed" | "turn.event" | "turn.file.report" | "sandbox.drained" | "pong" | "protocol.error";
+export type SandboxFrameType = "sandbox.hello" | "sandbox.sync" | "session.open" | "session.activate" | "turn.start" | "turn.cancel" | "session.close" | "sandbox.drain" | "sandbox.shutdown" | "event.ack" | "auth.rotate" | "ping" | "sandbox.ready" | "sandbox.heartbeat" | "command.ack" | "session.opened" | "session.closed" | "turn.event" | "turn.file.report" | "sandbox.drained" | "sandbox.log" | "pong" | "protocol.error";
 export declare class UnsupportedSandboxProtocolError extends Error {
     readonly schemaVersion: unknown;
     constructor(schemaVersion: unknown);

package/dist/agent-service-ws-protocol.js

@@ -22,6 +22,7 @@ const FRAME_TYPES = new Set([
     "turn.event",
     "turn.file.report",
     "sandbox.drained",
+    "sandbox.log",
     "pong",
     "protocol.error",
 ]);

package/dist/log.d.ts

@@ -1,4 +1,13 @@
 type Level = "info" | "warn" | "error" | "debug";
+export interface OperationalLogEntry {
+    level: Level;
+    message: string;
+    fields?: Record<string, unknown>;
+    timestamp: string;
+}
+export type OperationalLogSink = (entry: OperationalLogEntry) => void;
+/** One managed sandbox daemon runs per process, so it owns one ephemeral remote sink. */
+export declare function setOperationalLogSink(sink: OperationalLogSink): () => void;
 export interface Logger {
     info(msg: string, fields?: Record<string, unknown>): void;
     warn(msg: string, fields?: Record<string, unknown>): void;

package/dist/log.js

@@ -1,7 +1,7 @@
 import { appendFileSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync } from "node:fs";
 import path from "node:path";
 import { daemonHome } from "./auth-store.js";
-import { redactSecretsDeep } from "./redaction.js";
+import { redactSecretString, redactSecretsDeep } from "./redaction.js";
 const LOG_DIR = path.join(daemonHome(), "logs");
 const LOG_FILE = path.join(LOG_DIR, "daemon.log");
 const LOG_ROTATE_MAX_BYTES = 10 * 1024 * 1024;
@@ -18,6 +18,15 @@ function ensureDir() {
     }
     inited = true;
 }
+let operationalLogSink = null;
+/** One managed sandbox daemon runs per process, so it owns one ephemeral remote sink. */
+export function setOperationalLogSink(sink) {
+    operationalLogSink = sink;
+    return () => {
+        if (operationalLogSink === sink)
+            operationalLogSink = null;
+    };
+}
 function formatValue(value) {
     if (value instanceof Error)
         return JSON.stringify(value.stack ?? value.message);
@@ -131,7 +140,9 @@ function write(level, msg, fields) {
     ensureDir();
     // 所有 fields 值序列化前先深度脱敏，token 类值绝不落盘/上屏。
     const safeFields = fields === undefined ? undefined : redactSecretsDeep(fields);
-    const line = formatLogLine(level, msg, safeFields);
+    const safeMessage = redactSecretString(msg);
+    const timestamp = new Date();
+    const line = formatLogLine(level, safeMessage, safeFields, timestamp);
     try {
         rotateLogIfNeeded(LOG_FILE, Buffer.byteLength(line) + 1);
         appendFileSync(LOG_FILE, line + "\n", { mode: 0o600 });
@@ -141,6 +152,17 @@ function write(level, msg, fields) {
     }
     // 同步镜像到 stderr，前台运行时可直接观察。
     process.stderr.write(line + "\n");
+    try {
+        operationalLogSink?.({
+            level,
+            message: safeMessage,
+            fields: safeFields,
+            timestamp: timestamp.toISOString(),
+        });
+    }
+    catch {
+        // Observability must never affect daemon execution or recurse into the logger.
+    }
 }
 export const log = {
     info: (msg, fields) => write("info", msg, fields),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botlearn-course/daemon",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "Lightweight BotLearn Course daemon: run course tasks on your own machine with your own agent runtime (BYOA).",
   "type": "module",
   "bin": {