@pikku/cli 0.12.120 → 0.12.122

package/dist/src/functions/wirings/agent/serialize-public-agent.js

@@ -53,7 +53,11 @@ export const ThreadRef = z.object({
 
 export const ThreadDeleted = z.object({ deleted: z.boolean() })
 `;
-    const functions = `import { canAccessThread, threadOwnerConstraint } from '@pikku/core/agent'
+    const functions = `import {
+  agentCallOptions,
+  canAccessThread,
+  threadOwnerConstraint,
+} from '@pikku/core/agent'
 import { pikkuSessionlessFunc } from '${leaf('function')}'
 import { pikkuPermission } from '${leaf('auth')}'
 import { defineHTTPRoutes, wireHTTPRoutes } from '${leaf('http')}'
@@ -87,15 +91,7 @@ export const agentCaller = pikkuSessionlessFunc({
   auth: false,
   input: AgentCall,
   func: async (_services, data, { rpc }) => {
-    return await rpc.agent.run(data.agentName as any, {
-      message: data.message,
-      threadId: data.threadId,
-      resourceId: data.resourceId,
-      ...(data.attachments ? { attachments: data.attachments } : {}),
-      ...(data.model ? { model: data.model } : {}),
-      ...(data.temperature !== undefined ? { temperature: data.temperature } : {}),
-      ...(data.context ? { context: data.context } : {}),
-    })
+    return await rpc.agent.run(data.agentName as any, agentCallOptions(data))
   },
 })
 
@@ -104,15 +100,7 @@ export const agentStreamCaller = pikkuSessionlessFunc({
   auth: false,
   input: AgentCall,
   func: async (_services, data, { rpc }) => {
-    await rpc.agent.stream(data.agentName as any, {
-      message: data.message,
-      threadId: data.threadId,
-      resourceId: data.resourceId,
-      ...(data.attachments ? { attachments: data.attachments } : {}),
-      ...(data.model ? { model: data.model } : {}),
-      ...(data.temperature !== undefined ? { temperature: data.temperature } : {}),
-      ...(data.context ? { context: data.context } : {}),
-    })
+    await rpc.agent.stream(data.agentName as any, agentCallOptions(data))
   },
 })
 

package/dist/src/functions/wirings/console/serialize-console-functions.js

@@ -40,13 +40,8 @@ export const pikkuConsoleGetVariable = pikkuFunc({
     if (!exists) {
       return { exists: false, value: null }
     }
-    try {
-      const value = await variables.get(variableId)
-      return { exists: true, value }
-    } catch {
-      const value = await variables.get(variableId)
-      return { exists: true, value }
-    }
+    const value = await variables.get(variableId)
+    return { exists: true, value }
   },
 })
 
@@ -57,11 +52,7 @@ export const pikkuConsoleSetVariable = pikkuFunc({
   input: SetVariable,
   output: Success,
   func: async ({ variables }, { variableId, value }) => {
-    if (typeof value === 'string') {
-      await variables.set(variableId, value)
-    } else {
-      await variables.set(variableId, value)
-    }
+    await variables.set(variableId, value)
     return { success: true }
   },
 })

package/dist/src/functions/wirings/emails/serialize-emails.d.ts

@@ -16,5 +16,15 @@ type SerializeEmailsInput = {
     partials: Record<string, string>;
     templates: Record<string, EmailTemplateAssets>;
 };
+/**
+ * The generated module is the assets and the types over them — the renderer
+ * itself is `renderEmail` in @pikku/core, which is the same for every
+ * application and which nothing here could typecheck or lint.
+ *
+ * What is genuinely per-application: the four asset blobs, the union of
+ * template and locale names taken from their keys, and `TemplateVariableMap`,
+ * which is what makes `renderEmailTemplate` reject a variable the named
+ * template does not declare.
+ */
 export declare const serializeEmailsModule: ({ theme, locales, partials, templates, }: SerializeEmailsInput) => string;
 export {};

package/dist/src/functions/wirings/emails/serialize-emails.js

@@ -1,9 +1,21 @@
+/**
+ * The generated module is the assets and the types over them — the renderer
+ * itself is `renderEmail` in @pikku/core, which is the same for every
+ * application and which nothing here could typecheck or lint.
+ *
+ * What is genuinely per-application: the four asset blobs, the union of
+ * template and locale names taken from their keys, and `TemplateVariableMap`,
+ * which is what makes `renderEmailTemplate` reject a variable the named
+ * template does not declare.
+ */
 export const serializeEmailsModule = ({ theme, locales, partials, templates, }) => {
     const serializedTheme = JSON.stringify(theme, null, 2);
     const serializedLocales = JSON.stringify(locales, null, 2);
     const serializedPartials = JSON.stringify(partials, null, 2);
     const serializedTemplates = JSON.stringify(templates, null, 2);
-    return `type EmailPrimitive = string | number | boolean | null | undefined
+    return `import { renderEmail, type EmailAssets } from '@pikku/core/services'
+
+type EmailPrimitive = string | number | boolean | null | undefined
 type EmailTemplateValue = EmailPrimitive | Record<string, unknown> | Array<unknown>
 
 const EMAIL_THEME = ${serializedTheme} as const
@@ -48,192 +60,37 @@ export type RenderedEmail<TName extends EmailTemplateName> = {
   hash: (typeof EMAIL_TEMPLATES)[TName]['hashes'][EmailLocale]['contentHash']
 }
 
-function getNestedValue(source: Record<string, unknown>, path: string): string {
-  const segments = path.split('.')
-  let current: unknown = source
-  for (const segment of segments) {
-    if (!current || typeof current !== 'object' || !(segment in current)) {
-      return ''
-    }
-    current = (current as Record<string, unknown>)[segment]
-  }
-  return typeof current === 'string' || typeof current === 'number'
-    ? String(current)
-    : ''
-}
-
-const HTML_ESCAPES: Record<string, string> = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  "'": '&#39;',
-}
-
-function escapeHtml(value: string): string {
-  return value.replace(/[&<>"']/g, (char) => HTML_ESCAPES[char] ?? char)
-}
-
-// Matches the raw {{{ value }}} form before the escaped {{ value }} form, so the
-// opt-in escape hatch is never mistaken for a normal substitution.
-const TEMPLATE_TOKEN = /\\{\\{\\{\\s*([^{}]+?)\\s*\\}\\}\\}|\\{\\{\\s*([^}]+?)\\s*\\}\\}/g
-
-const PARTIAL_TOKEN = /\\{\\{\\s*>\\s*([a-zA-Z0-9-_/.]+)\\s*\\}\\}/g
-
-const MAX_TEMPLATE_DEPTH = 5
-
-// theme.json and the locale files ship with the templates, so they are treated as
-// template-author input: expanded before caller data and allowed to contain their
-// own placeholders. Everything else is caller-supplied.
-const TRUSTED_ROOTS = ['theme', 't']
-
-function isTrustedKey(key: string): boolean {
-  return TRUSTED_ROOTS.includes(String(key.split('.')[0]))
-}
-
-function readToken(rawTriple: unknown, rawDouble: unknown) {
-  const raw = typeof rawTriple === 'string'
-  return { raw, key: String(raw ? rawTriple : rawDouble).trim() }
-}
-
-function expandPartials(source: string, depth = 0): string {
-  if (depth >= MAX_TEMPLATE_DEPTH) return source
-  let found = false
-  const expanded = source.replace(PARTIAL_TOKEN, (_match, partialName) => {
-    found = true
-    const partial =
-      EMAIL_PARTIALS[String(partialName).trim() as keyof typeof EMAIL_PARTIALS]
-    return typeof partial === 'string' ? partial : ''
-  })
-  return found ? expandPartials(expanded, depth + 1) : expanded
-}
-
-function expandTrusted(
-  source: string,
-  context: Record<string, unknown>,
-  escape: boolean
-): string {
-  let rendered = source
-  for (let i = 0; i < MAX_TEMPLATE_DEPTH; i += 1) {
-    let found = false
-    const next = rendered.replace(
-      TEMPLATE_TOKEN,
-      (match, rawTriple, rawDouble) => {
-        const { raw, key } = readToken(rawTriple, rawDouble)
-        if (!isTrustedKey(key)) return match
-        found = true
-        const value = getNestedValue(context, key)
-        return raw || !escape ? value : escapeHtml(value)
-      }
-    )
-    if (!found || next === rendered) break
-    rendered = next
-  }
-  return rendered
-}
-
-// A single substitution pass — the replacement text is never rescanned, so a
-// caller-supplied value can never be reinterpreted as a template.
-function substitute(
-  source: string,
-  context: Record<string, unknown>,
-  escape: boolean
-): string {
-  return source.replace(TEMPLATE_TOKEN, (_match, rawTriple, rawDouble) => {
-    const { raw, key } = readToken(rawTriple, rawDouble)
-    if (key === 'content') {
-      return typeof context.content === 'string' ? context.content : ''
-    }
-    if (key.startsWith('>')) {
-      return ''
-    }
-    const value = getNestedValue(context, key)
-    return raw || !escape ? value : escapeHtml(value)
-  })
-}
-
-function renderTemplate(
-  source: string,
-  context: Record<string, unknown>,
-  escape: boolean
-): string {
-  const composed = expandTrusted(expandPartials(source), context, escape)
-  return substitute(composed, context, escape)
-}
+// The assets are frozen literals so their keys can drive the types above; the
+// renderer reads them as plain records.
+const EMAIL_ASSETS = {
+  theme: EMAIL_THEME,
+  locales: EMAIL_LOCALES,
+  partials: EMAIL_PARTIALS,
+  templates: EMAIL_TEMPLATES,
+} as unknown as EmailAssets
 
 export const EMAILS = EMAIL_TEMPLATES
 
 export function renderEmailTemplate<TName extends EmailTemplateName>(
   input: RenderEmailInput<TName>
 ): RenderedEmail<TName> {
-  const locale = (input.locale ?? 'en') as EmailLocale
-  const template = EMAIL_TEMPLATES[input.name]
-  if (!template) {
-    throw new Error(\`Unknown email template: \${String(input.name)}\`)
-  }
-
-  const strings = EMAIL_LOCALES[locale]
-  if (!strings) {
-    throw new Error(\`Unknown email locale: \${String(locale)}\`)
-  }
-
-  const data = (input.data ?? {}) as Record<string, unknown>
-  const appName =
-    (typeof data.appName === 'string' && data.appName) ||
-    getNestedValue(EMAIL_THEME as Record<string, unknown>, 'appName')
-
-  const baseContext = {
-    ...data,
-    locale,
-    theme: EMAIL_THEME,
-    t: strings,
-    appName,
-  }
-
-  const subject = renderTemplate(template.subject, baseContext, false).trim()
-
-  const htmlBody = renderTemplate(
-    template.html,
+  const { locale, subject, html, text, variables, hash } = renderEmail(
+    EMAIL_ASSETS,
     {
-      ...baseContext,
-      subject,
-    },
-    true
+      name: String(input.name),
+      locale: input.locale as string | undefined,
+      data: (input.data ?? {}) as Record<string, unknown>,
+    }
   )
 
-  const html = EMAIL_PARTIALS.layout
-    ? renderTemplate(
-        EMAIL_PARTIALS.layout,
-        {
-          ...baseContext,
-          subject,
-          content: htmlBody,
-        },
-        true
-      )
-    : htmlBody
-
-  const text = template.text
-    ? renderTemplate(
-        template.text,
-        {
-          ...baseContext,
-          subject,
-        },
-        false
-      ).trim()
-    : undefined
-  const hash = (template.hashes[locale]?.contentHash ??
-    '') as RenderedEmail<TName>['hash']
-
   return {
     name: input.name,
-    locale,
+    locale: locale as EmailLocale,
     subject,
     html,
     ...(text ? { text } : {}),
-    variables: template.variables,
-    hash,
+    variables,
+    hash: hash as RenderedEmail<TName>['hash'],
   }
 }
 `;