@chatlychat/cli 0.4.0 → 0.5.1

package/dist/help.js

@@ -31,6 +31,7 @@ AUTH
   login                       Store an API key in ~/.config/chatly/config.json (0600)
   logout                      Remove the stored key
   whoami                      Which workspace this key belongs to, and its scopes
+                              (a cp_ credential: scopes, expiry and guardrails)
 
 CONVERSATIONS
   conversations list          Open conversations, newest first
@@ -96,7 +97,7 @@ ROUTING + AUTOMATION
   knowledge-gaps list | triage <id>
 
 INTEGRATIONS
-  webhooks deliveries         --status
+  webhooks deliveries         --status --endpoint --trace <ulid> (X-Chatly-Trace)
   webhooks delivery <id>
   webhooks redeliver <id>
   webhooks endpoints          Subscriptions, not traffic
@@ -112,6 +113,18 @@ INTEGRATIONS
   docs-sources subscribe <id> A refusal is a success: read the response
   channels list | get <id> | adapters | create | update <id>
   channels rotate-secret <id>
+  channels brand <id>         --url <brand.json> | --file/--body to apply; neither reads back
+
+DATA RIGHTS
+  privacy executor-key        Mint the credential a privacy platform registers.
+                              Answers with the executor URL, the workspace id
+                              and the secret — shown ONCE. The key carries
+                              exactly privacy:execute and reaches nothing but
+                              /v1/privacy/*
+  privacy lookup              --body <json>  resolve a person to a subjectId
+  privacy request             --body <json>  file one; caseId is the replay key
+  privacy status <id>         Read a request back
+  privacy cancel <id>         Withdraw one that has not run
 
 DEVELOPING AGAINST WEBHOOKS AND AGENTS
   listen                      Tail this workspace's webhook deliveries and POST
@@ -145,6 +158,22 @@ WORKSPACE AS CODE
                               --prune         also delete what the document omits
                               --write-only    also send fields that cannot be read back
                               --exit-code     plan only: exit 2 when there is drift
+  platform plan               The same over /v1/platform/* with a cp_ credential:
+  platform apply              workspaces, users, apiKeys, botCredentials,
+                              knowledgeSources and settings (business hours,
+                              routing, widget channel) across many tenants.
+                              Default file: ./chatly.platform.json. Same flags.
+                              apply re-reads afterwards and exits 1 unless
+                              everything matches the document
+
+INSTALL
+  init next|remix|astro|express
+                              Scaffold the widget into this project for a web channel:
+                              identity route, launcher or snippet, CSP sources
+                              (chatly.csp.mjs) and a privacy table. Never overwrites
+                              --public-id <id>   which web channel (needed if several)
+                              --identity hmac|atlas   default hmac (atlas: next, remix)
+                              --dir <path>   default .   --dry-run   --force
 
 AI
   ai providers | quota

package/dist/help.js.map

@@ -1 +1 @@
-{"version":3,"file":"help.js","sourceRoot":"","sources":["../src/help.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2KnB,CAAC"}
+{"version":3,"file":"help.js","sourceRoot":"","sources":["../src/help.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwMnB,CAAC"}

package/dist/init/shared.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The parts of `chatly init` (CHT-F02) that do not depend on the framework:
+ * the CSP module and the privacy-policy table. Both are rendered from the
+ * channel's own `embed` block, read off `GET /v1/channels` with the caller's
+ * key — the same block the dashboard's install screen shows — so neither is a
+ * hand-kept copy of something the server already says.
+ */
+/** One generated file. `path` is relative to the target directory. */
+export interface ScaffoldFile {
+    readonly path: string;
+    readonly contents: string;
+}
+/** The fields of `channel.embed` this wizard reads. Everything else is ignored. */
+export interface EmbedBlock {
+    readonly snippet: string;
+    readonly contentSecurityPolicy: {
+        readonly scriptSrc: ReadonlyArray<string>;
+        readonly connectSrc: ReadonlyArray<string>;
+        readonly imgSrc: ReadonlyArray<string>;
+        readonly mediaSrc: ReadonlyArray<string>;
+    };
+    readonly storage: ReadonlyArray<StorageKey>;
+}
+/** One row of `embed.storage` — the public storage declaration. */
+export interface StorageKey {
+    readonly key: string;
+    readonly store: string;
+    readonly purpose: string;
+    readonly lifetime: string;
+    readonly category: string;
+    readonly writtenWhen: string;
+}
+export interface ScaffoldInput {
+    readonly publicId: string;
+    readonly embed: EmbedBlock;
+    /** `hmac` signs the user id on your server; `atlas` passes an Atlas token. */
+    readonly identity: 'hmac' | 'atlas';
+    /** ISO date, stamped into each header so a stale file can be recognised. */
+    readonly generatedOn: string;
+}
+/**
+ * The module every framework's CSP is merged from.
+ *
+ * `.mjs` and dependency-free on purpose: `next.config.{js,mjs,ts}` and an
+ * Express server can both import it, and a header built from it needs no
+ * library. It does NOT write a header itself — the host page already has a
+ * policy, and a second `Content-Security-Policy` header INTERSECTS with the
+ * first rather than extending it, which would block the host's own scripts.
+ * So it merges into the directives the integrator already has.
+ */
+export declare function cspModule(input: ScaffoldInput): ScaffoldFile;
+/**
+ * The privacy-policy table (CHT-DOC12's content, rendered for this channel).
+ *
+ * Every key with the channel's `publicId` already substituted, which is the
+ * form a privacy policy or a consent tool's cookie scan needs. `cookies` is
+ * stated as none because the declaration says so — an omitted row reads as
+ * "not declared", not as "none".
+ */
+export declare function privacyTable(input: ScaffoldInput): ScaffoldFile;
+//# sourceMappingURL=shared.d.ts.map

package/dist/init/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/init/shared.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,sEAAsE;AACtE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,mFAAmF;AACnF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,qBAAqB,EAAE;QAC9B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QAC1C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QAC3C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QACvC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;KAC1C,CAAC;IACF,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CAC7C;AAED,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CAwD5D;AAOD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CA0B/D"}

package/dist/init/shared.js

@@ -0,0 +1,110 @@
+/**
+ * The parts of `chatly init` (CHT-F02) that do not depend on the framework:
+ * the CSP module and the privacy-policy table. Both are rendered from the
+ * channel's own `embed` block, read off `GET /v1/channels` with the caller's
+ * key — the same block the dashboard's install screen shows — so neither is a
+ * hand-kept copy of something the server already says.
+ */
+/**
+ * The module every framework's CSP is merged from.
+ *
+ * `.mjs` and dependency-free on purpose: `next.config.{js,mjs,ts}` and an
+ * Express server can both import it, and a header built from it needs no
+ * library. It does NOT write a header itself — the host page already has a
+ * policy, and a second `Content-Security-Policy` header INTERSECTS with the
+ * first rather than extending it, which would block the host's own scripts.
+ * So it merges into the directives the integrator already has.
+ */
+export function cspModule(input) {
+    const csp = input.embed.contentSecurityPolicy;
+    const list = (values) => `[${values.map((v) => JSON.stringify(v)).join(', ')}]`;
+    return {
+        path: 'chatly.csp.mjs',
+        contents: `/**
+ * Chatly's Content-Security-Policy sources for the web channel ${input.publicId}.
+ *
+ * Generated by \`chatly init\` on ${input.generatedOn} from the channel's own
+ * \`embed.contentSecurityPolicy\`. Re-run \`chatly init\` (or read
+ * \`GET /v1/channels\`) when Chatly announces a host change — the lists are
+ * the origins CHATLY serves from, not an image URL an operator put in a theme.
+ *
+ * MERGE these into your existing directives; do not send a second
+ * Content-Security-Policy header. Two headers intersect, so a second one
+ * would block your own scripts rather than allow Chatly's.
+ *
+ * The embed snippet is an inline <script>: your script-src needs a nonce or
+ * hash for it, or load the widget with @chatlychat/widget-react instead.
+ */
+export const chatlyCsp = {
+  'script-src': ${list(csp.scriptSrc)},
+  'connect-src': ${list(csp.connectSrc)},
+  'img-src': ${list(csp.imgSrc)},
+  'media-src': ${list(csp.mediaSrc)},
+};
+
+/**
+ * Your directives with Chatly's sources appended, de-duplicated.
+ * Directive names are the header's own (\`'script-src'\`, not \`scriptSrc\`).
+ *
+ * @param {Record<string, string[]>} directives
+ * @returns {Record<string, string[]>}
+ */
+export function withChatly(directives) {
+  const out = { ...directives };
+  for (const [name, sources] of Object.entries(chatlyCsp)) {
+    out[name] = [...new Set([...(out[name] ?? ["'self'"]), ...sources])];
+  }
+  return out;
+}
+
+/**
+ * Directives to a header value: \`"script-src 'self' https://…; connect-src …"\`.
+ *
+ * @param {Record<string, string[]>} directives
+ * @returns {string}
+ */
+export function toHeader(directives) {
+  return Object.entries(directives)
+    .map(([name, sources]) => [name, ...sources].join(' '))
+    .join('; ');
+}
+`,
+    };
+}
+/** Escape a value for a Markdown table cell. */
+function cell(value) {
+    return value.replaceAll('|', '\\|').replaceAll('\n', ' ');
+}
+/**
+ * The privacy-policy table (CHT-DOC12's content, rendered for this channel).
+ *
+ * Every key with the channel's `publicId` already substituted, which is the
+ * form a privacy policy or a consent tool's cookie scan needs. `cookies` is
+ * stated as none because the declaration says so — an omitted row reads as
+ * "not declared", not as "none".
+ */
+export function privacyTable(input) {
+    const rows = input.embed.storage.map((k) => `| \`${cell(k.key)}\` | ${cell(k.store)} | ${cell(k.purpose)} | ${cell(k.lifetime)} | ` +
+        `${cell(k.category)} | ${cell(k.writtenWhen)} |`);
+    return {
+        path: 'CHATLY-PRIVACY.md',
+        contents: `# What the Chatly widget stores in a visitor's browser
+
+Generated by \`chatly init\` on ${input.generatedOn} from the storage
+declaration of web channel \`${input.publicId}\` — the same list Chatly
+publishes for that channel without a key. Paste the table into your privacy
+policy or cookie notice.
+
+**Cookies: none.** The widget sets no cookies.
+
+| Key | Store | Purpose | Lifetime | Category | Written when |
+| --- | --- | --- | --- | --- | --- |
+${rows.join('\n')}
+
+Whether ANY of these is written is decided by the \`storage\` option on your
+embed, which the server never sees — \`storage: 'deny'\` writes none of them.
+See https://chatlychat.com/guides/consent.
+`,
+    };
+}
+//# sourceMappingURL=shared.js.map

package/dist/init/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../src/init/shared.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAuCH;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS,CAAC,KAAoB;IAC5C,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,qBAAqB,CAAC;IAC9C,MAAM,IAAI,GAAG,CAAC,MAA6B,EAAU,EAAE,CACrD,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;IACzD,OAAO;QACL,IAAI,EAAE,gBAAgB;QACtB,QAAQ,EAAE;kEACoD,KAAK,CAAC,QAAQ;;qCAE3C,KAAK,CAAC,WAAW;;;;;;;;;;;;;kBAapC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;mBAClB,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC;eACxB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;iBACd,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlC;KACE,CAAC;AACJ,CAAC;AAED,gDAAgD;AAChD,SAAS,IAAI,CAAC,KAAa;IACzB,OAAO,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,KAAoB;IAC/C,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAClC,CAAC,CAAC,EAAE,EAAE,CACJ,OAAO,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK;QACvF,GAAG,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CACnD,CAAC;IACF,OAAO;QACL,IAAI,EAAE,mBAAmB;QACzB,QAAQ,EAAE;;kCAEoB,KAAK,CAAC,WAAW;+BACpB,KAAK,CAAC,QAAQ;;;;;;;;EAQ3C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;CAKhB;KACE,CAAC;AACJ,CAAC"}

package/dist/init/templates.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The framework templates for `chatly init` (CHT-F02).
+ *
+ * Every API a generated file uses is in a PUBLISHED package at the version on
+ * npm today — `chatlyUserHash` from `@chatlychat/widget-react/server`,
+ * `<ChatlyLauncher>`'s `externalId`/`userHash`/`getToken` props, and
+ * `Chatly('identify', …)` on the snippet. A template that imported something
+ * from a working tree would scaffold a project that does not install.
+ *
+ * ═══ THE ONE THING A WIZARD CANNOT KNOW ═══════════════════════════════════
+ *
+ * Who is signed in. Every identity route below has a `currentUserId` stub
+ * that answers `null`, so a freshly scaffolded app runs with every visitor
+ * ANONYMOUS — never with an unsigned claim. Wiring it to the integrator's
+ * auth is the step the summary names first.
+ */
+import { type ScaffoldFile, type ScaffoldInput } from './shared.js';
+export declare const FRAMEWORKS: readonly ["next", "remix", "astro", "express"];
+export type Framework = (typeof FRAMEWORKS)[number];
+/**
+ * The frameworks with no `--identity atlas` output. An Atlas token is minted
+ * in the browser, so there is no server half to generate, and these two have
+ * no React component to pass `getToken` to — the page calls
+ * `Chatly('identify', { getToken })` itself.
+ */
+export declare const NO_ATLAS: ReadonlyArray<Framework>;
+/** Every file `chatly init <framework>` writes, in the order it reports them. */
+export declare function scaffold(framework: Framework, input: ScaffoldInput): ReadonlyArray<ScaffoldFile>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/init/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/init/templates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAA2B,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAE7F,eAAO,MAAM,UAAU,gDAAiD,CAAC;AACzE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,aAAa,CAAC,SAAS,CAAwB,CAAC;AAsTvE,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,aAAa,GAAG,aAAa,CAAC,YAAY,CAAC,CAwChG"}

package/dist/init/templates.js

@@ -0,0 +1,362 @@
+/**
+ * The framework templates for `chatly init` (CHT-F02).
+ *
+ * Every API a generated file uses is in a PUBLISHED package at the version on
+ * npm today — `chatlyUserHash` from `@chatlychat/widget-react/server`,
+ * `<ChatlyLauncher>`'s `externalId`/`userHash`/`getToken` props, and
+ * `Chatly('identify', …)` on the snippet. A template that imported something
+ * from a working tree would scaffold a project that does not install.
+ *
+ * ═══ THE ONE THING A WIZARD CANNOT KNOW ═══════════════════════════════════
+ *
+ * Who is signed in. Every identity route below has a `currentUserId` stub
+ * that answers `null`, so a freshly scaffolded app runs with every visitor
+ * ANONYMOUS — never with an unsigned claim. Wiring it to the integrator's
+ * auth is the step the summary names first.
+ */
+import { cspModule, privacyTable } from './shared.js';
+export const FRAMEWORKS = ['next', 'remix', 'astro', 'express'];
+/**
+ * The frameworks with no `--identity atlas` output. An Atlas token is minted
+ * in the browser, so there is no server half to generate, and these two have
+ * no React component to pass `getToken` to — the page calls
+ * `Chatly('identify', { getToken })` itself.
+ */
+export const NO_ATLAS = ['express', 'astro'];
+const IDENTITY_ROUTE_NEXT = (input) => `/**
+ * Chatly identity verification (HMAC) for web channel ${input.publicId}.
+ * Generated by \`chatly init next\` on ${input.generatedOn}.
+ *
+ * Signs the signed-in user's id with the channel's IDV secret, so the widget
+ * can prove who the visitor is. The secret stays on this server:
+ * \`@chatlychat/widget-react/server\` refuses to run in a browser bundle.
+ *
+ * Wire \`currentUserId\` to your auth before shipping. Until then it answers
+ * \`{ identity: null }\` and every visitor chats anonymously.
+ */
+import { chatlyUserHash } from '@chatlychat/widget-react/server';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+const NO_STORE = { 'cache-control': 'no-store' };
+
+/** TODO: return the signed-in user's stable id from your auth library, or null. */
+async function currentUserId(): Promise<string | null> {
+  return null;
+}
+
+export async function GET(): Promise<NextResponse> {
+  const externalId = await currentUserId();
+  if (externalId === null) {
+    return NextResponse.json({ identity: null }, { headers: NO_STORE });
+  }
+  const secret = process.env.CHATLY_IDV_SECRET;
+  if (secret === undefined || secret === '') {
+    // Loud rather than anonymous: a signed-in user silently chatting as a
+    // stranger is a misconfiguration nobody would notice.
+    return NextResponse.json(
+      { error: 'CHATLY_IDV_SECRET is not set on the server' },
+      { status: 500, headers: NO_STORE },
+    );
+  }
+  return NextResponse.json(
+    { identity: { externalId, userHash: chatlyUserHash(secret, externalId) } },
+    { headers: NO_STORE },
+  );
+}
+`;
+const LAUNCHER_NEXT_HMAC = (input) => `'use client';
+/**
+ * The Chatly launcher for web channel ${input.publicId}, identified through
+ * \`app/api/chatly/identity/route.ts\`. Generated by \`chatly init next\` on
+ * ${input.generatedOn}. Render <Chatly /> once, in your root layout.
+ */
+import { ChatlyLauncher } from '@chatlychat/widget-react';
+import { useEffect, useState } from 'react';
+
+interface Identity {
+  readonly externalId: string;
+  readonly userHash: string;
+}
+
+export function Chatly() {
+  // undefined = still asking; null = anonymous.
+  const [identity, setIdentity] = useState<Identity | null | undefined>(undefined);
+
+  useEffect(() => {
+    let live = true;
+    fetch('/api/chatly/identity', { cache: 'no-store' })
+      .then(async (r) => (r.ok ? ((await r.json()) as { identity: Identity | null }) : { identity: null }))
+      .then((body) => live && setIdentity(body.identity))
+      .catch(() => live && setIdentity(null));
+    return () => {
+      live = false;
+    };
+  }, []);
+
+  // Rendered only once the identity is known, so the widget starts as the
+  // right visitor instead of starting anonymous and switching.
+  if (identity === undefined) {
+    return null;
+  }
+  return <ChatlyLauncher publicId=${JSON.stringify(input.publicId)} {...(identity ?? {})} />;
+}
+`;
+const LAUNCHER_NEXT_ATLAS = (input) => `'use client';
+/**
+ * The Chatly launcher for web channel ${input.publicId}, identified with an
+ * Atlas token (\`identityVerification.mode: 'atlas'\`). Generated by
+ * \`chatly init next --identity atlas\` on ${input.generatedOn}.
+ *
+ * Pass \`getToken\` for a signed-in user and leave it out for a signed-out one:
+ *
+ *   <Chatly getToken={() => atlas.session.getToken({ template: 'chatly' })} />
+ *
+ * The template and the channel setting it must match are on
+ * https://chatlychat.com/guides/identity-verification#worked-example-an-atlas-instance-on-the-shared-host
+ */
+import { ChatlyLauncher } from '@chatlychat/widget-react';
+
+export function Chatly({ getToken }: { getToken?: () => Promise<string> }) {
+  return (
+    <ChatlyLauncher
+      publicId=${JSON.stringify(input.publicId)}
+      {...(getToken === undefined ? {} : { getToken })}
+    />
+  );
+}
+`;
+const IDENTITY_EXPRESS = (input) => `/**
+ * Chatly identity verification (HMAC) for web channel ${input.publicId}.
+ * Generated by \`chatly init express\` on ${input.generatedOn}.
+ *
+ *   import { chatlyIdentity } from './chatly/identity.mjs';
+ *   app.get('/api/chatly/identity', chatlyIdentity((req) => req.user?.id ?? null));
+ *
+ * \`userIdOf\` is the one thing to write: return the signed-in user's stable id,
+ * or null for a signed-out visitor, who then chats anonymously.
+ */
+import { createHmac } from 'node:crypto';
+
+/** HMAC-SHA256(secret, externalId), hex — what the widget sends as userHash. */
+export function chatlyUserHash(secret, externalId) {
+  return createHmac('sha256', secret).update(externalId).digest('hex');
+}
+
+/** @param {(req: any) => string | null | Promise<string | null>} userIdOf */
+export function chatlyIdentity(userIdOf) {
+  return async (req, res) => {
+    res.set('cache-control', 'no-store');
+    const externalId = await userIdOf(req);
+    if (externalId === null || externalId === undefined) {
+      return res.json({ identity: null });
+    }
+    const secret = process.env.CHATLY_IDV_SECRET;
+    if (!secret) {
+      return res.status(500).json({ error: 'CHATLY_IDV_SECRET is not set on the server' });
+    }
+    return res.json({ identity: { externalId, userHash: chatlyUserHash(secret, externalId) } });
+  };
+}
+`;
+const SNIPPET_EXPRESS = (input) => `<!--
+  Chatly for web channel ${input.publicId}. Generated by \`chatly init express\`
+  on ${input.generatedOn}. Paste before </body>. The first script is the
+  channel's own embed snippet; the second identifies a signed-in visitor
+  through /api/chatly/identity (see chatly/identity.mjs).
+-->
+${input.embed.snippet}
+<script>
+  fetch('/api/chatly/identity', { cache: 'no-store' })
+    .then(function (r) { return r.ok ? r.json() : { identity: null }; })
+    .then(function (body) { if (body.identity) Chatly('identify', body.identity); })
+    .catch(function () {});
+</script>
+`;
+/**
+ * The Remix loader imports nothing from Remix or React Router on purpose. A
+ * `LoaderFunctionArgs` import would pin the file to `@remix-run/node` (Remix
+ * v2) or to `react-router` (v7 framework mode), and a loader that takes
+ * `{ request }` and returns a `Response` is a valid loader in both.
+ */
+const IDENTITY_ROUTE_REMIX = (input) => `/**
+ * Chatly identity verification (HMAC) for web channel ${input.publicId}.
+ * Generated by \`chatly init remix\` on ${input.generatedOn}.
+ *
+ * A resource route (a loader and no component), served at
+ * /api/chatly/identity by Remix v2's flat routes and by React Router v7's
+ * \`flatRoutes()\`. Signs the signed-in user's id with the channel's IDV
+ * secret, so the widget can prove who the visitor is. The secret stays on
+ * this server: a loader never reaches the browser bundle, and
+ * \`@chatlychat/widget-react/server\` refuses to run in one anyway.
+ *
+ * Wire \`currentUserId\` to your auth before shipping. Until then it answers
+ * \`{ identity: null }\` and every visitor chats anonymously.
+ */
+import { chatlyUserHash } from '@chatlychat/widget-react/server';
+
+const HEADERS = { 'content-type': 'application/json', 'cache-control': 'no-store' };
+
+/** TODO: return the signed-in user's stable id from your session, or null. */
+async function currentUserId(request: Request): Promise<string | null> {
+  void request;
+  return null;
+}
+
+export async function loader({ request }: { request: Request }): Promise<Response> {
+  const externalId = await currentUserId(request);
+  if (externalId === null) {
+    return new Response(JSON.stringify({ identity: null }), { headers: HEADERS });
+  }
+  const secret = process.env.CHATLY_IDV_SECRET;
+  if (secret === undefined || secret === '') {
+    // Loud rather than anonymous: a signed-in user silently chatting as a
+    // stranger is a misconfiguration nobody would notice.
+    return new Response(JSON.stringify({ error: 'CHATLY_IDV_SECRET is not set on the server' }), {
+      status: 500,
+      headers: HEADERS,
+    });
+  }
+  return new Response(
+    JSON.stringify({ identity: { externalId, userHash: chatlyUserHash(secret, externalId) } }),
+    { headers: HEADERS },
+  );
+}
+`;
+/**
+ * Remix's launcher is Next's without `'use client'` and with its own header:
+ * every Remix component renders on the server and hydrates, and the identity
+ * fetch is in an effect, so it runs in the browser only.
+ */
+const LAUNCHER_REMIX_HMAC = (input) => LAUNCHER_NEXT_HMAC(input)
+    .replace(/^'use client';\n/, '')
+    .replace('`app/api/chatly/identity/route.ts`', '`app/routes/api.chatly.identity.ts`')
+    .replace('`chatly init next`', '`chatly init remix`')
+    .replace('in your root layout', 'in app/root.tsx');
+const LAUNCHER_REMIX_ATLAS = (input) => LAUNCHER_NEXT_ATLAS(input)
+    .replace(/^'use client';\n/, '')
+    .replace('`chatly init next --identity atlas`', '`chatly init remix --identity atlas`');
+/**
+ * Astro's endpoint signs with `node:crypto`, like Express's, rather than
+ * importing `@chatlychat/widget-react/server`: an Astro site has no reason to
+ * install a React package, and the construction is one line.
+ */
+const IDENTITY_ROUTE_ASTRO = (input) => `/**
+ * Chatly identity verification (HMAC) for web channel ${input.publicId}.
+ * Generated by \`chatly init astro\` on ${input.generatedOn}.
+ *
+ * Served at /api/chatly/identity. \`prerender = false\` makes it run per
+ * request, which needs a server adapter with Node built-ins
+ * (\`@astrojs/node\`, or another adapter with \`node:crypto\`): a prerendered
+ * identity would be one visitor's answer frozen into a static file.
+ *
+ * Wire \`currentUserId\` to your auth before shipping. Until then it answers
+ * \`{ identity: null }\` and every visitor chats anonymously.
+ */
+import { createHmac } from 'node:crypto';
+
+import type { APIRoute } from 'astro';
+
+export const prerender = false;
+
+const HEADERS = { 'content-type': 'application/json', 'cache-control': 'no-store' };
+
+/** HMAC-SHA256(secret, externalId), hex — what the widget sends as userHash. */
+export function chatlyUserHash(secret: string, externalId: string): string {
+  return createHmac('sha256', secret).update(externalId).digest('hex');
+}
+
+/** TODO: return the signed-in user's stable id (from \`locals\`, a cookie, …), or null. */
+async function currentUserId(context: Parameters<APIRoute>[0]): Promise<string | null> {
+  void context;
+  return null;
+}
+
+export const GET: APIRoute = async (context) => {
+  const externalId = await currentUserId(context);
+  if (externalId === null) {
+    return new Response(JSON.stringify({ identity: null }), { headers: HEADERS });
+  }
+  const secret = process.env.CHATLY_IDV_SECRET;
+  if (secret === undefined || secret === '') {
+    // Loud rather than anonymous: a signed-in user silently chatting as a
+    // stranger is a misconfiguration nobody would notice.
+    return new Response(JSON.stringify({ error: 'CHATLY_IDV_SECRET is not set on the server' }), {
+      status: 500,
+      headers: HEADERS,
+    });
+  }
+  return new Response(
+    JSON.stringify({ identity: { externalId, userHash: chatlyUserHash(secret, externalId) } }),
+    { headers: HEADERS },
+  );
+};
+`;
+/**
+ * The snippet is a string in the frontmatter and rendered with `set:html`, not
+ * pasted into the template: a bare `<script>` in an `.astro` file is bundled
+ * and turned into a module, which would move the shim off `window` and out of
+ * order. `set:html` emits it byte for byte, and `is:inline` does the same for
+ * the identify call.
+ */
+const COMPONENT_ASTRO = (input) => `---
+/**
+ * Chatly for web channel ${input.publicId}. Generated by \`chatly init astro\`
+ * on ${input.generatedOn}. Render <Chatly /> once, before </body> in your
+ * layout. The first script is the channel's own embed snippet; the second
+ * identifies a signed-in visitor through /api/chatly/identity
+ * (src/pages/api/chatly/identity.ts).
+ */
+const snippet = ${JSON.stringify(input.embed.snippet)};
+---
+
+<Fragment set:html={snippet} />
+<script is:inline>
+  fetch('/api/chatly/identity', { cache: 'no-store' })
+    .then(function (r) { return r.ok ? r.json() : { identity: null }; })
+    .then(function (body) { if (body.identity) Chatly('identify', body.identity); })
+    .catch(function () {});
+</script>
+`;
+/** Every file `chatly init <framework>` writes, in the order it reports them. */
+export function scaffold(framework, input) {
+    const common = [cspModule(input), privacyTable(input)];
+    if (framework === 'next') {
+        return [
+            ...(input.identity === 'hmac'
+                ? [{ path: 'app/api/chatly/identity/route.ts', contents: IDENTITY_ROUTE_NEXT(input) }]
+                : []),
+            {
+                path: 'components/chatly.tsx',
+                contents: input.identity === 'hmac' ? LAUNCHER_NEXT_HMAC(input) : LAUNCHER_NEXT_ATLAS(input),
+            },
+            ...common,
+        ];
+    }
+    if (framework === 'remix') {
+        return [
+            ...(input.identity === 'hmac'
+                ? [{ path: 'app/routes/api.chatly.identity.ts', contents: IDENTITY_ROUTE_REMIX(input) }]
+                : []),
+            {
+                path: 'app/components/chatly.tsx',
+                contents: input.identity === 'hmac' ? LAUNCHER_REMIX_HMAC(input) : LAUNCHER_REMIX_ATLAS(input),
+            },
+            ...common,
+        ];
+    }
+    if (framework === 'astro') {
+        return [
+            { path: 'src/pages/api/chatly/identity.ts', contents: IDENTITY_ROUTE_ASTRO(input) },
+            { path: 'src/components/Chatly.astro', contents: COMPONENT_ASTRO(input) },
+            ...common,
+        ];
+    }
+    return [
+        { path: 'chatly/identity.mjs', contents: IDENTITY_EXPRESS(input) },
+        { path: 'chatly/snippet.html', contents: SNIPPET_EXPRESS(input) },
+        ...common,
+    ];
+}
+//# sourceMappingURL=templates.js.map

package/dist/init/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../src/init/templates.ts"],"names":[],"mappings":"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"}