@pylonsync/create-pylon 0.20.0 → 0.22.0

package/templates/imessage/lib/agent-call.ts

@@ -1,251 +0,0 @@
-// Run the `assistant` agent for an inbound text.
-//
-// `agent()` persists every turn into AgentRun/AgentMessage rows owned by the
-// caller, so it needs a signed-in user. Inbound texts arrive on a webhook or a
-// relay sync, where there is no user. The server therefore calls the agent
-// over HTTP as the owner: it mints a session for the owner's user id with
-// POST /api/auth/session (open in `pylon dev`; requires PYLON_ADMIN_TOKEN in
-// production), then POSTs /api/fn/assistant with that session. The owner's
-// session resolves to an admin (PYLON_ADMIN_EMAILS), which is the only caller
-// the agent accepts. The runs then show up live in the owner's dashboard
-// through the framework's owner-scoped AgentRun/AgentMessage sync.
-//
-// The session token lives only in this process's memory and is reused until
-// the server rejects it.
-
-import { AGENT_NAME } from "./assistant";
-
-type Env = Record<string, string | undefined>;
-
-export interface AgentResult {
-  runId: string;
-  text: string;
-  steps: number;
-  queued?: boolean;
-  cancelled?: boolean;
-}
-
-export type AgentCallOutcome =
-  | { ok: true; result: AgentResult }
-  | { ok: false; code: string; message: string };
-
-export type FetchLike = (url: string, init: RequestInit) => Promise<Response>;
-
-/**
- * Origin the server calls itself on. The request carries PYLON_ADMIN_TOKEN, so
- * it stays on this machine whenever the port is known (PYLON_PORT). Otherwise
- * it goes to APP_URL / PYLON_PUBLIC_URL, and only over https: a plain-http
- * public origin would put the admin token on the wire. Falls back to the
- * default local port.
- */
-export function selfBaseUrl(env: Env): string {
-  const port = Number.parseInt(env.PYLON_PORT ?? "", 10);
-  if (Number.isFinite(port) && port > 0 && port < 65536) return `http://127.0.0.1:${port}`;
-  const raw = (env.APP_URL || env.PYLON_PUBLIC_URL || "").trim();
-  if (raw !== "") {
-    try {
-      const u = new URL(raw);
-      if (u.protocol === "https:") return u.origin;
-    } catch {
-      // Fall through to the local default.
-    }
-  }
-  return "http://127.0.0.1:4321";
-}
-
-export interface SseEvent {
-  event: string;
-  data: string;
-}
-
-/** Parse a complete text/event-stream body into events. Comment and id lines are dropped. */
-export function parseSse(body: string): SseEvent[] {
-  const events: SseEvent[] = [];
-  for (const block of body.replace(/\r\n?/g, "\n").split("\n\n")) {
-    let event = "message";
-    const data: string[] = [];
-    for (const line of block.split("\n")) {
-      if (line.startsWith("event:")) event = line.slice(6).trim();
-      else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, ""));
-    }
-    if (data.length > 0) events.push({ event, data: data.join("\n") });
-  }
-  return events;
-}
-
-/** True once `body` holds a complete `result` or `error` event. */
-export function hasTerminalEvent(body: string): boolean {
-  const complete = body.replace(/\r\n?/g, "\n");
-  const end = complete.lastIndexOf("\n\n");
-  if (end === -1) return false;
-  return parseSse(complete.slice(0, end)).some((e) => e.event === "result" || e.event === "error");
-}
-
-/**
- * Read an SSE response until its `result` or `error` event, then stop. The
- * server can hold a finished stream open (it stays resumable for a while), so
- * waiting for the connection to close would hang.
- */
-async function readUntilTerminalEvent(res: Response): Promise<string> {
-  if (!res.body) return "";
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder();
-  let body = "";
-  try {
-    for (;;) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      body += decoder.decode(value, { stream: true });
-      if (hasTerminalEvent(body)) break;
-    }
-  } finally {
-    await reader.cancel().catch(() => {});
-  }
-  return body;
-}
-
-function asResult(value: unknown): AgentResult | null {
-  if (typeof value !== "object" || value === null) return null;
-  const v = value as Record<string, unknown>;
-  if (typeof v.runId !== "string") return null;
-  return {
-    runId: v.runId,
-    text: typeof v.text === "string" ? v.text : "",
-    steps: typeof v.steps === "number" ? v.steps : 0,
-    queued: v.queued === true,
-    cancelled: v.cancelled === true,
-  };
-}
-
-function asError(value: unknown, fallback: string): { code: string; message: string } {
-  const v = (value ?? {}) as Record<string, unknown>;
-  const e = (typeof v.error === "object" && v.error !== null ? v.error : v) as Record<string, unknown>;
-  return {
-    code: typeof e.code === "string" ? e.code : "AGENT_FAILED",
-    message: typeof e.message === "string" ? e.message : fallback,
-  };
-}
-
-/** Interpret the agent endpoint's response: SSE when it streamed, JSON otherwise. */
-export function readAgentResponse(status: number, contentType: string, body: string): AgentCallOutcome {
-  if (contentType.includes("text/event-stream")) {
-    const events = parseSse(body);
-    const result = events.find((e) => e.event === "result");
-    if (result) {
-      try {
-        const parsed = asResult(JSON.parse(result.data));
-        if (parsed) return { ok: true, result: parsed };
-      } catch {
-        // Reported below.
-      }
-    }
-    const error = events.find((e) => e.event === "error");
-    if (error) {
-      try {
-        return { ok: false, ...asError(JSON.parse(error.data), error.data) };
-      } catch {
-        return { ok: false, code: "AGENT_FAILED", message: error.data.slice(0, 300) };
-      }
-    }
-    return { ok: false, code: "AGENT_NO_RESULT", message: "The agent stream ended without a result" };
-  }
-  let json: unknown = null;
-  try {
-    json = JSON.parse(body);
-  } catch {
-    return { ok: false, code: `HTTP_${status}`, message: body.slice(0, 300) || `HTTP ${status}` };
-  }
-  if (status >= 200 && status < 300) {
-    const parsed = asResult(json);
-    if (parsed) return { ok: true, result: parsed };
-  }
-  return { ok: false, ...asError(json, `HTTP ${status}`) };
-}
-
-interface CachedSession {
-  userId: string;
-  token: string;
-}
-
-let cached: CachedSession | null = null;
-
-async function mintSession(
-  base: string,
-  userId: string,
-  adminToken: string,
-  fetchImpl: FetchLike,
-): Promise<string> {
-  const headers: Record<string, string> = { "content-type": "application/json" };
-  if (adminToken) headers.authorization = `Bearer ${adminToken}`;
-  const res = await fetchImpl(`${base}/api/auth/session`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ user_id: userId }),
-    signal: AbortSignal.timeout(15_000),
-  });
-  const body = (await res.json().catch(() => ({}))) as Record<string, unknown>;
-  if (!res.ok || typeof body.token !== "string") {
-    const err = asError(body, `HTTP ${res.status}`);
-    throw Object.assign(new Error(err.message), {
-      code: res.status === 403 ? "OWNER_SESSION_FORBIDDEN" : err.code,
-    });
-  }
-  return body.token;
-}
-
-export interface AgentCallArgs {
-  input: string;
-  runId?: string;
-  title?: string;
-}
-
-export async function runAgentAsOwner(
-  env: Env,
-  ownerUserId: string,
-  args: AgentCallArgs,
-  fetchImpl: FetchLike = fetch,
-): Promise<AgentCallOutcome> {
-  const base = selfBaseUrl(env);
-  const adminToken = (env.PYLON_ADMIN_TOKEN ?? "").trim();
-
-  for (let attempt = 0; attempt < 2; attempt++) {
-    if (!cached || cached.userId !== ownerUserId) {
-      try {
-        cached = { userId: ownerUserId, token: await mintSession(base, ownerUserId, adminToken, fetchImpl) };
-      } catch (err) {
-        const e = err as { code?: string; message?: string };
-        return { ok: false, code: e.code ?? "OWNER_SESSION_FAILED", message: e.message ?? String(err) };
-      }
-    }
-    let res: Response;
-    try {
-      res = await fetchImpl(`${base}/api/fn/${AGENT_NAME}`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          accept: "text/event-stream",
-          authorization: `Bearer ${cached.token}`,
-        },
-        body: JSON.stringify(args),
-        signal: AbortSignal.timeout(280_000),
-      });
-    } catch (err) {
-      return { ok: false, code: "AGENT_UNREACHABLE", message: err instanceof Error ? err.message : String(err) };
-    }
-    const contentType = res.headers.get("content-type") ?? "";
-    const body = contentType.includes("text/event-stream") ? await readUntilTerminalEvent(res) : await res.text();
-    const outcome = readAgentResponse(res.status, contentType, body);
-    // A session the server no longer accepts: mint a new one and retry once.
-    if (!outcome.ok && (res.status === 401 || res.status === 403) && attempt === 0) {
-      cached = null;
-      continue;
-    }
-    return outcome;
-  }
-  return { ok: false, code: "AGENT_AUTH_FAILED", message: "Could not authenticate as the owner" };
-}
-
-/** Test seam: forget the cached owner session. */
-export function resetOwnerSessionCache(): void {
-  cached = null;
-}

package/templates/imessage/tests/agent-call.test.ts

@@ -1,112 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-import {
-  hasTerminalEvent,
-  parseSse,
-  readAgentResponse,
-  resetOwnerSessionCache,
-  runAgentAsOwner,
-  selfBaseUrl,
-} from "../lib/agent-call";
-
-const RESULT = { runId: "run_1", text: "Hi there", steps: 1, usage: { input_tokens: 1, output_tokens: 1 } };
-const SSE_BODY = `retry: 1000\n\nid: 1\ndata: Hi \n\nid: 2\ndata: there\n\nid: 3\nevent: result\ndata: ${JSON.stringify(RESULT)}\n\n`;
-
-beforeEach(() => resetOwnerSessionCache());
-
-describe("SSE parsing", () => {
-  test("parses events and multi-line data", () => {
-    expect(parseSse("event: tool\ndata: a\ndata: b\n\ndata: plain\n\n")).toEqual([
-      { event: "tool", data: "a\nb" },
-      { event: "message", data: "plain" },
-    ]);
-  });
-
-  test("detects a complete terminal event only", () => {
-    expect(hasTerminalEvent(SSE_BODY)).toBe(true);
-    expect(hasTerminalEvent(SSE_BODY.slice(0, -2))).toBe(false);
-    expect(hasTerminalEvent("data: x\n\n")).toBe(false);
-  });
-
-  test("reads a streamed result, a streamed error, and a JSON error", () => {
-    expect(readAgentResponse(200, "text/event-stream", SSE_BODY)).toEqual({
-      ok: true,
-      result: { runId: "run_1", text: "Hi there", steps: 1, queued: false, cancelled: false },
-    });
-    expect(
-      readAgentResponse(200, "text/event-stream", `event: error\ndata: {"code":"LLM_NOT_CONFIGURED","message":"no key"}\n\n`),
-    ).toEqual({ ok: false, code: "LLM_NOT_CONFIGURED", message: "no key" });
-    expect(readAgentResponse(403, "application/json", `{"error":{"code":"FORBIDDEN","message":"admin only"}}`)).toEqual({
-      ok: false,
-      code: "FORBIDDEN",
-      message: "admin only",
-    });
-  });
-});
-
-describe("selfBaseUrl", () => {
-  test("prefers loopback, then an https public origin, never plain-http public", () => {
-    expect(selfBaseUrl({ PYLON_PORT: "4541", APP_URL: "https://a.example.com" })).toBe("http://127.0.0.1:4541");
-    expect(selfBaseUrl({ APP_URL: "https://a.example.com/path" })).toBe("https://a.example.com");
-    expect(selfBaseUrl({ PYLON_PUBLIC_URL: "https://b.example.com" })).toBe("https://b.example.com");
-    expect(selfBaseUrl({ APP_URL: "http://a.example.com" })).toBe("http://127.0.0.1:4321");
-    expect(selfBaseUrl({ APP_URL: "javascript:alert(1)" })).toBe("http://127.0.0.1:4321");
-  });
-});
-
-/** A streaming response that sends `body` and then never closes. */
-function openStream(body: string): Response {
-  const stream = new ReadableStream({
-    start(controller) {
-      controller.enqueue(new TextEncoder().encode(body));
-    },
-  });
-  return new Response(stream, { headers: { "content-type": "text/event-stream" } });
-}
-
-describe("runAgentAsOwner", () => {
-  test("mints an owner session, calls the agent, and returns once the result arrives", async () => {
-    const calls: { url: string; auth: string | null; body: unknown }[] = [];
-    const fetchImpl = async (url: string, init: RequestInit) => {
-      const headers = init.headers as Record<string, string>;
-      calls.push({ url, auth: headers.authorization ?? null, body: JSON.parse(String(init.body)) });
-      if (url.endsWith("/api/auth/session")) return Response.json({ token: "owner-session", user_id: "u1" }, { status: 201 });
-      return openStream(SSE_BODY);
-    };
-    const env = { APP_URL: "https://app.example.com", PYLON_ADMIN_TOKEN: "admin-token" };
-    const out = await runAgentAsOwner(env, "u1", { input: "hi", title: "conv_1" }, fetchImpl);
-    expect(out.ok && out.result.text).toBe("Hi there");
-    expect(calls.map((c) => c.url)).toEqual([
-      "https://app.example.com/api/auth/session",
-      "https://app.example.com/api/fn/assistant",
-    ]);
-    expect(calls[0].auth).toBe("Bearer admin-token");
-    expect(calls[0].body).toEqual({ user_id: "u1" });
-    expect(calls[1].auth).toBe("Bearer owner-session");
-    expect(calls[1].body).toEqual({ input: "hi", title: "conv_1" });
-
-    // The session is reused on the next call.
-    await runAgentAsOwner(env, "u1", { input: "again" }, fetchImpl);
-    expect(calls.filter((c) => c.url.endsWith("/api/auth/session")).length).toBe(1);
-  });
-
-  test("re-mints once when the cached session is rejected", async () => {
-    let mints = 0;
-    let agentCalls = 0;
-    const fetchImpl = async (url: string) => {
-      if (url.endsWith("/api/auth/session")) return Response.json({ token: `s${++mints}` });
-      agentCalls += 1;
-      if (agentCalls === 1) return Response.json({ error: { code: "AUTH_REQUIRED", message: "expired" } }, { status: 401 });
-      return openStream(SSE_BODY);
-    };
-    const out = await runAgentAsOwner({}, "u1", { input: "hi" }, fetchImpl);
-    expect(out.ok).toBe(true);
-    expect(mints).toBe(2);
-  });
-
-  test("reports a refused session mint", async () => {
-    const fetchImpl = async () =>
-      Response.json({ error: { code: "FORBIDDEN", message: "/api/auth/session requires admin auth" } }, { status: 403 });
-    const out = await runAgentAsOwner({}, "u1", { input: "hi" }, fetchImpl);
-    expect(out).toEqual({ ok: false, code: "OWNER_SESSION_FORBIDDEN", message: "/api/auth/session requires admin auth" });
-  });
-});