@treeseed/core 0.1.2

package/dist/utils/forms/service.js

@@ -0,0 +1,55 @@
+import { getTreeseedFormsProvider } from "../../deploy/runtime.js";
+import { resolveFormsProvider } from "../plugin-runtime.js";
+import {
+  getContactRoutingMap,
+  getFormSecret,
+  getSmtpConfig,
+  getSubscribeRecipients,
+  getTurnstileSecret
+} from "./config.js";
+import { resolveFormRuntimeCapabilities } from "./runtime.js";
+import { SITE } from "../site-config.js";
+import { handleFormSubmissionWithConfig, handleTokenRequestWithConfig } from "./service-core.js";
+function getBindings(locals) {
+  const runtime = locals.runtime;
+  const env = runtime?.env;
+  return env ?? null;
+}
+function createAstroRequestContext(context) {
+  return {
+    request: context.request,
+    url: context.url,
+    getCookie(name) {
+      return context.cookies.get(name)?.value;
+    },
+    setCookie(cookie) {
+      context.cookies.set(cookie.name, cookie.value, cookie.options);
+    },
+    redirect(location, status) {
+      return context.redirect(location, status);
+    }
+  };
+}
+function createAstroFormConfig(context) {
+  return {
+    runtime: resolveFormRuntimeCapabilities(context.locals),
+    bindings: getBindings(context.locals),
+    formsProvider: resolveFormsProvider(getTreeseedFormsProvider()),
+    formSecret: getFormSecret(),
+    turnstileSecret: getTurnstileSecret(),
+    contactRouting: getContactRoutingMap(),
+    subscribeRecipients: getSubscribeRecipients(),
+    smtpConfig: getSmtpConfig(),
+    siteUrl: SITE.url
+  };
+}
+async function handleTokenRequest(context) {
+  return handleTokenRequestWithConfig(createAstroRequestContext(context), createAstroFormConfig(context));
+}
+async function handleFormSubmission(context) {
+  return handleFormSubmissionWithConfig(createAstroRequestContext(context), createAstroFormConfig(context));
+}
+export {
+  handleFormSubmission,
+  handleTokenRequest
+};

package/dist/utils/forms/session.js

@@ -0,0 +1,57 @@
+import { createOpaqueId, signFormToken, verifyFormToken } from "./crypto.js";
+import { FORM_SESSION_COOKIE } from "./constants.js";
+async function issueFormToken(formType, secret) {
+  const sessionId = createOpaqueId();
+  const nonce = createOpaqueId();
+  const issuedAt = Date.now();
+  if (!secret) {
+    throw new Error("TREESEED_FORM_TOKEN_SECRET is not configured.");
+  }
+  const formToken = await signFormToken(
+    {
+      formType,
+      sessionId,
+      nonce,
+      issuedAt
+    },
+    secret
+  );
+  return {
+    formToken,
+    sessionId,
+    issuedAt,
+    nonce
+  };
+}
+async function verifyIssuedToken(formToken, sessionId, formType, secret) {
+  if (!secret) {
+    return { ok: false, reason: "missing-secret" };
+  }
+  const result = await verifyFormToken(formToken, secret);
+  if (!result.ok) {
+    return result;
+  }
+  if (result.payload.sessionId !== sessionId || result.payload.formType !== formType) {
+    return { ok: false, reason: "mismatch", payload: result.payload };
+  }
+  return result;
+}
+function createSessionCookie(sessionId, requestUrl) {
+  const isSecureRequest = requestUrl?.protocol === "https:";
+  return {
+    name: FORM_SESSION_COOKIE,
+    value: sessionId,
+    options: {
+      httpOnly: true,
+      path: "/",
+      sameSite: "lax",
+      secure: isSecureRequest,
+      maxAge: 60 * 60
+    }
+  };
+}
+export {
+  createSessionCookie,
+  issueFormToken,
+  verifyIssuedToken
+};

package/dist/utils/forms/smtp-cloudflare.js

@@ -0,0 +1,107 @@
+async function createSocketContext(port, host) {
+  const { connect } = await import("cloudflare:sockets");
+  const socket = connect(
+    { hostname: host, port },
+    {
+      secureTransport: port === 465 ? "on" : "off"
+    }
+  );
+  return {
+    socket,
+    reader: socket.readable.getReader(),
+    writer: socket.writable.getWriter()
+  };
+}
+async function readSmtpResponse(reader) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\r\n").filter(Boolean);
+    const lastLine = lines.at(-1);
+    if (lastLine && /^\d{3} /.test(lastLine)) {
+      return {
+        code: Number.parseInt(lastLine.slice(0, 3), 10),
+        raw: buffer
+      };
+    }
+  }
+  throw new Error("SMTP connection closed unexpectedly.");
+}
+async function sendCommand(context, command) {
+  await context.writer.write(new TextEncoder().encode(`${command}\r
+`));
+  return readSmtpResponse(context.reader);
+}
+function normalizeBody(text) {
+  return text.replace(/\r?\n/g, "\r\n").split("\r\n").map((line) => line.startsWith(".") ? `.${line}` : line).join("\r\n");
+}
+function toEnvelopeAddress(value) {
+  const match = value.match(/<([^>]+)>/);
+  return (match?.[1] ?? value).trim();
+}
+function buildMessage({ to, subject, text, replyTo }, from) {
+  const headers = [
+    `From: ${from}`,
+    `To: ${to.join(", ")}`,
+    `Subject: ${subject}`,
+    "MIME-Version: 1.0",
+    "Content-Type: text/plain; charset=UTF-8",
+    `Date: ${(/* @__PURE__ */ new Date()).toUTCString()}`
+  ];
+  if (replyTo) {
+    headers.push(`Reply-To: ${replyTo}`);
+  }
+  return `${headers.join("\r\n")}\r
+\r
+${normalizeBody(text)}\r
+.`;
+}
+async function upgradeToTls(context) {
+  if (typeof context.socket.startTls !== "function") {
+    throw new Error("SMTP socket does not support STARTTLS upgrade.");
+  }
+  const secureSocket = context.socket.startTls();
+  return {
+    socket: secureSocket,
+    reader: secureSocket.readable.getReader(),
+    writer: secureSocket.writable.getWriter()
+  };
+}
+function assertResponse(response, acceptedCodes) {
+  if (!acceptedCodes.includes(response.code)) {
+    throw new Error(`SMTP command failed: ${response.raw}`);
+  }
+}
+async function sendEmailWithCloudflareSockets(message, { smtp, siteUrl }) {
+  const envelopeFrom = toEnvelopeAddress(smtp.from);
+  if (!smtp.host || !smtp.port || !smtp.from || !envelopeFrom) {
+    throw new Error("SMTP is not fully configured for Cloudflare-compatible delivery.");
+  }
+  let context = await createSocketContext(smtp.port, smtp.host);
+  assertResponse(await readSmtpResponse(context.reader), [220]);
+  assertResponse(await sendCommand(context, `EHLO ${new URL(siteUrl).hostname}`), [250]);
+  if (smtp.port === 587) {
+    assertResponse(await sendCommand(context, "STARTTLS"), [220]);
+    context = await upgradeToTls(context);
+    assertResponse(await sendCommand(context, `EHLO ${new URL(siteUrl).hostname}`), [250]);
+  }
+  if (smtp.username) {
+    assertResponse(await sendCommand(context, "AUTH LOGIN"), [334]);
+    assertResponse(await sendCommand(context, btoa(smtp.username)), [334]);
+    assertResponse(await sendCommand(context, btoa(smtp.password)), [235]);
+  }
+  assertResponse(await sendCommand(context, `MAIL FROM:<${envelopeFrom}>`), [250]);
+  for (const recipient of message.to) {
+    assertResponse(await sendCommand(context, `RCPT TO:<${recipient}>`), [250, 251]);
+  }
+  assertResponse(await sendCommand(context, "DATA"), [354]);
+  assertResponse(await sendCommand(context, buildMessage(message, smtp.from)), [250]);
+  await sendCommand(context, "QUIT");
+  await context.writer.close();
+}
+export {
+  sendEmailWithCloudflareSockets
+};

package/dist/utils/forms/smtp-node.js

@@ -0,0 +1,27 @@
+import nodemailer from "nodemailer";
+import { getSmtpConfig } from "./config.js";
+async function sendEmailWithNode(message) {
+  const smtp = getSmtpConfig();
+  if (!smtp.host || !smtp.port || !smtp.from) {
+    throw new Error("SMTP is not fully configured for local delivery.");
+  }
+  const transporter = nodemailer.createTransport({
+    host: smtp.host,
+    port: smtp.port,
+    secure: smtp.port === 465,
+    auth: smtp.username ? {
+      user: smtp.username,
+      pass: smtp.password
+    } : void 0
+  });
+  await transporter.sendMail({
+    from: smtp.from,
+    to: message.to.join(", "),
+    subject: message.subject,
+    text: message.text,
+    replyTo: message.replyTo || smtp.replyTo || void 0
+  });
+}
+export {
+  sendEmailWithNode
+};

package/dist/utils/forms/smtp.js

@@ -0,0 +1,10 @@
+async function sendEmail(message, runtime, options) {
+  if (runtime.isCloudflareRuntime) {
+    const { sendEmailWithCloudflareSockets } = await import("./smtp-cloudflare.js");
+    return sendEmailWithCloudflareSockets(message, options);
+  }
+  throw new Error("Email delivery requires Cloudflare runtime bindings in this docs deployment.");
+}
+export {
+  sendEmail
+};

package/dist/utils/forms/subscribers-local.js

@@ -0,0 +1,21 @@
+import { hashValue } from "./crypto.js";
+const localSubscribers = globalThis.__treeseedFixtureSubscribers ?? /* @__PURE__ */ new Map();
+globalThis.__treeseedFixtureSubscribers = localSubscribers;
+async function upsertLocalSubscriber(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const ipHash = await hashValue(input.ip || "unknown");
+  const existing = localSubscribers.get(input.email);
+  localSubscribers.set(input.email, {
+    email: input.email,
+    name: input.name,
+    source: input.source,
+    status: "active",
+    consentAt: now,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    ipHash
+  });
+}
+export {
+  upsertLocalSubscriber
+};

package/dist/utils/forms/subscribers.js

@@ -0,0 +1,53 @@
+import { hashValue } from "./crypto.js";
+async function hasRuntimeRecordsTable(db) {
+  const row = await db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'runtime_records' LIMIT 1").first();
+  return Boolean(row?.name);
+}
+async function upsertSubscriber(db, input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const ipHash = await hashValue(input.ip || "unknown");
+  if (await hasRuntimeRecordsTable(db)) {
+    const payloadJson = JSON.stringify({
+      email: input.email,
+      name: input.name || null,
+      source: input.source,
+      consentAt: now,
+      ipHash
+    });
+    const metaJson = JSON.stringify({});
+    await db.prepare(
+      `INSERT INTO runtime_records (
+					record_type,
+					record_key,
+					lookup_key,
+					status,
+					schema_version,
+					created_at,
+					updated_at,
+					payload_json,
+					meta_json
+				) VALUES (?, ?, ?, 'active', 1, ?, ?, ?, ?)
+				ON CONFLICT(record_type, record_key) DO UPDATE SET
+					lookup_key = excluded.lookup_key,
+					status = 'active',
+					updated_at = excluded.updated_at,
+					payload_json = excluded.payload_json,
+					meta_json = excluded.meta_json`
+    ).bind("subscription", input.email, input.email, now, now, payloadJson, metaJson).run();
+    return;
+  }
+  await db.prepare(
+    `INSERT INTO subscriptions (email, name, status, source, consent_at, created_at, updated_at, ip_hash)
+			 VALUES (?, ?, 'active', ?, ?, ?, ?, ?)
+			 ON CONFLICT(email) DO UPDATE SET
+			 	name = excluded.name,
+			 	status = 'active',
+			 	source = excluded.source,
+			 	consent_at = excluded.consent_at,
+			 	updated_at = excluded.updated_at,
+			 	ip_hash = excluded.ip_hash`
+  ).bind(input.email, input.name || null, input.source, now, now, now, ipHash).run();
+}
+export {
+  upsertSubscriber
+};

package/dist/utils/forms/turnstile.js

@@ -0,0 +1,31 @@
+async function verifyTurnstileToken(token, remoteIp, expectedAction, runtime, secret) {
+  if (runtime.bypassTurnstile || !runtime.turnstileEnabled) {
+    return { ok: true, bypassed: true };
+  }
+  if (!secret || !token) {
+    return { ok: false, reason: "missing-config" };
+  }
+  const form = new FormData();
+  form.set("secret", secret);
+  form.set("response", token);
+  if (remoteIp) {
+    form.set("remoteip", remoteIp);
+  }
+  form.set("idempotency_key", crypto.randomUUID());
+  const response = await fetch("https://challenges.cloudflare.com/turnstile/v0/siteverify", {
+    method: "POST",
+    body: form
+  });
+  const result = await response.json();
+  if (!result.success || result.action !== expectedAction) {
+    return {
+      ok: false,
+      reason: "verification-failed",
+      errors: result["error-codes"] ?? []
+    };
+  }
+  return { ok: true };
+}
+export {
+  verifyTurnstileToken
+};

package/dist/utils/forms/validation.js

@@ -0,0 +1,58 @@
+import { CONTACT_TYPES } from "../../types/forms.js";
+function normalizeEmail(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function readText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function parsePayload(formData) {
+  const formType = readText(formData.get("formType"));
+  if (formType === "contact") {
+    const contactType = readText(formData.get("contactType"));
+    if (!CONTACT_TYPES.includes(contactType)) {
+      return null;
+    }
+    const payload = {
+      formType,
+      name: readText(formData.get("name")),
+      email: normalizeEmail(formData.get("email")),
+      organization: readText(formData.get("organization")),
+      contactType,
+      subject: readText(formData.get("subject")),
+      message: readText(formData.get("message"))
+    };
+    return payload;
+  }
+  if (formType === "subscribe") {
+    const payload = {
+      formType,
+      email: normalizeEmail(formData.get("email")),
+      name: readText(formData.get("name"))
+    };
+    return payload;
+  }
+  return null;
+}
+function validatePayload(payload) {
+  if (payload.formType === "contact") {
+    if (!payload.name || !payload.email || !payload.subject || !payload.message) {
+      return { ok: false, message: "Please complete the required contact fields." };
+    }
+    if (payload.message.length < 10) {
+      return { ok: false, message: "Please share a bit more detail in your message." };
+    }
+  }
+  if (payload.formType === "subscribe") {
+    if (!payload.email) {
+      return { ok: false, message: "Please provide your email address." };
+    }
+  }
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(payload.email)) {
+    return { ok: false, message: "Please enter a valid email address." };
+  }
+  return { ok: true };
+}
+export {
+  parsePayload,
+  validatePayload
+};

package/dist/utils/hub-content.js

@@ -0,0 +1,28 @@
+import { getCollection, getEntries, getEntry } from "astro:content";
+function sortEntriesByDateDescending(entries) {
+  return [...entries].sort((left, right) => right.data.date.valueOf() - left.data.date.valueOf());
+}
+async function resolveContributor(reference) {
+  return getEntry(reference);
+}
+async function resolveContributorsForEntries(entries) {
+  const contributors = await Promise.all(entries.map((entry) => resolveContributor(entry.data.primaryContributor)));
+  return new Map(entries.map((entry, index) => [entry.id, contributors[index] ?? null]));
+}
+async function resolveReferences(references) {
+  return getEntries(references);
+}
+async function getPublishedQuestions() {
+  return sortEntriesByDateDescending(await getCollection("questions", ({ data }) => !data.draft));
+}
+async function getPublishedObjectives() {
+  return sortEntriesByDateDescending(await getCollection("objectives", ({ data }) => !data.draft));
+}
+export {
+  getPublishedObjectives,
+  getPublishedQuestions,
+  resolveContributor,
+  resolveContributorsForEntries,
+  resolveReferences,
+  sortEntriesByDateDescending
+};

package/dist/utils/plugin-runtime.js

@@ -0,0 +1,158 @@
+import { loadTreeseedPluginRuntime } from "../plugins/runtime.js";
+import { BUILTIN_FORMS_PROVIDERS, finalizeFormsProvider } from "./forms/provider-core.js";
+import { StubExecutionAdapter, ManualExecutionAdapter, CopilotExecutionAdapter } from "./agents/adapters/execution.js";
+import { LocalBranchMutationAdapter } from "./agents/adapters/mutations.js";
+import { StubNotificationAdapter } from "./agents/adapters/notification.js";
+import { GitRepositoryInspectionAdapter, StubRepositoryInspectionAdapter } from "./agents/adapters/repository.js";
+import { StubResearchAdapter } from "./agents/adapters/research.js";
+import { LocalVerificationAdapter, StubVerificationAdapter } from "./agents/adapters/verification.js";
+let cachedAgentRuntime = null;
+let cachedFormsRuntime = null;
+function readPluginRecord(pluginEntry, key) {
+  const value = pluginEntry.plugin[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function assertUniqueProvider(registry, id, owner) {
+  if (registry.has(id)) {
+    throw new Error(`Treeseed plugin runtime found duplicate provider "${id}" from ${owner}.`);
+  }
+}
+function resetTreeseedPluginRuntimeForTests() {
+  cachedAgentRuntime = null;
+  cachedFormsRuntime = null;
+}
+function resolveFormsProvider(providerId) {
+  if (!cachedFormsRuntime) {
+    const runtime = loadTreeseedPluginRuntime();
+    const providers = /* @__PURE__ */ new Map();
+    for (const provider2 of Object.values(BUILTIN_FORMS_PROVIDERS)) {
+      providers.set(provider2.id, provider2);
+    }
+    for (const pluginEntry of runtime.plugins) {
+      const contributedProviders = readPluginRecord(pluginEntry, "formsProviders");
+      for (const [id, provider2] of Object.entries(contributedProviders)) {
+        assertUniqueProvider(providers, id, pluginEntry.package);
+        providers.set(id, provider2);
+      }
+    }
+    cachedFormsRuntime = { providers };
+  }
+  const provider = cachedFormsRuntime.providers.get(providerId);
+  if (!provider) {
+    throw new Error(`Treeseed forms provider "${providerId}" is not registered.`);
+  }
+  return finalizeFormsProvider(provider);
+}
+function collectAgentHandlersFromPlugin(pluginEntry, registry) {
+  const contributedHandlers = readPluginRecord(pluginEntry, "agentHandlers");
+  for (const [id, handler] of Object.entries(contributedHandlers)) {
+    assertUniqueProvider(registry, id, pluginEntry.package);
+    registry.set(id, handler);
+  }
+}
+function buildAgentRuntime() {
+  const runtime = loadTreeseedPluginRuntime();
+  const execution = /* @__PURE__ */ new Map([
+    ["stub", () => new StubExecutionAdapter()],
+    ["manual", () => new ManualExecutionAdapter()],
+    ["copilot", () => new CopilotExecutionAdapter()]
+  ]);
+  const mutation = /* @__PURE__ */ new Map([
+    ["local_branch", (repoRoot) => new LocalBranchMutationAdapter(repoRoot)]
+  ]);
+  const repository = /* @__PURE__ */ new Map([
+    ["stub", () => new StubRepositoryInspectionAdapter()],
+    ["git", () => new GitRepositoryInspectionAdapter()]
+  ]);
+  const verification = /* @__PURE__ */ new Map([
+    ["stub", () => new StubVerificationAdapter()],
+    ["local", () => new LocalVerificationAdapter()]
+  ]);
+  const notification = /* @__PURE__ */ new Map([
+    ["stub", () => new StubNotificationAdapter()]
+  ]);
+  const research = /* @__PURE__ */ new Map([
+    ["stub", () => new StubResearchAdapter()]
+  ]);
+  const handlers = /* @__PURE__ */ new Map();
+  for (const pluginEntry of runtime.plugins) {
+    const agentProviders = readPluginRecord(pluginEntry, "agentProviders");
+    for (const [id, factory] of Object.entries(agentProviders.execution ?? {})) {
+      assertUniqueProvider(execution, id, pluginEntry.package);
+      execution.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(
+      agentProviders.mutation ?? {}
+    )) {
+      assertUniqueProvider(mutation, id, pluginEntry.package);
+      mutation.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(
+      agentProviders.repository ?? {}
+    )) {
+      assertUniqueProvider(repository, id, pluginEntry.package);
+      repository.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(
+      agentProviders.verification ?? {}
+    )) {
+      assertUniqueProvider(verification, id, pluginEntry.package);
+      verification.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(
+      agentProviders.notification ?? {}
+    )) {
+      assertUniqueProvider(notification, id, pluginEntry.package);
+      notification.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(
+      agentProviders.research ?? {}
+    )) {
+      assertUniqueProvider(research, id, pluginEntry.package);
+      research.set(id, factory);
+    }
+    collectAgentHandlersFromPlugin(pluginEntry, handlers);
+  }
+  return {
+    providers: {
+      execution,
+      mutation,
+      repository,
+      verification,
+      notification,
+      research
+    },
+    handlers
+  };
+}
+function resolveAgentRuntimeProviders(repoRoot, selections) {
+  if (!cachedAgentRuntime) {
+    cachedAgentRuntime = buildAgentRuntime();
+  }
+  const executionFactory = cachedAgentRuntime.providers.execution.get(selections.execution);
+  const mutationFactory = cachedAgentRuntime.providers.mutation.get(selections.mutation);
+  const repositoryFactory = cachedAgentRuntime.providers.repository.get(selections.repository);
+  const verificationFactory = cachedAgentRuntime.providers.verification.get(selections.verification);
+  const notificationFactory = cachedAgentRuntime.providers.notification.get(selections.notification);
+  const researchFactory = cachedAgentRuntime.providers.research.get(selections.research);
+  if (!executionFactory) throw new Error(`Treeseed agent execution provider "${selections.execution}" is not registered.`);
+  if (!mutationFactory) throw new Error(`Treeseed agent mutation provider "${selections.mutation}" is not registered.`);
+  if (!repositoryFactory) throw new Error(`Treeseed agent repository provider "${selections.repository}" is not registered.`);
+  if (!verificationFactory) throw new Error(`Treeseed agent verification provider "${selections.verification}" is not registered.`);
+  if (!notificationFactory) throw new Error(`Treeseed agent notification provider "${selections.notification}" is not registered.`);
+  if (!researchFactory) throw new Error(`Treeseed agent research provider "${selections.research}" is not registered.`);
+  return {
+    execution: executionFactory(),
+    mutations: mutationFactory(repoRoot),
+    repository: repositoryFactory(),
+    verification: verificationFactory(),
+    notifications: notificationFactory(),
+    research: researchFactory(),
+    handlers: cachedAgentRuntime.handlers
+  };
+}
+export {
+  resetTreeseedPluginRuntimeForTests,
+  resolveAgentRuntimeProviders,
+  resolveFormsProvider
+};

package/dist/utils/routes.js

@@ -0,0 +1,17 @@
+import { SITE_HEADER_MENU } from "./site-config.js";
+const SITE_NAV_GROUPS = SITE_HEADER_MENU;
+function normalizeSitePath(path) {
+  return path.endsWith("/") ? path : `${path}/`;
+}
+function isCurrentSitePath(currentPath, href) {
+  return normalizeSitePath(currentPath) === normalizeSitePath(href);
+}
+function groupContainsCurrentPath(currentPath, group) {
+  return group.items.some((item) => isCurrentSitePath(currentPath, item.href));
+}
+export {
+  SITE_NAV_GROUPS,
+  groupContainsCurrentPath,
+  isCurrentSitePath,
+  normalizeSitePath
+};

package/dist/utils/seo.js

@@ -0,0 +1,4 @@
+import { SITE } from "./site-config.js";
+export {
+  SITE
+};