@aopslabs/aops-server 0.2.0

package/build/server/chunks/_server.ts-B9gjXi95.js

@@ -0,0 +1,260 @@
+import { j as json } from './index.js-BQnOaW3H.js';
+import { Effect } from 'effect';
+import { normalizeDocmanFlowAction, saveDocmanGroupFlow, saveDocmanDocumentFlow, saveDocmanSectionFlow, copyDocmanSectionFlow, createLinkedDocmanSection, linkExistingDocmanSection, linkExistingDocmanPageVersion, updateDocmanDocumentSectionLinksFlow, updateDocmanSectionPageLinksFlow, saveDocmanPageVersionDraftFlow, updateDocmanDocumentVersionFlow, updateDocmanPageFlow, copyDocmanPageFlow, createDocmanDocumentVersionFlow, createDocmanPageWithInitialVersionFlow, createLinkedDocmanPage, inferDocmanFlowErrorStatus } from '@aopslabs/domain-product-docman';
+import { a as attachResolvedProjectScope, b as resolveProjectScopeFromLocals } from './request-context-9wzBoKrz.js';
+import { e as errResult, o as okResult } from './xf-result-BRDjvftr.js';
+import './aops-runtime-config-CHpDUCdE.js';
+import 'node:fs';
+import 'node:path';
+import 'pg';
+import '@aopslabs/xf-dm-kits/appConfig';
+import '@aopslabs/xf-dm-kits';
+import '@aopslabs/domain-kit-agentspace';
+import './project-alias-BdnRxWft.js';
+
+function toRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function inferScopeStatus(result) {
+  if (result.ok) return 200;
+  const message = String(result.messages?.[0]?.messageText ?? "").trim().toLowerCase();
+  if (message === "unauthorized") return 401;
+  if (message === "forbidden") return 403;
+  if (message === "project_required") return 409;
+  if (message === "project_not_found") return 404;
+  return 400;
+}
+function normalizeNonEmpty(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : "";
+}
+async function resolveDocmanFlowScope(params) {
+  const projectSvc = await params.kit.createProjectService();
+  const directProject = typeof projectSvc.getById === "function" ? await Effect.runPromise(projectSvc.getById(params.projectId)).catch(() => null) : null;
+  const projectId = normalizeNonEmpty(directProject?.id) || normalizeNonEmpty(params.projectId);
+  const projectScopeId = normalizeNonEmpty(directProject?.scopeId);
+  const defaultScopeId = projectScopeId || projectId;
+  if (!defaultScopeId) {
+    return {
+      ok: false,
+      status: 404,
+      result: errResult("project_scope_not_found", { projectId: params.projectId })
+    };
+  }
+  const requestedScopeId = normalizeNonEmpty(params.requestedScopeId);
+  if (!requestedScopeId) {
+    return { ok: true, scopeId: defaultScopeId };
+  }
+  if (requestedScopeId === projectId || requestedScopeId === projectScopeId) {
+    return { ok: true, scopeId: requestedScopeId };
+  }
+  return {
+    ok: false,
+    status: 409,
+    result: errResult("scope_not_in_project", {
+      projectId: params.projectId,
+      scopeId: requestedScopeId
+    })
+  };
+}
+async function readJsonBody(request) {
+  try {
+    return toRecord(await request.json());
+  } catch {
+    return {};
+  }
+}
+const POST = async ({ request, locals }) => {
+  await attachResolvedProjectScope({ request, locals });
+  const body = await readJsonBody(request);
+  const attachedScopeId = normalizeNonEmpty(locals.scopeId);
+  const requestedScopeId = normalizeNonEmpty(body.scopeId);
+  let resolvedScopeId = attachedScopeId;
+  if (!resolvedScopeId || requestedScopeId && requestedScopeId !== resolvedScopeId) {
+    const scope = await resolveProjectScopeFromLocals({
+      input: {
+        projectId: body.projectId ?? locals.projectId,
+        projectName: body.projectName,
+        project: body.project
+      },
+      locals
+    });
+    if (!scope.ok) return json(scope.result, { status: inferScopeStatus(scope.result) });
+    const resolvedScope = await resolveDocmanFlowScope({
+      projectId: scope.projectId,
+      requestedScopeId: requestedScopeId || void 0,
+      kit: scope.kit
+    });
+    if (!resolvedScope.ok) {
+      return json(resolvedScope.result, { status: resolvedScope.status });
+    }
+    resolvedScopeId = resolvedScope.scopeId;
+  }
+  if (!resolvedScopeId) {
+    return json(errResult("project_required"), { status: 409 });
+  }
+  const action = normalizeDocmanFlowAction(body.action);
+  if (!action) {
+    return json(errResult("unsupported_docman_flow_action"), { status: 400 });
+  }
+  try {
+    if (action === "save-group") {
+      const result2 = await saveDocmanGroupFlow({
+        scopeId: resolvedScopeId,
+        groupId: body.groupId,
+        data: body.data
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "save-document") {
+      const result2 = await saveDocmanDocumentFlow({
+        scopeId: resolvedScopeId,
+        documentId: body.documentId,
+        data: body.data
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "save-section") {
+      const result2 = await saveDocmanSectionFlow({
+        scopeId: resolvedScopeId,
+        sectionId: body.sectionId,
+        data: body.data
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "copy-section") {
+      const result2 = await copyDocmanSectionFlow({
+        scopeId: resolvedScopeId,
+        sourceSectionId: body.sourceSectionId,
+        targetDocumentVersionId: body.targetDocumentVersionId,
+        parentLinkId: body.parentLinkId,
+        position: body.position,
+        rename: body.rename,
+        clonePages: body.clonePages
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "create-linked-section") {
+      const result2 = await createLinkedDocmanSection({
+        scopeId: resolvedScopeId,
+        documentVersionId: body.documentVersionId,
+        parentLinkId: body.parentLinkId
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "link-existing-section") {
+      const result2 = await linkExistingDocmanSection({
+        scopeId: resolvedScopeId,
+        documentVersionId: body.documentVersionId,
+        sectionId: body.sectionId,
+        parentLinkId: body.parentLinkId,
+        position: body.position,
+        titleOverride: body.titleOverride,
+        numbering: body.numbering
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "link-existing-page-version") {
+      const result2 = await linkExistingDocmanPageVersion({
+        scopeId: resolvedScopeId,
+        sectionId: body.sectionId,
+        pageId: body.pageId,
+        pageVersionId: body.pageVersionId,
+        position: body.position,
+        titleOverride: body.titleOverride,
+        numbering: body.numbering
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "update-document-section-links") {
+      const result2 = await updateDocmanDocumentSectionLinksFlow({
+        scopeId: resolvedScopeId,
+        documentVersionId: body.documentVersionId,
+        updates: body.updates
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "update-section-page-links") {
+      const result2 = await updateDocmanSectionPageLinksFlow({
+        scopeId: resolvedScopeId,
+        sectionId: body.sectionId,
+        updates: body.updates
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "save-page-version-draft") {
+      const result2 = await saveDocmanPageVersionDraftFlow({
+        scopeId: resolvedScopeId,
+        pageVersionId: body.pageVersionId,
+        documentLinkId: body.documentLinkId,
+        data: body.data
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "update-document-version") {
+      const result2 = await updateDocmanDocumentVersionFlow({
+        scopeId: resolvedScopeId,
+        documentVersionId: body.documentVersionId,
+        documentId: body.documentId,
+        data: body.data
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "update-page") {
+      const result2 = await updateDocmanPageFlow({
+        scopeId: resolvedScopeId,
+        pageId: body.pageId,
+        data: body.data
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "copy-page") {
+      const result2 = await copyDocmanPageFlow({
+        scopeId: resolvedScopeId,
+        sourcePageId: body.sourcePageId,
+        sourcePageVersionId: body.sourcePageVersionId,
+        targetSectionId: body.targetSectionId,
+        position: body.position,
+        rename: body.rename,
+        clonePage: body.clonePage
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "create-document-version") {
+      const result2 = await createDocmanDocumentVersionFlow({
+        scopeId: resolvedScopeId,
+        documentId: body.documentId,
+        data: body.data,
+        documentInitMode: body.documentInitMode,
+        sourceVersionId: body.sourceVersionId,
+        sourceSectionLinkIds: body.sourceSectionLinkIds
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    if (action === "create-page-with-initial-version") {
+      const result2 = await createDocmanPageWithInitialVersionFlow({
+        scopeId: resolvedScopeId,
+        data: body.format === void 0 ? body.data : {
+          ...toRecord(body.data),
+          format: body.format
+        }
+      });
+      return json(okResult(result2), { status: 200 });
+    }
+    const result = await createLinkedDocmanPage({
+      scopeId: resolvedScopeId,
+      documentVersionId: body.documentVersionId,
+      sectionId: body.sectionId,
+      parentLinkId: body.parentLinkId,
+      format: body.format
+    });
+    return json(okResult(result), { status: 200 });
+  } catch (error) {
+    const message = error instanceof Error && error.message.trim().length > 0 ? error.message : "docman_flow_failed";
+    return json(errResult(message), { status: inferDocmanFlowErrorStatus(message) });
+  }
+};
+
+export { POST };

package/build/server/chunks/_server.ts-BX4X0tW0.js

@@ -0,0 +1,16 @@
+import { j as json } from './index.js-BQnOaW3H.js';
+import { o as okResult } from './xf-result-BRDjvftr.js';
+
+const GET = async ({ locals }) => {
+  if (!locals.principal) {
+    return json({ ok: false, error: "auth_principal_missing" }, { status: 500 });
+  }
+  return json(okResult({
+    principal: locals.principal,
+    tenantId: locals.tenantId,
+    authProvider: "trusted-local",
+    authRequired: false
+  }));
+};
+
+export { GET };

package/build/server/chunks/_server.ts-BkxSxdd0.js

@@ -0,0 +1,172 @@
+import { j as json } from './index.js-BQnOaW3H.js';
+import { z } from 'zod';
+import { g as getAgentGateway } from './agent-gateway-runtime-C7Kvvy0H.js';
+import { n as normalizePluginFailure, t as toSafePluginFailureLogDetails, i as inferFailureStatusFromPayload, c as classifyInvokeFailureMessage } from './plugin-error-normalize-DNeRsopQ.js';
+import { a as attachResolvedProjectScope, r as resolveHostRequestContext } from './request-context-9wzBoKrz.js';
+import '@aopslabs/host-core';
+import '@aopslabs/manifest';
+import './registry-DO8ob5o1.js';
+import 'node:path';
+import 'node:module';
+import 'node:url';
+import './aops-runtime-config-CHpDUCdE.js';
+import 'node:fs';
+import 'pg';
+import 'node:worker_threads';
+import './admission-snapshot-C2wGfTWE.js';
+import 'node:crypto';
+import 'node:child_process';
+import 'node:util';
+import './project-alias-BdnRxWft.js';
+import './canonical-text-order-DbXJJnFD.js';
+import 'ajv';
+import '@aopslabs/xf-dm-kits/appConfig';
+import '@aopslabs/xf-dm-kits';
+import '@aopslabs/domain-kit-agentspace';
+import './xf-result-BRDjvftr.js';
+import 'effect';
+
+const invokeEnvelopeSchema = z.object({
+  sourceId: z.string().trim().min(1).optional(),
+  input: z.unknown().optional(),
+  preview: z.boolean().optional(),
+  apply: z.boolean().optional(),
+  confirm: z.boolean().optional(),
+  idempotencyKey: z.string().trim().min(1).max(200).optional()
+}).strict();
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error ?? "unknown_error");
+}
+function sanitizeInvokeHeaders(input) {
+  const headers = new Headers();
+  if (!input) return headers;
+  for (const [nameRaw, value] of Object.entries(input)) {
+    const name = nameRaw.trim().toLowerCase();
+    if (!name) continue;
+    if (name === "content-length" || name === "content-type" || name === "transfer-encoding" || name === "connection" || name === "keep-alive" || name === "content-encoding") {
+      continue;
+    }
+    headers.set(name, value);
+  }
+  return headers;
+}
+function hasClientProvidedContext(input) {
+  return isRecord(input) && Object.prototype.hasOwnProperty.call(input, "context");
+}
+function resolveActivitySourceKind(event) {
+  const candidate = String(event.request.headers.get("x-activity-source-kind") ?? "").trim().toLowerCase();
+  if (candidate === "aops-cli" || candidate === "desktop" || candidate === "runner" || candidate === "system") {
+    return candidate;
+  }
+  return "system";
+}
+async function parseInvokePayload(event) {
+  try {
+    const rawText = await event.request.text();
+    if (!rawText.trim()) {
+      return { ok: true, input: void 0 };
+    }
+    const rawPayload = JSON.parse(rawText);
+    const shouldParseEnvelope = isRecord(rawPayload) && ("input" in rawPayload || "preview" in rawPayload || "apply" in rawPayload || "confirm" in rawPayload || "idempotencyKey" in rawPayload || Object.keys(rawPayload).every(
+      (key) => key === "sourceId" || key === "input" || key === "preview" || key === "apply" || key === "confirm" || key === "idempotencyKey"
+    ));
+    if (!shouldParseEnvelope) {
+      if (hasClientProvidedContext(rawPayload)) {
+        return {
+          ok: false,
+          error: "invalid_input",
+          message: "invalid_invoke_payload:context_not_allowed"
+        };
+      }
+      return { ok: true, input: rawPayload };
+    }
+    const parsedEnvelope = invokeEnvelopeSchema.safeParse(rawPayload);
+    if (!parsedEnvelope.success) {
+      return {
+        ok: false,
+        error: "invalid_input",
+        message: `invalid_invoke_payload:${parsedEnvelope.error.issues[0]?.message ?? "invalid_envelope"}`
+      };
+    }
+    if (hasClientProvidedContext(parsedEnvelope.data.input)) {
+      return {
+        ok: false,
+        error: "invalid_input",
+        message: "invalid_invoke_payload:input.context_not_allowed"
+      };
+    }
+    return {
+      ok: true,
+      sourceId: parsedEnvelope.data.sourceId?.trim().toLowerCase(),
+      input: parsedEnvelope.data.input,
+      preview: parsedEnvelope.data.preview,
+      apply: parsedEnvelope.data.apply,
+      confirm: parsedEnvelope.data.confirm,
+      idempotencyKey: parsedEnvelope.data.idempotencyKey?.trim()
+    };
+  } catch {
+    return {
+      ok: false,
+      error: "invalid_input",
+      message: "invalid_json_body"
+    };
+  }
+}
+const POST = async (event) => {
+  await attachResolvedProjectScope(event);
+  const toolId = event.params.toolId?.trim().toLowerCase();
+  if (!toolId) {
+    return json({ ok: false, error: "missing_tool_id" }, { status: 400 });
+  }
+  const gateway = getAgentGateway();
+  const parsedPayload = await parseInvokePayload(event);
+  if (!parsedPayload.ok) {
+    return json({ ok: false, error: parsedPayload.error, message: parsedPayload.message }, { status: 400 });
+  }
+  try {
+    const result = await gateway.invokeTool({
+      toolId,
+      sourceId: parsedPayload.sourceId,
+      input: parsedPayload.input,
+      preview: parsedPayload.preview,
+      apply: parsedPayload.apply,
+      confirm: parsedPayload.confirm,
+      idempotencyKey: parsedPayload.idempotencyKey,
+      context: {
+        ...resolveHostRequestContext(event),
+        activitySourceKind: resolveActivitySourceKind(event)
+      }
+    });
+    const normalized = normalizePluginFailure(result.status, result.data);
+    if (normalized.sanitized) {
+      console.warn("[agent-invoke] sanitized plugin error response", {
+        toolId,
+        ...toSafePluginFailureLogDetails(normalized.payload)
+      });
+    }
+    const effectiveStatus = inferFailureStatusFromPayload(normalized.payload, normalized.status);
+    const payloadOk = isRecord(normalized.payload) ? normalized.payload.ok !== false : true;
+    const responseOk = effectiveStatus < 400 && payloadOk;
+    return json(
+      {
+        ok: responseOk,
+        tool: result.tool,
+        data: normalized.payload,
+        response: normalized.payload
+      },
+      { status: effectiveStatus, headers: sanitizeInvokeHeaders(result.headers) }
+    );
+  } catch (error) {
+    const message = normalizeErrorMessage(error);
+    const classification = classifyInvokeFailureMessage(message);
+    return json(
+      { ok: false, error: classification.error, message },
+      { status: classification.status }
+    );
+  }
+};
+
+export { POST };

package/build/server/chunks/_server.ts-Bly8fCZa.js

@@ -0,0 +1,90 @@
+const SERVER_STATUS_PAGE = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="light dark" />
+    <title>AOPS Community Server</title>
+    <style>
+      :root {
+        font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+        color: #2f2925;
+        background: #f7efe1;
+      }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+      }
+      main {
+        width: min(42rem, calc(100vw - 3rem));
+        border: 1px solid #d7c7ad;
+        background: #fffaf1;
+        padding: 2rem;
+        box-shadow: 0.75rem 0.75rem 0 #eadbc2;
+      }
+      h1 {
+        margin: 0 0 0.75rem;
+        font-size: clamp(1.35rem, 3vw, 2rem);
+        font-weight: 600;
+      }
+      p {
+        line-height: 1.6;
+      }
+      .status {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.55rem;
+        margin: 0 0 1.5rem;
+      }
+      .status::before {
+        width: 0.65rem;
+        height: 0.65rem;
+        border-radius: 50%;
+        background: #2d8a5b;
+        content: "";
+      }
+      nav {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.65rem 1.25rem;
+        margin-top: 1.5rem;
+      }
+      a {
+        color: #8a3f20;
+        text-underline-offset: 0.2em;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>AOPS Community Server</h1>
+      <p class="status">Server interface is running</p>
+      <p>
+        This port owns the AOPS API and discovery surface. AOPS Cockpit is a
+        separate local service.
+      </p>
+      <nav aria-label="Server resources">
+        <a href="/api/health">Health</a>
+        <a href="/api-info">API information</a>
+        <a href="/api-info.json">Discovery JSON</a>
+        <a href="/openapi.json">OpenAPI</a>
+      </nav>
+    </main>
+  </body>
+</html>`;
+const GET = async () => new Response(SERVER_STATUS_PAGE, {
+  status: 200,
+  headers: {
+    "cache-control": "no-store",
+    "content-security-policy": "default-src 'none'; base-uri 'none'; frame-ancestors 'none'; style-src 'unsafe-inline'",
+    "content-type": "text/html; charset=utf-8",
+    "cross-origin-resource-policy": "same-origin",
+    "referrer-policy": "no-referrer",
+    "x-content-type-options": "nosniff",
+    "x-frame-options": "DENY"
+  }
+});
+
+export { GET };

package/build/server/chunks/_server.ts-Bz-Erv-1.js

@@ -0,0 +1,43 @@
+import { j as json } from './index.js-BQnOaW3H.js';
+import { t as testRuntimeConfigAdminTarget, g as getResolvedAopsServerRuntimeConfig } from './aops-runtime-config-CHpDUCdE.js';
+import { o as okResult } from './xf-result-BRDjvftr.js';
+import 'node:fs';
+import 'node:path';
+import 'pg';
+
+function toSafeErrorMessage(_error, fallback = "PostgreSQL status probe failed.") {
+  return fallback;
+}
+async function getDbAdminStatus() {
+  const runtime = getResolvedAopsServerRuntimeConfig();
+  if (!runtime.repoUrl) {
+    return {
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      env: { repoUrlEnv: "AOPS_PG_URL", repoUrlPresent: false },
+      connection: { ok: false, databaseName: null, message: "AOPS_PG_URL is required.", redactedUrl: null },
+      schema: { verificationLevel: "sentinel-relations-only", ready: false, sentinelsPresent: false, configuredRelationCount: 5, existingRelationCount: 0, existingRelations: [], missingRelations: ["projects", "docman_documents", "projectman_kanban_boards", "chatv3-rooms", "sys_event_stores"] },
+      capabilities: { status: true, probe: true, reset: false, backup: false, restore: false }
+    };
+  }
+  try {
+    const probe = await testRuntimeConfigAdminTarget();
+    return {
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      env: { repoUrlEnv: "AOPS_PG_URL", repoUrlPresent: true },
+      connection: { ...probe.connection, redactedUrl: probe.target.redactedRepoUrl },
+      schema: probe.schema,
+      capabilities: { status: true, probe: true, reset: false, backup: false, restore: false }
+    };
+  } catch (error) {
+    return {
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      env: { repoUrlEnv: "AOPS_PG_URL", repoUrlPresent: true },
+      connection: { ok: false, databaseName: null, message: toSafeErrorMessage(), redactedUrl: null },
+      schema: { verificationLevel: "sentinel-relations-only", ready: false, sentinelsPresent: false, configuredRelationCount: 5, existingRelationCount: 0, existingRelations: [], missingRelations: ["projects", "docman_documents", "projectman_kanban_boards", "chatv3-rooms", "sys_event_stores"] },
+      capabilities: { status: true, probe: true, reset: false, backup: false, restore: false }
+    };
+  }
+}
+const GET = async () => json(okResult(await getDbAdminStatus()), { status: 200 });
+
+export { GET };

package/build/server/chunks/_server.ts-CRKd0KAC.js

@@ -0,0 +1,43 @@
+import { j as json } from './index.js-BQnOaW3H.js';
+import { a as getAgentToolDetailDocument } from './discovery-BvDEgiqC.js';
+import { r as resolveRequestBaseUrl } from './request-base-url-zKJpVUv5.js';
+import './agent-gateway-runtime-C7Kvvy0H.js';
+import '@aopslabs/host-core';
+import '@aopslabs/manifest';
+import './registry-DO8ob5o1.js';
+import 'node:path';
+import 'node:module';
+import 'node:url';
+import './aops-runtime-config-CHpDUCdE.js';
+import 'node:fs';
+import 'pg';
+import 'node:worker_threads';
+import './admission-snapshot-C2wGfTWE.js';
+import 'node:crypto';
+import 'node:child_process';
+import 'node:util';
+import './project-alias-BdnRxWft.js';
+import './canonical-text-order-DbXJJnFD.js';
+import 'ajv';
+import 'zod';
+import './auth-provider-C07OUlnz.js';
+
+const GET = async ({ params, request, url }) => {
+  const toolId = params.toolId?.trim().toLowerCase();
+  if (!toolId) {
+    return json({ ok: false, error: "missing_tool_id" }, { status: 400 });
+  }
+  try {
+    const serverBaseUrl = resolveRequestBaseUrl(request, url);
+    const detail = await getAgentToolDetailDocument({ toolId, serverBaseUrl });
+    if (!detail) {
+      return json({ ok: false, error: "tool_not_found", toolId }, { status: 404 });
+    }
+    return json(detail, { status: 200 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error ?? "unknown_error");
+    return json({ ok: false, error: "tool_detail_failed", message }, { status: 500 });
+  }
+};
+
+export { GET };