runcloud 0.2.196 → 0.2.197

package/dist/commands/support.js

@@ -0,0 +1,273 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { requireCredentials, resolveProject } from '../config.js';
+import { SUPPORT_CHAT_TSX } from './supportChat.generated.js';
+export const SUPPORT_CONFIG = 'src/lib/newly-support.json';
+export const SUPPORT_CHAT = 'src/components/SupportChat.tsx';
+export function writeSupportChat(dir, force = false) {
+    const path = join(dir, SUPPORT_CHAT);
+    if (existsSync(path) && !force)
+        return { path, written: false };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, Buffer.from(SUPPORT_CHAT_TSX, 'base64'));
+    return { path, written: true };
+}
+const ENVS = ['development', 'production'];
+const base = (projectId) => `/projects/${encodeURIComponent(projectId)}/support`;
+export function envFrom(flag) {
+    if (flag === undefined || flag === 'dev' || flag === 'development')
+        return 'development';
+    if (flag === 'prod' || flag === 'production')
+        return 'production';
+    throw new Error('--env must be dev or prod');
+}
+export function supabaseAuth(url) {
+    let host;
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== 'https:')
+            throw new Error();
+        host = parsed.host;
+    }
+    catch {
+        throw new Error(`Not a Supabase project URL: ${url}`);
+    }
+    const issuer = `https://${host}/auth/v1`;
+    return { auth_issuer: issuer, auth_jwks_url: `${issuer}/.well-known/jwks.json`, auth_audience: 'authenticated' };
+}
+export function writeSupportConfig(dir, config) {
+    const path = join(dir, SUPPORT_CONFIG);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`);
+    return path;
+}
+export async function runSupportStatus(client, projectId, log) {
+    const { settings, keys } = (await client.get(`${base(projectId)}/settings`));
+    const summary = await client.get(`${base(projectId)}/summary`);
+    log(JSON.stringify({ settings, keys, summary }, null, 2));
+}
+export async function runSupportEnable(client, projectId, apiUrl, dir, log, opts = {}) {
+    await client.put(`${base(projectId)}/settings`, { enabled: true });
+    const { keys } = (await client.get(`${base(projectId)}/settings`));
+    const written = {};
+    for (const env of ENVS) {
+        written[env] = keys[env].publishable
+            ?? (await client.post(`${base(projectId)}/keys`, { environment: env, kind: 'publishable' })).key;
+    }
+    const path = writeSupportConfig(dir, { projectId, apiUrl, keys: written });
+    const chat = writeSupportChat(dir, opts.forceChat);
+    log(`Customer support is on. Keys written to ${path}.`);
+    log(chat.written
+        ? `Help chat component written to ${chat.path}. Give it a route (for example app/help.tsx rendering <SupportChat appName="..." />) and a way in from Settings.`
+        : `Kept the existing ${chat.path} (pass --force-chat to replace it).`);
+}
+export async function runSupportDisable(client, projectId, log) {
+    await client.put(`${base(projectId)}/settings`, { enabled: false });
+    log('Customer support is off. The help chat in the app now says support is unavailable.');
+}
+export async function runSupportRotate(client, projectId, apiUrl, dir, env, secret, log) {
+    const { key } = (await client.post(`${base(projectId)}/keys`, { environment: env, kind: secret ? 'secret' : 'publishable' }));
+    if (secret) {
+        log(`Secret support key for ${env} (shown once, store it on your server as NEWLY_SUPPORT_SECRET):\n${key}`);
+        return;
+    }
+    const path = join(dir, SUPPORT_CONFIG);
+    let current = {};
+    try {
+        current = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch { }
+    const keys = { development: current.keys?.development ?? '', production: current.keys?.production ?? '', [env]: key };
+    writeSupportConfig(dir, { projectId, apiUrl, keys });
+    log(`New ${env} key written to ${path}. The old key stops working now.`);
+}
+export async function runSupportAuth(client, projectId, opts, log) {
+    let patch;
+    if (opts.clear)
+        patch = { auth_issuer: null, auth_jwks_url: null, auth_audience: null };
+    else if (opts.supabaseUrl)
+        patch = supabaseAuth(opts.supabaseUrl);
+    else if (opts.issuer && opts.jwks && opts.audience)
+        patch = { auth_issuer: opts.issuer, auth_jwks_url: opts.jwks, auth_audience: opts.audience };
+    else
+        throw new Error('Pass --supabase-url <url>, or all of --issuer, --jwks and --audience, or --clear.');
+    await client.put(`${base(projectId)}/settings`, patch);
+    log(opts.clear ? 'Signed-in customers are no longer recognised.' : 'Signed-in customers are now recognised from their sign-in token.');
+}
+export async function runArticlesList(client, projectId, log) {
+    const { articles } = (await client.get(`${base(projectId)}/articles`));
+    if (!articles.length) {
+        log('No articles yet. Add one with newly support articles add --title <title> --file <path>.');
+        return;
+    }
+    for (const a of articles)
+        log(`${a.id}  ${a.title}  (updated ${a.updated_at})`);
+}
+const bodyOf = (opts) => {
+    if (opts.file)
+        return readFileSync(opts.file, 'utf8');
+    if (opts.body)
+        return opts.body;
+    throw new Error('Pass --body <text> or --file <path>.');
+};
+export async function runArticleAdd(client, projectId, opts, log) {
+    const { article } = (await client.post(`${base(projectId)}/articles`, { title: opts.title, body: bodyOf(opts) }));
+    log(`Added ${article.id}  ${article.title}`);
+}
+export async function runArticleEdit(client, projectId, id, opts, log) {
+    const { articles } = (await client.get(`${base(projectId)}/articles`));
+    const current = articles.find((a) => a.id === id);
+    if (!current)
+        throw new Error(`No article ${id}. List them with newly support articles list.`);
+    const body = opts.body || opts.file ? bodyOf(opts) : current.body;
+    await client.put(`${base(projectId)}/articles/${encodeURIComponent(id)}`, { title: opts.title ?? current.title, body });
+    log(`Updated ${id}`);
+}
+export async function runArticleRemove(client, projectId, id, log) {
+    await client.delete(`${base(projectId)}/articles/${encodeURIComponent(id)}`);
+    log(`Removed ${id}`);
+}
+const onOff = (value, flag) => {
+    if (value === 'on')
+        return true;
+    if (value === 'off')
+        return false;
+    throw new Error(`${flag} must be on or off`);
+};
+const days = (value, flag, max) => {
+    if (!/^\d+$/.test(value) || Number(value) > max)
+        throw new Error(`${flag} must be a whole number from 0 to ${max}`);
+    return Number(value);
+};
+export function settingsPatch(flags) {
+    const patch = {};
+    if (flags.ai !== undefined)
+        patch.ai_enabled = onOff(flags.ai, '--ai');
+    if (flags.quality !== undefined) {
+        if (flags.quality !== 'standard' && flags.quality !== 'advanced')
+            throw new Error('--quality must be standard or advanced');
+        patch.ai_quality = flags.quality;
+    }
+    if (flags.dailyLimit !== undefined)
+        patch.ai_daily_cap = days(flags.dailyLimit, '--daily-limit', 5_000);
+    if (flags.autoCloseDays !== undefined)
+        patch.auto_close_days = days(flags.autoCloseDays, '--auto-close-days', 90);
+    if (flags.chatHistory !== undefined)
+        patch.chat_history = onOff(flags.chatHistory, '--chat-history');
+    return patch;
+}
+export async function runSupportSettings(client, projectId, flags, log) {
+    const patch = settingsPatch(flags);
+    const result = Object.keys(patch).length
+        ? (await client.put(`${base(projectId)}/settings`, patch)).settings
+        : (await client.get(`${base(projectId)}/settings`)).settings;
+    log(JSON.stringify({
+        support: result.enabled ? 'on' : 'off', ai_answers: result.ai_enabled ? 'on' : 'off', quality: result.ai_quality ?? 'standard',
+        daily_limit: result.ai_daily_cap, auto_close_days: result.auto_close_days ?? 5, chat_history: result.chat_history ? 'on' : 'off',
+    }, null, 2));
+}
+export async function runSupportFeedback(client, projectId, log) {
+    const f = (await client.get(`${base(projectId)}/feedback`));
+    if (!f.count) {
+        log('No ratings yet.');
+        return;
+    }
+    log(`Average ${f.average} out of 5 from ${f.count} ${f.count === 1 ? 'rating' : 'ratings'} (5: ${f.distribution['5']}, 4: ${f.distribution['4']}, 3: ${f.distribution['3']}, 2: ${f.distribution['2']}, 1: ${f.distribution['1']})`);
+    for (const chat of f.chats.slice(0, 10))
+        log(`${chat.rating}/5  ${chat.answered_by === 'team' ? 'team' : 'AI'}  ${chat.question ?? ''}`);
+}
+const importedLine = (r) => `Imported ${r.articles.length} ${r.articles.length === 1 ? 'article' : 'articles'} (used ${r.credits_charged} ${r.credits_charged === 1 ? 'credit' : 'credits'}):\n`
+    + r.articles.map((a) => `${a.id}  ${a.title}`).join('\n');
+export async function runArticleImportPdf(client, projectId, path, log) {
+    if (!client.upload)
+        throw new Error('This client cannot upload files.');
+    const name = path.split('/').pop() || 'document.pdf';
+    const result = (await client.upload(`${base(projectId)}/articles/import/pdf?${new URLSearchParams({ name })}`, readFileSync(path), 'application/pdf'));
+    log(importedLine(result));
+}
+export async function runArticleImportUrl(client, projectId, url, refresh, log) {
+    const result = (await client.post(`${base(projectId)}/articles/import/url`, { url, replace: refresh }));
+    log(importedLine(result));
+}
+export function registerSupport(program) {
+    const support = program.command('support').description('Customer support inside your app: help chat, AI answers and knowledge base');
+    const ctx = (project) => {
+        const credentials = requireCredentials();
+        return { client: new ApiClient(credentials.apiUrl, credentials.token), projectId: resolveProject(process.cwd(), project), apiUrl: credentials.apiUrl };
+    };
+    const run = (work) => work().catch((error) => {
+        console.error(error instanceof Error && !('status' in error) ? error.message : friendlyApiError(error));
+        process.exitCode = 1;
+    });
+    const log = (m) => console.log(m);
+    support.command('status').option('--project <id>').action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runSupportStatus(c.client, c.projectId, log);
+    }));
+    support.command('enable').description(`Turn support on, write the app's keys to ${SUPPORT_CONFIG} and the chat to ${SUPPORT_CHAT}`)
+        .option('--force-chat', `replace an existing ${SUPPORT_CHAT}`).option('--project <id>')
+        .action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runSupportEnable(c.client, c.projectId, c.apiUrl, process.cwd(), log, { forceChat: Boolean(o.forceChat) });
+    }));
+    support.command('disable').option('--project <id>').action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runSupportDisable(c.client, c.projectId, log);
+    }));
+    support.command('rotate').description('Replace a support key; --secret makes a server key, shown once')
+        .option('--env <environment>', 'dev or prod', 'dev').option('--secret', 'a secret key for your server').option('--project <id>')
+        .action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runSupportRotate(c.client, c.projectId, c.apiUrl, process.cwd(), envFrom(o.env), Boolean(o.secret), log);
+    }));
+    support.command('auth').description("Recognise signed-in customers from your app's sign-in provider")
+        .option('--supabase-url <url>', 'your Supabase project URL').option('--issuer <url>').option('--jwks <url>').option('--audience <aud>')
+        .option('--clear').option('--project <id>')
+        .action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runSupportAuth(c.client, c.projectId, { supabaseUrl: o.supabaseUrl, issuer: o.issuer, jwks: o.jwks, audience: o.audience, clear: o.clear }, log);
+    }));
+    support.command('settings').description('AI answers, quality, daily limit, auto-close and chat history; no flags prints them')
+        .option('--ai <on|off>').option('--quality <standard|advanced>').option('--daily-limit <n>')
+        .option('--auto-close-days <n>', '0 turns auto-close off').option('--chat-history <on|off>').option('--project <id>')
+        .action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runSupportSettings(c.client, c.projectId, o, log);
+    }));
+    support.command('feedback').description("Customers' ratings of resolved chats").option('--project <id>')
+        .action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runSupportFeedback(c.client, c.projectId, log);
+    }));
+    const articles = support.command('articles').description('The knowledge base AI answers come from');
+    articles.command('list').option('--project <id>').action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runArticlesList(c.client, c.projectId, log);
+    }));
+    articles.command('add').requiredOption('--title <title>').option('--body <text>').option('--file <path>').option('--project <id>')
+        .action((o) => run(async () => {
+        const c = ctx(o.project);
+        await runArticleAdd(c.client, c.projectId, o, log);
+    }));
+    articles.command('edit <id>').option('--title <title>').option('--body <text>').option('--file <path>').option('--project <id>')
+        .action((id, o) => run(async () => {
+        const c = ctx(o.project);
+        await runArticleEdit(c.client, c.projectId, id, o, log);
+    }));
+    articles.command('import-pdf <path>').description('Turn a PDF into articles (uses 1 credit)').option('--project <id>')
+        .action((path, o) => run(async () => {
+        const c = ctx(o.project);
+        await runArticleImportPdf(c.client, c.projectId, path, log);
+    }));
+    articles.command('import-url <url>').description("Turn a docs page into articles (uses 1 credit); --refresh replaces that page's articles")
+        .option('--refresh').option('--project <id>')
+        .action((url, o) => run(async () => {
+        const c = ctx(o.project);
+        await runArticleImportUrl(c.client, c.projectId, url, Boolean(o.refresh), log);
+    }));
+    articles.command('remove <id>').option('--project <id>').action((id, o) => run(async () => {
+        const c = ctx(o.project);
+        await runArticleRemove(c.client, c.projectId, id, log);
+    }));
+}

package/dist/commands/supportChat.generated.js

@@ -0,0 +1 @@
+export const SUPPORT_CHAT_TSX = "import { useCallback, useEffect, useRef, useState } from 'react';
import {
  ActivityIndicator, FlatList, KeyboardAvoidingView, Platform, Pressable, StyleSheet, Text, TextInput, View, useColorScheme,
} from 'react-native';

import support from '@/lib/newly-support.json';
import { storage } from '@/lib/storage';

// `newly support enable` writes this app's project, API origin and publishable keys here. The
// keys are public by design: they only open this app's help chat.
const { apiUrl, keys } = support as { projectId: string; apiUrl: string; keys: { development: string; production: string } };
const KEY = __DEV__ ? keys.development : keys.production;
const TOKEN_KEY = `newly.support.token.${__DEV__ ? 'dev' : 'prod'}`;
const CHAT_KEY = `newly.support.chat.${__DEV__ ? 'dev' : 'prod'}`;

type Status = 'open' | 'waiting' | 'resolved';
type Source = { kind: 'article'; id: string; title: string } | { kind: 'history' };
type Message = { id: string; author: 'customer' | 'ai' | 'maker' | 'system'; content: string; sources: Source[]; created_at: string };
type Thread = { status: Status; rating: number | null; answering: boolean; messages: Message[] };
type ChatSummary = { id: string; status: Status; unread: number; last_message: string | null; last_message_at: string; rating: number | null };

/**
 * Who is asking. Pass `idToken` (the signed-in user's token from Supabase, Firebase, Clerk...) so
 * the app's team sees a verified customer; without it the chat is anonymous to this device.
 */
export type SupportCustomer = { idToken?: string | null; name?: string | null; email?: string | null };

const STATUS_LABEL: Record<Status, string> = { open: 'Open', waiting: 'Waiting for the team', resolved: 'Resolved' };

async function call<T>(path: string, init: RequestInit = {}): Promise<T> {
  const res = await fetch(`${apiUrl}/app-support/v1${path}`, {
    ...init,
    headers: { 'Content-Type': 'application/json', ...(init.headers ?? {}) },
  });
  if (res.status === 204) return undefined as T;
  const body = await res.json().catch(() => ({}));
  if (!res.ok) throw Object.assign(new Error(body.error ?? 'Support is unavailable right now.'), { status: res.status });
  return body as T;
}

async function visitorToken(customer: SupportCustomer, fresh = false): Promise<string> {
  const saved = storage.getString(TOKEN_KEY);
  if (saved && !fresh) return saved;
  const { token } = await call<{ token: string }>('/visitors', {
    method: 'POST',
    headers: { 'x-newly-support-key': KEY },
    body: JSON.stringify({ idToken: customer.idToken ?? undefined, name: customer.name ?? undefined, email: customer.email ?? undefined }),
  });
  storage.set(TOKEN_KEY, token);
  return token;
}

const timeLabel = (iso: string) => {
  const minutes = Math.round((Date.now() - Date.parse(iso)) / 60_000);
  if (minutes < 1) return 'Just now';
  if (minutes < 60) return `${minutes} min ago`;
  if (minutes < 60 * 24) return `${Math.round(minutes / 60)} h ago`;
  return new Date(iso).toLocaleDateString();
};

/**
 * The app's help chat: the AI answers first and the team replies in the same thread. "Your chats"
 * lists every earlier chat with its status; a resolved chat asks for a rating, and writing again
 * starts a new chat.
 */
export function SupportChat({ customer = {}, appName = 'Help' }: { customer?: SupportCustomer; appName?: string }) {
  const c = useColorScheme() === 'dark' ? palette.dark : palette.light;
  const [token, setToken] = useState<string | null>(null);
  const [view, setView] = useState<'chat' | 'list'>('chat');
  const [chatId, setChatId] = useState<string | null>(() => storage.getString(CHAT_KEY) ?? null);
  const [thread, setThread] = useState<Thread | null>(null);
  const [chats, setChats] = useState<ChatSummary[] | null>(null);
  const [draft, setDraft] = useState('');
  const [error, setError] = useState<string | null>(null);
  const [sending, setSending] = useState(false);
  const signedIn = Boolean(customer.idToken);
  const lastSignedIn = useRef(signedIn);

  // A sign-in or sign-out gets a new visitor, so a verified customer never shares an anonymous history.
  useEffect(() => {
    const changed = lastSignedIn.current !== signedIn;
    lastSignedIn.current = signedIn;
    if (changed) {
      storage.remove(CHAT_KEY);
      setChatId(null);
      setThread(null);
      setChats(null);
    }
    visitorToken(customer, changed).then(setToken, (e: Error) => setError(e.message));
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [signedIn]);

  const authed = useCallback(<T,>(path: string, init: RequestInit = {}) =>
    call<T>(path, { ...init, headers: { Authorization: `Bearer ${token}`, ...(init.headers ?? {}) } }).catch(async (e: Error & { status?: number }) => {
      if (e.status === 401) setToken(await visitorToken(customer, true));
      throw e;
    }), [token, customer]);

  const open = (id: string | null) => {
    if (id) storage.set(CHAT_KEY, id);
    else storage.remove(CHAT_KEY);
    setChatId(id);
    setThread(null);
    setView('chat');
  };

  const loadChats = useCallback(async () => {
    if (!token) return;
    try {
      setChats((await authed<{ conversations: ChatSummary[] }>('/conversations')).conversations);
    } catch {
      // the list stays as it was; the chat itself keeps working
    }
  }, [token, authed]);

  const loadThread = useCallback(async () => {
    if (!token || !chatId) return;
    try {
      setThread(await authed<Thread>(`/conversations/${chatId}/messages`));
      await authed(`/conversations/${chatId}/read`, { method: 'POST' });
    } catch (e) {
      if ((e as { status?: number }).status === 404) open(null);
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [token, chatId, authed]);

  useEffect(() => { void loadChats(); }, [loadChats]);

  // Faster while an answer is being written, slower otherwise; the list refreshes while it's shown.
  useEffect(() => {
    const tick = () => void (view === 'chat' ? loadThread() : loadChats());
    tick();
    const timer = setInterval(tick, view === 'chat' && thread?.answering ? 1500 : 4000);
    return () => clearInterval(timer);
  }, [view, loadThread, loadChats, thread?.answering]);

  const resolved = thread?.status === 'resolved';
  const send = async () => {
    const message = draft.trim();
    if (!message || !token || sending) return;
    setSending(true);
    setError(null);
    try {
      if (chatId && !resolved) {
        await authed(`/conversations/${chatId}/messages`, { method: 'POST', body: JSON.stringify({ message }) });
        await loadThread();
      } else {
        // No chat yet, or the last one is resolved: this message starts a new chat.
        const { conversation } = await authed<{ conversation: { id: string } }>('/conversations', { method: 'POST', body: JSON.stringify({ message }) });
        open(conversation.id);
      }
      setDraft('');
    } catch (e) {
      setError((e as Error).message);
    } finally {
      setSending(false);
    }
  };

  const rate = async (rating: number) => {
    if (!chatId) return;
    await authed(`/conversations/${chatId}/rating`, { method: 'POST', body: JSON.stringify({ rating }) }).catch(() => {});
    await loadThread();
  };

  const unreadElsewhere = (chats ?? []).some((chat) => chat.unread > 0 && chat.id !== chatId);
  return (
    <KeyboardAvoidingView style={[styles.screen, { backgroundColor: c.bg }]} behavior={Platform.OS === 'ios' ? 'padding' : undefined}>
      <View style={[styles.header, { borderColor: c.border, backgroundColor: c.card }]}>
        {view === 'list' ? (
          <Pressable onPress={() => setView('chat')} accessibilityRole="button" accessibilityLabel="Back to the chat" style={styles.headerButton}>
            <Text style={[styles.headerButtonText, { color: c.accent }]}>Back</Text>
          </Pressable>
        ) : null}
        <View style={styles.headerText}>
          <Text style={[styles.title, { color: c.text }]}>{view === 'list' ? 'Your chats' : appName}</Text>
          <Text style={[styles.subtitle, { color: c.muted }]}>
            {view === 'list' ? 'Every question you asked, newest first' : resolved ? 'Resolved' : 'AI assistant, and the team when you need them'}
          </Text>
        </View>
        {view === 'chat' ? (
          <Pressable onPress={() => { setView('list'); void loadChats(); }} accessibilityRole="button" accessibilityLabel="Your chats" style={styles.headerButton}>
            <Text style={[styles.headerButtonText, { color: c.accent }]}>Your chats{unreadElsewhere ? ' •' : ''}</Text>
          </Pressable>
        ) : (
          <Pressable onPress={() => open(null)} accessibilityRole="button" accessibilityLabel="New chat" style={styles.headerButton}>
            <Text style={[styles.headerButtonText, { color: c.accent }]}>New chat</Text>
          </Pressable>
        )}
      </View>

      {view === 'list' ? (
        <FlatList
          data={chats ?? []}
          keyExtractor={(chat) => chat.id}
          contentContainerStyle={styles.list}
          ListEmptyComponent={chats === null ? <ActivityIndicator color={c.muted} /> : <Text style={[styles.empty, { color: c.muted }]}>No chats yet. Ask anything about {appName}.</Text>}
          renderItem={({ item }) => (
            <Pressable onPress={() => open(item.id)} accessibilityRole="button" accessibilityLabel={`${STATUS_LABEL[item.status]} chat`}
              style={[styles.chatRow, { borderColor: c.border, backgroundColor: c.card }]}>
              <View style={styles.chatRowText}>
                <Text style={[styles.chatPreview, { color: c.text }]} numberOfLines={2}>{item.last_message ?? 'New chat'}</Text>
                <Text style={[styles.subtitle, { color: c.muted }]}>{timeLabel(item.last_message_at)}</Text>
              </View>
              <View style={styles.chatRowRight}>
                <Text style={[styles.pill, item.status === 'resolved' ? { color: c.muted, borderColor: c.border } : { color: c.accent, borderColor: c.accent }]}>
                  {STATUS_LABEL[item.status]}
                </Text>
                {item.unread > 0 ? <View style={[styles.dot, { backgroundColor: c.accent }]} accessibilityLabel="Unread" /> : null}
              </View>
            </Pressable>
          )}
        />
      ) : (
        <FlatList
          data={thread?.messages ?? []}
          keyExtractor={(m) => m.id}
          contentContainerStyle={styles.list}
          ListEmptyComponent={chatId && !thread ? <ActivityIndicator color={c.muted} /> : <Text style={[styles.empty, { color: c.muted }]}>Ask anything about {appName}. You'll get an answer here.</Text>}
          ListFooterComponent={thread?.answering ? <ActivityIndicator style={styles.typing} color={c.muted} /> : null}
          renderItem={({ item }) => <Bubble message={item} colors={c} />}
        />
      )}

      {view === 'chat' && resolved ? (
        <View style={[styles.resolved, { borderColor: c.border, backgroundColor: c.card }]} accessibilityLiveRegion="polite">
          <Text style={[styles.resolvedTitle, { color: c.text }]}>This chat is resolved</Text>
          {thread?.rating === null ? (
            <>
              <Text style={[styles.subtitle, { color: c.muted }]}>How did we do?</Text>
              <View style={styles.faces}>
                {['😞', '🙁', '😐', '🙂', '😄'].map((face, i) => (
                  <Pressable key={face} onPress={() => void rate(i + 1)} accessibilityLabel={`${i + 1} of 5`} style={styles.face}>
                    <Text style={styles.faceText}>{face}</Text>
                  </Pressable>
                ))}
              </View>
            </>
          ) : <Text style={[styles.subtitle, { color: c.muted }]}>Thanks for your rating. Write below to start a new chat.</Text>}
        </View>
      ) : null}
      {error ? <Text style={[styles.error, { color: c.danger }]}>{error}</Text> : null}
      {view === 'chat' ? (
        <View style={[styles.composer, { borderColor: c.border, backgroundColor: c.card }]}>
          <TextInput
            value={draft}
            onChangeText={setDraft}
            placeholder={resolved ? 'Ask something new' : `Message ${appName}`}
            placeholderTextColor={c.muted}
            style={[styles.input, { color: c.text }]}
            multiline
            maxLength={4000}
          />
          <Pressable onPress={() => void send()} disabled={!draft.trim() || sending} style={[styles.send, { backgroundColor: c.accent, opacity: draft.trim() ? 1 : 0.4 }]} accessibilityLabel="Send">
            <Text style={styles.sendText}>↑</Text>
          </Pressable>
        </View>
      ) : null}
    </KeyboardAvoidingView>
  );
}

function Bubble({ message, colors: c }: { message: Message; colors: typeof palette.light }) {
  if (message.author === 'system') return <Text style={[styles.system, { color: c.muted }]}>{message.content}</Text>;
  const mine = message.author === 'customer';
  return (
    <View style={[styles.row, mine ? styles.right : styles.left]}>
      {message.author === 'maker' ? <Text style={[styles.who, { color: c.muted }]}>Team</Text> : null}
      <View style={[styles.bubble, mine ? { backgroundColor: c.accent } : { backgroundColor: c.card, borderColor: c.border, borderWidth: 1 }]}>
        <Text style={{ color: mine ? '#fff' : c.text, fontSize: 16, lineHeight: 22 }}>{message.content}</Text>
      </View>
      {message.sources.length ? (
        <View style={styles.chips}>
          {message.sources.map((s) => (
            <Text key={s.kind === 'article' ? s.id : 'history'} style={[styles.chip, { color: c.accent, borderColor: c.border }]}>
              {s.kind === 'article' ? s.title : 'Your chat history'}
            </Text>
          ))}
        </View>
      ) : null}
    </View>
  );
}

const palette = {
  light: { bg: '#F7F8FA', card: '#FFFFFF', text: '#0B0B0F', muted: '#596474', border: 'rgba(15,23,42,0.10)', accent: '#3C63FF', danger: '#C2410C' },
  dark: { bg: '#0B0B0F', card: '#16181D', text: '#F2F4F7', muted: '#98A2B3', border: 'rgba(255,255,255,0.10)', accent: '#6B8AFF', danger: '#FB923C' },
};

const styles = StyleSheet.create({
  screen: { flex: 1 },
  header: { flexDirection: 'row', alignItems: 'center', gap: 8, paddingHorizontal: 16, paddingVertical: 12, borderBottomWidth: 1 },
  headerText: { flex: 1 },
  headerButton: { minHeight: 44, justifyContent: 'center', paddingHorizontal: 4 },
  headerButtonText: { fontSize: 15, fontWeight: '600' },
  title: { fontSize: 17, fontWeight: '700' },
  subtitle: { fontSize: 13, marginTop: 2 },
  list: { padding: 16, gap: 10, flexGrow: 1 },
  empty: { textAlign: 'center', marginTop: 40, fontSize: 15 },
  typing: { alignSelf: 'flex-start', marginTop: 4 },
  chatRow: { flexDirection: 'row', alignItems: 'center', gap: 12, padding: 14, borderRadius: 16, borderWidth: 1 },
  chatRowText: { flex: 1, gap: 2 },
  chatPreview: { fontSize: 15, fontWeight: '600' },
  chatRowRight: { alignItems: 'flex-end', gap: 6 },
  pill: { fontSize: 12, fontWeight: '600', borderWidth: 1, borderRadius: 12, paddingHorizontal: 8, paddingVertical: 2, overflow: 'hidden' },
  dot: { width: 8, height: 8, borderRadius: 4 },
  row: { maxWidth: '85%', gap: 6 },
  left: { alignSelf: 'flex-start' },
  right: { alignSelf: 'flex-end' },
  who: { fontSize: 12 },
  bubble: { borderRadius: 20, paddingHorizontal: 14, paddingVertical: 10 },
  chips: { flexDirection: 'row', flexWrap: 'wrap', gap: 6 },
  chip: { fontSize: 13, fontWeight: '600', borderWidth: 1, borderRadius: 14, paddingHorizontal: 10, paddingVertical: 4, overflow: 'hidden' },
  system: { alignSelf: 'center', fontSize: 13, textAlign: 'center', paddingHorizontal: 24 },
  resolved: { marginHorizontal: 12, marginTop: 4, padding: 14, borderRadius: 16, borderWidth: 1, gap: 6 },
  resolvedTitle: { fontSize: 15, fontWeight: '600' },
  faces: { flexDirection: 'row', justifyContent: 'space-between' },
  face: { minWidth: 44, minHeight: 44, alignItems: 'center', justifyContent: 'center' },
  faceText: { fontSize: 26 },
  error: { paddingHorizontal: 16, paddingBottom: 6, fontSize: 13 },
  composer: { flexDirection: 'row', alignItems: 'flex-end', gap: 8, margin: 12, paddingLeft: 16, paddingRight: 6, paddingVertical: 6, borderRadius: 24, borderWidth: 1 },
  input: { flex: 1, fontSize: 16, maxHeight: 120, paddingVertical: 8 },
  send: { width: 38, height: 38, borderRadius: 19, alignItems: 'center', justifyContent: 'center' },
  sendText: { color: '#fff', fontSize: 18, fontWeight: '700' },
});
";

package/dist/index.js

@@ -15,6 +15,7 @@ import { registerCreds } from './commands/creds.js';
 import { registerBuild } from './commands/build.js';
 import { registerServices } from './commands/services.js';
 import { registerEmail } from './commands/email.js';
+import { registerSupport } from './commands/support.js';
 import { registerWebsite } from './commands/website.js';
 import { registerDomains } from './commands/domains.js';
 import { registerDns } from './commands/dns.js';
@@ -44,6 +45,7 @@ registerCreds(program);
 registerBuild(program);
 registerServices(program);
 registerEmail(program);
+registerSupport(program);
 registerWebsite(program);
 registerDomains(program);
 registerDns(program);

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.2.196';
+export const CLI_VERSION = '0.2.197';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runcloud",
-  "version": "0.2.196",
+  "version": "0.2.197",
   "description": "Create and control run.cloud remote mobile simulators and cloud sandboxes",
   "license": "Apache-2.0",
   "keywords": [