tthr 0.0.6

package/dist/index.js

@@ -0,0 +1,1766 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+import prompts from "prompts";
+import fs3 from "fs-extra";
+import path3 from "path";
+import { execSync } from "child_process";
+
+// src/utils/auth.ts
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+var CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || "", ".tether");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+async function getCredentials() {
+  try {
+    if (await fs.pathExists(CREDENTIALS_FILE)) {
+      return await fs.readJSON(CREDENTIALS_FILE);
+    }
+  } 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);
+    if (/* @__PURE__ */ new Date() > expiresAt) {
+      console.error(chalk.red("\n\u2717 Session expired\n"));
+      console.log(chalk.dim("Run `tthr login` to authenticate\n"));
+      process.exit(1);
+    }
+  }
+  return credentials;
+}
+async function saveCredentials(credentials) {
+  await fs.ensureDir(CONFIG_DIR);
+  await fs.writeJSON(CREDENTIALS_FILE, credentials, { spaces: 2, mode: 384 });
+}
+async function clearCredentials() {
+  try {
+    await fs.remove(CREDENTIALS_FILE);
+  } catch {
+  }
+}
+
+// src/commands/deploy.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import fs2 from "fs-extra";
+import path2 from "path";
+var isDev = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
+var API_URL = isDev ? "http://localhost:3001/api/v1" : "https://tthr.io/api/v1";
+async function deployCommand(options) {
+  const credentials = await requireAuth();
+  const configPath = path2.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs2.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);
+  }
+  const envPath = path2.resolve(process.cwd(), ".env");
+  let projectId;
+  if (await fs2.pathExists(envPath)) {
+    const envContent = await fs2.readFile(envPath, "utf-8");
+    const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
+    projectId = match?.[1]?.trim();
+  }
+  if (!projectId) {
+    console.log(chalk2.red("\nError: Project ID not found"));
+    console.log(chalk2.dim("Make sure TETHER_PROJECT_ID is set in your .env file\n"));
+    process.exit(1);
+  }
+  console.log(chalk2.bold("\n\u26A1 Deploying to Tether\n"));
+  console.log(chalk2.dim(`  Project: ${projectId}`));
+  console.log(chalk2.dim(`  API: ${API_URL}
+`));
+  const deploySchema = options.schema || !options.schema && !options.functions;
+  const deployFunctions = options.functions || !options.schema && !options.functions;
+  if (deploySchema) {
+    await deploySchemaToServer(projectId, credentials.accessToken, options.dryRun);
+  }
+  if (deployFunctions) {
+    await deployFunctionsToServer(projectId, credentials.accessToken, options.dryRun);
+  }
+  console.log(chalk2.green("\n\u2713 Deployment complete\n"));
+}
+async function deploySchemaToServer(projectId, token, dryRun) {
+  const spinner = ora("Reading schema...").start();
+  try {
+    const schemaPath = path2.resolve(process.cwd(), "tether", "schema.ts");
+    if (!await fs2.pathExists(schemaPath)) {
+      spinner.warn("No schema file found");
+      console.log(chalk2.dim("  Create tether/schema.ts to define your database schema\n"));
+      return;
+    }
+    const schemaSource = await fs2.readFile(schemaPath, "utf-8");
+    const tables = parseSchema(schemaSource);
+    spinner.text = `Found ${tables.length} table(s)`;
+    if (dryRun) {
+      spinner.info("Dry run - would deploy schema:");
+      for (const table of tables) {
+        console.log(chalk2.dim(`  - ${table.name}`));
+      }
+      return;
+    }
+    const sql = generateSchemaSQL(tables);
+    spinner.text = "Deploying schema...";
+    const response = await fetch(`${API_URL}/${projectId}/deploy/schema`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        sql,
+        tables: tables.map((t) => t.name)
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    spinner.succeed(`Schema deployed (${tables.length} table(s))`);
+  } catch (error) {
+    spinner.fail("Failed to deploy schema");
+    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+  }
+}
+async function deployFunctionsToServer(projectId, token, dryRun) {
+  const spinner = ora("Reading functions...").start();
+  try {
+    const functionsDir = path2.resolve(process.cwd(), "tether", "functions");
+    if (!await fs2.pathExists(functionsDir)) {
+      spinner.warn("No functions directory found");
+      console.log(chalk2.dim("  Create tether/functions/ to define your API functions\n"));
+      return;
+    }
+    const files = await fs2.readdir(functionsDir);
+    const tsFiles = files.filter((f) => f.endsWith(".ts"));
+    if (tsFiles.length === 0) {
+      spinner.info("No function files found");
+      return;
+    }
+    const functions = [];
+    for (const file of tsFiles) {
+      const filePath = path2.join(functionsDir, file);
+      const source = await fs2.readFile(filePath, "utf-8");
+      const moduleName = file.replace(".ts", "");
+      const parsedFunctions = parseFunctions(moduleName, source);
+      functions.push(...parsedFunctions);
+    }
+    spinner.text = `Found ${functions.length} function(s)`;
+    if (dryRun) {
+      spinner.info("Dry run - would deploy functions:");
+      for (const fn of functions) {
+        const icon = fn.type === "query" ? "\u{1F50D}" : fn.type === "mutation" ? "\u270F\uFE0F" : "\u26A1";
+        console.log(chalk2.dim(`  ${icon} ${fn.name} (${fn.type})`));
+      }
+      return;
+    }
+    spinner.text = "Deploying functions...";
+    const response = await fetch(`${API_URL}/${projectId}/deploy/functions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        functions: functions.map((fn) => ({
+          name: fn.name,
+          type: fn.type,
+          source: fn.source
+        }))
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    spinner.succeed(`Functions deployed (${functions.length} function(s))`);
+    const queries = functions.filter((f) => f.type === "query");
+    const mutations = functions.filter((f) => f.type === "mutation");
+    const actions = functions.filter((f) => f.type === "action");
+    if (queries.length > 0) {
+      console.log(chalk2.dim(`
+  Queries:`));
+      for (const fn of queries) {
+        console.log(chalk2.dim(`    - ${fn.name}`));
+      }
+    }
+    if (mutations.length > 0) {
+      console.log(chalk2.dim(`
+  Mutations:`));
+      for (const fn of mutations) {
+        console.log(chalk2.dim(`    - ${fn.name}`));
+      }
+    }
+    if (actions.length > 0) {
+      console.log(chalk2.dim(`
+  Actions:`));
+      for (const fn of actions) {
+        console.log(chalk2.dim(`    - ${fn.name}`));
+      }
+    }
+  } catch (error) {
+    spinner.fail("Failed to deploy functions");
+    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+  }
+}
+function parseSchema(source) {
+  const tables = [];
+  const schemaMatch = source.match(/defineSchema\s*\(\s*\{([\s\S]*)\}\s*\)/);
+  if (!schemaMatch) return tables;
+  const schemaContent = schemaMatch[1];
+  const tableRegex = /(\w+)\s*:\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}/g;
+  let match;
+  while ((match = tableRegex.exec(schemaContent)) !== null) {
+    const tableName = match[1];
+    const columnsContent = match[2];
+    const columns = {};
+    const columnRegex = /(\w+)\s*:\s*(\w+)\s*\(\s*\)([^,\n]*)/g;
+    let colMatch;
+    while ((colMatch = columnRegex.exec(columnsContent)) !== null) {
+      const colName = colMatch[1];
+      const colType = colMatch[2];
+      const modifiers = colMatch[3];
+      columns[colName] = {
+        type: colType,
+        primaryKey: modifiers.includes(".primaryKey()"),
+        notNull: modifiers.includes(".notNull()"),
+        unique: modifiers.includes(".unique()"),
+        hasDefault: modifiers.includes(".default("),
+        references: modifiers.match(/\.references\s*\(\s*['"]([^'"]+)['"]\s*\)/)?.[1]
+      };
+    }
+    tables.push({ name: tableName, columns });
+  }
+  return tables;
+}
+function generateSchemaSQL(tables) {
+  const statements = [];
+  for (const table of tables) {
+    const columnDefs = [];
+    for (const [colName, colDef] of Object.entries(table.columns)) {
+      const def = colDef;
+      let sqlType = "TEXT";
+      switch (def.type) {
+        case "text":
+          sqlType = "TEXT";
+          break;
+        case "integer":
+          sqlType = "INTEGER";
+          break;
+        case "real":
+          sqlType = "REAL";
+          break;
+        case "blob":
+          sqlType = "BLOB";
+          break;
+        case "timestamp":
+          sqlType = "TEXT";
+          break;
+        case "boolean":
+          sqlType = "INTEGER";
+          break;
+        case "json":
+          sqlType = "TEXT";
+          break;
+      }
+      let colSql = `${colName} ${sqlType}`;
+      if (def.primaryKey) colSql += " PRIMARY KEY";
+      if (def.notNull) colSql += " NOT NULL";
+      if (def.unique) colSql += " UNIQUE";
+      if (def.hasDefault && def.type === "timestamp") {
+        colSql += " DEFAULT (datetime('now'))";
+      }
+      if (def.references) {
+        const [refTable, refCol] = def.references.split(".");
+        colSql += ` REFERENCES ${refTable}(${refCol})`;
+      }
+      columnDefs.push(colSql);
+    }
+    statements.push(
+      `CREATE TABLE IF NOT EXISTS ${table.name} (
+  ${columnDefs.join(",\n  ")}
+);`
+    );
+  }
+  return statements.join("\n\n");
+}
+function parseFunctions(moduleName, source) {
+  const functions = [];
+  const exportRegex = /export\s+const\s+(\w+)\s*=\s*(query|mutation|action)\s*\(/g;
+  let match;
+  while ((match = exportRegex.exec(source)) !== null) {
+    const fnName = match[1];
+    const fnType = match[2];
+    const startIndex = match.index + match[0].length;
+    let depth = 1;
+    let endIndex = startIndex;
+    for (let i = startIndex; i < source.length && depth > 0; i++) {
+      const char = source[i];
+      if (char === "(" || char === "{") {
+        depth++;
+      } else if (char === ")" || char === "}") {
+        depth--;
+      }
+      endIndex = i;
+    }
+    const fnBody = source.slice(startIndex, endIndex);
+    functions.push({
+      name: `${moduleName}.${fnName}`,
+      type: fnType,
+      file: `${moduleName}.ts`,
+      source: `${fnType}(${fnBody})`
+    });
+  }
+  return functions;
+}
+
+// src/commands/init.ts
+var isDev2 = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
+var API_URL2 = isDev2 ? "http://localhost:3001/api/v1" : "https://tthr.io/api/v1";
+async function getLatestVersion(packageName) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+    if (!response.ok) {
+      return "latest";
+    }
+    const data = await response.json();
+    return `^${data.version}`;
+  } catch {
+    return "latest";
+  }
+}
+async function initCommand(name, options) {
+  const credentials = await requireAuth();
+  console.log(chalk3.bold("\n\u26A1 Create a new Tether project\n"));
+  let projectName = name;
+  if (!projectName) {
+    const response = await prompts({
+      type: "text",
+      name: "name",
+      message: "Project name:",
+      initial: "my-tether-app"
+    });
+    projectName = response.name;
+    if (!projectName) {
+      console.log(chalk3.red("Project name is required"));
+      process.exit(1);
+    }
+  }
+  let template = options.template;
+  if (options.template === "vue") {
+    const response = await prompts({
+      type: "select",
+      name: "template",
+      message: "Select a framework:",
+      choices: [
+        { title: "Nuxt (Vue)", value: "nuxt", description: "Full-stack Vue framework with SSR" },
+        { title: "Next.js (React)", value: "next", description: "Full-stack React framework with SSR" },
+        { title: "SvelteKit (Svelte)", value: "sveltekit", description: "Full-stack Svelte framework with SSR" },
+        { title: "Vanilla TypeScript", value: "vanilla", description: "Minimal setup for scripts and APIs" }
+      ],
+      initial: 0
+    });
+    template = response.template || "nuxt";
+  }
+  const projectPath = path3.resolve(process.cwd(), projectName);
+  if (await fs3.pathExists(projectPath)) {
+    const { overwrite } = await prompts({
+      type: "confirm",
+      name: "overwrite",
+      message: `Directory ${projectName} already exists. Overwrite?`,
+      initial: false
+    });
+    if (!overwrite) {
+      console.log(chalk3.yellow("Cancelled"));
+      process.exit(0);
+    }
+    await fs3.remove(projectPath);
+  }
+  const spinner = ora2("Creating project on Tether...").start();
+  let projectId;
+  let apiKey;
+  try {
+    const response = await fetch(`${API_URL2}/projects`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${credentials.accessToken}`
+      },
+      body: JSON.stringify({ name: projectName, source: "cli" })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(error.error || "Failed to create project on server");
+    }
+    const data = await response.json();
+    projectId = data.project.id;
+    apiKey = data.apiKey;
+    spinner.text = `Scaffolding ${template} project...`;
+    if (template === "nuxt") {
+      await scaffoldNuxtProject(projectName, projectPath, spinner);
+    } else if (template === "next") {
+      await scaffoldNextProject(projectName, projectPath, spinner);
+    } else if (template === "sveltekit") {
+      await scaffoldSvelteKitProject(projectName, projectPath, spinner);
+    } else {
+      await scaffoldVanillaProject(projectName, projectPath, spinner);
+    }
+    spinner.text = "Adding Tether configuration...";
+    await addTetherFiles(projectPath, projectId, apiKey, template);
+    spinner.text = "Configuring framework integration...";
+    await configureFramework(projectPath, template);
+    spinner.text = "Installing Tether packages...";
+    await installTetherPackages(projectPath, template);
+    spinner.text = "Creating demo page...";
+    await createDemoPage(projectPath, template);
+    spinner.succeed("Project created successfully!");
+    console.log("");
+    const originalCwd = process.cwd();
+    process.chdir(projectPath);
+    try {
+      await deployCommand({});
+    } finally {
+      process.chdir(originalCwd);
+    }
+    console.log("\n" + chalk3.green("\u2713") + " Project created successfully!\n");
+    console.log("Next steps:\n");
+    console.log(chalk3.cyan(`  cd ${projectName}`));
+    if (template === "vanilla") {
+      console.log(chalk3.cyan("  npm install"));
+    }
+    console.log(chalk3.cyan("  npm run dev"));
+    console.log("\n" + chalk3.dim("For more information, visit https://tthr.io/docs\n"));
+  } catch (error) {
+    spinner.fail("Failed to create project");
+    console.error(chalk3.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function scaffoldNuxtProject(projectName, projectPath, spinner) {
+  const parentDir = path3.dirname(projectPath);
+  spinner.stop();
+  console.log(chalk3.dim("\nRunning nuxi init...\n"));
+  try {
+    execSync(`npx nuxi@latest init ${projectName} --packageManager npm --gitInit false`, {
+      cwd: parentDir,
+      stdio: "inherit"
+    });
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
+      throw new Error("Nuxt project was not created successfully - package.json missing");
+    }
+    spinner.start();
+  } catch (error) {
+    spinner.start();
+    if (error instanceof Error && error.message.includes("package.json missing")) {
+      throw error;
+    }
+    throw new Error("Failed to create Nuxt project. Make sure you have npx installed.");
+  }
+}
+async function scaffoldNextProject(projectName, projectPath, spinner) {
+  const parentDir = path3.dirname(projectPath);
+  spinner.stop();
+  console.log(chalk3.dim("\nRunning create-next-app...\n"));
+  try {
+    execSync(`npx create-next-app@latest ${projectName} --typescript --eslint --tailwind --src-dir --app --import-alias "@/*" --use-npm`, {
+      cwd: parentDir,
+      stdio: "inherit"
+    });
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
+      throw new Error("Next.js project was not created successfully - package.json missing");
+    }
+    spinner.start();
+  } catch (error) {
+    spinner.start();
+    if (error instanceof Error && error.message.includes("package.json missing")) {
+      throw error;
+    }
+    throw new Error("Failed to create Next.js project. Make sure you have npx installed.");
+  }
+}
+async function scaffoldSvelteKitProject(projectName, projectPath, spinner) {
+  const parentDir = path3.dirname(projectPath);
+  spinner.stop();
+  console.log(chalk3.dim("\nRunning sv create...\n"));
+  try {
+    execSync(`npx sv create ${projectName} --template minimal --types ts --no-add-ons --no-install`, {
+      cwd: parentDir,
+      stdio: "inherit"
+    });
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
+      throw new Error("SvelteKit project was not created successfully - package.json missing");
+    }
+    spinner.start();
+  } catch (error) {
+    spinner.start();
+    if (error instanceof Error && error.message.includes("package.json missing")) {
+      throw error;
+    }
+    throw new Error("Failed to create SvelteKit project. Make sure you have npx installed.");
+  }
+}
+async function scaffoldVanillaProject(projectName, projectPath, spinner) {
+  spinner.text = "Creating vanilla TypeScript project...";
+  await fs3.ensureDir(projectPath);
+  await fs3.ensureDir(path3.join(projectPath, "src"));
+  const packageJson = {
+    name: projectName,
+    version: "0.0.1",
+    private: true,
+    type: "module",
+    scripts: {
+      "dev": "tsx watch src/index.ts",
+      "build": "tsc",
+      "start": "node dist/index.js"
+    },
+    devDependencies: {
+      "typescript": "latest",
+      "tsx": "latest",
+      "@types/node": "latest"
+    }
+  };
+  await fs3.writeJSON(path3.join(projectPath, "package.json"), packageJson, { spaces: 2 });
+  await fs3.writeJSON(
+    path3.join(projectPath, "tsconfig.json"),
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        outDir: "./dist",
+        rootDir: "./src",
+        paths: {
+          "@/*": ["./src/*"]
+        }
+      },
+      include: ["src/**/*.ts"],
+      exclude: ["node_modules", "dist"]
+    },
+    { spaces: 2 }
+  );
+  await fs3.writeFile(
+    path3.join(projectPath, "src", "index.ts"),
+    `import { createClient } from '@tthr/client';
+
+const tether = createClient({
+  projectId: process.env.TETHER_PROJECT_ID!,
+  url: process.env.TETHER_URL || 'https://tthr.io',
+});
+
+async function main() {
+  console.log('Hello from Tether!');
+
+  // Example: List all posts
+  // const posts = await tether.query('posts.list', { limit: 10 });
+  // console.log(posts);
+}
+
+main().catch(console.error);
+`
+  );
+  await fs3.writeFile(
+    path3.join(projectPath, ".gitignore"),
+    `node_modules/
+dist/
+.env
+.env.local
+.DS_Store
+`
+  );
+}
+async function addTetherFiles(projectPath, projectId, apiKey, template) {
+  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 fs3.writeFile(
+    path3.join(projectPath, "tether.config.ts"),
+    `import { defineConfig } from '${configPackage}';
+
+export default defineConfig({
+  // Project configuration
+  projectId: process.env.TETHER_PROJECT_ID,
+
+  // API endpoint (defaults to Tether Cloud)
+  url: process.env.TETHER_URL || 'https://tthr.io',
+
+  // Schema file location
+  schema: './tether/schema.ts',
+
+  // Functions directory
+  functions: './tether/functions',
+
+  // Generated types output
+  output: './_generated',
+});
+`
+  );
+  await fs3.writeFile(
+    path3.join(projectPath, "tether", "schema.ts"),
+    `import { defineSchema, text, integer, timestamp } from '@tthr/schema';
+
+export default defineSchema({
+  // Example: posts table
+  posts: {
+    id: text().primaryKey(),
+    title: text().notNull(),
+    content: text(),
+    authorId: text().notNull(),
+    createdAt: timestamp().notNull().default('now'),
+    updatedAt: timestamp().notNull().default('now'),
+  },
+
+  // Example: comments table
+  comments: {
+    id: text().primaryKey(),
+    postId: text().notNull().references('posts.id'),
+    content: text().notNull(),
+    authorId: text().notNull(),
+    createdAt: timestamp().notNull().default('now'),
+  },
+});
+`
+  );
+  await fs3.writeFile(
+    path3.join(projectPath, "tether", "functions", "posts.ts"),
+    `import { query, mutation, z } from '@tthr/server';
+
+// List all posts
+export const list = query({
+  args: z.object({
+    limit: z.number().optional().default(20),
+  }),
+  handler: async ({ args, db }) => {
+    return db.posts.findMany({
+      orderBy: { createdAt: 'desc' },
+      limit: args.limit,
+    });
+  },
+});
+
+// Get a single post
+export const get = query({
+  args: z.object({
+    id: z.string(),
+  }),
+  handler: async ({ args, db }) => {
+    return db.posts.findUnique({
+      where: { id: args.id },
+    });
+  },
+});
+
+// Create a new post
+export const create = mutation({
+  args: z.object({
+    title: z.string().min(1),
+    content: z.string().optional(),
+  }),
+  handler: async ({ args, ctx, db }) => {
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+
+    await db.posts.create({
+      data: {
+        id,
+        title: args.title,
+        content: args.content ?? '',
+        authorId: ctx.userId,
+        createdAt: now,
+        updatedAt: now,
+      },
+    });
+
+    return { id };
+  },
+});
+
+// Update a post
+export const update = mutation({
+  args: z.object({
+    id: z.string(),
+    title: z.string().min(1).optional(),
+    content: z.string().optional(),
+  }),
+  handler: async ({ args, db }) => {
+    await db.posts.update({
+      where: { id: args.id },
+      data: {
+        ...(args.title && { title: args.title }),
+        ...(args.content !== undefined && { content: args.content }),
+        updatedAt: new Date().toISOString(),
+      },
+    });
+  },
+});
+
+// Delete a post
+export const remove = mutation({
+  args: z.object({
+    id: z.string(),
+  }),
+  handler: async ({ args, db }) => {
+    await db.posts.delete({
+      where: { id: args.id },
+    });
+  },
+});
+`
+  );
+  const envContent = `# Tether Configuration
+TETHER_PROJECT_ID=${projectId}
+TETHER_URL=${isDev2 ? "http://localhost:3001" : "https://tthr.io"}
+TETHER_API_KEY=${apiKey}
+`;
+  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 fs3.writeFile(envPath, envContent);
+  }
+  const gitignorePath = path3.join(projectPath, ".gitignore");
+  const tetherGitignore = `
+# Tether
+_generated/
+.env
+.env.local
+`;
+  if (await fs3.pathExists(gitignorePath)) {
+    const existing = await fs3.readFile(gitignorePath, "utf-8");
+    if (!existing.includes("_generated/")) {
+      await fs3.writeFile(gitignorePath, existing + tetherGitignore);
+    }
+  } else {
+    await fs3.writeFile(gitignorePath, tetherGitignore.trim());
+  }
+}
+async function configureFramework(projectPath, template) {
+  if (template === "nuxt") {
+    await configureNuxt(projectPath);
+  } else if (template === "next") {
+    await configureNext(projectPath);
+  } else if (template === "sveltekit") {
+    await configureSvelteKit(projectPath);
+  }
+}
+async function configureNuxt(projectPath) {
+  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({
+  compatibilityDate: '2024-11-01',
+  devtools: { enabled: true },
+
+  modules: ['@tthr/vue/nuxt'],
+
+  tether: {
+    projectId: process.env.TETHER_PROJECT_ID,
+    url: process.env.TETHER_URL || 'https://tthr.io',
+  },
+});
+`
+    );
+    return;
+  }
+  let config = await fs3.readFile(configPath, "utf-8");
+  if (config.includes("modules:")) {
+    config = config.replace(
+      /modules:\s*\[/,
+      "modules: ['@tthr/vue/nuxt', "
+    );
+  } else {
+    config = config.replace(
+      /defineNuxtConfig\(\{/,
+      `defineNuxtConfig({
+  modules: ['@tthr/vue/nuxt'],
+`
+    );
+  }
+  if (!config.includes("tether:")) {
+    config = config.replace(
+      /(\}|\]|'|"|true|false|\d)\s*\n(\s*}\);?\s*)$/,
+      `$1,
+
+  tether: {
+    projectId: process.env.TETHER_PROJECT_ID,
+    url: process.env.TETHER_URL || 'https://tthr.io',
+  },
+});
+`
+    );
+  }
+  await fs3.writeFile(configPath, config);
+}
+async function configureNext(projectPath) {
+  const providersPath = path3.join(projectPath, "src", "app", "providers.tsx");
+  await fs3.writeFile(
+    providersPath,
+    `'use client';
+
+import { TetherProvider } from '@tthr/react';
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <TetherProvider
+      projectId={process.env.NEXT_PUBLIC_TETHER_PROJECT_ID!}
+      url={process.env.NEXT_PUBLIC_TETHER_URL || 'https://tthr.io'}
+    >
+      {children}
+    </TetherProvider>
+  );
+}
+`
+  );
+  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,
+        (match) => match + "import { Providers } from './providers';\n"
+      );
+    }
+    if (!layout.includes("<Providers>")) {
+      layout = layout.replace(
+        /(<body[^>]*>)([\s\S]*?)(<\/body>)/,
+        "$1<Providers>$2</Providers>$3"
+      );
+    }
+    await fs3.writeFile(layoutPath, layout);
+  }
+  const envLocalPath = path3.join(projectPath, ".env.local");
+  const nextEnvContent = `# Tether Configuration (client-side)
+NEXT_PUBLIC_TETHER_PROJECT_ID=\${TETHER_PROJECT_ID}
+NEXT_PUBLIC_TETHER_URL=\${TETHER_URL}
+`;
+  if (await fs3.pathExists(envLocalPath)) {
+    const existing = await fs3.readFile(envLocalPath, "utf-8");
+    await fs3.writeFile(envLocalPath, existing + "\n" + nextEnvContent);
+  } else {
+    await fs3.writeFile(envLocalPath, nextEnvContent);
+  }
+}
+async function configureSvelteKit(projectPath) {
+  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';
+
+export const tether = createClient({
+  projectId: PUBLIC_TETHER_PROJECT_ID,
+  url: PUBLIC_TETHER_URL || 'https://tthr.io',
+});
+`
+  );
+  const envPath = path3.join(projectPath, ".env");
+  const svelteEnvContent = `# Tether Configuration (public)
+PUBLIC_TETHER_PROJECT_ID=\${TETHER_PROJECT_ID}
+PUBLIC_TETHER_URL=\${TETHER_URL}
+`;
+  if (await fs3.pathExists(envPath)) {
+    const existing = await fs3.readFile(envPath, "utf-8");
+    if (!existing.includes("PUBLIC_TETHER_")) {
+      await fs3.writeFile(envPath, existing + "\n" + svelteEnvContent);
+    }
+  }
+}
+async function installTetherPackages(projectPath, template) {
+  const [
+    tthrClientVersion,
+    tthrSchemaVersion,
+    tthrServerVersion,
+    tthrCliVersion
+  ] = await Promise.all([
+    getLatestVersion("@tthr/client"),
+    getLatestVersion("@tthr/schema"),
+    getLatestVersion("@tthr/server"),
+    getLatestVersion("@tthr/cli")
+  ]);
+  const packages = [
+    `@tthr/client@${tthrClientVersion}`,
+    `@tthr/schema@${tthrSchemaVersion}`,
+    `@tthr/server@${tthrServerVersion}`
+  ];
+  const devPackages = [
+    `@tthr/cli@${tthrCliVersion}`
+  ];
+  if (template === "nuxt") {
+    const tthrVueVersion = await getLatestVersion("@tthr/vue");
+    packages.push(`@tthr/vue@${tthrVueVersion}`);
+  } else if (template === "next") {
+    const tthrReactVersion = await getLatestVersion("@tthr/react");
+    packages.push(`@tthr/react@${tthrReactVersion}`);
+  } else if (template === "sveltekit") {
+    const tthrSvelteVersion = await getLatestVersion("@tthr/svelte");
+    packages.push(`@tthr/svelte@${tthrSvelteVersion}`);
+  }
+  try {
+    execSync(`npm install ${packages.join(" ")}`, {
+      cwd: projectPath,
+      stdio: "pipe"
+    });
+    execSync(`npm install -D ${devPackages.join(" ")}`, {
+      cwd: projectPath,
+      stdio: "pipe"
+    });
+  } catch (error) {
+    console.warn(chalk3.yellow("\nNote: Some Tether packages may not be published yet."));
+  }
+}
+async function createDemoPage(projectPath, template) {
+  if (template === "nuxt") {
+    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 />
+</template>
+`
+    );
+  } else if (template === "next") {
+    const pagePath = path3.join(projectPath, "src", "app", "page.tsx");
+    await fs3.writeFile(
+      pagePath,
+      `'use client';
+
+import { useState } from 'react';
+import { useQuery, useMutation } from '@tthr/react';
+
+interface Post {
+  id: string;
+  title: string;
+  createdAt: string;
+}
+
+export default function Home() {
+  const [newPostTitle, setNewPostTitle] = useState('');
+  const { data: posts, isLoading, refetch } = useQuery<Post[]>('posts.list');
+  const { mutate: createPost, isPending } = useMutation('posts.create');
+  const { mutate: deletePost } = useMutation('posts.remove');
+
+  const handleCreatePost = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!newPostTitle.trim()) return;
+
+    await createPost({ title: newPostTitle.trim(), content: '' });
+    setNewPostTitle('');
+    refetch();
+  };
+
+  const handleDeletePost = async (id: string) => {
+    await deletePost({ id });
+    refetch();
+  };
+
+  return (
+    <main className="min-h-screen bg-gradient-to-br from-slate-900 via-purple-900 to-slate-900 text-white p-8">
+      <div className="max-w-2xl mx-auto space-y-8">
+        <header className="text-center space-y-4">
+          <h1 className="text-4xl font-bold bg-gradient-to-r from-indigo-400 to-purple-400 bg-clip-text text-transparent">
+            Welcome to Tether
+          </h1>
+          <p className="text-gray-400">Realtime SQLite for modern apps</p>
+        </header>
+
+        <section className="bg-white/5 border border-white/10 rounded-xl p-6 space-y-4">
+          <h2 className="text-xl font-semibold">Try it out</h2>
+          <p className="text-gray-400 text-sm">Create posts in realtime. Open in multiple tabs to see live updates!</p>
+
+          <form onSubmit={handleCreatePost} className="flex gap-3">
+            <input
+              type="text"
+              value={newPostTitle}
+              onChange={(e) => setNewPostTitle(e.target.value)}
+              placeholder="Enter a post title..."
+              className="flex-1 px-4 py-2 bg-black/30 border border-white/10 rounded-lg text-white placeholder-gray-500 focus:outline-none focus:border-indigo-500"
+              disabled={isPending}
+            />
+            <button
+              type="submit"
+              disabled={!newPostTitle.trim() || isPending}
+              className="px-6 py-2 bg-gradient-to-r from-indigo-500 to-purple-500 rounded-lg font-medium disabled:opacity-50 disabled:cursor-not-allowed hover:opacity-90 transition"
+            >
+              {isPending ? 'Creating...' : 'Create Post'}
+            </button>
+          </form>
+
+          <div className="space-y-2 min-h-[100px]">
+            {isLoading ? (
+              <p className="text-gray-500 text-center py-8">Loading posts...</p>
+            ) : posts?.length ? (
+              posts.map((post) => (
+                <div
+                  key={post.id}
+                  className="flex items-center justify-between p-3 bg-black/20 border border-white/5 rounded-lg hover:bg-black/30 transition"
+                >
+                  <div>
+                    <h3 className="font-medium">{post.title}</h3>
+                    <time className="text-xs text-gray-500">
+                      {new Date(post.createdAt).toLocaleDateString('en-GB', {
+                        day: 'numeric',
+                        month: 'short',
+                        year: 'numeric',
+                      })}
+                    </time>
+                  </div>
+                  <button
+                    onClick={() => handleDeletePost(post.id)}
+                    className="p-2 text-gray-500 hover:text-red-400 hover:bg-red-400/10 rounded transition"
+                  >
+                    <svg className="w-5 h-5" viewBox="0 0 20 20" fill="currentColor">
+                      <path fillRule="evenodd" d="M9 2a1 1 0 00-.894.553L7.382 4H4a1 1 0 000 2v10a2 2 0 002 2h8a2 2 0 002-2V6a1 1 0 100-2h-3.382l-.724-1.447A1 1 0 0011 2H9zM7 8a1 1 0 012 0v6a1 1 0 11-2 0V8zm5-1a1 1 0 00-1 1v6a1 1 0 102 0V8a1 1 0 00-1-1z" clipRule="evenodd" />
+                    </svg>
+                  </button>
+                </div>
+              ))
+            ) : (
+              <p className="text-gray-500 text-center py-8">No posts yet. Create your first one above!</p>
+            )}
+          </div>
+        </section>
+
+        <footer className="text-center text-gray-600 text-sm border-t border-white/5 pt-6">
+          Built with Tether by <a href="https://strands.gg" className="text-indigo-400 hover:underline">Strands Services</a>
+        </footer>
+      </div>
+    </main>
+  );
+}
+`
+    );
+  } else if (template === "sveltekit") {
+    const pagePath = path3.join(projectPath, "src", "routes", "+page.svelte");
+    await fs3.writeFile(
+      pagePath,
+      `<script lang="ts">
+  import { onMount } from 'svelte';
+  import { tether } from '$lib/tether';
+
+  interface Post {
+    id: string;
+    title: string;
+    createdAt: string;
+  }
+
+  let posts: Post[] = [];
+  let isLoading = true;
+  let newPostTitle = '';
+  let isPending = false;
+
+  onMount(async () => {
+    await loadPosts();
+  });
+
+  async function loadPosts() {
+    isLoading = true;
+    try {
+      posts = await tether.query('posts.list');
+    } catch (e) {
+      console.error('Failed to load posts:', e);
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  async function handleCreatePost() {
+    if (!newPostTitle.trim()) return;
+    isPending = true;
+    try {
+      await tether.mutation('posts.create', { title: newPostTitle.trim(), content: '' });
+      newPostTitle = '';
+      await loadPosts();
+    } catch (e) {
+      console.error('Failed to create post:', e);
+    } finally {
+      isPending = false;
+    }
+  }
+
+  async function handleDeletePost(id: string) {
+    try {
+      await tether.mutation('posts.remove', { id });
+      await loadPosts();
+    } catch (e) {
+      console.error('Failed to delete post:', e);
+    }
+  }
+
+  function formatDate(dateString: string): string {
+    return new Date(dateString).toLocaleDateString('en-GB', {
+      day: 'numeric',
+      month: 'short',
+      year: 'numeric',
+    });
+  }
+</script>
+
+<main>
+  <div class="container">
+    <header>
+      <h1>Welcome to Tether</h1>
+      <p>Realtime SQLite for modern apps</p>
+    </header>
+
+    <section class="demo">
+      <h2>Try it out</h2>
+      <p class="intro">Create posts in realtime. Open in multiple tabs to see live updates!</p>
+
+      <form on:submit|preventDefault={handleCreatePost}>
+        <input
+          type="text"
+          bind:value={newPostTitle}
+          placeholder="Enter a post title..."
+          disabled={isPending}
+        />
+        <button type="submit" disabled={!newPostTitle.trim() || isPending}>
+          {isPending ? 'Creating...' : 'Create Post'}
+        </button>
+      </form>
+
+      <div class="posts">
+        {#if isLoading}
+          <p class="empty">Loading posts...</p>
+        {:else if posts.length}
+          {#each posts as post (post.id)}
+            <article>
+              <div class="content">
+                <h3>{post.title}</h3>
+                <time>{formatDate(post.createdAt)}</time>
+              </div>
+              <button class="delete" on:click={() => handleDeletePost(post.id)}>
+                Delete
+              </button>
+            </article>
+          {/each}
+        {:else}
+          <p class="empty">No posts yet. Create your first one above!</p>
+        {/if}
+      </div>
+    </section>
+
+    <footer>
+      Built with Tether by <a href="https://strands.gg">Strands Services</a>
+    </footer>
+  </div>
+</main>
+
+<style>
+  main {
+    min-height: 100vh;
+    background: linear-gradient(135deg, #0f0f23 0%, #1a1a2e 50%, #16213e 100%);
+    color: #e4e4e7;
+    font-family: system-ui, sans-serif;
+    padding: 2rem;
+  }
+
+  .container {
+    max-width: 640px;
+    margin: 0 auto;
+    display: flex;
+    flex-direction: column;
+    gap: 2rem;
+  }
+
+  header {
+    text-align: center;
+  }
+
+  h1 {
+    font-size: 2.5rem;
+    background: linear-gradient(135deg, #6366f1 0%, #a855f7 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    margin: 0 0 0.5rem;
+  }
+
+  header p {
+    color: #a1a1aa;
+    margin: 0;
+  }
+
+  .demo {
+    background: rgba(255, 255, 255, 0.03);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    border-radius: 1rem;
+    padding: 1.5rem;
+  }
+
+  .demo h2 {
+    margin: 0 0 0.5rem;
+    font-size: 1.25rem;
+  }
+
+  .intro {
+    color: #a1a1aa;
+    font-size: 0.875rem;
+    margin: 0 0 1rem;
+  }
+
+  form {
+    display: flex;
+    gap: 0.75rem;
+    margin-bottom: 1rem;
+  }
+
+  input {
+    flex: 1;
+    padding: 0.75rem 1rem;
+    background: rgba(0, 0, 0, 0.3);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    border-radius: 0.5rem;
+    color: #e4e4e7;
+    font-size: 0.875rem;
+  }
+
+  input:focus {
+    outline: none;
+    border-color: #6366f1;
+  }
+
+  button {
+    padding: 0.75rem 1.5rem;
+    background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%);
+    border: none;
+    border-radius: 0.5rem;
+    color: white;
+    font-weight: 500;
+    cursor: pointer;
+  }
+
+  button:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .posts {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    min-height: 100px;
+  }
+
+  .empty {
+    color: #71717a;
+    text-align: center;
+    padding: 2rem;
+  }
+
+  article {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.875rem 1rem;
+    background: rgba(0, 0, 0, 0.2);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 0.5rem;
+  }
+
+  .content h3 {
+    margin: 0 0 0.25rem;
+    font-size: 0.9375rem;
+  }
+
+  .content time {
+    font-size: 0.75rem;
+    color: #71717a;
+  }
+
+  .delete {
+    padding: 0.5rem 1rem;
+    background: transparent;
+    border: 1px solid rgba(239, 68, 68, 0.3);
+    color: #fca5a5;
+    font-size: 0.75rem;
+  }
+
+  .delete:hover {
+    background: rgba(239, 68, 68, 0.1);
+  }
+
+  footer {
+    text-align: center;
+    color: #52525b;
+    font-size: 0.8125rem;
+    border-top: 1px solid rgba(255, 255, 255, 0.05);
+    padding-top: 1rem;
+  }
+
+  footer a {
+    color: #6366f1;
+    text-decoration: none;
+  }
+</style>
+`
+    );
+  }
+}
+
+// src/commands/dev.ts
+import chalk4 from "chalk";
+import ora3 from "ora";
+import fs4 from "fs-extra";
+import path4 from "path";
+async function devCommand(options) {
+  await requireAuth();
+  const configPath = path4.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs4.pathExists(configPath)) {
+    console.log(chalk4.red("\nError: Not a Tether project"));
+    console.log(chalk4.dim("Run `tthr init` to create a new project\n"));
+    process.exit(1);
+  }
+  console.log(chalk4.bold("\n\u26A1 Starting Tether development server\n"));
+  const spinner = ora3("Starting server...").start();
+  try {
+    spinner.succeed(`Development server running on port ${options.port}`);
+    console.log("\n" + chalk4.cyan(`  Local:   http://localhost:${options.port}`));
+    console.log(chalk4.cyan(`  WebSocket: ws://localhost:${options.port}/ws
+`));
+    console.log(chalk4.dim("  Press Ctrl+C to stop\n"));
+    process.on("SIGINT", () => {
+      console.log(chalk4.yellow("\n\nShutting down...\n"));
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  } catch (error) {
+    spinner.fail("Failed to start server");
+    console.error(chalk4.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+import fs5 from "fs-extra";
+import path5 from "path";
+async function generateCommand() {
+  await requireAuth();
+  const configPath = path5.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs5.pathExists(configPath)) {
+    console.log(chalk5.red("\nError: Not a Tether project"));
+    console.log(chalk5.dim("Run `tthr init` to create a new project\n"));
+    process.exit(1);
+  }
+  console.log(chalk5.bold("\n\u26A1 Generating types from schema\n"));
+  const spinner = ora4("Reading schema...").start();
+  try {
+    const schemaPath = path5.resolve(process.cwd(), "tether", "schema.ts");
+    const outputDir = path5.resolve(process.cwd(), "_generated");
+    if (!await fs5.pathExists(schemaPath)) {
+      spinner.fail("Schema file not found");
+      console.log(chalk5.dim(`Expected: ${schemaPath}
+`));
+      process.exit(1);
+    }
+    spinner.text = "Generating types...";
+    await fs5.ensureDir(outputDir);
+    await fs5.writeFile(
+      path5.join(outputDir, "db.ts"),
+      `// Auto-generated by Tether CLI - do not edit manually
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+import type { TetherDatabase } from '@tthr/client';
+
+export interface Post {
+  id: string;
+  title: string;
+  content: string | null;
+  authorId: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface Comment {
+  id: string;
+  postId: string;
+  content: string;
+  authorId: string;
+  createdAt: string;
+}
+
+export interface Schema {
+  posts: Post;
+  comments: Comment;
+}
+
+// Database client with typed tables
+export declare const db: TetherDatabase<Schema>;
+`
+    );
+    await fs5.writeFile(
+      path5.join(outputDir, "api.ts"),
+      `// Auto-generated by Tether CLI - do not edit manually
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+import type { TetherClient } from '@tthr/client';
+import type { Schema } from './db';
+
+export interface PostsApi {
+  list: (args?: { limit?: number }) => Promise<Schema['posts'][]>;
+  get: (args: { id: string }) => Promise<Schema['posts'] | null>;
+  create: (args: { title: string; content?: string }) => Promise<{ id: string }>;
+  update: (args: { id: string; title?: string; content?: string }) => Promise<void>;
+  remove: (args: { id: string }) => Promise<void>;
+}
+
+export interface Api {
+  posts: PostsApi;
+}
+
+// Typed Tether client
+export declare const tether: TetherClient<Api>;
+`
+    );
+    await fs5.writeFile(
+      path5.join(outputDir, "index.ts"),
+      `// Auto-generated by Tether CLI - do not edit manually
+export * from './db';
+export * from './api';
+`
+    );
+    spinner.succeed("Types generated");
+    console.log("\n" + chalk5.green("\u2713") + " Generated files:");
+    console.log(chalk5.dim("  _generated/db.ts"));
+    console.log(chalk5.dim("  _generated/api.ts"));
+    console.log(chalk5.dim("  _generated/index.ts\n"));
+  } catch (error) {
+    spinner.fail("Failed to generate types");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/migrate.ts
+import chalk6 from "chalk";
+import ora5 from "ora";
+import fs6 from "fs-extra";
+import path6 from "path";
+import prompts2 from "prompts";
+async function migrateCommand(action, options) {
+  await requireAuth();
+  const configPath = path6.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs6.pathExists(configPath)) {
+    console.log(chalk6.red("\nError: Not a Tether project"));
+    console.log(chalk6.dim("Run `tthr init` to create a new project\n"));
+    process.exit(1);
+  }
+  const migrationsDir = path6.resolve(process.cwd(), "tether", "migrations");
+  switch (action) {
+    case "create":
+      await createMigration(migrationsDir, options.name);
+      break;
+    case "up":
+      await runMigrations(migrationsDir, "up");
+      break;
+    case "down":
+      await runMigrations(migrationsDir, "down");
+      break;
+    case "status":
+    default:
+      await showStatus(migrationsDir);
+      break;
+  }
+}
+async function createMigration(migrationsDir, name) {
+  console.log(chalk6.bold("\n\u26A1 Create migration\n"));
+  let migrationName = name;
+  if (!migrationName) {
+    const response = await prompts2({
+      type: "text",
+      name: "name",
+      message: "Migration name:",
+      initial: "update_schema"
+    });
+    migrationName = response.name;
+    if (!migrationName) {
+      console.log(chalk6.red("Migration name is required"));
+      process.exit(1);
+    }
+  }
+  const spinner = ora5("Creating migration...").start();
+  try {
+    await fs6.ensureDir(migrationsDir);
+    const timestamp = Date.now();
+    const filename = `${timestamp}_${migrationName}.sql`;
+    const filepath = path6.join(migrationsDir, filename);
+    await fs6.writeFile(
+      filepath,
+      `-- Migration: ${migrationName}
+-- Created at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+-- Up migration
+-- Add your schema changes here
+
+-- Example:
+-- CREATE TABLE IF NOT EXISTS users (
+--   id TEXT PRIMARY KEY,
+--   email TEXT NOT NULL UNIQUE,
+--   name TEXT,
+--   created_at TEXT NOT NULL DEFAULT (datetime('now'))
+-- );
+
+-- Down migration (for rollback)
+-- DROP TABLE IF EXISTS users;
+`
+    );
+    spinner.succeed("Migration created");
+    console.log(chalk6.dim(`
+  ${filepath}
+`));
+  } catch (error) {
+    spinner.fail("Failed to create migration");
+    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function runMigrations(migrationsDir, direction) {
+  console.log(chalk6.bold(`
+\u26A1 Running migrations (${direction})
+`));
+  const spinner = ora5("Checking migrations...").start();
+  try {
+    if (!await fs6.pathExists(migrationsDir)) {
+      spinner.info("No migrations directory found");
+      console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      return;
+    }
+    const files = await fs6.readdir(migrationsDir);
+    const migrations = files.filter((f) => f.endsWith(".sql")).sort((a, b) => direction === "up" ? a.localeCompare(b) : b.localeCompare(a));
+    if (migrations.length === 0) {
+      spinner.info("No migrations found");
+      console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      return;
+    }
+    spinner.text = `Found ${migrations.length} migration(s)`;
+    spinner.succeed(`Would run ${migrations.length} migration(s)`);
+    console.log("\nMigrations to run:");
+    for (const migration of migrations) {
+      console.log(chalk6.dim(`  ${migration}`));
+    }
+    console.log(chalk6.yellow("\nNote: Migration execution not yet implemented\n"));
+  } catch (error) {
+    spinner.fail("Failed to run migrations");
+    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function showStatus(migrationsDir) {
+  console.log(chalk6.bold("\n\u26A1 Migration status\n"));
+  try {
+    if (!await fs6.pathExists(migrationsDir)) {
+      console.log(chalk6.dim("No migrations directory found"));
+      console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      return;
+    }
+    const files = await fs6.readdir(migrationsDir);
+    const migrations = files.filter((f) => f.endsWith(".sql")).sort();
+    if (migrations.length === 0) {
+      console.log(chalk6.dim("No migrations found"));
+      console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      return;
+    }
+    console.log(`Found ${migrations.length} migration(s):
+`);
+    for (const migration of migrations) {
+      console.log(chalk6.yellow("  \u25CB") + ` ${migration} ${chalk6.dim("(pending)")}`);
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/login.ts
+import chalk7 from "chalk";
+import ora6 from "ora";
+var isDev3 = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
+var API_URL3 = isDev3 ? "http://localhost:3001/api/v1" : "https://tthr.io/api/v1";
+var AUTH_URL = isDev3 ? "http://localhost:3000/cli" : "https://tthr.io/cli";
+async function loginCommand() {
+  console.log(chalk7.bold("\u26A1 Login to Tether\n"));
+  const existing = await getCredentials();
+  if (existing) {
+    console.log(chalk7.green("\u2713") + ` Already logged in as ${chalk7.cyan(existing.email)}`);
+    console.log(chalk7.dim("\nRun `tthr logout` to sign out\n"));
+    return;
+  }
+  const spinner = ora6("Generating authentication code...").start();
+  try {
+    const deviceCode = await requestDeviceCode();
+    spinner.stop();
+    const authUrl = `${AUTH_URL}/${deviceCode.userCode}`;
+    console.log(chalk7.dim("Open this URL in your browser to authenticate:\n"));
+    console.log(chalk7.cyan.bold(`  ${authUrl}
+`));
+    console.log(chalk7.dim(`Your code: ${chalk7.white.bold(deviceCode.userCode)}
+`));
+    const credentials = await pollForApproval(deviceCode.deviceCode, deviceCode.interval, deviceCode.expiresIn);
+    await saveCredentials(credentials);
+    console.log(chalk7.green("\u2713") + ` Logged in as ${chalk7.cyan(credentials.email)}`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    console.error(chalk7.red(error instanceof Error ? error.message : "Unknown error"));
+    console.log(chalk7.dim("\nTry again or visit https://tthr.io/docs/cli for help\n"));
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  console.log(chalk7.bold("\n\u26A1 Logout from Tether\n"));
+  const credentials = await getCredentials();
+  if (!credentials) {
+    console.log(chalk7.dim("Not logged in\n"));
+    return;
+  }
+  const spinner = ora6("Logging out...").start();
+  try {
+    await clearCredentials();
+    spinner.succeed(`Logged out from ${chalk7.cyan(credentials.email)}`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Logout failed");
+    console.error(chalk7.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function whoamiCommand() {
+  const credentials = await getCredentials();
+  if (!credentials) {
+    console.log(chalk7.dim("\nNot logged in"));
+    console.log(chalk7.dim("Run `tthr login` to authenticate\n"));
+    return;
+  }
+  console.log(chalk7.bold("\n\u26A1 Current user\n"));
+  console.log(`  Email:   ${chalk7.cyan(credentials.email)}`);
+  console.log(`  User ID: ${chalk7.dim(credentials.userId)}`);
+  if (credentials.expiresAt) {
+    const expiresAt = new Date(credentials.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    if (expiresAt > now) {
+      console.log(`  Session: ${chalk7.green("Active")}`);
+    } else {
+      console.log(`  Session: ${chalk7.yellow("Expired")}`);
+    }
+  }
+  console.log();
+}
+function generateUserCode() {
+  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ";
+  const nums = "23456789";
+  let code = "";
+  for (let i = 0; i < 4; i++) {
+    code += chars[Math.floor(Math.random() * chars.length)];
+  }
+  code += "-";
+  for (let i = 0; i < 4; i++) {
+    code += nums[Math.floor(Math.random() * nums.length)];
+  }
+  return code;
+}
+async function requestDeviceCode() {
+  const userCode = generateUserCode();
+  const deviceCode = crypto.randomUUID();
+  const response = await fetch(`${API_URL3}/auth/device`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ userCode, deviceCode })
+  }).catch(() => null);
+  if (response?.ok) {
+    return await response.json();
+  }
+  return {
+    deviceCode,
+    userCode,
+    expiresIn: 120,
+    // 2 minutes
+    interval: 5
+    // Poll every 5 seconds
+  };
+}
+async function pollForApproval(deviceCode, interval, expiresIn) {
+  const startTime = Date.now();
+  const expiresAt = startTime + expiresIn * 1e3;
+  const spinner = ora6("").start();
+  const updateCountdown = () => {
+    const remaining = Math.max(0, Math.ceil((expiresAt - Date.now()) / 1e3));
+    const mins = Math.floor(remaining / 60);
+    const secs = remaining % 60;
+    const timeStr = mins > 0 ? `${mins}:${secs.toString().padStart(2, "0")}` : `${secs}s`;
+    spinner.text = `Waiting for approval... ${chalk7.dim(`(${timeStr} remaining)`)}`;
+  };
+  updateCountdown();
+  const countdownInterval = setInterval(updateCountdown, 1e3);
+  try {
+    while (Date.now() < expiresAt) {
+      await sleep(interval * 1e3);
+      spinner.text = `Checking... ${chalk7.dim(`(${Math.ceil((expiresAt - Date.now()) / 1e3)}s remaining)`)}`;
+      const response = await fetch(`${API_URL3}/auth/device/${deviceCode}`, {
+        method: "GET"
+      }).catch(() => null);
+      updateCountdown();
+      if (response?.ok) {
+        const data = await response.json();
+        if (data.status === "approved" && data.credentials) {
+          spinner.stop();
+          return data.credentials;
+        }
+        if (data.status === "denied") {
+          spinner.fail("Authentication denied");
+          throw new Error("Authentication request was denied");
+        }
+        if (data.status === "expired") {
+          spinner.fail("Authentication expired");
+          throw new Error("Authentication request expired");
+        }
+      }
+    }
+    spinner.fail("Authentication timed out");
+    throw new Error("Authentication timed out");
+  } finally {
+    clearInterval(countdownInterval);
+    spinner.stop();
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("tthr").description("Tether CLI - Realtime SQLite for modern applications").version("0.0.1");
+program.command("init [name]").description("Create a new Tether project").option("-t, --template <template>", "Project template (vue, svelte, react, vanilla)", "vue").action(initCommand);
+program.command("dev").description("Start local development server with hot reload").option("-p, --port <port>", "Port to run on", "3001").action(devCommand);
+program.command("generate").alias("gen").description("Generate types from schema").action(generateCommand);
+program.command("migrate").description("Database migrations").argument("[action]", "Migration action: create, up, down, status", "status").option("-n, --name <name>", "Migration name (for create)").action(migrateCommand);
+program.command("deploy").description("Deploy schema and functions to Tether").option("-s, --schema", "Deploy schema only").option("-f, --functions", "Deploy functions only").option("--dry-run", "Show what would be deployed without deploying").action(deployCommand);
+program.command("login").description("Authenticate with Tether").action(loginCommand);
+program.command("logout").description("Sign out of Tether").action(logoutCommand);
+program.command("whoami").description("Show current authenticated user").action(whoamiCommand);
+program.parse();