@biaoo/tiangong-wiki 0.2.2 → 0.3.0

package/dist/daemon/write-actor.js

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import { AppError } from "../utils/errors.js";
+const ASCII_ID_PATTERN = /^[A-Za-z0-9._:@/-]+$/;
+function isPlainObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+}
+function normalizeOptionalString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim();
+    return normalized ? normalized : null;
+}
+function validateAsciiField(field, value) {
+    if (!ASCII_ID_PATTERN.test(value)) {
+        throw new AppError(`${field} must be a stable ASCII identifier, got ${value}`, "config", {
+            code: "invalid_request",
+            field,
+        });
+    }
+    return value;
+}
+function newRequestId() {
+    return `req:${randomUUID()}`;
+}
+function getBodyActor(body) {
+    return isPlainObject(body.actor) ? body.actor : null;
+}
+export function buildCliWriteActor(env = process.env) {
+    return {
+        actorId: validateAsciiField("actorId", env.WIKI_ACTOR_ID?.trim() || "user:local-cli"),
+        actorType: validateAsciiField("actorType", env.WIKI_ACTOR_TYPE?.trim() || "user"),
+        requestId: validateAsciiField("requestId", env.WIKI_REQUEST_ID?.trim() || newRequestId()),
+    };
+}
+export function buildSystemWriteActor(label = "daemon") {
+    return {
+        actorId: validateAsciiField("actorId", `system:${label}`),
+        actorType: validateAsciiField("actorType", "system"),
+        requestId: validateAsciiField("requestId", newRequestId()),
+    };
+}
+export function resolveWriteActor(request, body, fallback) {
+    const bodyActor = getBodyActor(body);
+    const actorId = normalizeOptionalString(request.headers["x-wiki-actor-id"]) ??
+        normalizeOptionalString(bodyActor?.actorId) ??
+        fallback.actorId;
+    const actorType = normalizeOptionalString(request.headers["x-wiki-actor-type"]) ??
+        normalizeOptionalString(bodyActor?.actorType) ??
+        fallback.actorType;
+    const requestId = normalizeOptionalString(request.headers["x-request-id"]) ??
+        normalizeOptionalString(bodyActor?.requestId) ??
+        fallback.requestId ??
+        newRequestId();
+    return {
+        actorId: validateAsciiField("actorId", actorId),
+        actorType: validateAsciiField("actorType", actorType),
+        requestId: validateAsciiField("requestId", requestId),
+    };
+}

package/dist/daemon/write-queue.js

@@ -0,0 +1,360 @@
+import { randomUUID } from "node:crypto";
+import { openRuntimeDb } from "../core/runtime.js";
+import { AppError, asAppError } from "../utils/errors.js";
+import { toOffsetIso } from "../utils/time.js";
+const DEFAULT_MAX_DEPTH = 100;
+const DEFAULT_JOB_TIMEOUT_MS = 300_000;
+const RECENT_JOB_LIMIT = 12;
+const QUEUED_JOB_PREVIEW_LIMIT = 20;
+function parsePositiveInteger(value, fallback) {
+    const parsed = Number.parseInt(value ?? "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function parseOptionalObject(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function serializeOptionalObject(value) {
+    return value ? JSON.stringify(value) : null;
+}
+function snapshotDurationMs(job) {
+    if (!job.startedAt || !job.finishedAt) {
+        return null;
+    }
+    const startedAtMs = new Date(job.startedAt).getTime();
+    const finishedAtMs = new Date(job.finishedAt).getTime();
+    if (!Number.isFinite(startedAtMs) || !Number.isFinite(finishedAtMs)) {
+        return null;
+    }
+    return Math.max(0, finishedAtMs - startedAtMs);
+}
+function cloneSnapshot(snapshot, positionInQueue = snapshot.positionInQueue) {
+    return {
+        ...snapshot,
+        positionInQueue,
+        resultSummary: snapshot.resultSummary ? { ...snapshot.resultSummary } : null,
+        errorDetails: snapshot.errorDetails ? { ...snapshot.errorDetails } : null,
+    };
+}
+function createInitialSnapshot(taskType, timeoutMs, queueDepthAtEnqueue) {
+    return {
+        jobId: randomUUID(),
+        taskType,
+        status: "queued",
+        enqueuedAt: toOffsetIso(),
+        startedAt: null,
+        finishedAt: null,
+        durationMs: null,
+        timeoutMs,
+        queueDepthAtEnqueue,
+        positionInQueue: queueDepthAtEnqueue + 1,
+        resultSummary: null,
+        errorMessage: null,
+        errorDetails: null,
+    };
+}
+function readPersistedRecentJobs(env, limit = RECENT_JOB_LIMIT) {
+    const { db } = openRuntimeDb(env);
+    try {
+        const rows = db.prepare(`
+        SELECT
+          job_id AS jobId,
+          task_type AS taskType,
+          status,
+          enqueued_at AS enqueuedAt,
+          started_at AS startedAt,
+          finished_at AS finishedAt,
+          duration_ms AS durationMs,
+          timeout_ms AS timeoutMs,
+          queue_depth_at_enqueue AS queueDepthAtEnqueue,
+          result_summary AS resultSummary,
+          error_message AS errorMessage,
+          error_details AS errorDetails
+        FROM daemon_write_jobs
+        WHERE status IN ('succeeded', 'failed', 'timed_out')
+        ORDER BY COALESCE(finished_at, enqueued_at) DESC
+        LIMIT ?
+      `).all(limit);
+        return rows.map((row) => ({
+            jobId: row.jobId,
+            taskType: row.taskType,
+            status: row.status,
+            enqueuedAt: row.enqueuedAt,
+            startedAt: row.startedAt,
+            finishedAt: row.finishedAt,
+            durationMs: row.durationMs,
+            timeoutMs: row.timeoutMs,
+            queueDepthAtEnqueue: row.queueDepthAtEnqueue,
+            positionInQueue: null,
+            resultSummary: parseOptionalObject(row.resultSummary),
+            errorMessage: row.errorMessage,
+            errorDetails: parseOptionalObject(row.errorDetails),
+        }));
+    }
+    finally {
+        db.close();
+    }
+}
+function readPersistedJob(env, jobId) {
+    const { db } = openRuntimeDb(env);
+    try {
+        const row = db.prepare(`
+        SELECT
+          job_id AS jobId,
+          task_type AS taskType,
+          status,
+          enqueued_at AS enqueuedAt,
+          started_at AS startedAt,
+          finished_at AS finishedAt,
+          duration_ms AS durationMs,
+          timeout_ms AS timeoutMs,
+          queue_depth_at_enqueue AS queueDepthAtEnqueue,
+          result_summary AS resultSummary,
+          error_message AS errorMessage,
+          error_details AS errorDetails
+        FROM daemon_write_jobs
+        WHERE job_id = ?
+      `).get(jobId);
+        if (!row) {
+            return null;
+        }
+        return {
+            jobId: row.jobId,
+            taskType: row.taskType,
+            status: row.status,
+            enqueuedAt: row.enqueuedAt,
+            startedAt: row.startedAt,
+            finishedAt: row.finishedAt,
+            durationMs: row.durationMs,
+            timeoutMs: row.timeoutMs,
+            queueDepthAtEnqueue: row.queueDepthAtEnqueue,
+            positionInQueue: null,
+            resultSummary: parseOptionalObject(row.resultSummary),
+            errorMessage: row.errorMessage,
+            errorDetails: parseOptionalObject(row.errorDetails),
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+function persistJobSnapshot(env, snapshot) {
+    const { db } = openRuntimeDb(env);
+    try {
+        db.prepare(`
+        INSERT INTO daemon_write_jobs (
+          job_id,
+          task_type,
+          status,
+          enqueued_at,
+          started_at,
+          finished_at,
+          duration_ms,
+          timeout_ms,
+          queue_depth_at_enqueue,
+          result_summary,
+          error_message,
+          error_details
+        )
+        VALUES (
+          @job_id,
+          @task_type,
+          @status,
+          @enqueued_at,
+          @started_at,
+          @finished_at,
+          @duration_ms,
+          @timeout_ms,
+          @queue_depth_at_enqueue,
+          @result_summary,
+          @error_message,
+          @error_details
+        )
+        ON CONFLICT(job_id) DO UPDATE SET
+          task_type = excluded.task_type,
+          status = excluded.status,
+          enqueued_at = excluded.enqueued_at,
+          started_at = excluded.started_at,
+          finished_at = excluded.finished_at,
+          duration_ms = excluded.duration_ms,
+          timeout_ms = excluded.timeout_ms,
+          queue_depth_at_enqueue = excluded.queue_depth_at_enqueue,
+          result_summary = excluded.result_summary,
+          error_message = excluded.error_message,
+          error_details = excluded.error_details
+      `).run({
+            job_id: snapshot.jobId,
+            task_type: snapshot.taskType,
+            status: snapshot.status,
+            enqueued_at: snapshot.enqueuedAt,
+            started_at: snapshot.startedAt,
+            finished_at: snapshot.finishedAt,
+            duration_ms: snapshot.durationMs,
+            timeout_ms: snapshot.timeoutMs,
+            queue_depth_at_enqueue: snapshot.queueDepthAtEnqueue,
+            result_summary: serializeOptionalObject(snapshot.resultSummary),
+            error_message: snapshot.errorMessage,
+            error_details: serializeOptionalObject(snapshot.errorDetails),
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+export class DaemonWriteQueue {
+    maxDepth;
+    jobTimeoutMs;
+    env;
+    hooks;
+    pendingJobs = [];
+    idleResolvers = [];
+    activeJob = null;
+    constructor(env, hooks = {}) {
+        this.env = env;
+        this.hooks = hooks;
+        this.maxDepth = parsePositiveInteger(env.WIKI_TEST_WRITE_QUEUE_MAX_DEPTH, DEFAULT_MAX_DEPTH);
+        this.jobTimeoutMs = parsePositiveInteger(env.WIKI_TEST_WRITE_QUEUE_TIMEOUT_MS, DEFAULT_JOB_TIMEOUT_MS);
+    }
+    hasWork() {
+        return this.activeJob !== null || this.pendingJobs.length > 0;
+    }
+    getSummary() {
+        return {
+            limits: {
+                maxDepth: this.maxDepth,
+                jobTimeoutMs: this.jobTimeoutMs,
+            },
+            counts: {
+                queued: this.pendingJobs.length,
+                running: this.activeJob ? 1 : 0,
+                recent: readPersistedRecentJobs(this.env).length,
+            },
+            activeJob: this.activeJob ? cloneSnapshot(this.activeJob.snapshot, null) : null,
+            queuedJobs: this.pendingJobs
+                .slice(0, QUEUED_JOB_PREVIEW_LIMIT)
+                .map((job, index) => cloneSnapshot(job.snapshot, index + 1)),
+            recentJobs: readPersistedRecentJobs(this.env),
+            generatedAt: toOffsetIso(),
+        };
+    }
+    getJob(jobId) {
+        if (this.activeJob?.snapshot.jobId === jobId) {
+            return cloneSnapshot(this.activeJob.snapshot, null);
+        }
+        const pendingIndex = this.pendingJobs.findIndex((job) => job.snapshot.jobId === jobId);
+        if (pendingIndex >= 0) {
+            return cloneSnapshot(this.pendingJobs[pendingIndex].snapshot, pendingIndex + 1);
+        }
+        return readPersistedJob(this.env, jobId);
+    }
+    async waitForIdle() {
+        if (!this.hasWork()) {
+            return;
+        }
+        await new Promise((resolve) => {
+            this.idleResolvers.push(resolve);
+        });
+    }
+    enqueue(taskType, run, options = {}) {
+        if (this.pendingJobs.length >= this.maxDepth) {
+            throw new AppError("Write queue is full.", "runtime", {
+                code: "queue_full",
+                maxDepth: this.maxDepth,
+            });
+        }
+        const snapshot = createInitialSnapshot(taskType, this.jobTimeoutMs, this.pendingJobs.length);
+        persistJobSnapshot(this.env, snapshot);
+        return new Promise((resolve, reject) => {
+            this.pendingJobs.push({
+                snapshot,
+                run: () => run(),
+                resolve: (value) => resolve(value),
+                reject,
+                summarizeResult: options.summarizeResult
+                    ? (result) => options.summarizeResult(result)
+                    : undefined,
+            });
+            void this.processNext();
+        });
+    }
+    notifyIdleIfNeeded() {
+        if (this.hasWork()) {
+            return;
+        }
+        while (this.idleResolvers.length > 0) {
+            this.idleResolvers.pop()();
+        }
+    }
+    async processNext() {
+        if (this.activeJob || this.pendingJobs.length === 0) {
+            return;
+        }
+        const job = this.pendingJobs.shift();
+        this.activeJob = job;
+        job.snapshot.status = "running";
+        job.snapshot.startedAt = toOffsetIso();
+        job.snapshot.positionInQueue = null;
+        persistJobSnapshot(this.env, job.snapshot);
+        this.hooks.onJobStart?.(cloneSnapshot(job.snapshot, null));
+        let timeoutHandle = null;
+        let didTimeout = false;
+        const runPromise = Promise.resolve().then(job.run);
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                didTimeout = true;
+                reject(new AppError(`Write queue job timed out after ${job.snapshot.timeoutMs}ms.`, "runtime", {
+                    code: "job_timeout",
+                    jobId: job.snapshot.jobId,
+                    taskType: job.snapshot.taskType,
+                    timeoutMs: job.snapshot.timeoutMs,
+                }));
+            }, job.snapshot.timeoutMs);
+        });
+        try {
+            const result = await Promise.race([runPromise, timeoutPromise]);
+            job.snapshot.status = "succeeded";
+            job.snapshot.finishedAt = toOffsetIso();
+            job.snapshot.durationMs = snapshotDurationMs(job.snapshot);
+            job.snapshot.resultSummary = job.summarizeResult?.(result) ?? null;
+            job.snapshot.errorMessage = null;
+            job.snapshot.errorDetails = null;
+            persistJobSnapshot(this.env, job.snapshot);
+            job.resolve(result);
+        }
+        catch (error) {
+            const appError = asAppError(error);
+            job.snapshot.status = didTimeout ? "timed_out" : "failed";
+            job.snapshot.finishedAt = toOffsetIso();
+            job.snapshot.durationMs = snapshotDurationMs(job.snapshot);
+            job.snapshot.errorMessage = appError.message;
+            job.snapshot.errorDetails =
+                typeof appError.details === "object" && appError.details !== null && !Array.isArray(appError.details)
+                    ? { ...appError.details }
+                    : null;
+            persistJobSnapshot(this.env, job.snapshot);
+            job.reject(appError);
+        }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            if (didTimeout) {
+                await runPromise.catch(() => undefined);
+            }
+            this.activeJob = null;
+            this.hooks.onJobFinish?.(cloneSnapshot(job.snapshot, null));
+            this.notifyIdleIfNeeded();
+            void this.processNext();
+        }
+    }
+}

package/dist/operations/dashboard.js

@@ -3,6 +3,7 @@ import { getMeta } from "../core/db.js";
 import { parsePage } from "../core/frontmatter.js";
 import { buildDoctorReport } from "../core/onboarding.js";
 import { resolveRuntimePaths } from "../core/paths.js";
+import { readCanonicalPageSource } from "../core/page-source.js";
 import { compactPageSummary } from "../core/presenters.js";
 import { listPageColumns, mapPageRow, selectPageById } from "../core/query.js";
 import { openRuntimeDb } from "../core/runtime.js";
@@ -859,16 +860,10 @@ export async function getDashboardPageSource(env = process.env, inputPageId) {
             throw new AppError(`Page not found: ${pageId}`, "not_found");
         }
         const pageFilePath = path.join(paths.wikiPath, ...String(page.id).split("/"));
-        const parsed = parsePage(pageFilePath, paths.wikiPath, config);
-        const rawData = parsed.ok ? parsed.parsed.rawData : {};
+        const pageSource = readCanonicalPageSource(pageFilePath, paths.wikiPath, config);
         return {
-            pageSource: {
-                pageId: String(page.id),
-                pagePath: pageFilePath,
-                rawMarkdown: readOptionalText(pageFilePath),
-                frontmatter: rawData,
-            },
-            vaultSource: await resolvePageVaultSource(db, config, env, page, rawData),
+            pageSource,
+            vaultSource: await resolvePageVaultSource(db, config, env, page, pageSource.frontmatter),
             generatedAt: toOffsetIso(),
         };
     }

package/dist/operations/write.js

@@ -1,10 +1,18 @@
 import { getTemplate } from "../core/config.js";
 import { resolveAgentSettings } from "../core/paths.js";
+import { normalizePageId } from "../core/paths.js";
 import { createPageFromTemplate } from "../core/page-files.js";
+import { updatePageById } from "../core/page-files.js";
+import { readCanonicalPageSourceById } from "../core/page-source.js";
 import { loadRuntimeConfig } from "../core/runtime.js";
+import { openRuntimeDb } from "../core/runtime.js";
 import { syncWorkspace } from "../core/sync.js";
 import { getVaultQueueItem, processVaultQueueBatch } from "../core/vault-processing.js";
-import { AppError } from "../utils/errors.js";
+import { selectPageById } from "../core/query.js";
+import { AppError, asAppError } from "../utils/errors.js";
+function isPlainObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+}
 function assertValidSyncCommandOptions(options) {
     if (options.vaultFileId && !options.process) {
         throw new AppError("--vault-file requires --process.", "config");
@@ -132,12 +140,92 @@ export async function createPage(env = process.env, options) {
         title: options.title,
         nodeId: options.nodeId ?? undefined,
     });
-    await syncWorkspace({
-        env,
-        targetPaths: [created.pageId],
-    });
+    try {
+        await syncWorkspace({
+            env,
+            targetPaths: [created.pageId],
+        });
+    }
+    catch (error) {
+        const appError = asAppError(error);
+        throw new AppError(`Sync failed after creating page: ${created.pageId}`, "runtime", {
+            code: "sync_failed",
+            pageId: created.pageId,
+            filePath: created.filePath,
+            revisionAfter: readCanonicalPageSourceById(created.pageId, paths.wikiPath, config).revision,
+            cause: appError.message,
+        });
+    }
     return {
         created: created.pageId,
         filePath: created.filePath,
     };
 }
+export async function updatePage(env = process.env, options) {
+    const pageIdInput = typeof options.pageId === "string" ? options.pageId.trim() : "";
+    if (!pageIdInput) {
+        throw new AppError("pageId is required.", "config", {
+            code: "invalid_request",
+            field: "pageId",
+        });
+    }
+    const hasBodyMarkdown = typeof options.bodyMarkdown === "string";
+    const hasFrontmatterPatch = options.frontmatterPatch !== undefined &&
+        isPlainObject(options.frontmatterPatch) &&
+        Object.keys(options.frontmatterPatch).length > 0;
+    if (options.frontmatterPatch !== undefined && !isPlainObject(options.frontmatterPatch)) {
+        throw new AppError("frontmatterPatch must be an object.", "config", {
+            code: "invalid_request",
+            field: "frontmatterPatch",
+        });
+    }
+    if (!hasBodyMarkdown && !hasFrontmatterPatch) {
+        throw new AppError("bodyMarkdown or frontmatterPatch is required.", "config", {
+            code: "invalid_request",
+        });
+    }
+    const { db, config, paths } = openRuntimeDb(env);
+    let canonicalPageId;
+    try {
+        const normalizedPageId = normalizePageId(pageIdInput, paths.wikiPath);
+        const page = selectPageById(db, config, normalizedPageId);
+        if (!page) {
+            throw new AppError(`Page not found: ${normalizedPageId}`, "not_found");
+        }
+        canonicalPageId = String(page.id);
+    }
+    finally {
+        db.close();
+    }
+    const currentSource = readCanonicalPageSourceById(canonicalPageId, paths.wikiPath, config);
+    const expectedRevision = typeof options.ifRevision === "string" && options.ifRevision.trim() ? options.ifRevision.trim() : null;
+    if (expectedRevision && currentSource.revision !== expectedRevision) {
+        throw new AppError(`Page revision conflict: ${canonicalPageId}`, "runtime", {
+            code: "revision_conflict",
+            pageId: canonicalPageId,
+            ifRevision: expectedRevision,
+            currentRevision: currentSource.revision,
+        });
+    }
+    updatePageById(paths, canonicalPageId, {
+        bodyMarkdown: hasBodyMarkdown ? options.bodyMarkdown : undefined,
+        frontmatterPatch: hasFrontmatterPatch ? options.frontmatterPatch : undefined,
+    });
+    try {
+        await syncWorkspace({
+            env,
+            targetPaths: [canonicalPageId],
+        });
+    }
+    catch (error) {
+        const appError = asAppError(error);
+        throw new AppError(`Sync failed after updating page: ${canonicalPageId}`, "runtime", {
+            code: "sync_failed",
+            pageId: canonicalPageId,
+            revisionBefore: currentSource.revision,
+            revisionAfter: readCanonicalPageSourceById(canonicalPageId, paths.wikiPath, config).revision,
+            cause: appError.message,
+        });
+    }
+    return readCanonicalPageSourceById(canonicalPageId, paths.wikiPath, config);
+}

package/mcp-server/dist/daemon-client.js

@@ -0,0 +1,90 @@
+import { setTimeout as delay } from "node:timers/promises";
+export class DaemonHttpError extends Error {
+    type;
+    httpStatus;
+    details;
+    constructor(message, type, httpStatus, details) {
+        super(message);
+        this.type = type;
+        this.httpStatus = httpStatus;
+        this.details = details;
+        this.name = "DaemonHttpError";
+    }
+}
+function parsePort(rawValue) {
+    if (!rawValue || !rawValue.trim()) {
+        return null;
+    }
+    const value = Number.parseInt(rawValue.trim(), 10);
+    if (!Number.isInteger(value) || value < 0 || value > 65535) {
+        throw new Error(`Invalid WIKI_DAEMON_PORT: ${rawValue}`);
+    }
+    return value;
+}
+export function resolveDaemonBaseUrl(env = process.env) {
+    const rawBaseUrl = env.WIKI_DAEMON_BASE_URL?.trim();
+    if (rawBaseUrl) {
+        return new URL(rawBaseUrl.endsWith("/") ? rawBaseUrl : `${rawBaseUrl}/`);
+    }
+    const port = parsePort(env.WIKI_DAEMON_PORT);
+    if (port === null) {
+        throw new Error("WIKI_DAEMON_BASE_URL or WIKI_DAEMON_PORT is required for the MCP adapter.");
+    }
+    const host = env.WIKI_DAEMON_HOST?.trim() || "127.0.0.1";
+    return new URL(`http://${host}:${port}/`);
+}
+function buildUrl(baseUrl, routePath, query) {
+    const url = new URL(routePath.startsWith("/") ? routePath.slice(1) : routePath, baseUrl);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        if (value === null || value === undefined) {
+            continue;
+        }
+        url.searchParams.set(key, String(value));
+    }
+    return url;
+}
+export async function requestDaemonJson(options) {
+    const controller = new AbortController();
+    const timeout = options.timeoutMs ?? (options.method === "POST" ? 310_000 : 10_000);
+    const timer = delay(timeout, undefined, { signal: controller.signal }).then(() => controller.abort()).catch(() => undefined);
+    try {
+        const response = await fetch(buildUrl(resolveDaemonBaseUrl(options.env), options.path, options.query), {
+            method: options.method,
+            headers: options.body === undefined ? options.headers : { "content-type": "application/json", ...options.headers },
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal: controller.signal,
+        });
+        const rawText = await response.text();
+        const payload = rawText ? JSON.parse(rawText) : null;
+        if (!response.ok) {
+            const details = payload && typeof payload === "object" && payload !== null && "details" in payload
+                ? payload.details
+                : { status: response.status };
+            const type = payload && typeof payload === "object" && payload !== null && "type" in payload
+                ? String(payload.type)
+                : "runtime";
+            const message = payload && typeof payload === "object" && payload !== null && "error" in payload
+                ? String(payload.error)
+                : `Daemon request failed with HTTP ${response.status}`;
+            throw new DaemonHttpError(message, type, response.status, details);
+        }
+        return payload;
+    }
+    catch (error) {
+        if (error instanceof DaemonHttpError) {
+            throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new DaemonHttpError(`Daemon request timed out after ${timeout}ms.`, "runtime", 504, {
+                code: "timeout",
+            });
+        }
+        throw new DaemonHttpError(error instanceof Error ? error.message : String(error), "runtime", 500, {
+            code: "transport_error",
+        });
+    }
+    finally {
+        controller.abort();
+        await timer;
+    }
+}

package/mcp-server/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { startMcpHttpServer } from "./server.js";
+async function main() {
+    const started = await startMcpHttpServer(process.env);
+    process.stdout.write(`${JSON.stringify({
+        status: "listening",
+        host: started.host,
+        port: started.port,
+        healthUrl: started.healthUrl,
+        mcpUrl: started.mcpUrl,
+    })}\n`);
+    const shutdown = async () => {
+        await started.close();
+        process.exit(0);
+    };
+    process.once("SIGINT", () => {
+        void shutdown();
+    });
+    process.once("SIGTERM", () => {
+        void shutdown();
+    });
+}
+void main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exit(1);
+});