@voltro/cli 0.1.0

package/templates/apps/edge-functions/functions/currencyConvert.serverless.ts

@@ -0,0 +1,47 @@
+// currencyConvert — convert an amount between currencies using a live rate.
+//
+// Demonstrates: outbound HTTP with the framework-provided `HttpClient`,
+// reading the JSON response (`yield* response.json`), transforming it, and a
+// typed error status when the upstream can't answer (422). Uses a public,
+// no-key FX endpoint so it runs out of the box.
+//
+//   curl -X POST http://localhost:8910/ -d '{"from":"USD","to":"EUR","amount":42}'
+
+import { Effect, Schema } from 'effect'
+import { HttpClient, HttpClientRequest } from '@effect/platform'
+import { defineServerless, ServerlessHttpError } from '@voltro/serverless'
+
+const CODE = Schema.String.pipe(Schema.pattern(/^[A-Za-z]{3}$/))
+
+export default defineServerless({
+  name: 'currency-convert',
+  method: 'POST',
+  input: Schema.Struct({
+    from: CODE,
+    to: CODE,
+    amount: Schema.Number.pipe(Schema.greaterThanOrEqualTo(0)),
+  }),
+  output: Schema.Struct({
+    from: Schema.String,
+    to: Schema.String,
+    amount: Schema.Number,
+    rate: Schema.Number,
+    result: Schema.Number,
+  }),
+  runtime: { memoryMb: 128, timeoutSeconds: 10 },
+  handler: ({ from, to, amount }, _ctx) =>
+    Effect.gen(function* () {
+      const base = from.toUpperCase()
+      const quote = to.toUpperCase()
+      const http = yield* HttpClient.HttpClient
+      const response = yield* http.execute(HttpClientRequest.get(`https://open.er-api.com/v6/latest/${base}`))
+      const body = (yield* response.json) as { rates?: Record<string, number> }
+      const rate = body.rates?.[quote]
+      if (typeof rate !== 'number') {
+        return yield* Effect.fail(
+          new ServerlessHttpError({ status: 422, message: 'unknown-currency', detail: `no rate ${base}->${quote}` }),
+        )
+      }
+      return { from: base, to: quote, amount, rate, result: Math.round(amount * rate * 100) / 100 }
+    }),
+})

package/templates/apps/edge-functions/functions/geoGreeting.serverless.ts

@@ -0,0 +1,44 @@
+// geoGreeting — a localized greeting based on the caller's country.
+//
+// Demonstrates: reading the raw request via `ctx.request.headers` (the geo
+// header the edge host injects), plus an optional GET query param. The whole
+// point of running at the edge is being close to the user — this reacts to
+// where they are.
+//
+//   curl 'http://localhost:8910/?name=Ada' -H 'cf-ipcountry: DE'
+
+import { Effect, Schema } from 'effect'
+import { defineServerless } from '@voltro/serverless'
+
+const HELLO: Record<string, string> = {
+  DE: 'Hallo',
+  FR: 'Bonjour',
+  ES: 'Hola',
+  IT: 'Ciao',
+  JP: 'こんにちは',
+  US: 'Hi',
+  GB: 'Hello',
+}
+
+export default defineServerless({
+  name: 'geo-greeting',
+  method: 'GET',
+  input: Schema.Struct({ name: Schema.optional(Schema.String) }),
+  output: Schema.Struct({
+    greeting: Schema.String,
+    country: Schema.String,
+  }),
+  handler: ({ name }, ctx) =>
+    Effect.sync(() => {
+      // Cloudflare sets `cf-ipcountry`; other proxies use varied headers. We
+      // read whatever the host injected — the function code stays the same.
+      const country = (
+        ctx.request.headers.get('cf-ipcountry') ??
+        ctx.request.headers.get('x-vercel-ip-country') ??
+        ctx.request.headers.get('x-forwarded-country') ??
+        'XX'
+      ).toUpperCase()
+      const hello = HELLO[country] ?? 'Hello'
+      return { greeting: `${hello}, ${name ?? 'there'}!`, country }
+    }),
+})

package/templates/apps/edge-functions/functions/health.serverless.ts

@@ -0,0 +1,29 @@
+// health — the simplest function: a GET diagnostic.
+//
+// Demonstrates: GET (input from the query string), reading `ctx.env`, and a
+// pure synchronous handler (`Effect.sync`). No I/O, no secrets.
+//
+//   voltro serverless dev functions/health.serverless.ts
+//   curl http://localhost:8910/
+
+import { Effect, Schema } from 'effect'
+import { defineServerless } from '@voltro/serverless'
+
+export default defineServerless({
+  name: 'health',
+  method: 'GET',
+  input: Schema.Struct({}),
+  output: Schema.Struct({
+    status: Schema.Literal('ok'),
+    region: Schema.String,
+    now: Schema.String,
+  }),
+  handler: (_input, ctx) =>
+    Effect.sync(() => ({
+      status: 'ok' as const,
+      // The provider injects region into the env (Scaleway SCW_REGION, your own
+      // VOLTRO_REGION on a node host). Cloudflare is global → 'edge'.
+      region: ctx.env.VOLTRO_REGION ?? ctx.env.SCW_REGION ?? ctx.env.AWS_REGION ?? 'edge',
+      now: new Date().toISOString(),
+    })),
+})

package/templates/apps/edge-functions/functions/resolveLink.serverless.ts

@@ -0,0 +1,32 @@
+// resolveLink — resolve a short code to its destination URL (the read side of
+// a link shortener; `shareLink` is the write side).
+//
+// Demonstrates: GET with a query param, a lookup, and a 404 via
+// `ServerlessHttpError` when the code is unknown. Swap the in-memory map for a
+// KV / D1 / database read in a real shortener — the shape stays the same.
+//
+//   curl 'http://localhost:8910/?code=docs'
+
+import { Effect, Schema } from 'effect'
+import { defineServerless, ServerlessHttpError } from '@voltro/serverless'
+
+const LINKS: Record<string, string> = {
+  docs: 'https://voltro.dev/docs',
+  gh: 'https://github.com/SinPP',
+  home: 'https://voltro.dev',
+}
+
+export default defineServerless({
+  name: 'resolve-link',
+  method: 'GET',
+  input: Schema.Struct({ code: Schema.String.pipe(Schema.minLength(1)) }),
+  output: Schema.Struct({ code: Schema.String, url: Schema.String }),
+  handler: ({ code }, _ctx) =>
+    Effect.gen(function* () {
+      const url = LINKS[code.toLowerCase()]
+      if (!url) {
+        return yield* Effect.fail(new ServerlessHttpError({ status: 404, message: 'unknown-code', detail: code }))
+      }
+      return { code, url }
+    }),
+})

package/templates/apps/edge-functions/functions/shareLink.serverless.ts

@@ -0,0 +1,30 @@
+// shareLink — turn a resource id into a short-lived share URL.
+//
+// Demonstrates: POST with a JSON body, schema-typed input/output, `ctx.env`
+// config, and runtime hints (memory / timeout / region). Pure compute — no
+// I/O — so it is trivially edge-safe and scales to zero.
+//
+//   curl -X POST http://localhost:8910/ -d '{"resourceId":"doc-1","ttlMinutes":30}'
+
+import { Effect, Schema } from 'effect'
+import { defineServerless } from '@voltro/serverless'
+
+export default defineServerless({
+  name: 'share-link',
+  method: 'POST',
+  input: Schema.Struct({
+    resourceId: Schema.String.pipe(Schema.minLength(1)),
+    ttlMinutes: Schema.Number.pipe(Schema.greaterThan(0)),
+  }),
+  output: Schema.Struct({
+    url: Schema.String,
+    expiresAt: Schema.Number,
+  }),
+  runtime: { memoryMb: 128, timeoutSeconds: 10, region: 'fr-par' },
+  handler: ({ resourceId, ttlMinutes }, ctx) =>
+    Effect.sync(() => {
+      const base = ctx.env.SHARE_BASE_URL ?? 'https://share.example'
+      const expiresAt = Date.now() + ttlMinutes * 60_000
+      return { url: `${base}/s/${encodeURIComponent(resourceId)}?exp=${expiresAt}`, expiresAt }
+    }),
+})

package/templates/apps/edge-functions/functions/slackNotify.serverless.ts

@@ -0,0 +1,40 @@
+// slackNotify — post a message to a Slack incoming webhook, fire-and-forget.
+//
+// Demonstrates: `ctx.waitUntil(...)` — schedule work that OUTLIVES the
+// response. The caller gets `{ queued: true }` immediately; the actual
+// delivery runs in the background (on Cloudflare via the real
+// `ExecutionContext.waitUntil`, best-effort elsewhere). We use the global
+// `fetch` here because a detached background POST needs no HttpClient features.
+//
+//   SLACK_WEBHOOK_URL=https://hooks.slack.com/... voltro serverless dev functions/slackNotify.serverless.ts
+//   curl -X POST http://localhost:8910/ -d '{"text":"deploy finished"}'
+
+import { Effect, Schema } from 'effect'
+import { defineServerless, ServerlessHttpError } from '@voltro/serverless'
+
+export default defineServerless({
+  name: 'slack-notify',
+  method: 'POST',
+  input: Schema.Struct({ text: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(3000)) }),
+  output: Schema.Struct({ queued: Schema.Boolean }),
+  handler: ({ text }, ctx) =>
+    Effect.gen(function* () {
+      const webhook = ctx.env.SLACK_WEBHOOK_URL
+      if (!webhook) {
+        return yield* Effect.fail(
+          new ServerlessHttpError({ status: 503, message: 'slack-not-configured', detail: 'Set SLACK_WEBHOOK_URL.' }),
+        )
+      }
+      // Schedule the delivery in the background and respond NOW.
+      ctx.waitUntil(
+        fetch(webhook, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ text }),
+        }).catch(() => {
+          /* best-effort — a failed notification must not fail the request */
+        }),
+      )
+      return { queued: true }
+    }),
+})

package/templates/apps/edge-functions/functions/verifySignature.serverless.ts

@@ -0,0 +1,52 @@
+// verifySignature — verify an HMAC-SHA256 signature over a payload.
+//
+// Demonstrates: the Web Crypto API (`crypto.subtle`) — available on every
+// serverless host (Workers, Scaleway node, your own node) without any import —
+// wrapped in `Effect.promise`, plus controlling the HTTP status with
+// `ServerlessHttpError` (401 when the signature does not match).
+//
+//   SIGNING_SECRET=s3cret voltro serverless dev functions/verifySignature.serverless.ts
+
+import { Effect, Schema } from 'effect'
+import { defineServerless, ServerlessHttpError } from '@voltro/serverless'
+
+const toHex = (buf: ArrayBuffer): string =>
+  [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')
+
+const hmacHex = async (secret: string, payload: string): Promise<string> => {
+  const enc = new TextEncoder()
+  const key = await crypto.subtle.importKey('raw', enc.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign'])
+  return toHex(await crypto.subtle.sign('HMAC', key, enc.encode(payload)))
+}
+
+// Constant-time-ish compare — avoid leaking match position via early return.
+const safeEqual = (a: string, b: string): boolean => {
+  if (a.length !== b.length) return false
+  let diff = 0
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i)
+  return diff === 0
+}
+
+export default defineServerless({
+  name: 'verify-signature',
+  method: 'POST',
+  input: Schema.Struct({
+    payload: Schema.String,
+    signature: Schema.String.pipe(Schema.pattern(/^[0-9a-f]+$/i)),
+  }),
+  output: Schema.Struct({ valid: Schema.Literal(true) }),
+  handler: ({ payload, signature }, ctx) =>
+    Effect.gen(function* () {
+      const secret = ctx.env.SIGNING_SECRET
+      if (!secret) {
+        return yield* Effect.fail(
+          new ServerlessHttpError({ status: 503, message: 'signing-not-configured', detail: 'Set SIGNING_SECRET.' }),
+        )
+      }
+      const expected = yield* Effect.promise(() => hmacHex(secret, payload))
+      if (!safeEqual(expected, signature.toLowerCase())) {
+        return yield* Effect.fail(new ServerlessHttpError({ status: 401, message: 'invalid-signature' }))
+      }
+      return { valid: true as const }
+    }),
+})

package/templates/apps/edge-functions/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@{{projectName}}/{{appName}}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "list": "voltro serverless list .",
+    "build": "voltro serverless build .",
+    "serve": "voltro serverless serve .",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@effect/platform": "^0.96.1",
+    "@voltro/cli": "0.1.0",
+    "@voltro/serverless": "0.1.0",
+    "effect": "^3.21.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0"
+  }
+}

package/templates/apps/edge-functions/template.json

@@ -0,0 +1,6 @@
+{
+  "id": "edge-functions",
+  "kind": "serverless",
+  "summary": "A standalone library of `*.serverless.ts` functions covering the range of what edge functions do: pure compute, request-header/geo, outbound HTTP (fire-and-forget + fetch-and-transform), Web Crypto HMAC verify, an LLM call, and status-controlled errors. Run with `voltro serverless dev`, ship to node / Cloudflare / Scaleway. No long-running server, no port.",
+  "tags": ["serverless", "edge", "functions", "cloudflare", "scaleway", "node", "httpclient", "crypto", "ai"]
+}

package/templates/apps/edge-functions/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler"
+  },
+  "include": ["functions/**/*"],
+  "exclude": ["node_modules", "dist", ".voltro"]
+}

package/templates/apps/frontend-admin/README.md

@@ -0,0 +1,40 @@
+# frontend-admin
+
+An **auto-admin back-office** that discovers your api's entities at runtime and
+renders a live, reactive, permission-gated UI per entity — assembled from
+already-shipped framework primitives, as **editable template code** (not a
+sealed runtime feature).
+
+## What it does
+
+- **Discovers entities** from the api's capability map
+  (`useCapabilityManifest` + `deriveEntityAdmins`) — point it at any Voltro api
+  and the sidebar + pages adapt. No per-entity code.
+- **Per entity**: a live `<DataTable>` (the list query) + an `<AutoForm>` (the
+  create mutation), fields/columns straight from the descriptors' schemas.
+- **Permission-gated**: write actions are hidden via `useCan` on conventional
+  `<table>:create` / `<table>:delete` scopes (UX gating — the api's
+  `permission()` guards remain the real boundary).
+- **Provenance**: a per-row "Why?" drawer (`useProvenance`, innovation/08).
+- **Undo/redo**: the topbar bar wraps the `__voltro.undo.*` built-ins
+  (`useUndoLog`) — revert the last change across the whole admin.
+
+## Use it
+
+```sh
+voltro create-project myApp --api=api-backend --web=frontend-admin
+voltro dev   # the admin discovers api-backend's entities
+```
+
+Sign in at `/login` (demo cookie gate) → `/admin`.
+
+## Make it yours
+
+Everything under `src/pages/admin/` is yours to edit. Common first changes:
+
+- **Real auth**: swap the cookie gate in `src/lib/auth.ts` + the demo scopes in
+  `src/lib/admin.ts` (feed your session's real scopes to `<PermissionProvider>`).
+- **Undo off**: if you run with `VOLTRO_UNDO=off`, delete the `UndoBar` in
+  `src/pages/admin/layout.tsx`.
+- **Custom per-entity views**: replace the generic `[entity].tsx` binding with a
+  hand-built page for an entity that needs more than CRUD.

package/templates/apps/frontend-admin/app.config.ts

@@ -0,0 +1,37 @@
+// Web app for the {{projectName}} project — an AUTO-ADMIN back-office.
+//
+// It points at an api (below) and, at runtime, reads that api's capability map
+// (`/_voltro/inspect/manifest`) to discover every entity + the procedures that
+// read/write it — then renders a live, reactive table + form per entity. Point
+// it at ANY Voltro api and it adapts; there's no per-entity code to write (but
+// the page code IS yours to edit — see src/pages/admin/).
+import { defineEnv, envVar } from '@voltro/env'
+
+export const env = defineEnv({
+  VOLTRO_PUBLIC_APP_NAME: envVar.string({ access: 'public', default: '{{capProjectName}} Admin' }),
+})
+
+export default {
+  type: 'web' as const,
+  name: '{{capProjectName}}{{capAppName}}',
+  port: {{port}},
+  // Follow the visitor's OS theme, set before first paint (no flash).
+  theme: 'system' as const,
+  env,
+  // Bilingual by default. The framework auto-wires a cookie-driven
+  // <I18nProvider> from these codes and loads the matching
+  // `src/locales/<code>.ts` catalog — so `<T id="…" />` / `useT()` /
+  // `useLocale()` work app-wide with no manual setup. The <LocaleSwitcher>
+  // in the layout writes the `voltro:lang` cookie + reloads. Grow the app to
+  // more languages by adding a code here + a `src/locales/<code>.ts`.
+  locales:       ['en', 'de'] as const,
+  defaultLocale: 'en'         as const,
+  // The api this admin introspects + binds to. The NAME ('app') is the lookup
+  // key the hooks + components use (`<DataTable api="app" .../>`). The `package`
+  // resolves the sibling api in this project (scaffold it with
+  // `--api=api-backend`); codegen pulls its typed rpc surface — INCLUDING the
+  // __voltro.undo.* built-ins (when undo capture is on) the admin's undo bar uses.
+  apis: {
+    app: { package: '@{{projectName}}/api' },
+  },
+}

package/templates/apps/frontend-admin/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@{{projectName}}/{{appName}}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "voltro dev .",
+    "build": "voltro build .",
+    "start": "voltro start .",
+    "typecheck": "tsc --noEmit",
+    "test": "voltro test"
+  },
+  "dependencies": {
+    "@{{projectName}}/api": "0.1.0",
+    "@voltro/cli": "0.1.0",
+    "@voltro/client": "0.1.0",
+    "@voltro/env": "0.1.0",
+    "@voltro/i18n": "0.1.0",
+    "@voltro/ui-shadcn": "0.1.0",
+    "@voltro/web": "0.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/templates/apps/frontend-admin/src/config.ts

@@ -0,0 +1,8 @@
+// The brand name shown in the marketing header + admin sidebar.
+//
+// A plain constant — not `publicEnv` — so the template typechecks BEFORE
+// `voltro dev` generates the env types. `VOLTRO_PUBLIC_APP_NAME` is still
+// declared in app.config.ts (validated + in the env manifest); to read it
+// typed instead, after one `voltro dev` swap this for
+// `publicEnv.VOLTRO_PUBLIC_APP_NAME` from '@voltro/env/public'.
+export const APP_NAME = '{{capProjectName}} Admin'

package/templates/apps/frontend-admin/src/globals.css

@@ -0,0 +1,76 @@
+/* Plain CSS — no Tailwind, so there's no @source scanner to configure.
+   Swap in @voltro/ui-shadcn or Tailwind later if you want; see AGENTS.md. */
+:root {
+  --bg: #ffffff;
+  --fg: #0a0a0a;
+  --muted: #6b7280;
+  --accent: #4f46e5;
+  --danger: #dc2626;
+  --border: #e5e7eb;
+  --panel: #f9fafb;
+}
+:root.dark {
+  --bg: #0a0a0a;
+  --fg: #fafafa;
+  --muted: #9ca3af;
+  --accent: #818cf8;
+  --danger: #f87171;
+  --border: #1f2937;
+  --panel: #111827;
+}
+
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--fg);
+  font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
+  line-height: 1.55;
+}
+a { color: var(--accent); }
+
+/* Marketing */
+.marketing { max-width: 44rem; margin: 0 auto; padding: 2.5rem 1.25rem; }
+.marketing header { display: flex; gap: 1rem; align-items: center; margin-bottom: 2rem; }
+.marketing header .brand { font-weight: 700; }
+.marketing header .spacer { flex: 1; }
+.hero h1 { font-size: 2rem; margin: 0 0 0.5rem; }
+.btn {
+  display: inline-block; background: var(--accent); color: #fff; padding: 0.55rem 1rem;
+  border-radius: 8px; border: 0; font: inherit; font-weight: 600; cursor: pointer; text-decoration: none;
+}
+.btn.ghost { background: transparent; color: var(--accent); border: 1px solid var(--border); }
+.btn.danger { background: transparent; color: var(--danger); border: 1px solid var(--border); }
+.btn:disabled { opacity: 0.5; cursor: not-allowed; }
+
+/* Admin shell */
+.admin { display: grid; grid-template-columns: 15rem 1fr; min-height: 100vh; }
+.admin aside { border-right: 1px solid var(--border); background: var(--panel); padding: 1.25rem 1rem; }
+.admin aside .brand { font-weight: 700; margin-bottom: 1rem; }
+.admin nav { display: flex; flex-direction: column; gap: 0.15rem; }
+.admin nav a { color: var(--fg); text-decoration: none; padding: 0.35rem 0.6rem; border-radius: 6px; font-size: 0.92rem; }
+.admin nav a:hover { background: color-mix(in oklab, var(--fg) 7%, transparent); }
+.admin nav a[aria-current='page'] { background: color-mix(in oklab, var(--accent) 16%, transparent); color: var(--accent); font-weight: 600; }
+.admin main { padding: 1.75rem; min-width: 0; }
+.admin .topbar { display: flex; align-items: center; gap: 0.5rem; margin-bottom: 1.5rem; }
+.admin .topbar .spacer { flex: 1; }
+
+.cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr)); gap: 1rem; }
+.card { border: 1px solid var(--border); border-radius: 10px; padding: 1rem; background: var(--panel); text-decoration: none; color: inherit; display: block; }
+.card:hover { border-color: var(--accent); }
+.card .label { color: var(--muted); font-size: 0.8rem; }
+.card .value { font-size: 1.4rem; font-weight: 700; }
+.card .meta { color: var(--muted); font-size: 0.75rem; margin-top: 0.25rem; }
+
+.muted { color: var(--muted); }
+.skeleton { border: 1px solid var(--border); border-radius: 10px; height: 4rem; background: linear-gradient(90deg, var(--panel), color-mix(in oklab, var(--panel) 60%, var(--bg)), var(--panel)); }
+.banner { border: 1px solid var(--border); border-radius: 8px; padding: 0.75rem 1rem; background: var(--panel); color: var(--muted); font-size: 0.9rem; }
+code { background: color-mix(in oklab, var(--fg) 8%, transparent); padding: 0.1em 0.35em; border-radius: 4px; }
+
+.section { margin-bottom: 2rem; }
+.section h2 { font-size: 1rem; margin: 0 0 0.5rem; }
+.row-actions { display: inline-flex; gap: 0.4rem; }
+.drawer { border: 1px solid var(--border); border-radius: 10px; padding: 1rem; background: var(--panel); margin-top: 1rem; font-size: 0.85rem; }
+.drawer h3 { margin: 0 0 0.5rem; font-size: 0.9rem; }
+.drawer dl { display: grid; grid-template-columns: auto 1fr; gap: 0.2rem 0.75rem; margin: 0; }
+.drawer dt { color: var(--muted); }

package/templates/apps/frontend-admin/src/globals.d.ts

@@ -0,0 +1,6 @@
+// Ambient declarations.
+//
+// `declare module '*.css'`: TypeScript with `moduleResolution: Bundler`
+// rejects a bare `import './globals.css'` unless the asset module is
+// declared. Vite resolves it at build time; the declaration is type-only.
+declare module '*.css'

package/templates/apps/frontend-admin/src/lib/admin.ts

@@ -0,0 +1,16 @@
+// The scopes the admin gates its write actions on (via useCan). The admin
+// derives a CONVENTIONAL scope per entity action — `<table>:create`,
+// `<table>:write`, `<table>:delete` (see deriveEntityAdmins) — and hides any
+// action the current subject's scopes don't satisfy.
+//
+// DEMO: we feed `admin:full` (the blanket-bypass scope) so the demo shows every
+// action. In a real app, REPLACE this with the current subject's scopes from
+// your session — e.g. a reactive query:
+//
+//   const { data } = useSubscription<{ scopes: string[] }>('app', 'auth.session')
+//   <PermissionProvider scopes={data?.scopes ?? []}>…</PermissionProvider>
+//
+// useCan reads these reactively, so the admin's affordances update the instant
+// the subject's roles change. (This is UX gating, not enforcement — the api's
+// own permission() guards remain the real authorization boundary.)
+export const DEMO_SCOPES: ReadonlyArray<string> = ['admin:full']

package/templates/apps/frontend-admin/src/lib/auth.ts

@@ -0,0 +1,24 @@
+// The demo auth gate. This is intentionally a COOKIE-ONLY stand-in so the
+// template boots with zero backend wiring — `login` writes the cookie, the
+// admin layout loader reads it. Swap `isSignedIn` for a real check (verify a
+// signed session, call your api) when you wire auth for real. See AGENTS.md › Auth.
+
+export const SESSION_COOKIE = 'demo_session'
+
+// Browser-safe cookie parse — NO `node:*` import, so it's safe in the page
+// module graph. Runs in BOTH places the gate needs it:
+//   - SSR: the loader's `headers['cookie']` (raw Cookie request header)
+//   - client nav: `document.cookie` (the loader's `headers` is undefined there)
+export const readCookie = (
+  header: string | null | undefined,
+  name: string,
+): string | undefined => {
+  if (!header) return undefined
+  const match = new RegExp(`(?:^|;\\s*)${name}=([^;]*)`).exec(header)
+  return match ? decodeURIComponent(match[1]!) : undefined
+}
+
+export const isSignedIn = (headers: Record<string, string | undefined> | undefined): boolean => {
+  const cookieHeader = headers?.['cookie'] ?? (typeof document === 'undefined' ? '' : document.cookie)
+  return readCookie(cookieHeader, SESSION_COOKIE) !== undefined
+}

package/templates/apps/frontend-admin/src/locales/de.ts

@@ -0,0 +1,67 @@
+// German catalog. Mirrors every key in `en.ts` — `defineLocale<typeof en>()`
+// fails the build if a key is missing or misspelled. Translate the prose only;
+// keep ICU placeholders (`{table}`, `{id}`, `{entity}`, `{via}`, `{count}`) and
+// rich tags (`<code>`, `<strong>`) identical to `en.ts`.
+
+import { defineLocale } from '@voltro/i18n'
+import en from './en'
+
+export default defineLocale<typeof en>()({
+  'meta.landing.title':       'Admin',
+  'meta.landing.description': 'Ein Auto-Admin-Backoffice, das die Entitäten deiner API entdeckt und pro Entität eine live, rechtegeprüfte und rückgängig-fähige UI rendert.',
+  'meta.login.title':         'Anmelden',
+  'meta.overview.title':      'Übersicht',
+  'meta.entity.title':        'Entität',
+
+  'nav.admin':  'Admin',
+  'nav.signIn': 'Anmelden',
+  'lang.label': 'Sprache',
+
+  'landing.heading': 'Das Backoffice, für dich erledigt.',
+  'landing.body':    'Dieser Admin liest zur Laufzeit die <strong>Capability-Map</strong> deiner API und rendert eine live, reaktive <code>DataTable</code> + <code>AutoForm</code> für jede Entität, die sie freigibt — rechtegeprüft mit <code>useCan</code>, mit einer Herkunfts-Lade pro Zeile und universellem Undo/Redo. Richte ihn auf eine beliebige Voltro-API und er passt sich an; der Seiten-Code unter <code>src/pages/admin/</code> gehört dir zum Bearbeiten.',
+  'landing.cta':     'Beim Admin anmelden →',
+
+  'login.heading': 'Anmelden',
+  'login.body':    'Keine echte Authentifizierung hier — dieser Button setzt ein Demo-Session-Cookie, damit du siehst, wie das Admin-Gate dich durchlässt.',
+  'login.cta':     'Als Demo-Admin fortfahren →',
+
+  'admin.undo':           '↶ Rückgängig',
+  'admin.redo':           '↷ Wiederholen',
+  'admin.nav.overview':   'Übersicht',
+  'admin.nav.discovering': 'wird erkannt…',
+  'admin.nav.backToSite': '← Zurück zur Seite',
+
+  'overview.heading':        'Entitäten',
+  'overview.intro':          'Erkannt aus der Capability-Map von <code>app</code>. Jede Karte ist eine live, rechtegeprüfte CRUD-Ansicht — ohne Code pro Entität.',
+  'overview.error':          'Die Capability-Map der API war nicht erreichbar. Läuft die API mit aktiviertem Inspect?',
+  'overview.columns':        '{count, plural, one {# Spalte} other {# Spalten}}',
+  'overview.reactiveSuffix': ' · reaktiv',
+  'overview.readonly':       'schreibgeschützt',
+  'overview.empty':          'Diese API stellt keine Benutzer-Entitäten bereit.',
+
+  'entity.create':  'Erstellen',
+  'entity.addLabel': '{table} hinzufügen',
+  'entity.rows':    'Zeilen',
+  'entity.noList':  'Diese Entität stellt keine List-Query bereit.',
+  'entity.empty':   'Noch keine {table}.',
+  'entity.why':     'Warum?',
+  'entity.delete':  'Löschen',
+  'entity.unknown': 'Keine Entität <code>{entity}</code> in der Capability-Map dieser API.',
+
+  'prov.title':       'Herkunft · <code>{table}</code> #{id}',
+  'prov.close':       'schließen',
+  'prov.loading':     'lädt…',
+  'prov.none':        'Keine Herkunft (ist audit() auf dieser Tabelle + Inspect aktiviert?).',
+  'prov.lastWrite':   'letzte Änderung',
+  'prov.byActor':     'durch Akteur',
+  'prov.attribution': 'Zuordnung',
+  'prov.via':         ' (über {via})',
+  'prov.derived':     'abgeleitet',
+  'prov.yes':         'ja',
+
+  'error.heading':   'Etwas ist schiefgelaufen',
+  'error.retry':     'Erneut versuchen',
+  'notFound.heading': 'Nicht gefunden',
+  'notFound.body':   'Diese Admin-Seite existiert nicht.',
+  'notFound.back':   '← Zurück zur Übersicht',
+})