@tthr/cli 0.0.1

package/dist/chunk-MCKGQKYU.js

@@ -0,0 +1,15 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __require,
+  __commonJS
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,870 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+import fs2 from "fs-extra";
+import path2 from "path";
+
+// 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);
+  }
+  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/init.ts
+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 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(chalk2.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(chalk2.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: "Vue / Nuxt", value: "vue" },
+        { title: "Svelte / SvelteKit", value: "svelte" },
+        { title: "React / Next.js", value: "react" },
+        { title: "Vanilla JavaScript", value: "vanilla" }
+      ],
+      initial: 0
+    });
+    template = response.template || "vue";
+  }
+  const projectPath = path2.resolve(process.cwd(), projectName);
+  if (await fs2.pathExists(projectPath)) {
+    const { overwrite } = await prompts({
+      type: "confirm",
+      name: "overwrite",
+      message: `Directory ${projectName} already exists. Overwrite?`,
+      initial: false
+    });
+    if (!overwrite) {
+      console.log(chalk2.yellow("Cancelled"));
+      process.exit(0);
+    }
+    await fs2.remove(projectPath);
+  }
+  const spinner = ora("Creating project on Tether...").start();
+  let projectId;
+  let apiKey;
+  try {
+    const response = await fetch(`${API_URL}/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 = "Creating project structure...";
+    await fs2.ensureDir(projectPath);
+    await fs2.ensureDir(path2.join(projectPath, "tether"));
+    await fs2.ensureDir(path2.join(projectPath, "tether", "functions"));
+    await fs2.ensureDir(path2.join(projectPath, "_generated"));
+    await fs2.writeFile(
+      path2.join(projectPath, "tether.config.ts"),
+      `import { defineConfig } from '@tthr/cli';
+
+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 fs2.writeFile(
+      path2.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 fs2.writeFile(
+      path2.join(projectPath, "tether", "functions", "posts.ts"),
+      `import { query, mutation, z } from '@tthr/server';
+import { db } from '../../_generated/db';
+
+// List all posts
+export const list = query({
+  args: z.object({
+    limit: z.number().optional().default(20),
+  }),
+  handler: async ({ args }) => {
+    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 }) => {
+    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 }) => {
+    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 }) => {
+    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 }) => {
+    await db.posts.delete({
+      where: { id: args.id },
+    });
+  },
+});
+`
+    );
+    await fs2.writeFile(
+      path2.join(projectPath, "tether", "seed.ts"),
+      `import { db } from '../_generated/db';
+
+export async function seed() {
+  console.log('Seeding database...');
+
+  // Add your seed data here
+  const now = new Date().toISOString();
+
+  await db.posts.create({
+    data: {
+      id: 'post-1',
+      title: 'Welcome to Tether',
+      content: 'This is your first post. Edit or delete it to get started!',
+      authorId: 'system',
+      createdAt: now,
+      updatedAt: now,
+    },
+  });
+
+  console.log('Seeding complete!');
+}
+`
+    );
+    await fs2.writeFile(
+      path2.join(projectPath, ".env"),
+      `# Tether Configuration
+TETHER_PROJECT_ID=${projectId}
+TETHER_URL=${isDev ? "http://localhost:3001" : "https://tthr.io"}
+TETHER_API_KEY=${apiKey}
+`
+    );
+    await fs2.writeFile(
+      path2.join(projectPath, ".gitignore"),
+      `# Dependencies
+node_modules/
+
+# Build output
+dist/
+.output/
+
+# Generated files
+_generated/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+`
+    );
+    spinner.text = "Fetching latest package versions...";
+    const [
+      tthrClientVersion,
+      tthrSchemaVersion,
+      tthrServerVersion,
+      tthrCliVersion,
+      typescriptVersion,
+      tsxVersion
+    ] = await Promise.all([
+      getLatestVersion("@tthr/client"),
+      getLatestVersion("@tthr/schema"),
+      getLatestVersion("@tthr/server"),
+      getLatestVersion("@tthr/cli"),
+      getLatestVersion("typescript"),
+      getLatestVersion("tsx")
+    ]);
+    const dependencies = {
+      "@tthr/client": tthrClientVersion,
+      "@tthr/schema": tthrSchemaVersion,
+      "@tthr/server": tthrServerVersion
+    };
+    if (template === "vue") {
+      const [tthrVueVersion, vueVersion] = await Promise.all([
+        getLatestVersion("@tthr/vue"),
+        getLatestVersion("vue")
+      ]);
+      dependencies["@tthr/vue"] = tthrVueVersion;
+      dependencies["vue"] = vueVersion;
+    } else if (template === "react") {
+      const [tthrReactVersion, reactVersion, reactDomVersion] = await Promise.all([
+        getLatestVersion("@tthr/react"),
+        getLatestVersion("react"),
+        getLatestVersion("react-dom")
+      ]);
+      dependencies["@tthr/react"] = tthrReactVersion;
+      dependencies["react"] = reactVersion;
+      dependencies["react-dom"] = reactDomVersion;
+    } else if (template === "svelte") {
+      const [tthrSvelteVersion, svelteVersion] = await Promise.all([
+        getLatestVersion("@tthr/svelte"),
+        getLatestVersion("svelte")
+      ]);
+      dependencies["@tthr/svelte"] = tthrSvelteVersion;
+      dependencies["svelte"] = svelteVersion;
+    }
+    const packageJson = {
+      name: projectName,
+      version: "0.0.1",
+      private: true,
+      type: "module",
+      scripts: {
+        "dev": "tthr dev",
+        "generate": "tthr generate",
+        "migrate": "tthr migrate",
+        "seed": "tsx tether/seed.ts"
+      },
+      dependencies,
+      devDependencies: {
+        "@tthr/cli": tthrCliVersion,
+        "typescript": typescriptVersion,
+        "tsx": tsxVersion
+      }
+    };
+    await fs2.writeJSON(path2.join(projectPath, "package.json"), packageJson, { spaces: 2 });
+    await fs2.writeJSON(
+      path2.join(projectPath, "tsconfig.json"),
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          forceConsistentCasingInFileNames: true,
+          paths: {
+            "@/*": ["./*"]
+          }
+        },
+        include: ["**/*.ts"],
+        exclude: ["node_modules", "dist"]
+      },
+      { spaces: 2 }
+    );
+    spinner.succeed("Project structure created");
+    console.log("\n" + chalk2.green("\u2713") + " Project created successfully!\n");
+    console.log("Next steps:\n");
+    console.log(chalk2.cyan(`  cd ${projectName}`));
+    console.log(chalk2.cyan("  npm install"));
+    console.log(chalk2.cyan("  npm run dev"));
+    console.log("\n" + chalk2.dim("For more information, visit https://tthr.io/docs\n"));
+  } catch (error) {
+    spinner.fail("Failed to create project");
+    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/dev.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+import fs3 from "fs-extra";
+import path3 from "path";
+async function devCommand(options) {
+  await requireAuth();
+  const configPath = path3.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs3.pathExists(configPath)) {
+    console.log(chalk3.red("\nError: Not a Tether project"));
+    console.log(chalk3.dim("Run `tthr init` to create a new project\n"));
+    process.exit(1);
+  }
+  console.log(chalk3.bold("\n\u26A1 Starting Tether development server\n"));
+  const spinner = ora2("Starting server...").start();
+  try {
+    spinner.succeed(`Development server running on port ${options.port}`);
+    console.log("\n" + chalk3.cyan(`  Local:   http://localhost:${options.port}`));
+    console.log(chalk3.cyan(`  WebSocket: ws://localhost:${options.port}/ws
+`));
+    console.log(chalk3.dim("  Press Ctrl+C to stop\n"));
+    process.on("SIGINT", () => {
+      console.log(chalk3.yellow("\n\nShutting down...\n"));
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  } catch (error) {
+    spinner.fail("Failed to start server");
+    console.error(chalk3.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+import chalk4 from "chalk";
+import ora3 from "ora";
+import fs4 from "fs-extra";
+import path4 from "path";
+async function generateCommand() {
+  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 Generating types from schema\n"));
+  const spinner = ora3("Reading schema...").start();
+  try {
+    const schemaPath = path4.resolve(process.cwd(), "tether", "schema.ts");
+    const outputDir = path4.resolve(process.cwd(), "_generated");
+    if (!await fs4.pathExists(schemaPath)) {
+      spinner.fail("Schema file not found");
+      console.log(chalk4.dim(`Expected: ${schemaPath}
+`));
+      process.exit(1);
+    }
+    spinner.text = "Generating types...";
+    await fs4.ensureDir(outputDir);
+    await fs4.writeFile(
+      path4.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 fs4.writeFile(
+      path4.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 fs4.writeFile(
+      path4.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" + chalk4.green("\u2713") + " Generated files:");
+    console.log(chalk4.dim("  _generated/db.ts"));
+    console.log(chalk4.dim("  _generated/api.ts"));
+    console.log(chalk4.dim("  _generated/index.ts\n"));
+  } catch (error) {
+    spinner.fail("Failed to generate types");
+    console.error(chalk4.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/migrate.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+import fs5 from "fs-extra";
+import path5 from "path";
+import prompts2 from "prompts";
+async function migrateCommand(action, options) {
+  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);
+  }
+  const migrationsDir = path5.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(chalk5.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(chalk5.red("Migration name is required"));
+      process.exit(1);
+    }
+  }
+  const spinner = ora4("Creating migration...").start();
+  try {
+    await fs5.ensureDir(migrationsDir);
+    const timestamp = Date.now();
+    const filename = `${timestamp}_${migrationName}.sql`;
+    const filepath = path5.join(migrationsDir, filename);
+    await fs5.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(chalk5.dim(`
+  ${filepath}
+`));
+  } catch (error) {
+    spinner.fail("Failed to create migration");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function runMigrations(migrationsDir, direction) {
+  console.log(chalk5.bold(`
+\u26A1 Running migrations (${direction})
+`));
+  const spinner = ora4("Checking migrations...").start();
+  try {
+    if (!await fs5.pathExists(migrationsDir)) {
+      spinner.info("No migrations directory found");
+      console.log(chalk5.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      return;
+    }
+    const files = await fs5.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(chalk5.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(chalk5.dim(`  ${migration}`));
+    }
+    console.log(chalk5.yellow("\nNote: Migration execution not yet implemented\n"));
+  } catch (error) {
+    spinner.fail("Failed to run migrations");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function showStatus(migrationsDir) {
+  console.log(chalk5.bold("\n\u26A1 Migration status\n"));
+  try {
+    if (!await fs5.pathExists(migrationsDir)) {
+      console.log(chalk5.dim("No migrations directory found"));
+      console.log(chalk5.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      return;
+    }
+    const files = await fs5.readdir(migrationsDir);
+    const migrations = files.filter((f) => f.endsWith(".sql")).sort();
+    if (migrations.length === 0) {
+      console.log(chalk5.dim("No migrations found"));
+      console.log(chalk5.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(chalk5.yellow("  \u25CB") + ` ${migration} ${chalk5.dim("(pending)")}`);
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/login.ts
+import chalk6 from "chalk";
+import ora5 from "ora";
+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";
+var AUTH_URL = isDev2 ? "http://localhost:3000/cli" : "https://tthr.io/cli";
+async function loginCommand() {
+  console.log(chalk6.bold("\u26A1 Login to Tether\n"));
+  const existing = await getCredentials();
+  if (existing) {
+    console.log(chalk6.green("\u2713") + ` Already logged in as ${chalk6.cyan(existing.email)}`);
+    console.log(chalk6.dim("\nRun `tthr logout` to sign out\n"));
+    return;
+  }
+  const spinner = ora5("Generating authentication code...").start();
+  try {
+    const deviceCode = await requestDeviceCode();
+    spinner.stop();
+    const authUrl = `${AUTH_URL}/${deviceCode.userCode}`;
+    console.log(chalk6.dim("Open this URL in your browser to authenticate:\n"));
+    console.log(chalk6.cyan.bold(`  ${authUrl}
+`));
+    console.log(chalk6.dim(`Your code: ${chalk6.white.bold(deviceCode.userCode)}
+`));
+    const credentials = await pollForApproval(deviceCode.deviceCode, deviceCode.interval, deviceCode.expiresIn);
+    await saveCredentials(credentials);
+    console.log(chalk6.green("\u2713") + ` Logged in as ${chalk6.cyan(credentials.email)}`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+    console.log(chalk6.dim("\nTry again or visit https://tthr.io/docs/cli for help\n"));
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  console.log(chalk6.bold("\n\u26A1 Logout from Tether\n"));
+  const credentials = await getCredentials();
+  if (!credentials) {
+    console.log(chalk6.dim("Not logged in\n"));
+    return;
+  }
+  const spinner = ora5("Logging out...").start();
+  try {
+    await clearCredentials();
+    spinner.succeed(`Logged out from ${chalk6.cyan(credentials.email)}`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Logout failed");
+    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function whoamiCommand() {
+  const credentials = await getCredentials();
+  if (!credentials) {
+    console.log(chalk6.dim("\nNot logged in"));
+    console.log(chalk6.dim("Run `tthr login` to authenticate\n"));
+    return;
+  }
+  console.log(chalk6.bold("\n\u26A1 Current user\n"));
+  console.log(`  Email:   ${chalk6.cyan(credentials.email)}`);
+  console.log(`  User ID: ${chalk6.dim(credentials.userId)}`);
+  if (credentials.expiresAt) {
+    const expiresAt = new Date(credentials.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    if (expiresAt > now) {
+      console.log(`  Session: ${chalk6.green("Active")}`);
+    } else {
+      console.log(`  Session: ${chalk6.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_URL2}/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 = ora5("").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... ${chalk6.dim(`(${timeStr} remaining)`)}`;
+  };
+  updateCountdown();
+  const countdownInterval = setInterval(updateCountdown, 1e3);
+  try {
+    while (Date.now() < expiresAt) {
+      await sleep(interval * 1e3);
+      spinner.text = `Checking... ${chalk6.dim(`(${Math.ceil((expiresAt - Date.now()) / 1e3)}s remaining)`)}`;
+      const response = await fetch(`${API_URL2}/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("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();

package/dist/open-OC46UHP7.js

@@ -0,0 +1,344 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-MCKGQKYU.js";
+
+// ../../node_modules/open/node_modules/is-docker/index.js
+var require_is_docker = __commonJS({
+  "../../node_modules/open/node_modules/is-docker/index.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var isDocker;
+    function hasDockerEnv() {
+      try {
+        fs.statSync("/.dockerenv");
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }
+    function hasDockerCGroup() {
+      try {
+        return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+      } catch (_) {
+        return false;
+      }
+    }
+    module.exports = () => {
+      if (isDocker === void 0) {
+        isDocker = hasDockerEnv() || hasDockerCGroup();
+      }
+      return isDocker;
+    };
+  }
+});
+
+// ../../node_modules/open/node_modules/is-wsl/index.js
+var require_is_wsl = __commonJS({
+  "../../node_modules/open/node_modules/is-wsl/index.js"(exports, module) {
+    "use strict";
+    var os = __require("os");
+    var fs = __require("fs");
+    var isDocker = require_is_docker();
+    var isWsl = () => {
+      if (process.platform !== "linux") {
+        return false;
+      }
+      if (os.release().toLowerCase().includes("microsoft")) {
+        if (isDocker()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isDocker() : false;
+      } catch (_) {
+        return false;
+      }
+    };
+    if (process.env.__IS_WSL_TEST__) {
+      module.exports = isWsl;
+    } else {
+      module.exports = isWsl();
+    }
+  }
+});
+
+// ../../node_modules/define-lazy-prop/index.js
+var require_define_lazy_prop = __commonJS({
+  "../../node_modules/define-lazy-prop/index.js"(exports, module) {
+    "use strict";
+    module.exports = (object, propertyName, fn) => {
+      const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+      Object.defineProperty(object, propertyName, {
+        configurable: true,
+        enumerable: true,
+        get() {
+          const result = fn();
+          define(result);
+          return result;
+        },
+        set(value) {
+          define(value);
+        }
+      });
+      return object;
+    };
+  }
+});
+
+// ../../node_modules/open/index.js
+var require_open = __commonJS({
+  "../../node_modules/open/index.js"(exports, module) {
+    var path = __require("path");
+    var childProcess = __require("child_process");
+    var { promises: fs, constants: fsConstants } = __require("fs");
+    var isWsl = require_is_wsl();
+    var isDocker = require_is_docker();
+    var defineLazyProperty = require_define_lazy_prop();
+    var localXdgOpenPath = path.join(__dirname, "xdg-open");
+    var { platform, arch } = process;
+    var hasContainerEnv = () => {
+      try {
+        fs.statSync("/run/.containerenv");
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    var cachedResult;
+    function isInsideContainer() {
+      if (cachedResult === void 0) {
+        cachedResult = hasContainerEnv() || isDocker();
+      }
+      return cachedResult;
+    }
+    var getWslDrivesMountPoint = /* @__PURE__ */ (() => {
+      const defaultMountPoint = "/mnt/";
+      let mountPoint;
+      return async function() {
+        if (mountPoint) {
+          return mountPoint;
+        }
+        const configFilePath = "/etc/wsl.conf";
+        let isConfigFileExists = false;
+        try {
+          await fs.access(configFilePath, fsConstants.F_OK);
+          isConfigFileExists = true;
+        } catch {
+        }
+        if (!isConfigFileExists) {
+          return defaultMountPoint;
+        }
+        const configContent = await fs.readFile(configFilePath, { encoding: "utf8" });
+        const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+        if (!configMountPoint) {
+          return defaultMountPoint;
+        }
+        mountPoint = configMountPoint.groups.mountPoint.trim();
+        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+        return mountPoint;
+      };
+    })();
+    var pTryEach = async (array, mapper) => {
+      let latestError;
+      for (const item of array) {
+        try {
+          return await mapper(item);
+        } catch (error) {
+          latestError = error;
+        }
+      }
+      throw latestError;
+    };
+    var baseOpen = async (options) => {
+      options = {
+        wait: false,
+        background: false,
+        newInstance: false,
+        allowNonzeroExitCode: false,
+        ...options
+      };
+      if (Array.isArray(options.app)) {
+        return pTryEach(options.app, (singleApp) => baseOpen({
+          ...options,
+          app: singleApp
+        }));
+      }
+      let { name: app, arguments: appArguments = [] } = options.app || {};
+      appArguments = [...appArguments];
+      if (Array.isArray(app)) {
+        return pTryEach(app, (appName) => baseOpen({
+          ...options,
+          app: {
+            name: appName,
+            arguments: appArguments
+          }
+        }));
+      }
+      let command;
+      const cliArguments = [];
+      const childProcessOptions = {};
+      if (platform === "darwin") {
+        command = "open";
+        if (options.wait) {
+          cliArguments.push("--wait-apps");
+        }
+        if (options.background) {
+          cliArguments.push("--background");
+        }
+        if (options.newInstance) {
+          cliArguments.push("--new");
+        }
+        if (app) {
+          cliArguments.push("-a", app);
+        }
+      } else if (platform === "win32" || isWsl && !isInsideContainer() && !app) {
+        const mountPoint = await getWslDrivesMountPoint();
+        command = isWsl ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process.env.SYSTEMROOT}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+        cliArguments.push(
+          "-NoProfile",
+          "-NonInteractive",
+          "\u2013ExecutionPolicy",
+          "Bypass",
+          "-EncodedCommand"
+        );
+        if (!isWsl) {
+          childProcessOptions.windowsVerbatimArguments = true;
+        }
+        const encodedArguments = ["Start"];
+        if (options.wait) {
+          encodedArguments.push("-Wait");
+        }
+        if (app) {
+          encodedArguments.push(`"\`"${app}\`""`, "-ArgumentList");
+          if (options.target) {
+            appArguments.unshift(options.target);
+          }
+        } else if (options.target) {
+          encodedArguments.push(`"${options.target}"`);
+        }
+        if (appArguments.length > 0) {
+          appArguments = appArguments.map((arg) => `"\`"${arg}\`""`);
+          encodedArguments.push(appArguments.join(","));
+        }
+        options.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+      } else {
+        if (app) {
+          command = app;
+        } else {
+          const isBundled = !__dirname || __dirname === "/";
+          let exeLocalXdgOpen = false;
+          try {
+            await fs.access(localXdgOpenPath, fsConstants.X_OK);
+            exeLocalXdgOpen = true;
+          } catch {
+          }
+          const useSystemXdgOpen = process.versions.electron || platform === "android" || isBundled || !exeLocalXdgOpen;
+          command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+        }
+        if (appArguments.length > 0) {
+          cliArguments.push(...appArguments);
+        }
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+          childProcessOptions.detached = true;
+        }
+      }
+      if (options.target) {
+        cliArguments.push(options.target);
+      }
+      if (platform === "darwin" && appArguments.length > 0) {
+        cliArguments.push("--args", ...appArguments);
+      }
+      const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+      if (options.wait) {
+        return new Promise((resolve, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("close", (exitCode) => {
+            if (!options.allowNonzeroExitCode && exitCode > 0) {
+              reject(new Error(`Exited with code ${exitCode}`));
+              return;
+            }
+            resolve(subprocess);
+          });
+        });
+      }
+      subprocess.unref();
+      return subprocess;
+    };
+    var open = (target, options) => {
+      if (typeof target !== "string") {
+        throw new TypeError("Expected a `target`");
+      }
+      return baseOpen({
+        ...options,
+        target
+      });
+    };
+    var openApp = (name, options) => {
+      if (typeof name !== "string") {
+        throw new TypeError("Expected a `name`");
+      }
+      const { arguments: appArguments = [] } = options || {};
+      if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
+        throw new TypeError("Expected `appArguments` as Array type");
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name,
+          arguments: appArguments
+        }
+      });
+    };
+    function detectArchBinary(binary) {
+      if (typeof binary === "string" || Array.isArray(binary)) {
+        return binary;
+      }
+      const { [arch]: archBinary } = binary;
+      if (!archBinary) {
+        throw new Error(`${arch} is not supported`);
+      }
+      return archBinary;
+    }
+    function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+      if (wsl && isWsl) {
+        return detectArchBinary(wsl);
+      }
+      if (!platformBinary) {
+        throw new Error(`${platform} is not supported`);
+      }
+      return detectArchBinary(platformBinary);
+    }
+    var apps = {};
+    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+      darwin: "google chrome",
+      win32: "chrome",
+      linux: ["google-chrome", "google-chrome-stable", "chromium"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+        x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+      darwin: "firefox",
+      win32: "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
+      linux: "firefox"
+    }, {
+      wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+    }));
+    defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+      darwin: "microsoft edge",
+      win32: "msedge",
+      linux: ["microsoft-edge", "microsoft-edge-dev"]
+    }, {
+      wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+    }));
+    open.apps = apps;
+    open.openApp = openApp;
+    module.exports = open;
+  }
+});
+export default require_open();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@tthr/cli",
+  "version": "0.0.1",
+  "description": "Tether CLI - project scaffolding, migrations, and deployment",
+  "type": "module",
+  "bin": {
+    "tthr": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "typecheck": "tsc --noEmit",
+    "start": "TETHER_DEV=true node dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "chalk": "^5.4.1",
+    "ora": "^8.1.1",
+    "prompts": "^2.4.2",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.2"
+  }
+}