tthr 0.3.21 → 0.3.23

package/dist/index.js

@@ -17,23 +17,53 @@ import {
 
 // src/index.ts
 import { Command } from "commander";
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 import { fileURLToPath } from "url";
-import path8 from "path";
+import path9 from "path";
+
+// src/utils/dotenv.ts
+import fs from "fs-extra";
+import path from "path";
+function loadDotenv(cwd = process.cwd()) {
+  applyEnvFile(path.resolve(cwd, ".env.local"));
+}
+function applyEnvFile(envPath) {
+  if (!fs.existsSync(envPath)) return;
+  let content;
+  try {
+    content = fs.readFileSync(envPath, "utf-8");
+  } catch {
+    return;
+  }
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!key || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+    if (Object.prototype.hasOwnProperty.call(process.env, key)) continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    process.env[key] = value;
+  }
+}
 
 // src/commands/init.ts
 import chalk2 from "chalk";
 import ora2 from "ora";
 import prompts from "prompts";
-import fs2 from "fs-extra";
-import path2 from "path";
+import fs3 from "fs-extra";
+import path3 from "path";
 import { execSync } from "child_process";
 
 // src/commands/deploy.ts
 import chalk from "chalk";
 import ora from "ora";
-import fs from "fs-extra";
-import path from "path";
+import fs2 from "fs-extra";
+import path2 from "path";
 import * as esbuild from "esbuild";
 async function describeHttpError(response, action) {
   const status = response.status;
@@ -73,8 +103,8 @@ async function describeHttpError(response, action) {
 }
 async function deployCommand(options) {
   const credentials = await requireAuth();
-  const configPath = path.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs.pathExists(configPath)) {
+  const configPath = path2.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs2.pathExists(configPath)) {
     console.log(chalk.red("\nError: Not a Tether project"));
     console.log(chalk.dim("Run `tthr init` to create a new project\n"));
     process.exit(1);
@@ -82,9 +112,9 @@ async function deployCommand(options) {
   const config = await loadConfig();
   let projectId = config.projectId;
   if (!projectId) {
-    const envPath = path.resolve(process.cwd(), ".env");
-    if (await fs.pathExists(envPath)) {
-      const envContent = await fs.readFile(envPath, "utf-8");
+    const envPath = path2.resolve(process.cwd(), ".env");
+    if (await fs2.pathExists(envPath)) {
+      const envContent = await fs2.readFile(envPath, "utf-8");
       const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
       projectId = match?.[1]?.trim();
     }
@@ -99,7 +129,8 @@ async function deployCommand(options) {
   console.log(chalk.bold("\n\u26A1 Deploying to Tether\n"));
   console.log(chalk.dim(`  Project: ${projectId}`));
   console.log(chalk.dim(`  Environment: ${environment}`));
-  console.log(chalk.dim(`  API: ${API_URL2}
+  console.log(chalk.dim(`  API: ${API_URL2}`));
+  console.log(chalk.dim(`  \u21B3 override with TETHER_API_URL in your shell or .env.local
 `));
   console.log(chalk.dim("  Generating types..."));
   try {
@@ -124,15 +155,15 @@ async function deploySchemaToServer(projectId, token, schemaPath, environment, d
   const API_URL2 = apiUrl || `${await resolveApiUrl()}/api/v1`;
   const spinner = ora("Reading schema...").start();
   try {
-    if (!await fs.pathExists(schemaPath)) {
+    if (!await fs2.pathExists(schemaPath)) {
       spinner.warn("No schema file found");
-      const relativePath = path.relative(process.cwd(), schemaPath);
+      const relativePath = path2.relative(process.cwd(), schemaPath);
       console.log(chalk.dim(`  Create ${relativePath} to define your database schema
 `));
       return;
     }
     console.log(chalk.dim(`  Schema path: ${schemaPath}`));
-    const schemaSource = await fs.readFile(schemaPath, "utf-8");
+    const schemaSource = await fs2.readFile(schemaPath, "utf-8");
     console.log(chalk.dim(`  Schema source length: ${schemaSource.length} chars`));
     console.log(chalk.dim(`  Parsing schema...`));
     const tables = parseSchema(schemaSource);
@@ -220,14 +251,14 @@ async function deployFunctionsToServer(projectId, token, functionsDir, environme
   const API_URL2 = apiUrl || `${await resolveApiUrl()}/api/v1`;
   const spinner = ora("Reading functions...").start();
   try {
-    if (!await fs.pathExists(functionsDir)) {
+    if (!await fs2.pathExists(functionsDir)) {
       spinner.warn("No functions directory found");
-      const relativePath = path.relative(process.cwd(), functionsDir);
+      const relativePath = path2.relative(process.cwd(), functionsDir);
       console.log(chalk.dim(`  Create ${relativePath}/ to define your API functions
 `));
       return;
     }
-    const files = await fs.readdir(functionsDir);
+    const files = await fs2.readdir(functionsDir);
     const tsFiles = files.filter((f) => f.endsWith(".ts") && !f.startsWith("_"));
     const helperFiles = files.filter((f) => f.endsWith(".ts") && f.startsWith("_"));
     if (tsFiles.length === 0) {
@@ -236,13 +267,13 @@ async function deployFunctionsToServer(projectId, token, functionsDir, environme
     }
     const helperSources = /* @__PURE__ */ new Map();
     for (const hf of helperFiles) {
-      const hfPath = path.join(functionsDir, hf);
-      helperSources.set(hf, await fs.readFile(hfPath, "utf-8"));
+      const hfPath = path2.join(functionsDir, hf);
+      helperSources.set(hf, await fs2.readFile(hfPath, "utf-8"));
     }
     const functions = [];
     for (const file of tsFiles) {
-      const filePath = path.join(functionsDir, file);
-      const source = await fs.readFile(filePath, "utf-8");
+      const filePath = path2.join(functionsDir, file);
+      const source = await fs2.readFile(filePath, "utf-8");
       const moduleName = file.replace(".ts", "");
       const parsedFunctions = parseFunctions(moduleName, source);
       if (parsedFunctions.length === 0) continue;
@@ -676,8 +707,8 @@ ${packageManager} is not installed on your system.`));
     });
     template = response.template || "nuxt";
   }
-  const projectPath = path2.resolve(process.cwd(), projectName);
-  if (await fs2.pathExists(projectPath)) {
+  const projectPath = path3.resolve(process.cwd(), projectName);
+  if (await fs3.pathExists(projectPath)) {
     const { overwrite } = await prompts({
       type: "confirm",
       name: "overwrite",
@@ -688,7 +719,7 @@ ${packageManager} is not installed on your system.`));
       console.log(chalk2.yellow("Cancelled"));
       process.exit(0);
     }
-    await fs2.remove(projectPath);
+    await fs3.remove(projectPath);
   }
   const spinner = ora2(`Scaffolding ${template} project...`).start();
   let projectId;
@@ -764,7 +795,7 @@ function getPackageRunnerCommand(pm) {
   }
 }
 async function scaffoldNuxtProject(projectName, projectPath, spinner, packageManager) {
-  const parentDir = path2.dirname(projectPath);
+  const parentDir = path3.dirname(projectPath);
   const runner = getPackageRunnerCommand(packageManager);
   spinner.stop();
   console.log(chalk2.dim("\nRunning nuxi init...\n"));
@@ -773,7 +804,7 @@ async function scaffoldNuxtProject(projectName, projectPath, spinner, packageMan
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs2.pathExists(path2.join(projectPath, "package.json"))) {
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
       throw new Error("Nuxt project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -786,7 +817,7 @@ async function scaffoldNuxtProject(projectName, projectPath, spinner, packageMan
   }
 }
 async function scaffoldNextProject(projectName, projectPath, spinner, packageManager) {
-  const parentDir = path2.dirname(projectPath);
+  const parentDir = path3.dirname(projectPath);
   const runner = getPackageRunnerCommand(packageManager);
   const pmFlag = packageManager === "npm" ? "--use-npm" : packageManager === "pnpm" ? "--use-pnpm" : packageManager === "yarn" ? "--use-yarn" : "--use-bun";
   spinner.stop();
@@ -796,7 +827,7 @@ async function scaffoldNextProject(projectName, projectPath, spinner, packageMan
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs2.pathExists(path2.join(projectPath, "package.json"))) {
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
       throw new Error("Next.js project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -809,7 +840,7 @@ async function scaffoldNextProject(projectName, projectPath, spinner, packageMan
   }
 }
 async function scaffoldSvelteKitProject(projectName, projectPath, spinner, packageManager) {
-  const parentDir = path2.dirname(projectPath);
+  const parentDir = path3.dirname(projectPath);
   const runner = getPackageRunnerCommand(packageManager);
   spinner.stop();
   console.log(chalk2.dim("\nRunning sv create...\n"));
@@ -818,7 +849,7 @@ async function scaffoldSvelteKitProject(projectName, projectPath, spinner, packa
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs2.pathExists(path2.join(projectPath, "package.json"))) {
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
       throw new Error("SvelteKit project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -837,8 +868,8 @@ async function scaffoldSvelteKitProject(projectName, projectPath, spinner, packa
 }
 async function scaffoldVanillaProject(projectName, projectPath, spinner) {
   spinner.text = "Creating vanilla TypeScript project...";
-  await fs2.ensureDir(projectPath);
-  await fs2.ensureDir(path2.join(projectPath, "src"));
+  await fs3.ensureDir(projectPath);
+  await fs3.ensureDir(path3.join(projectPath, "src"));
   const packageJson = {
     name: projectName,
     version: "0.0.1",
@@ -855,9 +886,9 @@ async function scaffoldVanillaProject(projectName, projectPath, spinner) {
       "@types/node": "latest"
     }
   };
-  await fs2.writeJSON(path2.join(projectPath, "package.json"), packageJson, { spaces: 2 });
-  await fs2.writeJSON(
-    path2.join(projectPath, "tsconfig.json"),
+  await fs3.writeJSON(path3.join(projectPath, "package.json"), packageJson, { spaces: 2 });
+  await fs3.writeJSON(
+    path3.join(projectPath, "tsconfig.json"),
     {
       compilerOptions: {
         target: "ES2022",
@@ -878,8 +909,8 @@ async function scaffoldVanillaProject(projectName, projectPath, spinner) {
     },
     { spaces: 2 }
   );
-  await fs2.writeFile(
-    path2.join(projectPath, "src", "index.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "src", "index.ts"),
     `import { createClient } from '@tthr/client';
 
 const tether = createClient({
@@ -898,8 +929,8 @@ async function main() {
 main().catch(console.error);
 `
   );
-  await fs2.writeFile(
-    path2.join(projectPath, ".gitignore"),
+  await fs3.writeFile(
+    path3.join(projectPath, ".gitignore"),
     `node_modules/
 dist/
 .env
@@ -909,11 +940,11 @@ dist/
   );
 }
 async function addTetherFiles(projectPath, projectId, apiKey, template) {
-  await fs2.ensureDir(path2.join(projectPath, "tether"));
-  await fs2.ensureDir(path2.join(projectPath, "tether", "functions"));
+  await fs3.ensureDir(path3.join(projectPath, "tether"));
+  await fs3.ensureDir(path3.join(projectPath, "tether", "functions"));
   const configPackage = template === "nuxt" ? "@tthr/vue" : template === "next" ? "@tthr/react" : template === "sveltekit" ? "@tthr/svelte" : "@tthr/client";
-  await fs2.writeFile(
-    path2.join(projectPath, "tether.config.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "tether.config.ts"),
     `import { defineConfig } from '${configPackage}';
 
 export default defineConfig({
@@ -925,8 +956,8 @@ export default defineConfig({
 });
 `
   );
-  await fs2.writeFile(
-    path2.join(projectPath, "tether", "schema.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "tether", "schema.ts"),
     `import { defineSchema, text, timestamp } from '@tthr/schema';
 
 export default defineSchema({
@@ -948,8 +979,8 @@ export default defineSchema({
 });
 `
   );
-  await fs2.writeFile(
-    path2.join(projectPath, "tether", "functions", "posts.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "tether", "functions", "posts.ts"),
     `import { query, mutation, z } from '../_generated/db';
 
 // List all posts
@@ -1030,8 +1061,8 @@ export const remove = mutation({
 });
 `
   );
-  await fs2.writeFile(
-    path2.join(projectPath, "tether", "functions", "index.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "tether", "functions", "index.ts"),
     `// Re-export all function modules
 // The Tether SDK uses this file to discover custom functions
 
@@ -1039,8 +1070,8 @@ export * as posts from './posts';
 export * as comments from './comments';
 `
   );
-  await fs2.writeFile(
-    path2.join(projectPath, "tether", "functions", "comments.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "tether", "functions", "comments.ts"),
     `import { query, mutation, z } from '../_generated/db';
 
 // List all comments
@@ -1108,26 +1139,26 @@ export const remove = mutation({
 TETHER_PROJECT_ID=${projectId}
 TETHER_API_KEY=${apiKey}
 `;
-  const envPath = path2.join(projectPath, ".env");
-  if (await fs2.pathExists(envPath)) {
-    const existing = await fs2.readFile(envPath, "utf-8");
-    await fs2.writeFile(envPath, existing + "\n" + envContent);
+  const envPath = path3.join(projectPath, ".env");
+  if (await fs3.pathExists(envPath)) {
+    const existing = await fs3.readFile(envPath, "utf-8");
+    await fs3.writeFile(envPath, existing + "\n" + envContent);
   } else {
-    await fs2.writeFile(envPath, envContent);
+    await fs3.writeFile(envPath, envContent);
   }
-  const gitignorePath = path2.join(projectPath, ".gitignore");
+  const gitignorePath = path3.join(projectPath, ".gitignore");
   const tetherGitignore = `
 # Tether
 .env
 .env.local
 `;
-  if (await fs2.pathExists(gitignorePath)) {
-    const existing = await fs2.readFile(gitignorePath, "utf-8");
+  if (await fs3.pathExists(gitignorePath)) {
+    const existing = await fs3.readFile(gitignorePath, "utf-8");
     if (!existing.includes("_generated/")) {
-      await fs2.writeFile(gitignorePath, existing + tetherGitignore);
+      await fs3.writeFile(gitignorePath, existing + tetherGitignore);
     }
   } else {
-    await fs2.writeFile(gitignorePath, tetherGitignore.trim());
+    await fs3.writeFile(gitignorePath, tetherGitignore.trim());
   }
 }
 async function configureFramework(projectPath, template) {
@@ -1140,9 +1171,9 @@ async function configureFramework(projectPath, template) {
   }
 }
 async function configureNuxt(projectPath) {
-  const configPath = path2.join(projectPath, "nuxt.config.ts");
-  if (!await fs2.pathExists(configPath)) {
-    await fs2.writeFile(
+  const configPath = path3.join(projectPath, "nuxt.config.ts");
+  if (!await fs3.pathExists(configPath)) {
+    await fs3.writeFile(
       configPath,
       `// https://nuxt.com/docs/api/configuration/nuxt-config
 export default defineNuxtConfig({
@@ -1160,7 +1191,7 @@ export default defineNuxtConfig({
     );
     return;
   }
-  let config = await fs2.readFile(configPath, "utf-8");
+  let config = await fs3.readFile(configPath, "utf-8");
   if (config.includes("modules:")) {
     config = config.replace(
       /modules:\s*\[/,
@@ -1187,11 +1218,11 @@ export default defineNuxtConfig({
 `
     );
   }
-  await fs2.writeFile(configPath, config);
+  await fs3.writeFile(configPath, config);
 }
 async function configureNext(projectPath) {
-  const providersPath = path2.join(projectPath, "src", "app", "providers.tsx");
-  await fs2.writeFile(
+  const providersPath = path3.join(projectPath, "src", "app", "providers.tsx");
+  await fs3.writeFile(
     providersPath,
     `'use client';
 
@@ -1209,9 +1240,9 @@ export function Providers({ children }: { children: React.ReactNode }) {
 }
 `
   );
-  const layoutPath = path2.join(projectPath, "src", "app", "layout.tsx");
-  if (await fs2.pathExists(layoutPath)) {
-    let layout = await fs2.readFile(layoutPath, "utf-8");
+  const layoutPath = path3.join(projectPath, "src", "app", "layout.tsx");
+  if (await fs3.pathExists(layoutPath)) {
+    let layout = await fs3.readFile(layoutPath, "utf-8");
     if (!layout.includes("import { Providers }")) {
       layout = layout.replace(
         /^(import.*\n)+/m,
@@ -1224,24 +1255,24 @@ export function Providers({ children }: { children: React.ReactNode }) {
         "$1<Providers>$2</Providers>$3"
       );
     }
-    await fs2.writeFile(layoutPath, layout);
+    await fs3.writeFile(layoutPath, layout);
   }
-  const envLocalPath = path2.join(projectPath, ".env.local");
+  const envLocalPath = path3.join(projectPath, ".env.local");
   const nextEnvContent = `# Tether Configuration (client-side)
 NEXT_PUBLIC_TETHER_PROJECT_ID=\${TETHER_PROJECT_ID}
 `;
-  if (await fs2.pathExists(envLocalPath)) {
-    const existing = await fs2.readFile(envLocalPath, "utf-8");
-    await fs2.writeFile(envLocalPath, existing + "\n" + nextEnvContent);
+  if (await fs3.pathExists(envLocalPath)) {
+    const existing = await fs3.readFile(envLocalPath, "utf-8");
+    await fs3.writeFile(envLocalPath, existing + "\n" + nextEnvContent);
   } else {
-    await fs2.writeFile(envLocalPath, nextEnvContent);
+    await fs3.writeFile(envLocalPath, nextEnvContent);
   }
 }
 async function configureSvelteKit(projectPath) {
-  const libPath = path2.join(projectPath, "src", "lib");
-  await fs2.ensureDir(libPath);
-  await fs2.writeFile(
-    path2.join(libPath, "tether.ts"),
+  const libPath = path3.join(projectPath, "src", "lib");
+  await fs3.ensureDir(libPath);
+  await fs3.writeFile(
+    path3.join(libPath, "tether.ts"),
     `import { createClient } from '@tthr/svelte';
 import { PUBLIC_TETHER_PROJECT_ID, PUBLIC_TETHER_URL } from '$env/static/public';
 
@@ -1251,14 +1282,14 @@ export const tether = createClient({
 });
 `
   );
-  const envPath = path2.join(projectPath, ".env");
+  const envPath = path3.join(projectPath, ".env");
   const svelteEnvContent = `# Tether Configuration (public)
 PUBLIC_TETHER_PROJECT_ID=\${TETHER_PROJECT_ID}
 `;
-  if (await fs2.pathExists(envPath)) {
-    const existing = await fs2.readFile(envPath, "utf-8");
+  if (await fs3.pathExists(envPath)) {
+    const existing = await fs3.readFile(envPath, "utf-8");
     if (!existing.includes("PUBLIC_TETHER_")) {
-      await fs2.writeFile(envPath, existing + "\n" + svelteEnvContent);
+      await fs3.writeFile(envPath, existing + "\n" + svelteEnvContent);
     }
   }
 }
@@ -1313,10 +1344,10 @@ async function installTetherPackages(projectPath, template, packageManager) {
 }
 async function createDemoPage(projectPath, template) {
   if (template === "nuxt") {
-    const nuxt4AppVuePath = path2.join(projectPath, "app", "app.vue");
-    const nuxt3AppVuePath = path2.join(projectPath, "app.vue");
-    const appVuePath = await fs2.pathExists(path2.join(projectPath, "app")) ? nuxt4AppVuePath : nuxt3AppVuePath;
-    await fs2.writeFile(
+    const nuxt4AppVuePath = path3.join(projectPath, "app", "app.vue");
+    const nuxt3AppVuePath = path3.join(projectPath, "app.vue");
+    const appVuePath = await fs3.pathExists(path3.join(projectPath, "app")) ? nuxt4AppVuePath : nuxt3AppVuePath;
+    await fs3.writeFile(
       appVuePath,
       `<template>
   <TetherWelcome />
@@ -1324,8 +1355,8 @@ async function createDemoPage(projectPath, template) {
 `
     );
   } else if (template === "next") {
-    const pagePath = path2.join(projectPath, "src", "app", "page.tsx");
-    await fs2.writeFile(
+    const pagePath = path3.join(projectPath, "src", "app", "page.tsx");
+    await fs3.writeFile(
       pagePath,
       `'use client';
 
@@ -1435,8 +1466,8 @@ export default function Home() {
 `
     );
   } else if (template === "sveltekit") {
-    const pagePath = path2.join(projectPath, "src", "routes", "+page.svelte");
-    await fs2.writeFile(
+    const pagePath = path3.join(projectPath, "src", "routes", "+page.svelte");
+    await fs3.writeFile(
       pagePath,
       `<script lang="ts">
   import { onMount } from 'svelte';
@@ -1704,8 +1735,8 @@ export default function Home() {
 // src/commands/dev.ts
 import chalk3 from "chalk";
 import ora3 from "ora";
-import fs3 from "fs-extra";
-import path3 from "path";
+import fs4 from "fs-extra";
+import path4 from "path";
 import { spawn } from "child_process";
 import { watch } from "chokidar";
 var frameworkProcess = null;
@@ -1779,7 +1810,7 @@ async function runDeploy(what, projectId, token, schemaPath, functionsDir, envir
 }
 async function validateSchema(schemaPath) {
   try {
-    const content = await fs3.readFile(schemaPath, "utf-8");
+    const content = await fs4.readFile(schemaPath, "utf-8");
     if (!content.includes("defineSchema")) {
       return { valid: false, error: "Missing defineSchema() call" };
     }
@@ -1801,17 +1832,17 @@ async function validateSchema(schemaPath) {
 }
 async function validateFunctions(functionsDir) {
   const errors = [];
-  if (!await fs3.pathExists(functionsDir)) {
+  if (!await fs4.pathExists(functionsDir)) {
     return { valid: true, errors: [] };
   }
-  const files = await fs3.readdir(functionsDir);
+  const files = await fs4.readdir(functionsDir);
   for (const file of files) {
     if (!file.endsWith(".ts") && !file.endsWith(".js")) continue;
-    const filePath = path3.join(functionsDir, file);
-    const stat = await fs3.stat(filePath);
+    const filePath = path4.join(functionsDir, file);
+    const stat = await fs4.stat(filePath);
     if (!stat.isFile()) continue;
     try {
-      const content = await fs3.readFile(filePath, "utf-8");
+      const content = await fs4.readFile(filePath, "utf-8");
       const hasExports = /export\s+const\s+\w+\s*=\s*(query|mutation)\s*\(/.test(content);
       if (!hasExports && !file.includes("index")) {
         errors.push(`${file}: No query or mutation exports found`);
@@ -1930,17 +1961,17 @@ function cleanup() {
 }
 async function devCommand(options) {
   const credentials = await requireAuth();
-  const configPath = path3.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs3.pathExists(configPath)) {
+  const configPath = path4.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs4.pathExists(configPath)) {
     console.log(chalk3.red("\nError: Not a Tether project"));
     console.log(chalk3.dim("Run `tthr init` to create a new project\n"));
     process.exit(1);
   }
   const config = await loadConfig();
   if (!config.projectId) {
-    const envPath = path3.resolve(process.cwd(), ".env");
-    if (await fs3.pathExists(envPath)) {
-      const envContent = await fs3.readFile(envPath, "utf-8");
+    const envPath = path4.resolve(process.cwd(), ".env");
+    if (await fs4.pathExists(envPath)) {
+      const envContent = await fs4.readFile(envPath, "utf-8");
       const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
       if (match) config.projectId = match[1].trim();
     }
@@ -1962,9 +1993,9 @@ async function devCommand(options) {
     console.log(chalk3.dim(`  Dev command: ${devCmd}`));
   }
   console.log(chalk3.dim(`  Environment: ${environment}${isLocal ? " (local)" : " (cloud)"}`));
-  console.log(chalk3.dim(`  Schema: ${path3.relative(process.cwd(), schemaPath)}`));
-  console.log(chalk3.dim(`  Functions: ${path3.relative(process.cwd(), functionsDir)}`));
-  console.log(chalk3.dim(`  Output: ${path3.relative(process.cwd(), outputDir)}`));
+  console.log(chalk3.dim(`  Schema: ${path4.relative(process.cwd(), schemaPath)}`));
+  console.log(chalk3.dim(`  Functions: ${path4.relative(process.cwd(), functionsDir)}`));
+  console.log(chalk3.dim(`  Output: ${path4.relative(process.cwd(), outputDir)}`));
   if (options.extraArgs && options.extraArgs.length > 0) {
     console.log(chalk3.dim(`  Extra args: ${options.extraArgs.join(" ")}`));
   }
@@ -2005,7 +2036,7 @@ async function devCommand(options) {
       spinner.warn("No project ID configured \u2014 skipping auto-deploy");
     }
     spinner.start("Setting up file watchers...");
-    if (await fs3.pathExists(schemaPath)) {
+    if (await fs4.pathExists(schemaPath)) {
       schemaWatcher = watch(schemaPath, {
         ignoreInitial: true,
         awaitWriteFinish: {
@@ -2026,8 +2057,8 @@ async function devCommand(options) {
         }
       });
     }
-    if (await fs3.pathExists(functionsDir)) {
-      functionsWatcher = watch(path3.join(functionsDir, "**/*.{ts,js}"), {
+    if (await fs4.pathExists(functionsDir)) {
+      functionsWatcher = watch(path4.join(functionsDir, "**/*.{ts,js}"), {
         ignoreInitial: true,
         awaitWriteFinish: {
           stabilityThreshold: 300,
@@ -2035,7 +2066,7 @@ async function devCommand(options) {
         }
       });
       functionsWatcher.on("all", async (event, filePath) => {
-        const relativePath = path3.relative(functionsDir, filePath);
+        const relativePath = path4.relative(functionsDir, filePath);
         console.log(chalk3.cyan(`
   Function ${event}: ${relativePath}`));
         const validation = await validateFunctions(functionsDir);
@@ -2090,7 +2121,8 @@ async function loginCommand() {
     console.log(chalk4.dim("\nRun `tthr logout` to sign out\n"));
     return;
   }
-  console.log(chalk4.dim(`  URL: ${API_URL}
+  console.log(chalk4.dim(`  URL: ${API_URL}`));
+  console.log(chalk4.dim(`  \u21B3 override with TETHER_API_URL in your shell or .env.local
 `));
   const spinner = ora4("Generating authentication code...").start();
   try {
@@ -2265,8 +2297,8 @@ function openBrowser(url) {
 // src/commands/update.ts
 import chalk5 from "chalk";
 import ora5 from "ora";
-import fs4 from "fs-extra";
-import path4 from "path";
+import fs5 from "fs-extra";
+import path5 from "path";
 import { execSync as execSync2 } from "child_process";
 var TETHER_PACKAGES = [
   "@tthr/client",
@@ -2278,21 +2310,21 @@ var TETHER_PACKAGES = [
 ];
 function detectPackageManager() {
   let dir = process.cwd();
-  const root = path4.parse(dir).root;
+  const root = path5.parse(dir).root;
   while (dir !== root) {
-    if (fs4.existsSync(path4.join(dir, "bun.lockb")) || fs4.existsSync(path4.join(dir, "bun.lock"))) {
+    if (fs5.existsSync(path5.join(dir, "bun.lockb")) || fs5.existsSync(path5.join(dir, "bun.lock"))) {
       return "bun";
     }
-    if (fs4.existsSync(path4.join(dir, "pnpm-lock.yaml"))) {
+    if (fs5.existsSync(path5.join(dir, "pnpm-lock.yaml"))) {
       return "pnpm";
     }
-    if (fs4.existsSync(path4.join(dir, "yarn.lock"))) {
+    if (fs5.existsSync(path5.join(dir, "yarn.lock"))) {
       return "yarn";
     }
-    if (fs4.existsSync(path4.join(dir, "package-lock.json"))) {
+    if (fs5.existsSync(path5.join(dir, "package-lock.json"))) {
       return "npm";
     }
-    dir = path4.dirname(dir);
+    dir = path5.dirname(dir);
   }
   return "npm";
 }
@@ -2321,14 +2353,14 @@ async function getLatestVersion2(packageName) {
   }
 }
 async function updateCommand(options) {
-  const packageJsonPath = path4.resolve(process.cwd(), "package.json");
-  if (!await fs4.pathExists(packageJsonPath)) {
+  const packageJsonPath = path5.resolve(process.cwd(), "package.json");
+  if (!await fs5.pathExists(packageJsonPath)) {
     console.log(chalk5.red("\nError: No package.json found"));
     console.log(chalk5.dim("Make sure you're in the root of your project\n"));
     process.exit(1);
   }
   console.log(chalk5.bold("\n\u26A1 Updating Tether packages\n"));
-  const packageJson = await fs4.readJson(packageJsonPath);
+  const packageJson = await fs5.readJson(packageJsonPath);
   const deps = packageJson.dependencies || {};
   const devDeps = packageJson.devDependencies || {};
   const installedDeps = [];
@@ -2414,8 +2446,8 @@ async function updateCommand(options) {
 // src/commands/exec.ts
 import chalk6 from "chalk";
 import ora6 from "ora";
-import fs5 from "fs-extra";
-import path5 from "path";
+import fs6 from "fs-extra";
+import path6 from "path";
 async function execCommand(sql) {
   if (!sql || sql.trim() === "") {
     console.log(chalk6.red("\nError: SQL query required"));
@@ -2423,10 +2455,10 @@ async function execCommand(sql) {
     process.exit(1);
   }
   const credentials = await requireAuth();
-  const envPath = path5.resolve(process.cwd(), ".env");
+  const envPath = path6.resolve(process.cwd(), ".env");
   let projectId;
-  if (await fs5.pathExists(envPath)) {
-    const envContent = await fs5.readFile(envPath, "utf-8");
+  if (await fs6.pathExists(envPath)) {
+    const envContent = await fs6.readFile(envPath, "utf-8");
     const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
     projectId = match?.[1]?.trim();
   }
@@ -2487,17 +2519,17 @@ async function execCommand(sql) {
 // src/commands/env.ts
 import chalk7 from "chalk";
 import ora7 from "ora";
-import fs6 from "fs-extra";
-import path6 from "path";
+import fs7 from "fs-extra";
+import path7 from "path";
 async function resolveApiUrl2() {
   const config = await loadConfig();
   return `${getApiUrl2(config)}/api/v1`;
 }
 async function getProjectId() {
-  const envPath = path6.resolve(process.cwd(), ".env");
+  const envPath = path7.resolve(process.cwd(), ".env");
   let projectId;
-  if (await fs6.pathExists(envPath)) {
-    const envContent = await fs6.readFile(envPath, "utf-8");
+  if (await fs7.pathExists(envPath)) {
+    const envContent = await fs7.readFile(envPath, "utf-8");
     const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
     projectId = match?.[1]?.trim();
   }
@@ -2654,15 +2686,15 @@ function maskApiKey(key) {
 // src/commands/migrate.ts
 import chalk8 from "chalk";
 import ora8 from "ora";
-import fs7 from "fs-extra";
-import path7 from "path";
+import fs8 from "fs-extra";
+import path8 from "path";
 import readline2 from "readline";
 async function migrateSystemColumnsCommand(options) {
   const credentials = await requireAuth();
-  const envPath = path7.resolve(process.cwd(), ".env");
+  const envPath = path8.resolve(process.cwd(), ".env");
   let projectId;
-  if (await fs7.pathExists(envPath)) {
-    const envContent = await fs7.readFile(envPath, "utf-8");
+  if (await fs8.pathExists(envPath)) {
+    const envContent = await fs8.readFile(envPath, "utf-8");
     const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
     projectId = match?.[1]?.trim();
   }
@@ -2800,9 +2832,10 @@ function askConfirmation(prompt) {
 }
 
 // src/index.ts
+loadDotenv();
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path8.dirname(__filename);
-var pkg = fs8.readJsonSync(path8.resolve(__dirname, "../package.json"));
+var __dirname = path9.dirname(__filename);
+var pkg = fs9.readJsonSync(path9.resolve(__dirname, "../package.json"));
 var program = new Command();
 program.name("tthr").description("Tether CLI - Realtime SQLite for modern applications").version(pkg.version).enablePositionalOptions();
 program.command("init [name]").description("Create a new Tether project").option("-t, --template <template>", "Project template (vue, svelte, react, vanilla)", "vue").action(initCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tthr",
-  "version": "0.3.21",
+  "version": "0.3.23",
   "description": "Tether CLI - project scaffolding and deployment",
   "type": "module",
   "bin": {