app/routes/api.operator.ts

Functions

Imports

It imports app/lib/context.ts, app/lib/operator/api.server.ts, app/lib/operator/auth.server.ts. No module of this repo imports it.

Source

1import { getEnv } from "~/lib/context";
2import { authenticateOperator, meterOperator } from "~/lib/operator/auth.server";
3import { TOOL_DESCRIPTORS, isToolName, runTool, toolNames } from "~/lib/operator/api.server";
4
5import type { Route } from "./+types/api.operator";
6
7/**
8 * A resource route, so the action can return a raw Response. One POST taking `{ tool, args }`, so an
9 * MCP front end maps onto it: `tools/call` carries a name and an argument object.
10 */
11
12const json = (body: unknown, status = 200, headers: HeadersInit = {}) =>
13  new Response(JSON.stringify(body, null, 2), {
14    status,
15    headers: {
16      "content-type": "application/json; charset=utf-8",
17      "cache-control": "no-store",
18      "x-robots-tag": "noindex, nofollow",
19      ...headers,
20    },
21  });
22
23/** A refused identity or allowance, with its Retry-After when the refusal is a rate limit. */
24const refusal = (outcome: { error: string; status: number; retryAfter?: number }) =>
25  json(
26    { ok: false, error: outcome.error },
27    outcome.status,
28    outcome.retryAfter ? { "retry-after": String(outcome.retryAfter) } : {},
29  );
30
31export async function action({ request, context }: Route.ActionArgs) {
32  if (request.method !== "POST") {
33    return json({ ok: false, error: "Use POST." }, 405, { allow: "POST" });
34  }
35
36  const env = getEnv(context) as Parameters<typeof authenticateOperator>[0];
37
38  const auth = await authenticateOperator(env, request);
39  if (!auth.ok) {
40    return refusal(auth);
41  }
42
43  /* Metered right after identity is proven, so an unauthenticated flood never reaches the Durable Object. */
44  const metered = await meterOperator(env, auth.id);
45  if (!metered.ok) {
46    return refusal(metered);
47  }
48
49  let body: unknown;
50  try {
51    body = await request.json();
52  } catch {
53    return json({ ok: false, error: "Body must be JSON." }, 400);
54  }
55
56  const { tool, args } = (body ?? {}) as { tool?: unknown; args?: unknown };
57
58  if (!isToolName(tool)) {
59    return json(
60      {
61        ok: false,
62        error: `Unknown tool. Available: ${toolNames().join(", ")}.`,
63      },
64      400,
65    );
66  }
67
68  const result = await runTool(
69    env,
70    { kind: "operator", id: auth.id },
71    tool,
72    (args ?? {}) as Record<string, unknown>,
73  );
74
75  if (!result.ok) {
76    return json({ ok: false, error: result.error, detail: result.detail }, result.status);
77  }
78  return json({ ok: true, data: result.data });
79}
80
81/**
82 * Behind the same token: an unauthenticated caller learns nothing. No rate limit: it changes nothing,
83 * and a client reading it before each publish would halve its own allowance.
84 */
85export async function loader({ request, context }: Route.LoaderArgs) {
86  const env = getEnv(context) as Parameters<typeof authenticateOperator>[0];
87  const auth = await authenticateOperator(env, request);
88  if (!auth.ok) {
89    return refusal(auth);
90  }
91
92  return json({
93    ok: true,
94    data: {
95      operator: auth.id,
96      tools: toolNames().map((name) => ({ name, ...TOOL_DESCRIPTORS[name] })),
97    },
98  });
99}