@botlearn-course/daemon 0.0.1

package/dist/runtimes/probe.d.ts

@@ -0,0 +1,17 @@
+import { execFileSync } from "node:child_process";
+/** Injection seam for PATH resolution + version probes, so tests can stub syscalls. */
+export interface ProbeDeps {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    execFileSyncFn?: typeof execFileSync;
+    existsSyncFn?: (p: string) => boolean;
+}
+/** Resolve a command name on PATH via `which`/`where`; returns null when missing. */
+export declare function resolveCommandOnPath(command: string, deps?: ProbeDeps): string | null;
+/** Return the first path in `candidates` that exists on disk, or null. */
+export declare function firstExistingPath(candidates: string[], deps?: ProbeDeps): string | null;
+/** Run `<command> [...args] --version` and return the first output line, or null. */
+export declare function readCommandVersion(command: string, args?: string[], deps?: ProbeDeps): string | null;
+/** Join `relativePath` against HOME (falls back to empty when unset). */
+export declare function resolveHomePath(relativePath: string, deps?: ProbeDeps): string;

package/dist/runtimes/probe.js

@@ -0,0 +1,54 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+function normalizeExecOutput(raw) {
+    return Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw ?? "");
+}
+/** Resolve a command name on PATH via `which`/`where`; returns null when missing. */
+export function resolveCommandOnPath(command, deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const execFn = deps.execFileSyncFn ?? execFileSync;
+    const locator = platform === "win32" ? "where" : "which";
+    try {
+        const out = normalizeExecOutput(execFn(locator, [command], {
+            stdio: ["ignore", "pipe", "ignore"],
+            env,
+        }));
+        const resolved = out.trim().split(/\r?\n/)[0];
+        return resolved || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Return the first path in `candidates` that exists on disk, or null. */
+export function firstExistingPath(candidates, deps = {}) {
+    const exists = deps.existsSyncFn ?? existsSync;
+    for (const c of candidates) {
+        if (exists(c))
+            return c;
+    }
+    return null;
+}
+/** Run `<command> [...args] --version` and return the first output line, or null. */
+export function readCommandVersion(command, args = [], deps = {}) {
+    const env = deps.env ?? process.env;
+    const execFn = deps.execFileSyncFn ?? execFileSync;
+    try {
+        const out = normalizeExecOutput(execFn(command, [...args, "--version"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env,
+            timeout: 5000,
+        }));
+        return out.trim().split(/\r?\n/)[0] || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Join `relativePath` against HOME (falls back to empty when unset). */
+export function resolveHomePath(relativePath, deps = {}) {
+    const home = deps.homeDir ?? deps.env?.HOME ?? process.env.HOME ?? "";
+    return path.join(home, relativePath);
+}

package/dist/runtimes/runtime-errors.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Runtime CLIs sometimes report authentication failures as ordinary final
+ * text. Keep this intentionally narrow so normal model replies about auth do
+ * not get reclassified unless they look like a top-level CLI/API failure.
+ */
+export declare function looksLikeRuntimeAuthFailure(text: string): boolean;
+export declare function looksLikeUsageLimit(text: string): boolean;
+/**
+ * Pull the reset hint straight out of the runtime's own words — never compute it
+ * locally, since the runtime already knows the user's plan window and timezone
+ * and we do not. Returns a ready-to-render fragment: an absolute clock time like
+ * "2pm (America/New_York)", a relative "in 3h 42m", or null when the runtime
+ * gave no hint.
+ */
+export declare function extractUsageLimitReset(text: string): string | null;
+/**
+ * Compose the calm, user-facing line for a usage/rate-limit error. Callers
+ * should gate on {@link looksLikeUsageLimit} first.
+ */
+export declare function formatUsageLimitMessage(text: string, runtime?: string): string;

package/dist/runtimes/runtime-errors.js

@@ -0,0 +1,95 @@
+/**
+ * Runtime CLIs sometimes report authentication failures as ordinary final
+ * text. Keep this intentionally narrow so normal model replies about auth do
+ * not get reclassified unless they look like a top-level CLI/API failure.
+ */
+export function looksLikeRuntimeAuthFailure(text) {
+    const s = text.trim();
+    if (!s)
+        return false;
+    return (/^(Failed to authenticate|Authentication failed|Invalid API key|Invalid Anthropic API key)\b/i.test(s) ||
+        /^API Error:\s*4\d\d\b/i.test(s) ||
+        /\b(API Error:\s*4\d\d|Request not allowed|invalid x-api-key)\b/i.test(s) ||
+        /^(Unauthorized|Forbidden)(?:\b|:)/i.test(s));
+}
+/**
+ * Usage / rate-limit exhaustion is reported by runtimes as ordinary error text,
+ * not a distinct status. Claude Code emits "Claude usage limit reached. Your
+ * limit will reset at 2pm (America/New_York)"; Codex emits "You've reached your
+ * 5-hour message limit. Try again in 3h 42m." or a bare
+ * `{"type":"error","error":{"type":"usage_limit_reached",...}}` blob. Detect it
+ * so the dispatcher can surface a calm, reset-time-forward sentence instead of a
+ * red "Runtime error" wrapped in an exit code and an error_ref.
+ */
+const USAGE_LIMIT_PATTERNS = [
+    /usage[_\s-]?limit[_\s-]?reached/i,
+    /\b\d+-hour (?:message )?limit\b/i,
+    /you'?ve (?:hit|reached) your (?:usage |message |daily |weekly )*limit/i,
+    /\binsufficient_quota\b/i,
+    /\bquota (?:exceeded|exhausted|reached)\b/i,
+    /\brate[_\s-]?limit(?:_?(?:exceeded|error)|ed|\s+(?:reached|exceeded|hit))/i,
+];
+export function looksLikeUsageLimit(text) {
+    const s = text?.trim();
+    if (!s)
+        return false;
+    return USAGE_LIMIT_PATTERNS.some((re) => re.test(s));
+}
+/**
+ * Pull the reset hint straight out of the runtime's own words — never compute it
+ * locally, since the runtime already knows the user's plan window and timezone
+ * and we do not. Returns a ready-to-render fragment: an absolute clock time like
+ * "2pm (America/New_York)", a relative "in 3h 42m", or null when the runtime
+ * gave no hint.
+ */
+export function extractUsageLimitReset(text) {
+    const s = (text ?? "").trim();
+    if (!s)
+        return null;
+    // Absolute: "...reset at 2pm (America/New_York)" /
+    //           "reset at approximately 11:00 PM Europe/Berlin time"
+    const at = s.match(/reset(?:s|ting)?\s+at\s+(?:approximately\s+)?(.+?)(?:\s+time\b)?\s*(?:[.,\n]|$)/i);
+    if (at?.[1])
+        return collapseWs(at[1]);
+    // Relative: "Try again in 3h 42m" / "please try again after 5 minutes"
+    const rel = s.match(/try again (?:in|after)\s+(.+?)\s*(?:[.,\n]|$)/i);
+    if (rel?.[1])
+        return `in ${collapseWs(rel[1])}`;
+    // Legacy Claude headless pipe form: "...reached|1719345600"
+    const pipe = s.match(/reached\s*\|\s*(\d{10,13})/);
+    if (pipe?.[1]) {
+        const ms = pipe[1].length >= 13 ? Number(pipe[1]) : Number(pipe[1]) * 1000;
+        if (Number.isFinite(ms))
+            return `${new Date(ms).toISOString().replace("T", " ").slice(0, 16)} UTC`;
+    }
+    return null;
+}
+/**
+ * Compose the calm, user-facing line for a usage/rate-limit error. Callers
+ * should gate on {@link looksLikeUsageLimit} first.
+ */
+export function formatUsageLimitMessage(text, runtime) {
+    const who = runtimeLabel(runtime);
+    const reset = extractUsageLimitReset(text);
+    if (reset) {
+        const when = /^in\s/i.test(reset) ? `resets ${reset}` : `resets at ${reset}`;
+        return `${who} usage limit reached — ${when}.`;
+    }
+    return `${who} usage limit reached — please try again later.`;
+}
+function runtimeLabel(runtime) {
+    switch ((runtime ?? "").toLowerCase()) {
+        case "claude-code":
+        case "claude":
+            return "Claude Code";
+        case "codex":
+            return "Codex";
+        case "gemini":
+            return "Gemini";
+        default:
+            return "Agent runtime";
+    }
+}
+function collapseWs(s) {
+    return s.replace(/\s+/g, " ").trim();
+}

package/dist/runtimes/text-cap.d.ts

@@ -0,0 +1,7 @@
+/** Return the UTF-8 byte length of a string. */
+export declare function utf8ByteLength(text: string): number;
+/**
+ * Slice a string to at most `maxBytes` UTF-8 bytes without splitting a code
+ * point. Used by runtime adapters whose safety caps are byte-oriented.
+ */
+export declare function sliceUtf8Bytes(text: string, maxBytes: number): string;

package/dist/runtimes/text-cap.js

@@ -0,0 +1,25 @@
+import { Buffer } from "node:buffer";
+/** Return the UTF-8 byte length of a string. */
+export function utf8ByteLength(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+/**
+ * Slice a string to at most `maxBytes` UTF-8 bytes without splitting a code
+ * point. Used by runtime adapters whose safety caps are byte-oriented.
+ */
+export function sliceUtf8Bytes(text, maxBytes) {
+    if (maxBytes <= 0)
+        return "";
+    if (utf8ByteLength(text) <= maxBytes)
+        return text;
+    let used = 0;
+    let out = "";
+    for (const ch of text) {
+        const n = utf8ByteLength(ch);
+        if (used + n > maxBytes)
+            break;
+        out += ch;
+        used += n;
+    }
+    return out;
+}

package/dist/transcript.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeBlock } from "./types.js";
+/**
+ * Transcript writer：块和最终回复追加写入 transcript.jsonl，供本地诊断与回放。
+ * 所有 text/raw 落盘前脱敏；raw 只进本地 transcript，不上 wire。
+ */
+export declare class TranscriptWriter {
+    private readonly file;
+    constructor(file: string);
+    writeBlock(block: RuntimeBlock): void;
+    writeFinal(text: string): void;
+    private append;
+    get path(): string;
+}

package/dist/transcript.js

@@ -0,0 +1,46 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { redactSecretString, redactSecretsDeep, truncateText } from "./redaction.js";
+// raw 深度脱敏后再序列化；序列化超过 8KiB 时整体降级为截断字符串（宁可丢结构不可撑爆磁盘）。
+const RAW_SERIALIZED_MAX_CHARS = 8 * 1024;
+/**
+ * Transcript writer：块和最终回复追加写入 transcript.jsonl，供本地诊断与回放。
+ * 所有 text/raw 落盘前脱敏；raw 只进本地 transcript，不上 wire。
+ */
+export class TranscriptWriter {
+    file;
+    constructor(file) {
+        this.file = file;
+        mkdirSync(path.dirname(file), { recursive: true });
+    }
+    writeBlock(block) {
+        const record = { type: "block", kind: block.kind };
+        if (block.text !== undefined)
+            record.text = redactSecretString(block.text);
+        if (block.raw !== undefined)
+            record.raw = sanitizeRaw(block.raw);
+        this.append(record);
+    }
+    writeFinal(text) {
+        this.append({ type: "message", role: "assistant", text: redactSecretString(text) });
+    }
+    append(record) {
+        appendFileSync(this.file, `${JSON.stringify({ ...record, ts: new Date().toISOString() })}\n`, "utf8");
+    }
+    get path() {
+        return this.file;
+    }
+}
+function sanitizeRaw(raw) {
+    const redacted = redactSecretsDeep(raw);
+    let serialized;
+    try {
+        serialized = JSON.stringify(redacted) ?? "";
+    }
+    catch {
+        return truncateText(String(redacted), RAW_SERIALIZED_MAX_CHARS);
+    }
+    if (serialized.length <= RAW_SERIALIZED_MAX_CHARS)
+        return redacted;
+    return truncateText(serialized, RAW_SERIALIZED_MAX_CHARS);
+}

package/dist/types.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Course-native 协议与 runtime 契约（spec: docs/specs/lightweight-course-daemon-package.md）。
+ *
+ * 本包不依赖 BotCord Hub/room/owner-chat 语义；wire 类型与后端
+ * `backend/botlearn_course/schemas.py` 的 daemon 契约严格对齐。
+ */
+/** `GET /daemon/runs/next` 下发的 run.start 载荷（snake_case，与后端 RunStartPayloadOut 一致）。 */
+export interface RunStartPayload {
+    agent_run_id: string;
+    course_run_id: string;
+    lesson_id: string | null;
+    task_id: string | null;
+    agent_instance_id: string | null;
+    runtime: {
+        id?: string;
+        model?: string;
+        reasoning_effort?: string;
+        thinking?: boolean;
+        web_search?: boolean;
+        [key: string]: unknown;
+    };
+    input: {
+        kind?: string;
+        text?: string;
+        locale?: string;
+    };
+    context: {
+        instructions?: string[];
+        metadata?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    limits: {
+        timeout_seconds?: number;
+        max_output_chars?: number;
+        max_tool_calls?: number;
+        [key: string]: unknown;
+    };
+}
+/**
+ * `POST /daemon/runs/{id}/events` 接受的事件类型。
+ * 与后端 DaemonRunEventIn.type 的 Literal 严格一致 —— 发送其他类型会得到 422。
+ */
+export type RunEventType = "run.accepted" | "run.started" | "run.block" | "run.message" | "run.completed" | "run.failed" | "run.cancelled";
+export interface RunEvent {
+    type: RunEventType;
+    /** Stable across retries; Course Service deduplicates within the current worker attempt. */
+    event_id?: string;
+    /** 1-based 单调递增。后端把 0/缺省视为「未设置」并自行计算，所以客户端 seq 必须从 1 开始。 */
+    seq?: number;
+    role?: "assistant" | "user" | "system";
+    text?: string;
+    error?: string;
+    payload?: Record<string, unknown>;
+}
+/** `POST /daemon/runs/{id}/files` 的文件候选（与后端 DaemonRunFileIn 一致）。 */
+export interface RunFileCandidate {
+    event?: "created" | "modified" | "deleted" | "upload_completed" | "upload_failed";
+    /** workspace 相对路径，正斜杠；不得包含 `..`、绝对路径或反斜杠（后端 400）。 */
+    path: string;
+    name?: string;
+    mime_type?: string;
+    size_bytes?: number;
+    sha256?: string;
+    preview_text?: string;
+}
+export interface RunFileRecord extends RunFileCandidate {
+    id: string;
+    agent_run_id: string;
+    storage_url?: string | null;
+    status: "candidate" | "saved" | "ignored" | "failed";
+}
+export interface RuntimeProfileArchiveFile {
+    path: string;
+    content: string;
+    sha256?: string;
+    size?: number;
+}
+export interface RuntimeProfileSkillPackage {
+    id: string;
+    version: string;
+    digest: string;
+    archiveManifest: {
+        name?: string;
+        skillMd: string;
+        files?: RuntimeProfileArchiveFile[];
+    };
+}
+export interface CourseRuntimeProfile {
+    schemaVersion: "botlearn-course-runtime-profile/0.1";
+    profileId: string;
+    profileHash: string;
+    courseVersionId: string;
+    promptPack: {
+        id: string;
+        version: string;
+        digest: string;
+        systemInstructions: string;
+    };
+    skillPackages: RuntimeProfileSkillPackage[];
+    requiredCapabilities: string[];
+}
+export interface AppliedRunRuntimeProfile {
+    profileId: string;
+    profileHash: string;
+    promptPackPath: string;
+    skillsRoot: string;
+    skillRefs: string[];
+}
+/** runtime adapter 产出的归一化块。wire 上只透传 text 与 kind；raw 仅进本地 transcript。 */
+export interface RuntimeBlock {
+    kind: "text_delta" | "text" | "thinking" | "tool_call" | "tool_result" | "status" | "error";
+    text?: string;
+    raw?: unknown;
+}
+export interface RuntimeAuthProbe {
+    checked: boolean;
+    ok: boolean;
+    message?: string;
+}
+/** doctor / capabilities 使用的探测结果。 */
+export interface RuntimeProbe {
+    available: boolean;
+    path?: string;
+    version?: string;
+    auth?: RuntimeAuthProbe;
+}
+/** runtime 执行期间向 dispatcher 汇报的通道。adapter 不直接触碰 Course API。 */
+export interface CourseRuntimeSink {
+    block(block: RuntimeBlock): Promise<void>;
+    message(text: string): Promise<void>;
+    file(file: RunFileCandidate): Promise<void>;
+}
+/** 一次 run 的本地执行上下文：服务器 payload + daemon 本地准备产物。 */
+export interface RunExecution {
+    payload: RunStartPayload;
+    /** 本 run 的隔离工作区目录（runtime 的 cwd）。 */
+    workspaceDir: string;
+}
+export interface CourseRuntime {
+    id: string;
+    probe?(): Promise<RuntimeProbe>;
+    /**
+     * 执行一次课程任务。最终回答走 `sink.message`；中间块走 `sink.block`。
+     * 失败必须 reject（由 dispatcher 归一化为 run.failed）；必须尊重 `signal`。
+     */
+    run(run: RunExecution, sink: CourseRuntimeSink, signal: AbortSignal): Promise<void>;
+}
+/** runtime 执行失败（dispatcher 折叠为 run.failed）。 */
+export declare class RuntimeExecutionError extends Error {
+    readonly errorType: "runtime_error" | "runtime_unavailable" | "timeout";
+    readonly failure?: Partial<RuntimeFailureSummary> | undefined;
+    constructor(message: string, errorType?: "runtime_error" | "runtime_unavailable" | "timeout", failure?: Partial<RuntimeFailureSummary> | undefined);
+}
+/** 本地诊断用的失败摘要（脱敏后可入日志/transcript，不上报 wire）。 */
+export interface RuntimeFailureSummary {
+    agent_run_id: string;
+    runtime: string;
+    cwd?: string;
+    command?: string[];
+    exit_code?: number | null;
+    signal?: string | null;
+    duration_ms?: number;
+    stderr_tail?: string;
+    stdout_tail?: string;
+    error_name?: string;
+    error_message?: string;
+}
+export interface RuntimeModule {
+    id: string;
+    displayName: string;
+    /** PATH 上的规范二进制名，doctor 展示用。 */
+    binary: string;
+    /** 覆盖二进制路径的环境变量；缺省为 `BOTLEARN_<ID>_BIN`（id 大写、`-`→`_`）。 */
+    envVar?: string;
+    /** 快速探测（安装/版本）。必须廉价：login/capabilities 上报会频繁调用，不得触发真实模型调用。 */
+    probe(): Promise<RuntimeProbe>;
+    /** 登录态探测，可能昂贵（如真实调用一次 CLI）。仅 doctor 按需调用。 */
+    probeAuth?(): Promise<RuntimeAuthProbe>;
+    create(): CourseRuntime;
+    /** probe 不可用时 doctor 显示的安装提示。 */
+    installHint?: string;
+    /** 仅测试/demo 用（如 fake），不进入 capabilities 上报，除非显式启用。 */
+    hidden?: boolean;
+}
+export interface RuntimeProbeEntry {
+    id: string;
+    displayName: string;
+    binary: string;
+    result: RuntimeProbe;
+    installHint?: string;
+}
+export interface DaemonAuth {
+    daemonId: string;
+    userId: string;
+    label: string;
+    accessToken: string;
+    refreshToken: string;
+    courseApiUrl: string;
+}

package/dist/types.js

@@ -0,0 +1,17 @@
+/**
+ * Course-native 协议与 runtime 契约（spec: docs/specs/lightweight-course-daemon-package.md）。
+ *
+ * 本包不依赖 BotCord Hub/room/owner-chat 语义；wire 类型与后端
+ * `backend/botlearn_course/schemas.py` 的 daemon 契约严格对齐。
+ */
+/** runtime 执行失败（dispatcher 折叠为 run.failed）。 */
+export class RuntimeExecutionError extends Error {
+    errorType;
+    failure;
+    constructor(message, errorType = "runtime_error", failure) {
+        super(message);
+        this.errorType = errorType;
+        this.failure = failure;
+        this.name = "RuntimeExecutionError";
+    }
+}

package/dist/workspace.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 每 run 隔离工作区（spec §4）：
+ *
+ * ```
+ * <daemonHome>/workspaces/<agent_run_id>/
+ *   work/               # runtime 的 cwd，文件候选只从这里扫描
+ *   transcript.jsonl
+ * ```
+ *
+ * agent_run_id 来自服务端，但用作本地路径段前必须过白名单校验，防路径注入。
+ */
+export declare const SAFE_ID_PATTERN: RegExp;
+export declare function assertSafeId(value: string, field: string): void;
+export declare function workspacesRoot(): string;
+export declare function runRootDir(agentRunId: string): string;
+/** runtime 的 cwd。 */
+export declare function runWorkspaceDir(agentRunId: string): string;
+export declare function transcriptPath(agentRunId: string): string;
+export declare function runtimeProfileDir(agentRunId: string): string;
+export declare function ensureRunWorkspace(agentRunId: string): {
+    rootDir: string;
+    workspaceDir: string;
+};

package/dist/workspace.js

@@ -0,0 +1,54 @@
+import { chmodSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { daemonHome } from "./auth-store.js";
+/**
+ * 每 run 隔离工作区（spec §4）：
+ *
+ * ```
+ * <daemonHome>/workspaces/<agent_run_id>/
+ *   work/               # runtime 的 cwd，文件候选只从这里扫描
+ *   transcript.jsonl
+ * ```
+ *
+ * agent_run_id 来自服务端，但用作本地路径段前必须过白名单校验，防路径注入。
+ */
+export const SAFE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+export function assertSafeId(value, field) {
+    if (!SAFE_ID_PATTERN.test(value)) {
+        throw new Error(`unsafe ${field}: must match ${SAFE_ID_PATTERN}`);
+    }
+}
+export function workspacesRoot() {
+    return path.join(daemonHome(), "workspaces");
+}
+export function runRootDir(agentRunId) {
+    assertSafeId(agentRunId, "agent_run_id");
+    return path.join(workspacesRoot(), agentRunId);
+}
+/** runtime 的 cwd。 */
+export function runWorkspaceDir(agentRunId) {
+    return path.join(runRootDir(agentRunId), "work");
+}
+export function transcriptPath(agentRunId) {
+    return path.join(runRootDir(agentRunId), "transcript.jsonl");
+}
+export function runtimeProfileDir(agentRunId) {
+    return path.join(runRootDir(agentRunId), "runtime-profile");
+}
+// recursive mkdir 只对新建目录生效 mode，已存在目录需 best-effort 收紧。
+function mkdirTolerant(dir) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch {
+        // Windows 等不支持 chmod 时忽略。
+    }
+}
+export function ensureRunWorkspace(agentRunId) {
+    const rootDir = runRootDir(agentRunId);
+    const workspaceDir = runWorkspaceDir(agentRunId);
+    mkdirTolerant(rootDir);
+    mkdirTolerant(workspaceDir);
+    return { rootDir, workspaceDir };
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@botlearn-course/daemon",
+  "version": "0.0.1",
+  "description": "Lightweight BotLearn Course daemon: run course tasks on your own machine with your own agent runtime (BYOA).",
+  "type": "module",
+  "bin": {
+    "botlearn-course-daemon": "dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/botlearn-ai/botlearn-course.git",
+    "directory": "packages/course-daemon"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "type-check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:release": "node --test scripts/*.test.mjs",
+    "test:watch": "vitest",
+    "prepublishOnly": "tsc -p tsconfig.build.json"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.0.18"
+  }
+}