@pylonsync/create-pylon 0.19.0 → 0.20.0

package/templates/imessage/app.ts

@@ -0,0 +1,299 @@
+import {
+  auth,
+  buildManifest,
+  cron,
+  discoverAppRoutes,
+  discoverFunctions,
+  entity,
+  field,
+  font,
+  llm,
+  policy,
+} from "@pylonsync/sdk";
+import { ASSISTANT_MODEL } from "./lib/assistant";
+
+// ---------------------------------------------------------------------------
+// imessage: an AI assistant people text over iMessage.
+//
+// Texts arrive through one of two transports (lib/transport.ts): Sendblue's
+// hosted API or a relay script on your own Mac. Each inbound message is
+// stored, checked against the allowlist and rate limit (lib/gate.ts), and, if
+// it should be answered, handed to the `assistant` agent (functions/assistant.ts),
+// which replies with conversation history and a few tools. Replies go back
+// through the same transport.
+//
+// The dashboard is for one person: the owner, the account whose verified
+// email is in PYLON_ADMIN_EMAILS. Pylon lifts that session to admin, and every
+// entity below is readable by admins only. Anonymous visitors and other
+// signed-in accounts read nothing.
+// ---------------------------------------------------------------------------
+
+// A person who texts the number, or whom the owner added to the allowlist.
+// `handle` is normalized (lib/handles.ts): E.164 phone or lowercase email.
+const Contact = entity(
+  "Contact",
+  {
+    handle: field.string(),
+    kind: field.string(),
+    displayName: field.string().optional(),
+    // "allowed" | "blocked" | "unknown". Only allowed contacts get answers.
+    status: field.string().default("unknown"),
+    // The contact texted STOP. Cleared by START.
+    optedOut: field.bool().default(false),
+    // When the one-time reply to an unknown sender went out.
+    autoReplySentAt: field.datetime().optional(),
+    // Last STOP / START confirmation sent. At most one of each per day.
+    optOutReplyAt: field.datetime().optional(),
+    optInReplyAt: field.datetime().optional(),
+    lastMessageAt: field.datetime().optional(),
+    demo: field.bool().default(false),
+    createdAt: field.datetime().defaultNow(),
+  },
+  {
+    indexes: [
+      { name: "by_handle", fields: ["handle"], unique: true },
+      { name: "by_status", fields: ["status"], unique: false },
+      { name: "by_created", fields: ["createdAt"], unique: false },
+    ],
+  },
+);
+
+// One thread per contact. It also carries the agent turn state: only one turn
+// runs per conversation at a time (functions/beginTurn.ts), and texts that
+// arrive during a turn are answered by the next one.
+const Conversation = entity(
+  "Conversation",
+  {
+    contactId: field.id("Contact"),
+    handle: field.string(),
+    lastMessageAt: field.datetime().optional(),
+    lastPreview: field.string().optional(),
+    lastDirection: field.string().optional(),
+    // The AgentRun that holds this conversation's model transcript.
+    agentRunId: field.string().optional(),
+    // "idle" | "running"
+    turnState: field.string().default("idle"),
+    turnId: field.string().optional(),
+    turnStartedAt: field.datetime().optional(),
+    needsAnotherTurn: field.bool().default(false),
+    lastError: field.string().optional(),
+    lastErrorAt: field.datetime().optional(),
+    demo: field.bool().default(false),
+    createdAt: field.datetime().defaultNow(),
+  },
+  {
+    indexes: [
+      { name: "by_contact", fields: ["contactId"], unique: true },
+      { name: "by_last_message", fields: ["lastMessageAt"], unique: false },
+      { name: "by_agent_run", fields: ["agentRunId"], unique: false },
+    ],
+  },
+);
+
+// Every text in or out.
+//   direction "in":  status received | processing | answered | ignored |
+//                    rate_limited | awaiting_setup | failed
+//   direction "out": status queued | leased | sent | dry_run | failed
+//   kind: inbound | agent | auto_reply | reminder | owner
+const Message = entity(
+  "Message",
+  {
+    conversationId: field.id("Conversation"),
+    contactId: field.id("Contact"),
+    direction: field.string(),
+    kind: field.string(),
+    text: field.string(),
+    status: field.string(),
+    // Why an inbound message was not answered, or why a send failed.
+    detail: field.string().optional(),
+    transport: field.string().optional(),
+    // Transport message id ("sendblue:<handle>" / "relay:<guid>"). Unique, so
+    // a retried webhook or a repeated relay batch stores nothing twice.
+    externalId: field.string().optional(),
+    turnId: field.string().optional(),
+    agentRunId: field.string().optional(),
+    // Delivery lease: a relay sync or a Sendblue delivery job holds a queued
+    // reply until this time. `leaseToken` names the holder, so only it can
+    // settle the message.
+    leaseUntil: field.datetime().optional(),
+    leaseToken: field.string().optional(),
+    attempts: field.int().default(0),
+    sentAt: field.datetime().optional(),
+    demo: field.bool().default(false),
+    createdAt: field.datetime().defaultNow(),
+  },
+  {
+    indexes: [
+      { name: "by_conversation_created", fields: ["conversationId", "createdAt"], unique: false },
+      { name: "by_contact_created", fields: ["contactId", "createdAt"], unique: false },
+      { name: "by_external_id", fields: ["externalId"], unique: true },
+      { name: "by_status", fields: ["status"], unique: false },
+    ],
+    // Messages grow forever. The dashboard replica holds the last 30 days.
+    sync: { where: 'data.createdAt >= ago("30d")', limit: 5000 },
+  },
+);
+
+// Short facts the assistant keeps about a contact (functions/assistant.ts tools).
+const Note = entity(
+  "Note",
+  {
+    contactId: field.id("Contact"),
+    text: field.string(),
+    demo: field.bool().default(false),
+    createdAt: field.datetime().defaultNow(),
+  },
+  { indexes: [{ name: "by_contact", fields: ["contactId"], unique: false }] },
+);
+
+// A follow-up text the assistant scheduled. functions/deliverReminder.ts runs
+// at `dueAt` through the job scheduler.
+const Reminder = entity(
+  "Reminder",
+  {
+    contactId: field.id("Contact"),
+    conversationId: field.id("Conversation"),
+    text: field.string(),
+    dueAt: field.datetime(),
+    // "scheduled" | "sending" | "sent" | "cancelled" | "failed"
+    status: field.string(),
+    detail: field.string().optional(),
+    sentAt: field.datetime().optional(),
+    demo: field.bool().default(false),
+    createdAt: field.datetime().defaultNow(),
+  },
+  {
+    indexes: [
+      { name: "by_contact_status", fields: ["contactId", "status"], unique: false },
+      { name: "by_contact_created", fields: ["contactId", "createdAt"], unique: false },
+      { name: "by_due", fields: ["dueAt"], unique: false },
+    ],
+  },
+);
+
+// Owner settings. One row, key "main" (lib/settings.ts fills defaults).
+const Settings = entity(
+  "Settings",
+  {
+    key: field.string(),
+    ownerName: field.string().optional(),
+    timezone: field.string(),
+    // "ignore" | "reply_once"
+    unknownSenderPolicy: field.string(),
+    unknownSenderReply: field.string(),
+    rateLimitPerHour: field.int(),
+    paused: field.bool().default(false),
+    demoSeededAt: field.datetime().optional(),
+    updatedAt: field.datetime().defaultNow(),
+  },
+  { indexes: [{ name: "by_key", fields: ["key"], unique: true }] },
+);
+
+// Last-seen times per transport, for the dashboard's status panel.
+const TransportState = entity(
+  "TransportState",
+  {
+    name: field.string(),
+    lastInboundAt: field.datetime().optional(),
+    lastOutboundAt: field.datetime().optional(),
+    lastError: field.string().optional(),
+    lastErrorAt: field.datetime().optional(),
+    relayLastSeenAt: field.datetime().optional(),
+    relayVersion: field.string().optional(),
+    relayHost: field.string().optional(),
+  },
+  { indexes: [{ name: "by_name", fields: ["name"], unique: true }] },
+);
+
+// The owner's account. Sign-in is by email code only (/login): the code
+// proves the address, and Pylon's PYLON_ADMIN_EMAILS check only promotes
+// verified emails. There is deliberately no `passwordHash` column, so the
+// built-in password routes cannot create or sign in to an account. That
+// closes a pre-registration takeover: without it, anyone could register the
+// owner's email with a password before the owner first signs in, and the
+// owner's later code sign-in would mark that attacker-created account
+// verified, making the attacker's password an admin login.
+const User = entity(
+  "User",
+  {
+    email: field.string(),
+    displayName: field.string().optional(),
+    avatarColor: field.string().optional(),
+    emailVerified: field.datetime().optional(),
+    createdAt: field.datetime().defaultNow(),
+  },
+  { indexes: [{ name: "by_email", fields: ["email"], unique: true }] },
+);
+
+// Owner-only reads; no client writes. Every write goes through a function.
+const ownerOnly = (name: string, entityName: string) =>
+  policy({
+    name,
+    entity: entityName,
+    allowRead: "auth.isAdmin",
+    allowInsert: "false",
+    allowUpdate: "false",
+    allowDelete: "false",
+  });
+
+const userPolicy = policy({
+  name: "user_self",
+  entity: "User",
+  allowRead: "auth.userId != null && auth.userId == data.id",
+  allowInsert: "false",
+  allowUpdate: "false",
+  allowDelete: "false",
+});
+
+const fns = await discoverFunctions();
+
+const manifest = buildManifest({
+  name: "__APP_NAME__",
+  version: "0.1.0",
+  entities: [Contact, Conversation, Message, Note, Reminder, Settings, TransportState, User],
+  queries: fns.queries,
+  actions: fns.actions,
+  // discoverFunctions() reports the `assistant` agent; this adds the
+  // framework's AgentRun/AgentMessage entities (owner-scoped, synced).
+  hasAgents: fns.hasAgents,
+  policies: [
+    ownerOnly("contact_owner", "Contact"),
+    ownerOnly("conversation_owner", "Conversation"),
+    ownerOnly("message_owner", "Message"),
+    ownerOnly("note_owner", "Note"),
+    ownerOnly("reminder_owner", "Reminder"),
+    ownerOnly("settings_owner", "Settings"),
+    ownerOnly("transport_state_owner", "TransportState"),
+    userPolicy,
+  ],
+  auth: auth(),
+  // The one model the assistant uses. ctx.llm refuses any other id.
+  llm: llm({ defaultModel: ASSISTANT_MODEL, allowedModels: [ASSISTANT_MODEL] }),
+  crons: [
+    // Recovers turns whose worker died and relay replies whose lease expired.
+    cron("*/5 * * * *", "sweep", { description: "Recover stuck turns and expired relay leases" }),
+  ],
+  fonts: [
+    font({
+      family: "Geist",
+      variable: "--font-ui",
+      weights: ["400", "500", "600", "700"],
+      subsets: ["latin"],
+      display: "swap",
+      preload: true,
+    }),
+    font({
+      family: "Geist Mono",
+      variable: "--font-code",
+      weights: ["400", "500"],
+      subsets: ["latin"],
+      display: "swap",
+    }),
+  ],
+  routes: await discoverAppRoutes(),
+});
+
+// The CLI runs `bun run app.ts` and reads the manifest from stdout. Keep this line.
+console.log(JSON.stringify(manifest, null, 2));
+
+export default manifest;

package/templates/imessage/bunfig

@@ -0,0 +1,4 @@
+[test]
+# Register a DOM (happy-dom) before any test runs so React component tests can
+# render under `pylon test` / `bun test`. Harmless for pure-logic tests.
+preload = ["./tests/setup.ts"]

package/templates/imessage/components/avatar.tsx

@@ -0,0 +1,46 @@
+import React from "react";
+import { initials } from "@/lib/format";
+import { cn } from "@/lib/utils";
+
+// Messages-style monogram: a soft gradient disc with initials.
+const TONES = [
+  "from-[#a1a1aa] to-[#71717a]",
+  "from-[#93c5fd] to-[#3b82f6]",
+  "from-[#86efac] to-[#16a34a]",
+  "from-[#fcd34d] to-[#d97706]",
+  "from-[#f9a8d4] to-[#db2777]",
+  "from-[#c4b5fd] to-[#7c3aed]",
+];
+
+function tone(seed: string): string {
+  let h = 0;
+  for (let i = 0; i < seed.length; i++) h = (h * 31 + seed.charCodeAt(i)) >>> 0;
+  return TONES[h % TONES.length];
+}
+
+export function Avatar({
+  name,
+  handle,
+  size = 40,
+  className,
+}: {
+  name: string | null | undefined;
+  handle: string;
+  size?: number;
+  className?: string;
+}) {
+  const known = Boolean(name && name.trim());
+  return (
+    <span
+      aria-hidden
+      className={cn(
+        "inline-flex shrink-0 select-none items-center justify-center rounded-full bg-gradient-to-b font-semibold text-white shadow-[inset_0_1px_0_rgba(255,255,255,0.25)]",
+        known ? tone(handle) : TONES[0],
+        className,
+      )}
+      style={{ width: size, height: size, fontSize: Math.round(size * 0.38) }}
+    >
+      {initials(name, handle)}
+    </span>
+  );
+}

package/templates/imessage/components/contact-panel.tsx

@@ -0,0 +1,263 @@
+import React, { useState } from "react";
+import { Bell, NotebookPen, Sparkles, X } from "lucide-react";
+import { Avatar } from "@/components/avatar";
+import { ago } from "@/lib/format";
+import { formatHandle } from "@/lib/handles";
+import { cn } from "@/lib/utils";
+
+export interface PanelNote {
+  id: string;
+  text: string;
+  createdAt: string;
+}
+export interface PanelReminder {
+  id: string;
+  text: string;
+  dueAt: string;
+  status: string;
+}
+export interface PanelActivity {
+  id: string;
+  label: string;
+  at: string;
+}
+export interface PanelRun {
+  status: string;
+  steps: number;
+  updatedAt: string;
+  error: string | null;
+}
+
+type Status = "allowed" | "unknown" | "blocked";
+
+const STATUS_OPTIONS: { value: Status; label: string }[] = [
+  { value: "allowed", label: "Allowed" },
+  { value: "unknown", label: "Not listed" },
+  { value: "blocked", label: "Blocked" },
+];
+
+export function ContactPanel({
+  name,
+  handle,
+  status,
+  optedOut,
+  unanswered,
+  notes,
+  reminders,
+  run,
+  activity,
+  onClose,
+  onStatus,
+  onRename,
+  onAnswerNow,
+  onDeleteNote,
+  onCancelReminder,
+}: {
+  name: string | null;
+  handle: string;
+  status: Status;
+  optedOut: boolean;
+  unanswered: number;
+  notes: PanelNote[];
+  reminders: PanelReminder[];
+  run: PanelRun | null;
+  activity: PanelActivity[];
+  onClose?: () => void;
+  onStatus: (status: Status) => void;
+  onRename: (name: string) => void;
+  onAnswerNow: () => void;
+  onDeleteNote: (id: string) => void;
+  onCancelReminder: (id: string) => void;
+}) {
+  const [editing, setEditing] = useState(false);
+  const [draft, setDraft] = useState(name ?? "");
+
+  return (
+    <aside className="flex h-full min-h-0 flex-col overflow-y-auto bg-rail/60 px-4 pb-6 pt-4" aria-label="Contact details">
+      {onClose ? (
+        <button
+          type="button"
+          onClick={onClose}
+          className="ml-auto rounded-full p-1.5 text-muted-foreground hover:bg-accent"
+          aria-label="Close details"
+        >
+          <X className="size-4" strokeWidth={1.5} />
+        </button>
+      ) : null}
+      <div className="flex flex-col items-center pt-2 text-center">
+        <Avatar name={name} handle={handle} size={64} />
+        {editing ? (
+          <form
+            className="mt-3 flex w-full gap-2"
+            onSubmit={(e) => {
+              e.preventDefault();
+              onRename(draft);
+              setEditing(false);
+            }}
+          >
+            <input
+              autoFocus
+              value={draft}
+              onChange={(e) => setDraft(e.target.value)}
+              aria-label="Name"
+              className="h-8 min-w-0 flex-1 rounded-lg border bg-background px-2.5 text-[14px] outline-none focus:ring-2 focus:ring-ring/30"
+            />
+            <button type="submit" className="rounded-lg bg-foreground px-3 text-[13px] font-medium text-background">
+              Save
+            </button>
+          </form>
+        ) : (
+          <button
+            type="button"
+            onClick={() => {
+              setDraft(name ?? "");
+              setEditing(true);
+            }}
+            className="mt-3 rounded-md px-1 text-[17px] font-semibold tracking-[-0.015em] hover:bg-accent"
+          >
+            {name ?? "Add a name"}
+          </button>
+        )}
+        <p className="mt-0.5 font-mono text-[12px] text-muted-foreground">{formatHandle(handle)}</p>
+      </div>
+
+      <Card className="mt-5">
+        <p className="text-[13px] font-medium">Assistant replies to this person</p>
+        <div className="mt-2.5 grid grid-cols-3 rounded-[0.65rem] bg-black/[0.05] p-0.5 dark:bg-white/[0.06]" role="radiogroup" aria-label="Allowlist status">
+          {STATUS_OPTIONS.map((o) => (
+            <button
+              key={o.value}
+              type="button"
+              role="radio"
+              aria-checked={status === o.value}
+              onClick={() => onStatus(o.value)}
+              className={cn(
+                "rounded-[0.55rem] py-1.5 text-[12px] font-medium transition-all duration-300 ease-[cubic-bezier(0.32,0.72,0,1)]",
+                status === o.value
+                  ? "bg-background text-foreground shadow-[0_1px_2px_rgba(0,0,0,0.08),0_0_0_0.5px_rgba(0,0,0,0.06)]"
+                  : "text-muted-foreground hover:text-foreground",
+              )}
+            >
+              {o.label}
+            </button>
+          ))}
+        </div>
+        <p className="mt-2 text-[12px] leading-snug text-muted-foreground">
+          {optedOut
+            ? "This person texted STOP. Nothing is sent to them until they text START."
+            : status === "allowed"
+              ? "Texts from this number get an answer from the assistant."
+              : status === "blocked"
+                ? "Texts are stored and never answered."
+                : "Texts are stored for you to review. The assistant does not answer."}
+        </p>
+        {unanswered > 0 && status === "allowed" && !optedOut ? (
+          <button
+            type="button"
+            onClick={onAnswerNow}
+            className="mt-3 w-full rounded-full bg-bubble-out py-2 text-[13px] font-medium text-white transition-transform duration-300 ease-[cubic-bezier(0.32,0.72,0,1)] active:scale-[0.98]"
+          >
+            Answer {unanswered} unanswered text{unanswered === 1 ? "" : "s"}
+          </button>
+        ) : null}
+      </Card>
+
+      <Section icon={<Sparkles className="size-3.5" strokeWidth={1.5} />} title="Assistant activity">
+        {run ? (
+          <p className="mb-2 text-[12px] text-muted-foreground">
+            Last run {run.status === "running" ? "is writing now" : run.status} · {run.steps} step
+            {run.steps === 1 ? "" : "s"} · {ago(run.updatedAt)}
+            {run.error ? <span className="mt-1 block text-destructive">{run.error}</span> : null}
+          </p>
+        ) : null}
+        {activity.length === 0 ? (
+          <Empty>No tool use yet.</Empty>
+        ) : (
+          <ul className="space-y-1.5">
+            {activity.map((a) => (
+              <li key={a.id} className="text-[13px] leading-snug">
+                {a.label}
+                <span className="ml-1.5 text-[11px] text-muted-foreground">{ago(a.at)}</span>
+              </li>
+            ))}
+          </ul>
+        )}
+      </Section>
+
+      <Section icon={<NotebookPen className="size-3.5" strokeWidth={1.5} />} title={`Notes${notes.length ? ` (${notes.length})` : ""}`}>
+        {notes.length === 0 ? (
+          <Empty>The assistant saves facts here when this person mentions them.</Empty>
+        ) : (
+          <ul className="space-y-1">
+            {notes.map((n) => (
+              <li key={n.id} className="group flex items-start gap-2 rounded-lg py-1 text-[13px] leading-snug">
+                <span className="flex-1">{n.text}</span>
+                <button
+                  type="button"
+                  onClick={() => onDeleteNote(n.id)}
+                  className="rounded p-0.5 text-muted-foreground opacity-0 transition-opacity hover:text-destructive group-hover:opacity-100 focus:opacity-100"
+                  aria-label={`Delete note: ${n.text}`}
+                >
+                  <X className="size-3.5" strokeWidth={1.5} />
+                </button>
+              </li>
+            ))}
+          </ul>
+        )}
+      </Section>
+
+      <Section icon={<Bell className="size-3.5" strokeWidth={1.5} />} title="Reminders">
+        {reminders.length === 0 ? (
+          <Empty>None scheduled.</Empty>
+        ) : (
+          <ul className="space-y-2">
+            {reminders.map((r) => (
+              <li key={r.id} className="rounded-lg bg-background/80 px-2.5 py-2 text-[13px] leading-snug ring-1 ring-border">
+                <p className="text-[12px] font-medium text-muted-foreground">
+                  {new Date(r.dueAt).toLocaleString("en-US", { weekday: "short", month: "short", day: "numeric", hour: "numeric", minute: "2-digit" })}
+                  {r.status !== "scheduled" ? ` · ${r.status}` : ""}
+                </p>
+                <p className="mt-0.5">{r.text}</p>
+                {r.status === "scheduled" ? (
+                  <button
+                    type="button"
+                    onClick={() => onCancelReminder(r.id)}
+                    className="mt-1 text-[12px] font-medium text-destructive hover:underline"
+                  >
+                    Cancel
+                  </button>
+                ) : null}
+              </li>
+            ))}
+          </ul>
+        )}
+      </Section>
+    </aside>
+  );
+}
+
+function Card({ children, className }: { children: React.ReactNode; className?: string }) {
+  return (
+    <div className={cn("rounded-[1.1rem] bg-black/[0.03] p-1 ring-1 ring-black/[0.04] dark:bg-white/[0.04] dark:ring-white/[0.06]", className)}>
+      <div className="rounded-[calc(1.1rem-0.25rem)] bg-background p-3 shadow-[inset_0_1px_0_rgba(255,255,255,0.6),0_1px_2px_rgba(0,0,0,0.03)]">
+        {children}
+      </div>
+    </div>
+  );
+}
+
+function Section({ icon, title, children }: { icon: React.ReactNode; title: string; children: React.ReactNode }) {
+  return (
+    <section className="mt-6 px-1">
+      <h2 className="mb-2 flex items-center gap-1.5 text-[13px] font-semibold text-foreground">
+        <span className="text-muted-foreground">{icon}</span>
+        {title}
+      </h2>
+      {children}
+    </section>
+  );
+}
+
+function Empty({ children }: { children: React.ReactNode }) {
+  return <p className="text-[12px] leading-snug text-muted-foreground">{children}</p>;
+}