tthr 0.3.15 → 0.3.17

package/dist/chunk-DR6CWO75.js

@@ -0,0 +1,733 @@
+// src/commands/generate.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import fs3 from "fs-extra";
+import path3 from "path";
+
+// src/utils/auth.ts
+import chalk from "chalk";
+import fs2 from "fs-extra";
+import path2 from "path";
+
+// src/utils/config.ts
+import fs from "fs-extra";
+import path from "path";
+var DEFAULT_CONFIG = {
+  schema: "./tether/schema.ts",
+  functions: "./tether/functions",
+  output: "./tether/_generated",
+  dev: {
+    port: 3001,
+    host: "localhost"
+  },
+  database: {
+    walMode: true
+  }
+};
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = path.resolve(cwd, "tether.config.ts");
+  if (!await fs.pathExists(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  const configSource = await fs.readFile(configPath, "utf-8");
+  const config = {};
+  const schemaMatch = configSource.match(/schema\s*:\s*['"]([^'"]+)['"]/);
+  if (schemaMatch) {
+    config.schema = schemaMatch[1];
+  }
+  const functionsMatch = configSource.match(/functions\s*:\s*['"]([^'"]+)['"]/);
+  if (functionsMatch) {
+    config.functions = functionsMatch[1];
+  }
+  const outputMatch = configSource.match(/output\s*:\s*['"]([^'"]+)['"]/);
+  if (outputMatch) {
+    config.output = outputMatch[1];
+  }
+  const projectIdMatch = configSource.match(/projectId\s*:\s*['"]([^'"]+)['"]/);
+  if (projectIdMatch) {
+    config.projectId = projectIdMatch[1];
+  }
+  const urlMatch = configSource.match(/(?:^|\n)\s*url\s*:\s*['"]([^'"]+)['"]/);
+  if (urlMatch) {
+    config.url = urlMatch[1];
+  }
+  const envMatch = configSource.match(/environment\s*:\s*['"]([^'"]+)['"]/);
+  if (envMatch) {
+    config.environment = envMatch[1];
+  }
+  const portMatch = configSource.match(/port\s*:\s*(\d+)/);
+  if (portMatch) {
+    config.dev = { ...config.dev, port: parseInt(portMatch[1], 10) };
+  }
+  const hostMatch = configSource.match(/host\s*:\s*['"]([^'"]+)['"]/);
+  if (hostMatch) {
+    config.dev = { ...config.dev, host: hostMatch[1] };
+  }
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    dev: { ...DEFAULT_CONFIG.dev, ...config.dev },
+    database: { ...DEFAULT_CONFIG.database, ...config.database }
+  };
+}
+async function resolveEnvironmentFromApiKey(cwd = process.cwd()) {
+  const envPath = path.resolve(cwd, ".env");
+  if (!await fs.pathExists(envPath)) return void 0;
+  const envContent = await fs.readFile(envPath, "utf-8");
+  const match = envContent.match(/TETHER_API_KEY=\s*(tthr_([^_]+)_[0-9a-f]+)/);
+  if (!match) return void 0;
+  const prefix = match[2];
+  switch (prefix) {
+    case "dev":
+      return "development";
+    case "prod":
+      return "production";
+    default:
+      return prefix;
+  }
+}
+var DEFAULT_API_URL = "https://api.tether.ngo";
+function getApiUrl(config) {
+  if (process.env.TETHER_API_URL) {
+    return process.env.TETHER_API_URL.replace(/\/+$/, "");
+  }
+  if (config?.url) {
+    return config.url.replace(/\/+$/, "");
+  }
+  const isDev = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
+  return isDev ? "http://localhost:3001" : DEFAULT_API_URL;
+}
+async function resolveApiUrl(config) {
+  if (process.env.TETHER_API_URL) {
+    return process.env.TETHER_API_URL.replace(/\/+$/, "");
+  }
+  const resolved = config ?? await loadConfig();
+  if (resolved?.url) {
+    return resolved.url.replace(/\/+$/, "");
+  }
+  const isDev = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
+  return isDev ? "http://localhost:3001" : DEFAULT_API_URL;
+}
+function resolvePath(configPath, cwd = process.cwd()) {
+  const normalised = configPath.replace(/^\.\//, "");
+  return path.resolve(cwd, normalised);
+}
+async function detectFramework(cwd = process.cwd()) {
+  const packageJsonPath = path.resolve(cwd, "package.json");
+  if (!await fs.pathExists(packageJsonPath)) {
+    return "unknown";
+  }
+  try {
+    const packageJson = await fs.readJson(packageJsonPath);
+    const deps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    if (deps.nuxt || deps["@nuxt/kit"]) {
+      return "nuxt";
+    }
+    if (deps.next) {
+      return "next";
+    }
+    if (deps["@sveltejs/kit"]) {
+      return "sveltekit";
+    }
+    if (deps.vite && !deps.nuxt && !deps.next && !deps["@sveltejs/kit"]) {
+      return "vite";
+    }
+    return "vanilla";
+  } catch {
+    return "unknown";
+  }
+}
+function getFrameworkDevCommand(framework) {
+  switch (framework) {
+    case "nuxt":
+      return "nuxt dev";
+    case "next":
+      return "next dev";
+    case "sveltekit":
+      return "vite dev";
+    case "vite":
+      return "vite dev";
+    case "vanilla":
+      return null;
+    // No default dev server for vanilla
+    default:
+      return null;
+  }
+}
+
+// src/utils/auth.ts
+var CONFIG_DIR = path2.join(process.env.HOME || process.env.USERPROFILE || "", ".tether");
+var CREDENTIALS_FILE = path2.join(CONFIG_DIR, "credentials.json");
+var REFRESH_THRESHOLD_DAYS = 7;
+async function getCredentials() {
+  try {
+    if (await fs2.pathExists(CREDENTIALS_FILE)) {
+      return await fs2.readJSON(CREDENTIALS_FILE);
+    }
+  } catch {
+  }
+  return null;
+}
+async function refreshSession(credentials) {
+  try {
+    const apiUrl = `${await resolveApiUrl()}/api/v1`;
+    const response = await fetch(`${apiUrl}/auth/session/refresh`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${credentials.accessToken}`
+      }
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const updated = {
+      ...credentials,
+      expiresAt: data.expiresAt
+    };
+    await saveCredentials(updated);
+    return updated;
+  } catch {
+    return null;
+  }
+}
+async function requireAuth() {
+  const credentials = await getCredentials();
+  if (!credentials) {
+    console.error(chalk.red("\n\u2717 Not logged in\n"));
+    console.log(chalk.dim("Run `tthr login` to authenticate\n"));
+    process.exit(1);
+  }
+  if (credentials.expiresAt) {
+    const expiresAt = new Date(credentials.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    if (now > expiresAt) {
+      await clearCredentials();
+      console.error(chalk.red("\n\u2717 Session expired \u2014 you have been signed out\n"));
+      console.log(chalk.dim("Run `tthr login` to authenticate\n"));
+      process.exit(1);
+    }
+    const daysUntilExpiry = (expiresAt.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24);
+    if (daysUntilExpiry <= REFRESH_THRESHOLD_DAYS) {
+      const refreshed = await refreshSession(credentials);
+      if (refreshed) {
+        return refreshed;
+      }
+    }
+  }
+  return credentials;
+}
+async function saveCredentials(credentials) {
+  await fs2.ensureDir(CONFIG_DIR);
+  await fs2.writeJSON(CREDENTIALS_FILE, credentials, { spaces: 2, mode: 384 });
+}
+async function clearCredentials() {
+  try {
+    await fs2.remove(CREDENTIALS_FILE);
+  } catch {
+  }
+}
+
+// src/commands/generate.ts
+function parseSchemaFile(source) {
+  const tables = [];
+  const schemaMatch = source.match(/defineSchema\s*\(\s*\{([\s\S]*)\}\s*\)/);
+  if (!schemaMatch) return tables;
+  const schemaContent = schemaMatch[1];
+  const tableStartRegex = /(\w+)\s*:\s*\{/g;
+  let match;
+  while ((match = tableStartRegex.exec(schemaContent)) !== null) {
+    const tableName = match[1];
+    const startOffset = match.index + match[0].length;
+    let braceCount = 1;
+    let endOffset = startOffset;
+    for (let i = startOffset; i < schemaContent.length && braceCount > 0; i++) {
+      const char = schemaContent[i];
+      if (char === "{") braceCount++;
+      else if (char === "}") braceCount--;
+      endOffset = i;
+    }
+    const columnsContent = schemaContent.slice(startOffset, endOffset);
+    const columns = parseColumns(columnsContent);
+    tables.push({ name: tableName, columns });
+  }
+  return tables;
+}
+function parseColumns(content) {
+  const columns = [];
+  const columnRegex = /(\w+)\s*:\s*(\w+)(?:<([^>]+)>)?\s*\(\s*\)((?:\[.*?\]|[^,\n}])*)/g;
+  let match;
+  while ((match = columnRegex.exec(content)) !== null) {
+    const name = match[1];
+    const schemaType = match[2];
+    const genericType = match[3];
+    const modifiers = match[4] || "";
+    const nullable = !modifiers.includes(".notNull()");
+    const oneOfMatch = modifiers.match(/\.oneOf\s*\(\s*\[(.*?)\]\s*\)/);
+    let oneOf;
+    if (oneOfMatch) {
+      oneOf = [...oneOfMatch[1].matchAll(/['"]([^'"]+)['"]/g)].map((m) => m[1]);
+    }
+    columns.push({
+      name,
+      type: schemaTypeToTS(schemaType),
+      nullable,
+      jsonType: genericType,
+      // Store the generic type for json columns
+      oneOf
+    });
+  }
+  return columns;
+}
+function schemaTypeToTS(schemaType) {
+  switch (schemaType) {
+    case "text":
+      return "string";
+    case "integer":
+      return "number";
+    case "real":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "timestamp":
+      return "string";
+    case "json":
+      return "unknown";
+    case "blob":
+      return "Uint8Array";
+    case "asset":
+      return "TetherAsset";
+    // Asset object returned by API
+    default:
+      return "unknown";
+  }
+}
+function extractSingleType(source, typeName) {
+  const interfaceStart = new RegExp(`(?:export\\s+)?interface\\s+${typeName}\\s*\\{`);
+  const interfaceMatch = interfaceStart.exec(source);
+  if (interfaceMatch) {
+    const braceStart = interfaceMatch.index + interfaceMatch[0].length;
+    let braceCount = 1;
+    let endIdx = braceStart;
+    for (let i = braceStart; i < source.length && braceCount > 0; i++) {
+      if (source[i] === "{") braceCount++;
+      else if (source[i] === "}") braceCount--;
+      endIdx = i;
+    }
+    return source.slice(interfaceMatch.index, endIdx + 1).replace(/^export\s+/, "");
+  }
+  const typeStart = new RegExp(`(?:export\\s+)?type\\s+${typeName}\\s*=`);
+  const typeMatch = typeStart.exec(source);
+  if (typeMatch) {
+    const semiIdx = source.indexOf(";", typeMatch.index);
+    if (semiIdx !== -1) {
+      return source.slice(typeMatch.index, semiIdx + 1).replace(/^export\s+/, "");
+    }
+  }
+  return null;
+}
+function extractTypeDefinitions(source, typeNames) {
+  if (typeNames.size === 0) return [];
+  const allDefinedTypes = /* @__PURE__ */ new Set();
+  const typeDefRegex = /(?:export\s+)?(?:interface|type)\s+(\w+)/g;
+  let m;
+  while ((m = typeDefRegex.exec(source)) !== null) {
+    allDefinedTypes.add(m[1]);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  const queue = [...typeNames];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (resolved.has(name)) continue;
+    const block = extractSingleType(source, name);
+    if (!block) continue;
+    resolved.set(name, block);
+    for (const definedType of allDefinedTypes) {
+      if (!resolved.has(definedType) && !queue.includes(definedType)) {
+        const refRegex = new RegExp(`\\b${definedType}\\b`);
+        if (refRegex.test(block)) {
+          queue.push(definedType);
+        }
+      }
+    }
+  }
+  const ordered = [];
+  const visited = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name)) return;
+    visited.add(name);
+    const block = resolved.get(name);
+    if (!block) return;
+    for (const dep of resolved.keys()) {
+      if (dep !== name && new RegExp(`\\b${dep}\\b`).test(block)) {
+        visit(dep);
+      }
+    }
+    ordered.push(name);
+  }
+  for (const name of resolved.keys()) {
+    visit(name);
+  }
+  return ordered.map((name) => resolved.get(name));
+}
+function tableNameToInterface(tableName) {
+  let name = tableName;
+  if (name.endsWith("ies")) {
+    name = name.slice(0, -3) + "y";
+  } else if (name.endsWith("s") && !name.endsWith("ss")) {
+    name = name.slice(0, -1);
+  }
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function generateDbFile(tables, schemaSource) {
+  const TS_PRIMITIVES = /* @__PURE__ */ new Set(["number", "string", "boolean", "unknown", "any", "void", "never", "undefined", "null", "object"]);
+  const jsonTypes = /* @__PURE__ */ new Set();
+  for (const table of tables) {
+    for (const col of table.columns) {
+      if (col.jsonType) {
+        const baseType = col.jsonType.replace(/\s*\|\s*null/g, "").replace(/\[\]/g, "").trim();
+        if (!TS_PRIMITIVES.has(baseType)) {
+          jsonTypes.add(baseType);
+        }
+      }
+    }
+  }
+  const lines = [
+    "// Auto-generated by Tether CLI - do not edit manually",
+    `// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "import { createDatabaseProxy, type TetherDatabase } from '@tthr/client';",
+    "import {",
+    "  type QueryDefinition,",
+    "  type MutationDefinition,",
+    "  z,",
+    "} from '@tthr/server';",
+    "import type { TetherEnv } from './env';"
+  ];
+  if (jsonTypes.size > 0) {
+    const typeBlocks = extractTypeDefinitions(schemaSource, jsonTypes);
+    if (typeBlocks.length > 0) {
+      lines.push("");
+      lines.push("// Schema types (inlined from schema.ts)");
+      for (const block of typeBlocks) {
+        lines.push(block);
+        lines.push("");
+      }
+    }
+  }
+  lines.push("");
+  lines.push("// Asset type returned by the API for asset columns");
+  lines.push("export interface TetherAsset {");
+  lines.push("  id: string;");
+  lines.push("  filename: string;");
+  lines.push("  contentType: string;");
+  lines.push("  size: number;");
+  lines.push("  url: string;");
+  lines.push("  createdAt: string;");
+  lines.push("}");
+  lines.push("");
+  for (const table of tables) {
+    const interfaceName = tableNameToInterface(table.name);
+    lines.push(`export interface ${interfaceName} {`);
+    lines.push("  _id: string;");
+    for (const col of table.columns) {
+      let colType;
+      if (col.oneOf && col.oneOf.length > 0) {
+        colType = col.oneOf.map((v) => `'${v}'`).join(" | ");
+      } else {
+        colType = col.jsonType || col.type;
+      }
+      const typeStr = col.nullable ? `${colType} | null` : colType;
+      const optional = col.nullable ? "?" : "";
+      lines.push(`  ${col.name}${optional}: ${typeStr};`);
+    }
+    lines.push("  _createdAt: string;");
+    lines.push("  _updatedAt?: string | null;");
+    lines.push("  _deletedAt?: string | null;");
+    lines.push("}");
+    lines.push("");
+  }
+  lines.push("export interface Schema {");
+  for (const table of tables) {
+    const interfaceName = tableNameToInterface(table.name);
+    lines.push(`  ${table.name}: ${interfaceName};`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("// Database client with typed tables");
+  lines.push("// This is a proxy that will be populated by the Tether runtime");
+  lines.push("export const db: TetherDatabase<Schema> = createDatabaseProxy<Schema>();");
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Typed function wrappers - use these instead of importing from @tthr/server");
+  lines.push("// This ensures the `db` and `env` parameters in handlers are properly typed");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push("/**");
+  lines.push(" * Define a query function with typed database and environment variable access.");
+  lines.push(" * The `db` and `env` parameters in the handler will have full type safety.");
+  lines.push(" */");
+  lines.push("export function query<TArgs = void, TResult = unknown>(");
+  lines.push("  definition: QueryDefinition<TArgs, TResult, Schema, TetherEnv>");
+  lines.push("): QueryDefinition<TArgs, TResult, Schema, TetherEnv> {");
+  lines.push("  return definition;");
+  lines.push("}");
+  lines.push("");
+  lines.push("/**");
+  lines.push(" * Define a mutation function with typed database and environment variable access.");
+  lines.push(" * The `db` and `env` parameters in the handler will have full type safety.");
+  lines.push(" */");
+  lines.push("export function mutation<TArgs = void, TResult = unknown>(");
+  lines.push("  definition: MutationDefinition<TArgs, TResult, Schema, TetherEnv>");
+  lines.push("): MutationDefinition<TArgs, TResult, Schema, TetherEnv> {");
+  lines.push("  return definition;");
+  lines.push("}");
+  lines.push("");
+  lines.push("// Re-export z for convenience");
+  lines.push("export { z };");
+  lines.push("");
+  return lines.join("\n");
+}
+async function parseFunctionsDir(functionsDir) {
+  const functions = [];
+  if (!await fs3.pathExists(functionsDir)) {
+    return functions;
+  }
+  const files = await fs3.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);
+    if (!stat.isFile()) continue;
+    const moduleName = file.replace(/\.(ts|js)$/, "");
+    const source = await fs3.readFile(filePath, "utf-8");
+    const exportRegex = /export\s+const\s+(\w+)\s*=\s*(query|mutation)\s*\(/g;
+    let match;
+    while ((match = exportRegex.exec(source)) !== null) {
+      functions.push({
+        name: match[1],
+        moduleName
+      });
+    }
+  }
+  return functions;
+}
+async function generateApiFile(functionsDir) {
+  const functions = await parseFunctionsDir(functionsDir);
+  const moduleMap = /* @__PURE__ */ new Map();
+  for (const fn of functions) {
+    if (!moduleMap.has(fn.moduleName)) {
+      moduleMap.set(fn.moduleName, []);
+    }
+    moduleMap.get(fn.moduleName).push(fn.name);
+  }
+  const lines = [
+    "// Auto-generated by Tether CLI - do not edit manually",
+    `// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "import { createApiProxy } from '@tthr/client';",
+    "",
+    "/**",
+    " * API function reference type for useQuery/useMutation.",
+    ' * The _name property contains the function path (e.g., "users.list").',
+    " */",
+    "export interface ApiFunction<TArgs = unknown, TResult = unknown> {",
+    "  _name: string;",
+    "  _args?: TArgs;",
+    "  _result?: TResult;",
+    "}",
+    ""
+  ];
+  if (moduleMap.size > 0) {
+    for (const [moduleName, fnNames] of moduleMap) {
+      const interfaceName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1) + "Api";
+      lines.push(`export interface ${interfaceName} {`);
+      for (const fnName of fnNames) {
+        lines.push(`  ${fnName}: ApiFunction;`);
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    lines.push("export interface Api {");
+    for (const moduleName of moduleMap.keys()) {
+      const interfaceName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1) + "Api";
+      lines.push(`  ${moduleName}: ${interfaceName};`);
+    }
+    lines.push("}");
+  } else {
+    lines.push("/**");
+    lines.push(" * Flexible API type that allows access to any function path.");
+    lines.push(" * Functions are accessed as api.moduleName.functionName");
+    lines.push(" * The actual types depend on your function definitions.");
+    lines.push(" */");
+    lines.push("export type Api = {");
+    lines.push("  [module: string]: {");
+    lines.push("    [fn: string]: ApiFunction;");
+    lines.push("  };");
+    lines.push("};");
+  }
+  lines.push("");
+  lines.push("// API client proxy - provides typed access to your functions");
+  lines.push("// On the client: returns { _name } references for useQuery/useMutation");
+  lines.push("// In Tether functions: calls the actual function implementation");
+  lines.push("export const api = createApiProxy<Api>();");
+  lines.push("");
+  return lines.join("\n");
+}
+async function fetchEnvVarKeys(projectId, environment, apiUrl) {
+  const credentials = await getCredentials();
+  if (!credentials) return [];
+  const baseUrl = apiUrl || `${await resolveApiUrl()}/api/v1`;
+  const envPath = environment !== "production" ? `/projects/${projectId}/env/${environment}/env-vars` : `/projects/${projectId}/env-vars`;
+  try {
+    const response = await fetch(`${baseUrl}${envPath}`, {
+      headers: {
+        "Authorization": `Bearer ${credentials.accessToken}`
+      }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return (data.envVars || []).map((v) => v.key).sort();
+  } catch {
+    return [];
+  }
+}
+function generateEnvFile(keys) {
+  const lines = [
+    "// Auto-generated by Tether CLI - do not edit manually",
+    `// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "/**",
+    " * Typed environment variables for this project.",
+    " * Keys are fetched from the Tether API \u2014 values are never exposed.",
+    ' * Use `env.get("KEY")` in your functions to access them.',
+    " */",
+    ""
+  ];
+  if (keys.length > 0) {
+    lines.push("export type EnvVarKey =");
+    for (let i = 0; i < keys.length; i++) {
+      const sep = i === keys.length - 1 ? ";" : "";
+      lines.push(`  | '${keys[i]}'${sep}`);
+    }
+    lines.push("");
+    lines.push("export interface TetherEnv {");
+    for (const key of keys) {
+      lines.push(`  ${key}: string;`);
+    }
+    lines.push("}");
+  } else {
+    lines.push("export type EnvVarKey = string;");
+    lines.push("");
+    lines.push("export interface TetherEnv {");
+    lines.push("  [key: string]: string;");
+    lines.push("}");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function generateTypes(options = {}) {
+  const config = await loadConfig();
+  const schemaPath = resolvePath(config.schema);
+  const outputDir = resolvePath(config.output);
+  const functionsDir = resolvePath(config.functions);
+  if (!await fs3.pathExists(schemaPath)) {
+    throw new Error(`Schema file not found: ${schemaPath}`);
+  }
+  const schemaSource = await fs3.readFile(schemaPath, "utf-8");
+  const tables = parseSchemaFile(schemaSource);
+  const environment = config.environment || await resolveEnvironmentFromApiKey() || "development";
+  let projectId;
+  const envFilePath = path3.resolve(process.cwd(), ".env");
+  if (await fs3.pathExists(envFilePath)) {
+    const envContent = await fs3.readFile(envFilePath, "utf-8");
+    const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
+    projectId = match?.[1]?.trim();
+  }
+  const apiUrl = `${await resolveApiUrl(config)}/api/v1`;
+  const envVarKeys = projectId ? await fetchEnvVarKeys(projectId, environment, apiUrl) : [];
+  await fs3.ensureDir(outputDir);
+  await fs3.writeFile(
+    path3.join(outputDir, "db.ts"),
+    generateDbFile(tables, schemaSource)
+  );
+  await fs3.writeFile(
+    path3.join(outputDir, "api.ts"),
+    await generateApiFile(functionsDir)
+  );
+  await fs3.writeFile(
+    path3.join(outputDir, "env.ts"),
+    generateEnvFile(envVarKeys)
+  );
+  await fs3.writeFile(
+    path3.join(outputDir, "index.ts"),
+    `// Auto-generated by Tether CLI - do not edit manually
+export * from './db';
+export * from './api';
+export * from './env';
+`
+  );
+  return { tables, envVarKeys, outputDir };
+}
+async function generateCommand() {
+  await requireAuth();
+  const configPath = path3.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs3.pathExists(configPath)) {
+    console.log(chalk2.red("\nError: Not a Tether project"));
+    console.log(chalk2.dim("Run `tthr init` to create a new project\n"));
+    process.exit(1);
+  }
+  console.log(chalk2.bold("\n\u26A1 Generating types from schema\n"));
+  const spinner = ora("Reading schema...").start();
+  try {
+    spinner.text = "Generating types...";
+    const { tables, envVarKeys, outputDir } = await generateTypes();
+    if (tables.length === 0) {
+      spinner.warn("No tables found in schema");
+      console.log(chalk2.dim("  Make sure your schema uses defineSchema({ ... })\n"));
+      return;
+    }
+    spinner.succeed(`Types generated for ${tables.length} table(s)`);
+    console.log("\n" + chalk2.green("\u2713") + " Tables:");
+    for (const table of tables) {
+      console.log(chalk2.dim(`  - ${table.name} (${table.columns.length} columns)`));
+    }
+    if (envVarKeys.length > 0) {
+      console.log("\n" + chalk2.green("\u2713") + ` Environment variables: ${envVarKeys.length} key(s)`);
+      for (const key of envVarKeys) {
+        console.log(chalk2.dim(`  - ${key}`));
+      }
+    }
+    const relativeOutput = path3.relative(process.cwd(), outputDir);
+    console.log("\n" + chalk2.green("\u2713") + " Generated files:");
+    console.log(chalk2.dim(`  ${relativeOutput}/db.ts`));
+    console.log(chalk2.dim(`  ${relativeOutput}/api.ts`));
+    console.log(chalk2.dim(`  ${relativeOutput}/env.ts`));
+    console.log(chalk2.dim(`  ${relativeOutput}/index.ts
+`));
+  } catch (error) {
+    spinner.fail("Failed to generate types");
+    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+export {
+  loadConfig,
+  resolveEnvironmentFromApiKey,
+  getApiUrl,
+  resolveApiUrl,
+  resolvePath,
+  detectFramework,
+  getFrameworkDevCommand,
+  getCredentials,
+  requireAuth,
+  saveCredentials,
+  clearCredentials,
+  generateTypes,
+  generateCommand
+};

package/dist/generate-M7G5AXMR.js

@@ -0,0 +1,8 @@
+import {
+  generateCommand,
+  generateTypes
+} from "./chunk-DR6CWO75.js";
+export {
+  generateCommand,
+  generateTypes
+};

package/dist/index.js

@@ -4,15 +4,16 @@ import {
   detectFramework,
   generateCommand,
   generateTypes,
-  getApiUrl,
+  getApiUrl as getApiUrl2,
   getCredentials,
   getFrameworkDevCommand,
   loadConfig,
   requireAuth,
+  resolveApiUrl,
   resolveEnvironmentFromApiKey,
   resolvePath,
   saveCredentials
-} from "./chunk-6PDXNJZH.js";
+} from "./chunk-DR6CWO75.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -58,11 +59,11 @@ async function deployCommand(options) {
     process.exit(1);
   }
   const environment = options.env || config.environment || await resolveEnvironmentFromApiKey() || "development";
-  const API_URL3 = `${getApiUrl(config)}/api/v1`;
+  const API_URL2 = `${getApiUrl(config)}/api/v1`;
   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_URL3}
+  console.log(chalk.dim(`  API: ${API_URL2}
 `));
   console.log(chalk.dim("  Generating types..."));
   try {
@@ -75,16 +76,16 @@ async function deployCommand(options) {
   const deployFunctions = options.functions || !options.schema && !options.functions;
   if (deploySchema) {
     const schemaPath = resolvePath(config.schema);
-    await deploySchemaToServer(projectId, credentials.accessToken, schemaPath, environment, options.dryRun, API_URL3);
+    await deploySchemaToServer(projectId, credentials.accessToken, schemaPath, environment, options.dryRun, API_URL2);
   }
   if (deployFunctions) {
     const functionsDir = resolvePath(config.functions);
-    await deployFunctionsToServer(projectId, credentials.accessToken, functionsDir, environment, options.dryRun, API_URL3);
+    await deployFunctionsToServer(projectId, credentials.accessToken, functionsDir, environment, options.dryRun, API_URL2);
   }
   console.log(chalk.green("\n\u2713 Deployment complete\n"));
 }
 async function deploySchemaToServer(projectId, token, schemaPath, environment, dryRun, apiUrl) {
-  const API_URL3 = apiUrl || `${getApiUrl()}/api/v1`;
+  const API_URL2 = apiUrl || `${await resolveApiUrl()}/api/v1`;
   const spinner = ora("Reading schema...").start();
   try {
     if (!await fs.pathExists(schemaPath)) {
@@ -114,7 +115,7 @@ async function deploySchemaToServer(projectId, token, schemaPath, environment, d
       return;
     }
     spinner.text = "Deploying schema...";
-    const schemaUrl = `${API_URL3}/projects/${projectId}/env/${environment}/deploy/schema`;
+    const schemaUrl = `${API_URL2}/projects/${projectId}/env/${environment}/deploy/schema`;
     console.log(chalk.dim(`
   URL: ${schemaUrl}`));
     const rlsConfigs = tables.filter((t) => t.rls).map((t) => ({
@@ -189,7 +190,7 @@ ${messages.join("\n")}`);
   return result.outputFiles[0].text;
 }
 async function deployFunctionsToServer(projectId, token, functionsDir, environment, dryRun, apiUrl) {
-  const API_URL3 = apiUrl || `${getApiUrl()}/api/v1`;
+  const API_URL2 = apiUrl || `${await resolveApiUrl()}/api/v1`;
   const spinner = ora("Reading functions...").start();
   try {
     if (!await fs.pathExists(functionsDir)) {
@@ -246,7 +247,7 @@ ${helperSource}`;
       return;
     }
     spinner.text = "Deploying functions...";
-    const functionsUrl = `${API_URL3}/projects/${projectId}/env/${environment}/deploy/functions`;
+    const functionsUrl = `${API_URL2}/projects/${projectId}/env/${environment}/deploy/functions`;
     console.log(chalk.dim(`
   URL: ${functionsUrl}`));
     const response = await fetch(functionsUrl, {
@@ -584,7 +585,6 @@ function parseFunctions(moduleName, source) {
 }
 
 // src/commands/init.ts
-var API_URL = `${getApiUrl()}/api/v1`;
 async function getLatestVersion(packageName) {
   try {
     const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
@@ -686,7 +686,8 @@ ${packageManager} is not installed on your system.`));
       await scaffoldVanillaProject(projectName, projectPath, spinner);
     }
     spinner.text = "Creating project on Tether...";
-    const response = await fetch(`${API_URL}/projects`, {
+    const API_URL2 = `${await resolveApiUrl()}/api/v1`;
+    const response = await fetch(`${API_URL2}/projects`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1704,7 +1705,7 @@ async function runGenerate(spinner) {
   }
   isGenerating = true;
   try {
-    const { generateTypes: generateTypes2 } = await import("./generate-7DINPVQ5.js");
+    const { generateTypes: generateTypes2 } = await import("./generate-M7G5AXMR.js");
     spinner.text = "Regenerating types...";
     await generateTypes2({ silent: true });
     spinner.succeed("Types regenerated");
@@ -1812,7 +1813,7 @@ async function validateFunctions(functionsDir) {
   return { valid: errors.length === 0, errors };
 }
 function connectToEnvironment(projectId, environment, token, spinner, apiBase) {
-  const base = apiBase || getApiUrl();
+  const base = apiBase || getApiUrl2();
   const wsBase = base.replace("https://", "wss://").replace("http://", "ws://");
   const wsUrl = environment && environment !== "production" ? `${wsBase}/ws/${projectId}/${environment}?token=${encodeURIComponent(token)}` : `${wsBase}/ws/${projectId}?token=${encodeURIComponent(token)}`;
   let reconnectAttempts = 0;
@@ -1934,7 +1935,7 @@ async function devCommand(options) {
   const devCmd = config.dev?.command || getFrameworkDevCommand(framework);
   const environment = options.env || config.environment || "development";
   const isLocal = options.local ?? false;
-  const apiUrl = `${getApiUrl(config)}/api/v1`;
+  const apiUrl = `${getApiUrl2(config)}/api/v1`;
   console.log(chalk3.bold("\n\u26A1 Starting Tether development server\n"));
   if (framework !== "unknown") {
     console.log(chalk3.dim(`  Framework: ${framework}`));
@@ -1976,7 +1977,7 @@ async function devCommand(options) {
       }
     }
     spinner.text = "Generating types...";
-    const { generateTypes: generateTypes2 } = await import("./generate-7DINPVQ5.js");
+    const { generateTypes: generateTypes2 } = await import("./generate-M7G5AXMR.js");
     await generateTypes2({ silent: true });
     spinner.succeed("Types generated");
     if (config.projectId) {
@@ -2033,7 +2034,7 @@ async function devCommand(options) {
     }
     spinner.succeed("File watchers ready");
     if (config.projectId) {
-      connectToEnvironment(config.projectId, environment, credentials.accessToken, spinner, getApiUrl(config));
+      connectToEnvironment(config.projectId, environment, credentials.accessToken, spinner, getApiUrl2(config));
     }
     if (devCmd && !options.skipFramework) {
       spinner.start(`Starting ${framework} dev server...`);
@@ -2061,8 +2062,9 @@ import ora4 from "ora";
 import os from "os";
 import { exec } from "child_process";
 import readline from "readline";
-var API_URL2 = `${getApiUrl()}/api/v1`;
+var API_URL = "";
 async function loginCommand() {
+  API_URL = `${await resolveApiUrl()}/api/v1`;
   console.log(chalk4.bold("\u26A1 Login to Tether\n"));
   const existing = await getCredentials();
   if (existing) {
@@ -2070,6 +2072,8 @@ async function loginCommand() {
     console.log(chalk4.dim("\nRun `tthr logout` to sign out\n"));
     return;
   }
+  console.log(chalk4.dim(`  URL: ${API_URL}
+`));
   const spinner = ora4("Generating authentication code...").start();
   try {
     const deviceCode = await requestDeviceCode();
@@ -2080,10 +2084,13 @@ async function loginCommand() {
 `));
     console.log(chalk4.dim(`Your code: ${chalk4.white.bold(deviceCode.userCode)}
 `));
-    await waitForEnter(chalk4.dim("Press Enter to open in browser..."));
-    openBrowser(authUrl);
-    console.log();
-    const credentials = await pollForApproval(deviceCode.deviceCode, deviceCode.interval, deviceCode.expiresIn);
+    const pollPromise = pollForApproval(deviceCode.deviceCode, deviceCode.interval, deviceCode.expiresIn);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(chalk4.dim("Press Enter to open in browser..."), () => {
+      openBrowser(authUrl);
+    });
+    const credentials = await pollPromise;
+    rl.close();
     await saveCredentials(credentials);
     console.log(chalk4.green("\u2713") + ` Logged in as ${chalk4.cyan(credentials.email)}`);
     console.log();
@@ -2150,7 +2157,7 @@ async function requestDeviceCode() {
   const userCode = generateUserCode();
   const deviceCode = crypto.randomUUID();
   const deviceName = os.hostname();
-  const response = await fetch(`${API_URL2}/auth/device`, {
+  const response = await fetch(`${API_URL}/auth/device`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ userCode, deviceCode, deviceName })
@@ -2158,7 +2165,7 @@ async function requestDeviceCode() {
   if (response?.ok) {
     return await response.json();
   }
-  const baseUrl = getApiUrl().replace(/\/api\/v1$/, "");
+  const baseUrl = API_URL.replace(/\/api\/v1$/, "");
   return {
     deviceCode,
     userCode,
@@ -2186,9 +2193,12 @@ async function pollForApproval(deviceCode, interval, expiresIn) {
     while (Date.now() < expiresAt) {
       await sleep(interval * 1e3);
       spinner.text = `Checking... ${chalk4.dim(`(${Math.ceil((expiresAt - Date.now()) / 1e3)}s remaining)`)}`;
-      const response = await fetch(`${API_URL2}/auth/device/${deviceCode}`, {
-        method: "GET"
-      }).catch(() => null);
+      let response = null;
+      try {
+        response = await fetch(`${API_URL}/auth/device/${deviceCode}`);
+      } catch (err) {
+        spinner.text = `Waiting for approval... ${chalk4.dim(`(connection error, retrying)`)}`;
+      }
       updateCountdown();
       if (response?.ok) {
         const data = await response.json();
@@ -2204,6 +2214,8 @@ async function pollForApproval(deviceCode, interval, expiresIn) {
           spinner.fail("Authentication expired");
           throw new Error("Authentication request expired");
         }
+      } else if (response) {
+        spinner.text = `Waiting for approval... ${chalk4.dim(`(server: ${response.status})`)}`;
       }
     }
     spinner.fail("Authentication timed out");
@@ -2231,18 +2243,6 @@ function openBrowser(url) {
     }
   });
 }
-function waitForEnter(prompt) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    rl.question(prompt, () => {
-      rl.close();
-      resolve();
-    });
-  });
-}
 
 // src/commands/update.ts
 import chalk5 from "chalk";
@@ -2418,10 +2418,10 @@ async function execCommand(sql) {
     process.exit(1);
   }
   const config = await loadConfig();
-  const API_URL3 = `${getApiUrl(config)}/api/v1`;
+  const API_URL2 = `${getApiUrl2(config)}/api/v1`;
   const spinner = ora6("Executing query...").start();
   try {
-    const response = await fetch(`${API_URL3}/projects/${projectId}/exec`, {
+    const response = await fetch(`${API_URL2}/projects/${projectId}/exec`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -2471,9 +2471,9 @@ import chalk7 from "chalk";
 import ora7 from "ora";
 import fs6 from "fs-extra";
 import path6 from "path";
-async function resolveApiUrl() {
+async function resolveApiUrl2() {
   const config = await loadConfig();
-  return `${getApiUrl(config)}/api/v1`;
+  return `${getApiUrl2(config)}/api/v1`;
 }
 async function getProjectId() {
   const envPath = path6.resolve(process.cwd(), ".env");
@@ -2493,10 +2493,10 @@ async function getProjectId() {
 async function envListCommand() {
   const credentials = await requireAuth();
   const projectId = await getProjectId();
-  const API_URL3 = await resolveApiUrl();
+  const API_URL2 = await resolveApiUrl2();
   const spinner = ora7("Fetching environments...").start();
   try {
-    const response = await fetch(`${API_URL3}/projects/${projectId}/environments`, {
+    const response = await fetch(`${API_URL2}/projects/${projectId}/environments`, {
       headers: {
         "Authorization": `Bearer ${credentials.accessToken}`
       }
@@ -2526,7 +2526,7 @@ async function envListCommand() {
 async function envCreateCommand(name, options) {
   const credentials = await requireAuth();
   const projectId = await getProjectId();
-  const API_URL3 = await resolveApiUrl();
+  const API_URL2 = await resolveApiUrl2();
   const normalizedName = name.toLowerCase();
   if (!/^[a-z][a-z0-9-_]*$/.test(normalizedName)) {
     console.log(chalk7.red("\nError: Invalid environment name"));
@@ -2540,7 +2540,7 @@ async function envCreateCommand(name, options) {
       body.cloneFrom = options.from;
       spinner.text = `Creating environment '${normalizedName}' from '${options.from}'...`;
     }
-    const response = await fetch(`${API_URL3}/projects/${projectId}/environments`, {
+    const response = await fetch(`${API_URL2}/projects/${projectId}/environments`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -2569,10 +2569,10 @@ async function envCreateCommand(name, options) {
 async function envDeleteCommand(name) {
   const credentials = await requireAuth();
   const projectId = await getProjectId();
-  const API_URL3 = await resolveApiUrl();
+  const API_URL2 = await resolveApiUrl2();
   const spinner = ora7(`Deleting environment '${name}'...`).start();
   try {
-    const response = await fetch(`${API_URL3}/projects/${projectId}/environments/${name}`, {
+    const response = await fetch(`${API_URL2}/projects/${projectId}/environments/${name}`, {
       method: "DELETE",
       headers: {
         "Authorization": `Bearer ${credentials.accessToken}`
@@ -2592,10 +2592,10 @@ async function envDeleteCommand(name) {
 async function envDefaultCommand(name) {
   const credentials = await requireAuth();
   const projectId = await getProjectId();
-  const API_URL3 = await resolveApiUrl();
+  const API_URL2 = await resolveApiUrl2();
   const spinner = ora7(`Setting '${name}' as default environment...`).start();
   try {
-    const response = await fetch(`${API_URL3}/projects/${projectId}/environments/default`, {
+    const response = await fetch(`${API_URL2}/projects/${projectId}/environments/default`, {
       method: "PATCH",
       headers: {
         "Content-Type": "application/json",
@@ -2661,8 +2661,8 @@ async function migrateSystemColumnsCommand(options) {
   const spinner = ora8("Analysing database tables...").start();
   try {
     const config = await loadConfig();
-    const API_URL3 = `${getApiUrl(config)}/api/v1`;
-    const baseUrl = `${API_URL3}/projects/${projectId}/env/${environment}/migrate/system-columns`;
+    const API_URL2 = `${getApiUrl2(config)}/api/v1`;
+    const baseUrl = `${API_URL2}/projects/${projectId}/env/${environment}/migrate/system-columns`;
     const dryRunResponse = await fetch(`${baseUrl}?dry_run=true`, {
       method: "POST",
       headers: {

package/package.json

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