create-better-t-stack 3.10.0 → 3.11.0-pr749.5d055e3

package/bin/create-better-t-stack

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * Bin stub for create-better-t-stack.
+ * Finds and runs the platform-specific compiled binary.
+ *
+ * The binary is installed as an optional dependency:
+ *   @better-t-stack/cli-{platform}-{arch}
+ *
+ * This stub searches node_modules for the matching binary package.
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { platform as osPlatform, arch as osArch } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function run(target) {
+    const result = spawnSync(target, process.argv.slice(2), {
+        stdio: "inherit",
+    });
+    if (result.error) {
+        console.error(result.error.message);
+        process.exit(1);
+    }
+    const code = typeof result.status === "number" ? result.status : 0;
+    process.exit(code);
+}
+
+// Allow override via environment variable
+const envPath = process.env.CREATE_BETTER_T_STACK_BIN_PATH;
+if (envPath) {
+    run(envPath);
+}
+
+const scriptPath = realpathSync(__filename);
+const scriptDir = dirname(scriptPath);
+
+const platformMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+};
+
+const archMap = {
+    x64: "x64",
+    arm64: "arm64",
+};
+
+let platform = platformMap[osPlatform()];
+if (!platform) {
+    platform = osPlatform();
+}
+
+let arch = archMap[osArch()];
+if (!arch) {
+    arch = osArch();
+}
+
+// Scoped package name: @better-t-stack/cli-{platform}-{arch}
+const scopedPackage = "@better-t-stack/cli-" + platform + "-" + arch;
+const binary = platform === "windows" ? "create-better-t-stack.exe" : "create-better-t-stack";
+
+function findBinary(startDir) {
+    let current = startDir;
+    for (; ;) {
+        const modules = join(current, "node_modules");
+        if (existsSync(modules)) {
+            // Check for scoped package: node_modules/@better-t-stack/cli-{platform}-{arch}
+            const scopedPath = join(modules, "@better-t-stack", "cli-" + platform + "-" + arch);
+            const candidate = join(scopedPath, "bin", binary);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return;
+        }
+        current = parent;
+    }
+}
+
+const resolved = findBinary(scriptDir);
+
+if (!resolved) {
+    console.error(
+        'No binary found for your platform (' + platform + '-' + arch + ').\n' +
+        'You can try manually installing the "' + scopedPackage + '" package.',
+    );
+    process.exit(1);
+}
+
+run(resolved);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "3.10.0",
+  "version": "3.11.0-pr749.5d055e3",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "keywords": [
     "better-auth",
@@ -37,59 +37,55 @@
     "directory": "apps/cli"
   },
   "bin": {
-    "create-better-t-stack": "dist/cli.mjs"
+    "create-better-t-stack": "./bin/create-better-t-stack"
   },
   "files": [
-    "dist",
-    "templates"
+    "bin",
+    "templates",
+    "scripts/postinstall.mjs"
   ],
   "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
-    },
-    "./cli": {
-      "import": "./dist/cli.mjs"
-    }
-  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsdown --publint",
-    "dev": "tsdown --watch",
+    "build": "bun run scripts/build.ts",
+    "build:local": "bun run scripts/build.ts --single",
+    "dev": "bun run src/cli.ts",
     "check-types": "tsc --noEmit",
-    "test": "bun run build && bun test",
-    "test:watch": "bun run build && bun test --watch",
-    "test:coverage": "bun run build && bun test --coverage",
-    "test:ci": "bun run build && AGENT=1 bun test --bail=5",
-    "prepublishOnly": "npm run build"
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage",
+    "test:ci": "AGENT=1 bun test --bail=5",
+    "prepublishOnly": "echo 'Build binaries separately before publishing'",
+    "postinstall": "node ./scripts/postinstall.mjs || true"
   },
   "dependencies": {
-    "@better-t-stack/types": "^3.10.0",
+    "@better-t-stack/types": "3.11.0-pr749.5d055e3",
     "@clack/prompts": "^1.0.0-alpha.8",
-    "@orpc/server": "^1.12.2",
+    "commander": "^14.0.2",
     "consola": "^3.4.2",
-    "execa": "^9.6.1",
-    "fs-extra": "^11.3.2",
+    "fs-extra": "^11.3.3",
     "gradient-string": "^3.0.0",
     "handlebars": "^4.7.8",
     "jsonc-parser": "^3.3.1",
-    "oxfmt": "^0.19.0",
     "picocolors": "^1.1.1",
     "tinyglobby": "^0.2.15",
-    "trpc-cli": "^0.12.1",
     "ts-morph": "^27.0.2",
     "yaml": "^2.8.2",
-    "zod": "^4.1.13"
+    "zod": "^4.2.1"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.17",
+    "@types/bun": "^1.3.5",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^24.10.2",
-    "publint": "^0.3.16",
-    "tsdown": "^0.17.2",
+    "@types/node": "^25.0.3",
     "typescript": "^5.9.3"
+  },
+  "optionalDependencies": {
+    "@better-t-stack/cli-darwin-arm64": "3.11.0",
+    "@better-t-stack/cli-darwin-x64": "3.11.0",
+    "@better-t-stack/cli-linux-arm64": "3.11.0",
+    "@better-t-stack/cli-linux-x64": "3.11.0",
+    "@better-t-stack/cli-windows-x64": "3.11.0"
   }
 }

package/scripts/postinstall.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for create-better-t-stack.
+ * Symlinks the platform-specific binary to the bin directory for convenience.
+ *
+ * This runs after npm install to set up the binary.
+ */
+
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+function detectPlatformAndArch() {
+  let platform;
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin";
+      break;
+    case "linux":
+      platform = "linux";
+      break;
+    case "win32":
+      platform = "windows";
+      break;
+    default:
+      platform = os.platform();
+      break;
+  }
+
+  let arch;
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64";
+      break;
+    case "arm64":
+      arch = "arm64";
+      break;
+    default:
+      arch = os.arch();
+      break;
+  }
+
+  return { platform, arch };
+}
+
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch();
+  // Scoped package: @better-t-stack/cli-{platform}-{arch}
+  const packageName = `@better-t-stack/cli-${platform}-${arch}`;
+  const binaryName = platform === "windows" ? "create-better-t-stack.exe" : "create-better-t-stack";
+
+  try {
+    // Use require.resolve to find the package
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageDir = path.dirname(packageJsonPath);
+    const binaryPath = path.join(packageDir, "bin", binaryName);
+
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error(`Binary not found at ${binaryPath}`);
+    }
+
+    return { binaryPath, binaryName };
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`);
+  }
+}
+
+function prepareBinDirectory(binaryName) {
+  const binDir = path.join(__dirname, "..", "bin");
+  const targetPath = path.join(binDir, binaryName);
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  // Remove existing binary/symlink if it exists
+  try {
+    if (fs.existsSync(targetPath) || fs.lstatSync(targetPath).isSymbolicLink()) {
+      fs.unlinkSync(targetPath);
+    }
+  } catch {
+    // File doesn't exist, that's fine
+  }
+
+  return { binDir, targetPath };
+}
+
+function symlinkBinary(sourcePath, binaryName) {
+  const { targetPath } = prepareBinDirectory(binaryName);
+
+  fs.symlinkSync(sourcePath, targetPath);
+  console.log(`create-better-t-stack binary symlinked: ${targetPath} -> ${sourcePath}`);
+
+  // Verify the file exists after operation
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Failed to symlink binary to ${targetPath}`);
+  }
+}
+
+async function main() {
+  try {
+    if (os.platform() === "win32") {
+      // On Windows, symlinks require admin privileges
+      // The bin stub will find the binary directly
+      console.log("Windows detected: skipping symlink (bin stub will find binary directly)");
+      return;
+    }
+
+    const { binaryPath, binaryName } = findBinary();
+    symlinkBinary(binaryPath, binaryName);
+  } catch (error) {
+    // Don't fail the install if we can't symlink - the bin stub will still work
+    console.log(`Note: Could not symlink binary (${error.message}). The CLI will still work.`);
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  // Silently continue - postinstall failures shouldn't break the install
+  console.log("Postinstall completed with warnings.");
+}

package/templates/auth/better-auth/convex/backend/convex/auth.ts.hbs

@@ -64,7 +64,7 @@ export { createAuth };
 export const getCurrentUser = query({
   args: {},
   returns: v.any(),
-  handler: async function (ctx, args) {
+  handler: async function (ctx) {
     return authComponent.getAuthUser(ctx);
   },
 });

package/templates/backend/convex/packages/backend/convex/convex.config.ts.hbs

@@ -0,0 +1,17 @@
+import { defineApp } from "convex/server";
+{{#if (eq auth "better-auth")}}
+import betterAuth from "@convex-dev/better-auth/convex.config";
+{{/if}}
+{{#if (includes examples "ai")}}
+import agent from "@convex-dev/agent/convex.config";
+{{/if}}
+
+const app = defineApp();
+{{#if (eq auth "better-auth")}}
+app.use(betterAuth);
+{{/if}}
+{{#if (includes examples "ai")}}
+app.use(agent);
+{{/if}}
+
+export default app;

package/templates/examples/ai/convex/packages/backend/convex/agent.ts.hbs

@@ -0,0 +1,9 @@
+import { Agent } from "@convex-dev/agent";
+import { google } from "@ai-sdk/google";
+import { components } from "./_generated/api";
+
+export const chatAgent = new Agent(components.agent, {
+  name: "Chat Agent",
+  languageModel: google("gemini-2.5-flash"),
+  instructions: "You are a helpful AI assistant. Be concise and friendly in your responses.",
+});

package/templates/examples/ai/convex/packages/backend/convex/chat.ts.hbs

@@ -0,0 +1,67 @@
+import {
+  createThread,
+  listUIMessages,
+  saveMessage,
+  syncStreams,
+  vStreamArgs,
+} from "@convex-dev/agent";
+import { paginationOptsValidator } from "convex/server";
+import { v } from "convex/values";
+
+import { components, internal } from "./_generated/api";
+import { internalAction, mutation, query } from "./_generated/server";
+import { chatAgent } from "./agent";
+
+export const createNewThread = mutation({
+  args: {},
+  handler: async (ctx) => {
+    const threadId = await createThread(ctx, components.agent, {});
+    return threadId;
+  },
+});
+
+export const listMessages = query({
+  args: {
+    threadId: v.string(),
+    paginationOpts: paginationOptsValidator,
+    streamArgs: vStreamArgs,
+  },
+  handler: async (ctx, args) => {
+    const paginated = await listUIMessages(ctx, components.agent, args);
+    const streams = await syncStreams(ctx, components.agent, args);
+    return { ...paginated, streams };
+  },
+});
+
+export const sendMessage = mutation({
+  args: {
+    threadId: v.string(),
+    prompt: v.string(),
+  },
+  handler: async (ctx, { threadId, prompt }) => {
+    const { messageId } = await saveMessage(ctx, components.agent, {
+      threadId,
+      prompt,
+    });
+    await ctx.scheduler.runAfter(0, internal.chat.generateResponseAsync, {
+      threadId,
+      promptMessageId: messageId,
+    });
+    return messageId;
+  },
+});
+
+export const generateResponseAsync = internalAction({
+  args: {
+    threadId: v.string(),
+    promptMessageId: v.string(),
+  },
+  handler: async (ctx, { threadId, promptMessageId }) => {
+    await chatAgent.streamText(
+      ctx,
+      { threadId },
+      { promptMessageId },
+      { saveStreamDeltas: true },
+    );
+  },
+});