_shared.ts

import { HospitableError } from "../hospitable/client.js";
import { writeAuditLog as realWriteAuditLog } from "../db.js";
import type { TenantContext } from "../auth.js";

type AuditLogger = (
  tenantIdHash: string | null,
  tool: string,
  result: "ok" | "error",
  errorMessage?: string
) => Promise<void>;

let auditLogger: AuditLogger = realWriteAuditLog;

/** Test hook: replace the audit logger. Returns a restore function. */
export function setAuditLogger(fn: AuditLogger): () => void {
  const prev = auditLogger;
  auditLogger = fn;
  return () => {
    auditLogger = prev;
  };
}

export interface ToolResult {
  [key: string]: unknown;
  content: Array<{ type: "text"; text: string }>;
  isError?: boolean;
}

export function jsonResponse(data: unknown): ToolResult {
  return {
    content: [{ type: "text", text: JSON.stringify(data) }],
  };
}

export function textResponse(text: string): ToolResult {
  return { content: [{ type: "text", text }] };
}

export function formatToolError(err: unknown): ToolResult {
  if (err instanceof HospitableError) {
    return {
      content: [
        {
          type: "text",
          text: `Hospitable API error ${err.status}: ${err.message}${err.body ? `\n${err.body}` : ""}`,
        },
      ],
      isError: true,
    };
  }
  const msg = err instanceof Error ? err.message : String(err);
  return {
    content: [{ type: "text", text: msg }],
    isError: true,
  };
}

export async function runTool(
  ctx: TenantContext,
  toolName: string,
  fn: () => Promise<unknown>
): Promise<ToolResult> {
  try {
    const data = await fn();
    void auditLogger(ctx.tenantIdHash, toolName, "ok");
    if (data === undefined || data === null) {
      return textResponse("OK");
    }
    return jsonResponse(data);
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    void auditLogger(ctx.tenantIdHash, toolName, "error", msg);
    return formatToolError(err);
  }
}