@agent-native/core 0.97.0 → 0.98.0

package/corpus/core/src/server/agent-chat/shared-thread.ts

@@ -0,0 +1,301 @@
+import {
+  getHeader,
+  getMethod,
+  setResponseHeader,
+  setResponseStatus,
+  type H3Event,
+} from "h3";
+
+import type { AgentRunSummary } from "../../agent/run-store.js";
+import { normalizeThreadRepository } from "../../agent/thread-data-builder.js";
+import type { ChatThread } from "../../chat-threads/store.js";
+
+// ---------------------------------------------------------------------------
+// Read-only shared-thread route: renders a public HTML/JSON view of a chat
+// thread reachable via its share token (see `handleSharedThreadRequest`).
+// ---------------------------------------------------------------------------
+
+function sanitizeSharedThread(thread: ChatThread): {
+  id: string;
+  title: string;
+  preview: string;
+  messageCount: number;
+  createdAt: number;
+  updatedAt: number;
+  scope: { type: string; label?: string } | null;
+  messages: Array<{
+    id?: string;
+    role: "user" | "assistant" | "system";
+    text: string;
+    createdAt?: string | number;
+  }>;
+} {
+  let repo: any = {};
+  try {
+    repo = normalizeThreadRepository(JSON.parse(thread.threadData));
+  } catch {
+    repo = {};
+  }
+  const messages = Array.isArray(repo.messages)
+    ? repo.messages
+        .map((entry: unknown) => sanitizeSharedMessage(entry))
+        .filter(
+          (
+            entry: unknown,
+          ): entry is NonNullable<ReturnType<typeof sanitizeSharedMessage>> =>
+            entry != null,
+        )
+    : [];
+  return {
+    id: thread.id,
+    title: thread.title,
+    preview: thread.preview,
+    messageCount: thread.messageCount,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    scope: thread.scope
+      ? {
+          type: thread.scope.type,
+          ...(thread.scope.label ? { label: thread.scope.label } : {}),
+        }
+      : null,
+    messages,
+  };
+}
+
+type SanitizedSharedThread = ReturnType<typeof sanitizeSharedThread>;
+
+export interface SharedThreadRouteDependencies {
+  getThreadByShareToken: (token: string) => Promise<ChatThread | null>;
+  listRunsForThread: (
+    threadId: string,
+    options?: { limit?: number },
+  ) => Promise<AgentRunSummary[]>;
+}
+
+function escapeSharedThreadHtml(value: unknown): string {
+  return String(value ?? "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function wantsSharedThreadHtml(event: H3Event): boolean {
+  const accept = getHeader(event, "accept")?.toLowerCase() ?? "";
+  return accept.includes("text/html") && !accept.includes("application/json");
+}
+
+function formatSharedThreadTime(value: string | number | null | undefined) {
+  if (value == null) return "";
+  const date =
+    typeof value === "number"
+      ? new Date(value)
+      : Number.isFinite(Number(value))
+        ? new Date(Number(value))
+        : new Date(value);
+  return Number.isNaN(date.getTime()) ? String(value) : date.toLocaleString();
+}
+
+function renderSharedThreadHtml(
+  thread: SanitizedSharedThread,
+  runs: AgentRunSummary[],
+): string {
+  const title = thread.title || "Shared agent session";
+  const messages = thread.messages
+    .map((message) => {
+      const time = formatSharedThreadTime(message.createdAt);
+      return `<article class="message ${escapeSharedThreadHtml(message.role)}">
+        <div class="meta">
+          <span>${escapeSharedThreadHtml(message.role)}</span>
+          ${time ? `<time>${escapeSharedThreadHtml(time)}</time>` : ""}
+        </div>
+        <pre>${escapeSharedThreadHtml(message.text)}</pre>
+      </article>`;
+    })
+    .join("");
+  const runsHtml = runs.length
+    ? `<section class="runs" aria-label="Recent runs">
+        <h2>Recent runs</h2>
+        <ol>${runs
+          .map((run) => {
+            const started = formatSharedThreadTime(run.startedAt);
+            const completed = formatSharedThreadTime(run.completedAt);
+            const detail = [
+              started ? `started ${started}` : "",
+              completed ? `completed ${completed}` : "",
+              run.errorCode ? `error ${run.errorCode}` : "",
+              run.abortReason ? `aborted ${run.abortReason}` : "",
+            ]
+              .filter(Boolean)
+              .join(" · ");
+            return `<li><strong>${escapeSharedThreadHtml(run.status)}</strong>${detail ? `<span>${escapeSharedThreadHtml(detail)}</span>` : ""}</li>`;
+          })
+          .join("")}</ol>
+      </section>`
+    : "";
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="robots" content="noindex, nofollow" />
+  <meta name="referrer" content="no-referrer" />
+  <title>${escapeSharedThreadHtml(title)}</title>
+  <style>
+    :root { color-scheme: light dark; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #f7f7f5; color: #1d1d1b; }
+    * { box-sizing: border-box; }
+    body { margin: 0; }
+    main { width: min(920px, calc(100vw - 32px)); margin: 0 auto; padding: 44px 0 64px; }
+    header { border-bottom: 1px solid rgba(0,0,0,.12); padding-bottom: 24px; margin-bottom: 28px; }
+    .eyebrow { margin: 0 0 10px; font-size: 12px; font-weight: 700; letter-spacing: .08em; text-transform: uppercase; color: #676760; }
+    h1 { margin: 0; font-size: 42px; line-height: 1.08; letter-spacing: 0; }
+    .summary { margin: 14px 0 0; color: #5c5c55; line-height: 1.6; max-width: 760px; }
+    .message { border: 1px solid rgba(0,0,0,.12); border-radius: 8px; background: rgba(255,255,255,.72); margin: 14px 0; padding: 16px; }
+    .message.assistant { border-left: 4px solid #2563eb; }
+    .message.user { border-left: 4px solid #0f766e; }
+    .message.system { border-left: 4px solid #737373; }
+    .meta { display: flex; gap: 12px; justify-content: space-between; color: #676760; font-size: 12px; font-weight: 700; text-transform: uppercase; }
+    pre { margin: 12px 0 0; white-space: pre-wrap; overflow-wrap: anywhere; font: inherit; line-height: 1.6; }
+    .empty, .runs { margin-top: 28px; color: #676760; }
+    .runs h2 { font-size: 16px; margin: 0 0 12px; }
+    .runs ol { margin: 0; padding-left: 20px; }
+    .runs li { margin: 8px 0; }
+    .runs span { color: #676760; margin-left: 8px; }
+    @media (prefers-color-scheme: dark) {
+      :root { background: #11110f; color: #f5f5ef; }
+      header, .message { border-color: rgba(255,255,255,.15); }
+      .message { background: rgba(255,255,255,.06); }
+      .summary, .eyebrow, .meta, .empty, .runs, .runs span { color: #b9b9ad; }
+    }
+    @media (max-width: 640px) {
+      h1 { font-size: 32px; }
+      main { width: min(100vw - 24px, 920px); padding-top: 32px; }
+    }
+  </style>
+</head>
+<body>
+  <main>
+    <header>
+      <p class="eyebrow">Read-only shared agent session</p>
+      <h1>${escapeSharedThreadHtml(title)}</h1>
+      <p class="summary">${escapeSharedThreadHtml(thread.preview || `${thread.messageCount} message${thread.messageCount === 1 ? "" : "s"}`)}</p>
+    </header>
+    ${messages || '<p class="empty">No transcript messages were shared.</p>'}
+    ${runsHtml}
+  </main>
+</body>
+</html>`;
+}
+
+function renderSharedThreadErrorHtml(status: number, message: string): string {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><meta name="robots" content="noindex, nofollow" /><title>${status} ${escapeSharedThreadHtml(message)}</title><style>body{margin:0;font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;background:#f7f7f5;color:#1d1d1b}main{max-width:720px;margin:0 auto;padding:64px 24px}p{color:#676760;line-height:1.6}@media(prefers-color-scheme:dark){body{background:#11110f;color:#f5f5ef}p{color:#b9b9ad}}</style></head><body><main><h1>${status}</h1><p>${escapeSharedThreadHtml(message)}</p></main></body></html>`;
+}
+
+function sharedThreadError(event: H3Event, status: number, message: string) {
+  setResponseStatus(event, status);
+  setResponseHeader(event, "Cache-Control", "private, no-store");
+  setResponseHeader(event, "X-Robots-Tag", "noindex, nofollow");
+  if (wantsSharedThreadHtml(event)) {
+    setResponseHeader(event, "Content-Type", "text/html; charset=utf-8");
+    return renderSharedThreadErrorHtml(status, message);
+  }
+  return { error: message };
+}
+
+export async function handleSharedThreadRequest(
+  event: H3Event,
+  deps: SharedThreadRouteDependencies,
+) {
+  const method = getMethod(event);
+  if (method !== "GET") {
+    return sharedThreadError(event, 405, "Method not allowed");
+  }
+
+  const token = parseSharedThreadToken(event);
+  if (!token) {
+    return sharedThreadError(event, 400, "Share token is required");
+  }
+
+  const thread = await deps.getThreadByShareToken(token);
+  if (!thread) {
+    return sharedThreadError(event, 404, "Shared thread not found");
+  }
+
+  const runs = await deps.listRunsForThread(thread.id, { limit: 10 });
+  const payload = {
+    thread: sanitizeSharedThread(thread),
+    runs,
+  };
+  setResponseHeader(event, "Cache-Control", "private, no-store");
+  setResponseHeader(event, "X-Robots-Tag", "noindex, nofollow");
+  if (wantsSharedThreadHtml(event)) {
+    setResponseHeader(event, "Content-Type", "text/html; charset=utf-8");
+    return renderSharedThreadHtml(payload.thread, runs);
+  }
+  setResponseHeader(event, "Content-Type", "application/json");
+  return payload;
+}
+
+function sanitizeSharedMessage(entry: unknown): {
+  id?: string;
+  role: "user" | "assistant" | "system";
+  text: string;
+  createdAt?: string | number;
+} | null {
+  if (!entry || typeof entry !== "object") return null;
+  const raw = entry as Record<string, unknown>;
+  const message =
+    raw.message && typeof raw.message === "object"
+      ? (raw.message as Record<string, unknown>)
+      : raw;
+  const role = message.role;
+  if (role !== "user" && role !== "assistant" && role !== "system") {
+    return null;
+  }
+  const text = sharedTextFromContent(message.content).trim();
+  if (!text) return null;
+  const id = typeof message.id === "string" ? message.id : undefined;
+  const createdAt =
+    typeof message.createdAt === "string" ||
+    typeof message.createdAt === "number"
+      ? message.createdAt
+      : undefined;
+  return {
+    ...(id ? { id } : {}),
+    role,
+    text,
+    ...(createdAt !== undefined ? { createdAt } : {}),
+  };
+}
+
+function sharedTextFromContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const r = part as Record<string, unknown>;
+    if (r.type !== "text") continue;
+    if (typeof r.text === "string") parts.push(r.text);
+  }
+  return parts.join("");
+}
+
+function parseSharedThreadToken(event: H3Event): string | null {
+  const candidates = [event.path, event.node?.req?.url].filter(
+    (value): value is string => typeof value === "string" && value.length > 0,
+  );
+  for (const candidate of candidates) {
+    const path = candidate.split("?")[0];
+    const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
+    const sharedIndex = parts.lastIndexOf("shared");
+    if (sharedIndex >= 0 && parts[sharedIndex + 1]) {
+      return decodeURIComponent(parts[sharedIndex + 1]);
+    }
+    if (parts[0]) return decodeURIComponent(parts[0]);
+  }
+  return null;
+}

package/corpus/core/src/server/agent-chat/skill-frontmatter.ts

@@ -0,0 +1,41 @@
+import {
+  getFrontmatterValue,
+  parseFrontmatter,
+} from "../../resources/metadata.js";
+
+export function parseSkillFrontmatter(content: string): {
+  name?: string;
+  description?: string;
+  userInvocable?: boolean;
+  scope?: "runtime" | "dev" | "both";
+} {
+  const frontmatter = parseFrontmatter(content);
+  const userInvocable = getFrontmatterValue(frontmatter, "user-invocable");
+  const scope = normalizeSkillFrontmatterScope(
+    getFrontmatterValue(frontmatter, "scope"),
+  );
+  return {
+    name: getFrontmatterValue(frontmatter, "name"),
+    description: getFrontmatterValue(frontmatter, "description"),
+    scope,
+    userInvocable:
+      userInvocable === undefined
+        ? undefined
+        : userInvocable.toLowerCase() === "true",
+  };
+}
+
+function normalizeSkillFrontmatterScope(
+  value: string | undefined,
+): "runtime" | "dev" | "both" | undefined {
+  if (!value) return undefined;
+  const normalized = value.trim().toLowerCase();
+  if (
+    normalized === "runtime" ||
+    normalized === "dev" ||
+    normalized === "both"
+  ) {
+    return normalized;
+  }
+  return "both";
+}