@chat-js/cli 0.3.0 → 0.6.0

package/templates/chat-app/lib/db/migrations/meta/_journal.json

@@ -309,6 +309,13 @@
       "when": 1769940346934,
       "tag": "0043_lyrical_pride",
       "breakpoints": true
+    },
+    {
+      "idx": 44,
+      "version": "7",
+      "when": 1773499312081,
+      "tag": "0044_gray_red_shift",
+      "breakpoints": true
     }
   ]
 }

package/templates/chat-app/lib/db/queries.ts

@@ -17,6 +17,7 @@ import type {
   ToolName,
   ToolOutput,
 } from "@/lib/ai/types";
+import { isSelectedModelValue } from "@/lib/ai/types";
 import { createModuleLogger } from "@/lib/logger";
 import { chatMessageToDbMessage } from "@/lib/message-conversion";
 
@@ -79,6 +80,35 @@ export async function saveChat({
   }
 }
 
+export async function saveChatIfNotExists({
+  id,
+  userId,
+  title,
+  projectId,
+}: {
+  id: string;
+  userId: string;
+  title: string;
+  projectId?: string;
+}) {
+  try {
+    return await db
+      .insert(chat)
+      .values({
+        id,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        userId,
+        title,
+        projectId: projectId ?? null,
+      })
+      .onConflictDoNothing();
+  } catch (error) {
+    console.error("Failed to save chat in database");
+    throw error;
+  }
+}
+
 export async function deleteChatById({ id }: { id: string }) {
   try {
     // Get all messages for this chat to clean up their attachments
@@ -341,6 +371,43 @@ export async function saveMessage({
   }
 }
 
+export async function saveMessageIfNotExists({
+  id,
+  chatId,
+  message: chatMessage,
+}: {
+  id: string;
+  chatId: string;
+  message: ChatMessage;
+}) {
+  try {
+    return await db.transaction(async (tx) => {
+      const dbMessage = chatMessageToDbMessage(chatMessage, chatId);
+      dbMessage.id = id;
+
+      const insertedMessages = await tx
+        .insert(message)
+        .values(dbMessage)
+        .onConflictDoNothing()
+        .returning({ id: message.id });
+
+      if (insertedMessages.length === 0) {
+        return;
+      }
+
+      const mappedDBParts = mapUIMessagePartsToDBParts(chatMessage.parts, id);
+      if (mappedDBParts.length > 0) {
+        await tx.insert(part).values(mappedDBParts);
+      }
+
+      await updateChatUpdatedAt({ chatId });
+    });
+  } catch (error) {
+    logger.error({ error, chatId, id }, "saveMessageIfNotExists failed");
+    throw error;
+  }
+}
+
 export async function saveChatMessages({
   messages,
 }: {
@@ -413,6 +480,11 @@ export async function updateMessage({
           attachments: dbMessage.attachments,
           createdAt: dbMessage.createdAt,
           parentMessageId: dbMessage.parentMessageId,
+          selectedModel: dbMessage.selectedModel,
+          selectedTool: dbMessage.selectedTool,
+          parallelGroupId: dbMessage.parallelGroupId,
+          parallelIndex: dbMessage.parallelIndex,
+          isPrimaryParallel: dbMessage.isPrimaryParallel,
           lastContext: dbMessage.lastContext,
           activeStreamId: dbMessage.activeStreamId,
         })
@@ -492,8 +564,12 @@ export async function getAllMessagesByChatId({
           createdAt: msg.createdAt,
           activeStreamId: msg.activeStreamId,
           parentMessageId: msg.parentMessageId,
-          selectedModel: (msg.selectedModel ||
-            "") as ChatMessage["metadata"]["selectedModel"],
+          parallelGroupId: msg.parallelGroupId,
+          parallelIndex: msg.parallelIndex,
+          isPrimaryParallel: msg.isPrimaryParallel,
+          selectedModel: isSelectedModelValue(msg.selectedModel)
+            ? msg.selectedModel
+            : ("" as ChatMessage["metadata"]["selectedModel"]),
           selectedTool: (msg.selectedTool ||
             undefined) as ChatMessage["metadata"]["selectedTool"],
           usage: msg.lastContext as ChatMessage["metadata"]["usage"],
@@ -797,8 +873,12 @@ export async function getChatMessageWithPartsById({
           createdAt: dbMessage.createdAt,
           activeStreamId: dbMessage.activeStreamId,
           parentMessageId: dbMessage.parentMessageId,
-          selectedModel: (dbMessage.selectedModel ||
-            "") as ChatMessage["metadata"]["selectedModel"],
+          parallelGroupId: dbMessage.parallelGroupId,
+          parallelIndex: dbMessage.parallelIndex,
+          isPrimaryParallel: dbMessage.isPrimaryParallel,
+          selectedModel: isSelectedModelValue(dbMessage.selectedModel)
+            ? dbMessage.selectedModel
+            : ("" as ChatMessage["metadata"]["selectedModel"]),
           selectedTool: (dbMessage.selectedTool ||
             undefined) as ChatMessage["metadata"]["selectedTool"],
           usage: dbMessage.lastContext as ChatMessage["metadata"]["usage"],

package/templates/chat-app/lib/db/schema.ts

@@ -113,8 +113,11 @@ export const message = pgTable("Message", {
   attachments: json("attachments").notNull(),
   createdAt: timestamp("createdAt").notNull(),
   annotations: json("annotations"),
-  selectedModel: varchar("selectedModel", { length: 256 }).default(""),
+  selectedModel: json("selectedModel"),
   selectedTool: varchar("selectedTool", { length: 256 }).default(""),
+  parallelGroupId: uuid("parallelGroupId"),
+  parallelIndex: integer("parallelIndex"),
+  isPrimaryParallel: boolean("isPrimaryParallel"),
   lastContext: json("lastContext"),
   activeStreamId: varchar("activeStreamId", { length: 64 }),
   /** Timestamp when this message's stream was canceled by the user. Null means not canceled. */

package/templates/chat-app/lib/editor/config.ts

@@ -8,8 +8,8 @@ import {
   type HeadingTagType,
   QuoteNode,
 } from "@lexical/rich-text";
-import type { LexicalEditor } from "lexical";
-import { $getSelection, $insertNodes } from "lexical";
+import type { EditorState, LexicalEditor } from "lexical";
+import { $getSelection, $insertNodes, type TextNode } from "lexical";
 
 // Create initial editor configuration
 export function createEditorConfig() {
@@ -37,7 +37,7 @@ function _createHeadingTransform(level: number) {
     export: null,
     importDOM: null,
     regExp: new RegExp(`^(#{1,${level}})\\s$`),
-    replace: (_textNode: any) => {
+    replace: (_textNode: TextNode) => {
       const selection = $getSelection();
       if (selection) {
         const headingTag = `h${level}` as HeadingTagType;
@@ -56,7 +56,7 @@ export const handleEditorChange = ({
   editor,
   onSaveContent,
 }: {
-  editorState: any;
+  editorState: EditorState;
   editor: LexicalEditor;
   onSaveContent: (updatedContent: string, debounce: boolean) => void;
 }) => {

package/templates/chat-app/lib/electron-auth.ts

@@ -0,0 +1,96 @@
+import { config } from "@/lib/config";
+import type { SocialAuthSignInOptions } from "@/lib/social-auth";
+
+export const ELECTRON_AUTH_CLIENT_ID = "electron";
+export const ELECTRON_AUTH_COOKIE_PREFIX = "better-auth";
+export const ELECTRON_AUTH_CALLBACK_PATH = "/auth/callback";
+export const ELECTRON_APP_SCHEME = config.appPrefix;
+// @better-auth/electron uses `${scheme}:/...` for its synthetic Origin header
+// and deep-link callback URLs. Keep the legacy `scheme://` form alongside it so
+// existing packaged registrations continue to validate too.
+export const ELECTRON_TRUSTED_ORIGINS = [
+  `${ELECTRON_APP_SCHEME}:/`,
+  `${ELECTRON_APP_SCHEME}://`,
+] as const;
+
+export function isDesktopAppEnabled(): boolean {
+  return config.desktopApp.enabled;
+}
+
+export function isElectronRenderer(): boolean {
+  return (
+    isDesktopAppEnabled() &&
+    typeof window !== "undefined" &&
+    typeof window.requestAuth === "function"
+  );
+}
+
+type SearchParamValue = string | string[] | undefined;
+
+export function toSearchParamRecord(
+  searchParams: Record<string, SearchParamValue>
+): Record<string, string> {
+  const query: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(searchParams)) {
+    if (typeof value === "string") {
+      query[key] = value;
+      continue;
+    }
+
+    if (Array.isArray(value) && value[0]) {
+      query[key] = value[0];
+    }
+  }
+
+  return query;
+}
+
+export function buildAuthPageHref(
+  pathname: string,
+  searchParams: Record<string, SearchParamValue>
+): string {
+  const query = new URLSearchParams(
+    toSearchParamRecord(searchParams)
+  ).toString();
+  return query ? `${pathname}?${query}` : pathname;
+}
+
+export function isElectronTransferQuery(
+  query: Record<string, string>
+): boolean {
+  return query.client_id === ELECTRON_AUTH_CLIENT_ID;
+}
+
+export function buildSocialAuthRequest(
+  query: Record<string, string>,
+  origin?: string
+): {
+  callbackURL?: string;
+  onRedirectToUrl?: (url: string) => void;
+  signInOptions?: SocialAuthSignInOptions;
+} {
+  const isElectronTransfer =
+    isDesktopAppEnabled() && isElectronTransferQuery(query);
+  const deviceLoginCallbackURL = origin
+    ? new URL("/device-login", origin).toString()
+    : "/device-login";
+
+  if (isElectronTransfer) {
+    return {
+      callbackURL: deviceLoginCallbackURL,
+      onRedirectToUrl: (url: string) => {
+        globalThis.location?.assign(url);
+      },
+      signInOptions: {
+        disableRedirect: true,
+        errorCallbackURL: deviceLoginCallbackURL,
+        newUserCallbackURL: deviceLoginCallbackURL,
+      },
+    };
+  }
+
+  return {
+    callbackURL: query.returnTo,
+  };
+}

package/templates/chat-app/lib/env-schema.ts

@@ -1,4 +1,9 @@
 import { z } from "zod";
+import { isPlaywrightTestEnvironment } from "@/lib/playwright-test-environment";
+
+const isPlaywrightTestEnvironmentEnabled = isPlaywrightTestEnvironment(
+  process.env
+);
 
 /**
  * Server environment variable schemas with descriptions.
@@ -12,10 +17,23 @@ import { z } from "zod";
  */
 export const serverEnvSchema = {
   // Required core
-  DATABASE_URL: z.string().min(1).describe("Postgres connection string"),
+  DATABASE_URL: z
+    .preprocess(
+      (value) =>
+        isPlaywrightTestEnvironmentEnabled && (value == null || value === "")
+          ? "postgres://postgres:postgres@127.0.0.1:5432/playwright"
+          : value,
+      z.string().min(1)
+    )
+    .describe("Postgres connection string"),
   AUTH_SECRET: z
-    .string()
-    .min(1)
+    .preprocess(
+      (value) =>
+        isPlaywrightTestEnvironmentEnabled && (value == null || value === "")
+          ? "playwright-test-auth-secret"
+          : value,
+      z.string().min(1)
+    )
     .describe("NextAuth.js secret for signing session tokens"),
 
   // Optional blob storage (enable in chat.config.ts)
@@ -102,8 +120,19 @@ export const serverEnvSchema = {
     .describe("Vercel API token for sandbox (non-Vercel deployments)"),
   VERCEL_SANDBOX_RUNTIME: z
     .string()
+    .min(1)
+    .optional()
+    .describe("Legacy default Vercel sandbox runtime identifier for Python"),
+  VERCEL_SANDBOX_RUNTIME_PYTHON: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("Vercel sandbox runtime identifier for Python execution"),
+  VERCEL_SANDBOX_RUNTIME_JAVASCRIPT: z
+    .string()
+    .min(1)
     .optional()
-    .describe("Vercel sandbox runtime identifier"),
+    .describe("Vercel sandbox runtime identifier for JavaScript execution"),
 
   // App URL (for non-Vercel deployments) - full URL including https://
   APP_URL: z

package/templates/chat-app/lib/message-conversion.ts

@@ -1,7 +1,11 @@
 import type { ModelId } from "@/lib/ai/app-models";
 import type { Chat, DBMessage } from "@/lib/db/schema";
 import type { UIChat } from "@/lib/types/ui-chat";
-import type { ChatMessage, UiToolName } from "./ai/types";
+import {
+  type ChatMessage,
+  isSelectedModelValue,
+  type UiToolName,
+} from "./ai/types";
 
 // Helper functions for type conversion
 export function dbChatToUIChat(chat: Chat): UIChat {
@@ -29,7 +33,12 @@ function _dbMessageToChatMessage(message: DBMessage): ChatMessage {
       createdAt: message.createdAt,
       activeStreamId: message.activeStreamId,
       parentMessageId: message.parentMessageId,
-      selectedModel: (message.selectedModel as ModelId) || ("" as ModelId),
+      parallelGroupId: message.parallelGroupId,
+      parallelIndex: message.parallelIndex,
+      isPrimaryParallel: message.isPrimaryParallel,
+      selectedModel: isSelectedModelValue(message.selectedModel)
+        ? message.selectedModel
+        : ("" as ModelId),
       selectedTool: (message.selectedTool as UiToolName | null) || undefined,
       usage: message.lastContext as ChatMessage["metadata"]["usage"],
     },
@@ -66,6 +75,9 @@ export function chatMessageToDbMessage(
     parentMessageId,
     selectedModel,
     selectedTool: message.metadata?.selectedTool || null,
+    parallelGroupId: message.metadata?.parallelGroupId || null,
+    parallelIndex: message.metadata?.parallelIndex ?? null,
+    isPrimaryParallel: message.metadata?.isPrimaryParallel ?? null,
     activeStreamId: message.metadata?.activeStreamId || null,
     canceledAt: null,
   };

package/templates/chat-app/lib/playwright-test-environment.ts

@@ -0,0 +1,18 @@
+function isEnabledFlag(value: string | undefined): boolean {
+  if (!value) {
+    return false;
+  }
+
+  const normalizedValue = value.trim().toLowerCase();
+  return !["0", "false", "no", "off"].includes(normalizedValue);
+}
+
+export function isPlaywrightTestEnvironment(
+  env: NodeJS.ProcessEnv = process.env
+): boolean {
+  return Boolean(
+    env.PLAYWRIGHT_TEST_BASE_URL ||
+      isEnabledFlag(env.PLAYWRIGHT) ||
+      isEnabledFlag(env.CI_PLAYWRIGHT)
+  );
+}

package/templates/chat-app/lib/social-auth.ts

@@ -0,0 +1,5 @@
+export type SocialAuthSignInOptions = {
+  disableRedirect?: boolean;
+  errorCallbackURL?: string;
+  newUserCallbackURL?: string;
+};

package/templates/chat-app/lib/stores/hooks-threads.ts

@@ -7,7 +7,7 @@ import {
   type CustomChatStoreState,
   useCustomChatStoreApi,
 } from "./custom-store-provider";
-import type { MessageSiblingInfo } from "./with-threads";
+import type { MessageSiblingInfo, ParallelGroupInfo } from "./with-threads";
 
 function useThreadStore<T>(
   selector: (store: CustomChatStoreState<ChatMessage>) => T,
@@ -95,3 +95,40 @@ export const useSwitchToSibling = () => {
     [store]
   );
 };
+
+export function useParallelGroupInfo(
+  messageId: string
+): ParallelGroupInfo<ChatMessage> | null {
+  return useThreadStore(
+    (state) => state.getParallelGroupInfo(messageId),
+    (a, b) => {
+      if (a === null && b === null) {
+        return true;
+      }
+
+      if (a === null || b === null) {
+        return false;
+      }
+
+      return (
+        a.parallelGroupId === b.parallelGroupId &&
+        a.selectedMessageId === b.selectedMessageId &&
+        a.messages.length === b.messages.length &&
+        a.messages.every(
+          (msg, i) =>
+            msg.id === b.messages[i]?.id &&
+            msg.metadata?.activeStreamId ===
+              b.messages[i]?.metadata?.activeStreamId
+        )
+      );
+    }
+  );
+}
+
+export const useSwitchToMessage = () => {
+  const store = useCustomChatStoreApi<ChatMessage>();
+  return useCallback(
+    (messageId: string) => store.getState().switchToMessage(messageId),
+    [store]
+  );
+};

package/templates/chat-app/lib/stores/with-threads.test.ts

@@ -0,0 +1,137 @@
+import assert from "node:assert/strict";
+import type { StoreState as BaseChatStoreState } from "@ai-sdk-tools/store";
+import { describe, it } from "vitest";
+import { createStore } from "zustand/vanilla";
+import type { ChatMessage } from "../ai/types";
+import { type ThreadAugmentedState, withThreads } from "./with-threads";
+
+function createMessage({
+  id,
+  role,
+  createdAt,
+  parentMessageId = null,
+  parallelGroupId = null,
+  parallelIndex = null,
+  activeStreamId = null,
+}: {
+  id: string;
+  role: ChatMessage["role"];
+  createdAt: string;
+  parentMessageId?: string | null;
+  parallelGroupId?: string | null;
+  parallelIndex?: number | null;
+  activeStreamId?: string | null;
+}): ChatMessage {
+  return {
+    id,
+    role,
+    parts: [],
+    metadata: {
+      createdAt: new Date(createdAt),
+      parentMessageId,
+      parallelGroupId,
+      parallelIndex,
+      isPrimaryParallel: parallelIndex === null ? null : parallelIndex === 0,
+      selectedModel: "openai/gpt-4o-mini",
+      activeStreamId,
+      selectedTool: undefined,
+    },
+  };
+}
+
+function createThreadStore(initialMessages: ChatMessage[]) {
+  return createStore<ThreadAugmentedState<ChatMessage>>()(
+    withThreads<ChatMessage, BaseChatStoreState<ChatMessage>>(
+      (set) =>
+        ({
+          messages: initialMessages,
+          setMessages: (messages: ChatMessage[]) => set({ messages }),
+        }) as BaseChatStoreState<ChatMessage>
+    )
+  );
+}
+
+describe("withThreads", () => {
+  it("preserves local-only optimistic branch nodes across server syncs", () => {
+    const rootUser = createMessage({
+      id: "user-root",
+      role: "user",
+      createdAt: "2024-01-01T00:00:00.000Z",
+    });
+    const branchA = createMessage({
+      id: "assistant-a",
+      role: "assistant",
+      createdAt: "2024-01-01T00:00:01.000Z",
+      parentMessageId: rootUser.id,
+      parallelGroupId: "group-root",
+      parallelIndex: 0,
+    });
+    const branchB = createMessage({
+      id: "assistant-b",
+      role: "assistant",
+      createdAt: "2024-01-01T00:00:02.000Z",
+      parentMessageId: rootUser.id,
+      parallelGroupId: "group-root",
+      parallelIndex: 1,
+    });
+    const nestedUser = createMessage({
+      id: "user-nested",
+      role: "user",
+      createdAt: "2024-01-01T00:00:03.000Z",
+      parentMessageId: branchA.id,
+    });
+    const nestedBranchA = createMessage({
+      id: "assistant-nested-a",
+      role: "assistant",
+      createdAt: "2024-01-01T00:00:04.000Z",
+      parentMessageId: nestedUser.id,
+      parallelGroupId: "group-nested",
+      parallelIndex: 0,
+      activeStreamId: "pending:assistant-nested-a",
+    });
+    const nestedBranchB = createMessage({
+      id: "assistant-nested-b",
+      role: "assistant",
+      createdAt: "2024-01-01T00:00:05.000Z",
+      parentMessageId: nestedUser.id,
+      parallelGroupId: "group-nested",
+      parallelIndex: 1,
+      activeStreamId: "pending:assistant-nested-b",
+    });
+
+    const store = createThreadStore([
+      rootUser,
+      branchA,
+      nestedUser,
+      nestedBranchA,
+    ]);
+
+    store.getState().addMessageToTree(branchB);
+    store.getState().addMessageToTree(nestedBranchB);
+
+    store.getState().setMessagesWithEpoch([rootUser, branchB]);
+    store.getState().setAllMessages([rootUser, branchA, branchB]);
+
+    const allMessageIds = store
+      .getState()
+      .allMessages.map((message: ChatMessage) => message.id);
+    assert.deepEqual(allMessageIds, [
+      "user-root",
+      "assistant-a",
+      "assistant-b",
+      "user-nested",
+      "assistant-nested-a",
+      "assistant-nested-b",
+    ]);
+
+    const restoredThread = store.getState().switchToMessage(branchA.id);
+    assert.deepEqual(
+      restoredThread?.map((message: ChatMessage) => message.id),
+      ["user-root", "assistant-a", "user-nested", "assistant-nested-b"]
+    );
+    assert.equal(
+      restoredThread?.at(-1)?.metadata.activeStreamId,
+      "pending:assistant-nested-b"
+    );
+  });
+});