d1s 0.2.13 → 0.3.0

package/dist/d1-studio.js

@@ -2,14 +2,63 @@
 import chalk from 'chalk';
 import open from 'open';
 import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
+import { dirname, join, resolve } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
 import express from 'express';
 import { createServer } from 'http';
 import next from 'next';
 import { findWranglerConfig } from './lib/find-wrangler-config.js';
 import logger from './lib/logger.js';
+import { activateLicense, getOrValidateLicense } from '../src/lib/license.js';
 import updateNotifier from 'update-notifier';
 import pkg from '../package.json' with { type: 'json' };
+import { trackEvent } from '../src/lib/telemetry.js';
+
+/**
+ * Detects wrangler credentials and optionally injects a Cloudflare API token.
+ *
+ * OAuth tokens from `wrangler login` are intentionally NOT injected as
+ * CLOUDFLARE_API_TOKEN — wrangler handles its own OAuth flow (including
+ * token refresh) when it finds the config file. Injecting the raw OAuth
+ * access token would bypass the refresh cycle and break auth when it expires.
+ *
+ * Only a real API token (api_token in the config, or CLOUDFLARE_API_TOKEN
+ * already in env) is injected so wrangler subprocesses inherit it explicitly.
+ *
+ * Returns 'injected' | 'oauth' | 'found' | null.
+ */
+function loadAndInjectWranglerCredentials() {
+  // If an explicit API token is already in the environment, nothing to do
+  if (process.env.CLOUDFLARE_API_TOKEN) return 'injected';
+
+  const home = homedir();
+  const candidates = [
+    join(home, 'Library', 'Preferences', '.wrangler', 'config', 'default.toml'), // macOS
+    join(home, '.config', '.wrangler', 'config', 'default.toml'),                 // Linux XDG
+    join(home, '.wrangler', 'config', 'default.toml'),                            // older versions
+  ];
+
+  for (const configPath of candidates) {
+    if (!existsSync(configPath)) continue;
+    try {
+      const content = readFileSync(configPath, 'utf8');
+      // Only inject a Cloudflare API token (not an OAuth access token)
+      const apiMatch = content.match(/api_token\s*=\s*"([^"]+)"/);
+      if (apiMatch?.[1]) {
+        process.env.CLOUDFLARE_API_TOKEN = apiMatch[1];
+        return 'injected';
+      }
+      // OAuth credentials from `wrangler login` — wrangler reads these itself
+      if (/oauth_token\s*=\s*"[^"]+"/.test(content)) return 'oauth';
+      // File exists but no usable token
+      return 'found';
+    } catch {
+      // Ignore read/parse errors, try next candidate
+    }
+  }
+  return null;
+}
 
 // Check for debug flag
 const hasDebugFlag = process.argv.includes('--debug');
@@ -18,6 +67,16 @@ if (hasDebugFlag) {
   logger.debug('Debug mode enabled');
 }
 
+// Parse --dir <path> to let users point at a project without cd-ing into it
+const dirFlagIndex = process.argv.indexOf('--dir');
+const dirFlag = dirFlagIndex !== -1 && process.argv[dirFlagIndex + 1]
+  ? resolve(process.argv[dirFlagIndex + 1])
+  : null;
+
+// Parse --license KEY to activate a Pro license
+const licenseFlagIndex = process.argv.indexOf('--license');
+const licenseFlag = licenseFlagIndex !== -1 ? process.argv[licenseFlagIndex + 1] : null;
+
 const notifier = updateNotifier({ 
   pkg,
   updateCheckInterval: 1000 * 60 * 60 * 24,
@@ -31,9 +90,8 @@ if (notifier.update) {
   
   // Version-specific messages
   const versionMessages = {
-    // Add specific version messages here
-    '0.2.11': 'Fixed table toolbar and table view horizontal/vertical scroll issues'
-    // Add more version messages as needed
+    '0.2.11': 'Fixed table toolbar and table view horizontal/vertical scroll issues',
+    '0.3.0': 'Per-db migrations_dir, seed exclusion from push, sidebar UX improvements',
   };
 
   // Create custom message
@@ -106,22 +164,21 @@ async function startServer(port, projectDirectory) {
 }
 
 async function startStudio() {
+  trackEvent('start', pkg.version); // fire-and-forget, never awaited
   try {
     logger.info(chalk.green('Initializing D1 Studio...'));
 
     // Get wrangler configuration
     try {
-      const userProjectPath = process.cwd();
-      if (!userProjectPath) {
-        logger.error(chalk.red('Error: Could not determine project directory'));
-        process.exit(1);
-      }
+      const userProjectPath = dirFlag || process.cwd();
 
       const wranglerResult = await findWranglerConfig(userProjectPath);
       if (!wranglerResult || !wranglerResult.config) {
-        logger.error(chalk.red('\nError: No wrangler.toml found in current directory'));
-        logger.info(chalk.yellow('Make sure you are in a Cloudflare Workers project directory'));
-        logger.info(chalk.yellow('with a valid wrangler.toml file.'));
+        logger.error(chalk.red(`\nError: No wrangler.toml found in: ${userProjectPath}`));
+        logger.info(chalk.yellow('\nTo fix this, either:'));
+        logger.info(chalk.cyan('  1. cd into your Cloudflare Workers project, then run d1s'));
+        logger.info(chalk.cyan('  2. Run d1s --dir /path/to/your-project'));
+        logger.info(chalk.gray('\nThe project must have a wrangler.toml with a [[d1_databases]] entry.'));
         process.exit(1);
       }
 
@@ -143,21 +200,53 @@ async function startStudio() {
         logger.info(chalk.blue(`  - ${db.database_name} (${db.binding})`));
       });
 
+      const credStatus = loadAndInjectWranglerCredentials();
+      if (credStatus === 'injected') {
+        logger.info(chalk.green('\n✓ Cloudflare API token found — remote sync & time travel ready'));
+      } else if (credStatus === 'oauth') {
+        logger.info(chalk.green('\n✓ Cloudflare credentials found (wrangler login) — remote sync & time travel ready'));
+      } else if (credStatus === 'found') {
+        logger.info(chalk.yellow('\n⚠ Wrangler config found but no usable token — run ' + chalk.cyan('wrangler login') + ' to enable Pro remote features'));
+      } else {
+        logger.info(chalk.yellow('\n⚠ No Cloudflare credentials — run ' + chalk.cyan('wrangler login') + ' to enable remote sync & time travel'));
+      }
+
+      // Validate license and set Pro status before starting the server
+      const license = await getOrValidateLicense();
+      process.env.D1_IS_PRO = license.isPro ? 'true' : 'false';
+
       const port = 4000;
       const url = `http://localhost:${port}`;
 
       await startServer(port, projectPath);
 
       logger.info(chalk.green(`
-    ┌─────────────────────────────────────────┐
-    │                                         │
-    │   D1 Studio is running on port ${port}    │
-    │                                         │
-    │   Local:  ${url}        │
-    │                                         │
-    └─────────────────────────────────────────┘
+    ┌─────────────────────────────────────────────────────┐
+    │                                                     │
+    │   d1-studio v${pkg.version} is ready                         │
+    │                                                     │
+    │   Local:   ${url}               │
+    │                                                     │
+    │   Free:    Table browser · SQL editor · Schema      │
+    │            Migrations · Import / Export             │
+    │   Pro:     Remote sync · Time travel                │
+    │            Multi-database switcher                  │
+    │                                                     │
+    └─────────────────────────────────────────────────────┘
       `));
 
+      if (license.isPro) {
+        logger.info(chalk.green(`  ✓ Pro features active — ${license.email}`));
+      } else {
+        logger.info(chalk.yellow(`  Run ${chalk.cyan('d1s --license YOUR-KEY')} to unlock Pro features`));
+      }
+
+      // Re-validate license every 4 hours in the background
+      setInterval(async () => {
+        const updated = await getOrValidateLicense().catch(() => null);
+        if (updated) process.env.D1_IS_PRO = updated.isPro ? 'true' : 'false';
+      }, 4 * 60 * 60 * 1000).unref();
+
       await new Promise(resolve => setTimeout(resolve, 2000));
 
       try {
@@ -193,7 +282,24 @@ process.on('SIGTERM', () => {
   process.exit(0);
 });
 
-startStudio().catch((error) => {
-  logger.error(chalk.red(`\nFailed to start D1 Studio: ${error}`));
-  process.exit(1);
-});
+if (licenseFlag) {
+  logger.info(chalk.blue('\nActivating license key...'));
+  activateLicense(licenseFlag)
+    .then((result) => {
+      logger.info(chalk.green('\n✓ License activated!'));
+      logger.info(chalk.white(`  Plan:    ${result.plan}`));
+      logger.info(chalk.white(`  Email:   ${result.email}`));
+      logger.info(chalk.white(`  Expires: ${new Date(result.expiresAt).toLocaleDateString()}`));
+      logger.info(chalk.gray('\nRun d1s to start D1 Studio with Pro features.'));
+      process.exit(0);
+    })
+    .catch((err) => {
+      logger.error(chalk.red(`\n✗ Activation failed: ${err.message}`));
+      process.exit(1);
+    });
+} else {
+  startStudio().catch((error) => {
+    logger.error(chalk.red(`\nFailed to start D1 Studio: ${error}`));
+    process.exit(1);
+  });
+}

package/dist/lib/license.js

@@ -3,97 +3,125 @@ import os from 'os';
 import { join } from 'path';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { createHash } from 'crypto';
-import { LicenseError } from './errors.js';
 
-export async function generateHardwareId() {
-  const osInfo = {
+const LICENSE_API =
+  process.env.D1STUDIO_API_URL ||
+  (process.env.NODE_ENV === 'development' ? 'http://localhost:3001' : 'https://d1-studio.com');
+
+const FOUR_HOURS_MS = 4 * 60 * 60 * 1000;
+
+const LICENSE_DIR = join(os.homedir(), '.d1studio');
+const LICENSE_PATH = join(LICENSE_DIR, 'license.json');
+
+export function generateHardwareId() {
+  const info = {
     platform: process.platform,
     arch: process.arch,
     cpus: os.cpus().length,
     hostname: os.hostname(),
-    username: os.userInfo().username
+    username: os.userInfo().username,
   };
-  
-  const systemString = JSON.stringify(osInfo);
-  return createHash('sha256').update(systemString).digest('hex');
+  return createHash('sha256').update(JSON.stringify(info)).digest('hex');
 }
 
-export async function checkLicenseFile() {
-  const licenseDir = join(os.homedir(), '.d1studio');
-  const licensePath = join(licenseDir, 'license.json');
-
+async function readLicenseFile() {
   try {
-    const licenseData = JSON.parse(await readFile(licensePath, 'utf8'));
-    const hardwareId = await generateHardwareId();
-
-    if (licenseData.hardwareId !== hardwareId) {
-      return null;
-    }
-
-    return licenseData;
-  } catch (error) {
+    return JSON.parse(await readFile(LICENSE_PATH, 'utf8'));
+  } catch {
     return null;
   }
 }
 
-export async function saveLicenseFile(licenseData) {
-  const licenseDir = join(os.homedir(), '.d1studio');
-  const licensePath = join(licenseDir, 'license.json');
+export async function saveLicenseFile(data) {
+  await mkdir(LICENSE_DIR, { recursive: true });
+  await writeFile(LICENSE_PATH, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Activates a license key for this machine.
+ * Called once when user passes --license KEY.
+ * Returns { valid, plan, email, expiresAt } on success.
+ */
+export async function activateLicense(key) {
+  const fingerprint = generateHardwareId();
 
+  const res = await fetch(`${LICENSE_API}/api/license/activate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ key: key.trim().toUpperCase(), fingerprint }),
+    signal: AbortSignal.timeout(10000),
+  });
+
+  let data;
   try {
-    await mkdir(licenseDir, { recursive: true });
-    await writeFile(licensePath, JSON.stringify(licenseData, null, 2));
-  } catch (error) {
-    throw new LicenseError('Failed to save license information', 'SAVE_ERROR');
+    data = await res.json();
+  } catch {
+    throw new Error(`Server returned an invalid response (status ${res.status}). Is d1studio-web running?`);
+  }
+
+  if (!res.ok || !data.valid) {
+    throw new Error(data.error || 'License activation failed');
   }
+
+  await saveLicenseFile({
+    licenseKey: key.trim().toUpperCase(),
+    fingerprint,
+    email: data.email,
+    plan: data.plan,
+    expiresAt: data.expiresAt,
+    lastValidated: new Date().toISOString(),
+    isPro: true,
+  });
+
+  return data;
 }
 
-export async function validateLicenseRemote(licenseKey, email, hardwareId) {
-  const baseUrl = process.env.NODE_ENV === 'development' 
-    ? 'http://localhost:4000' 
-    : 'https://d1-studio.com';
+/**
+ * Validates the stored license against the remote API.
+ * Main entry point — called on startup and every 4 hours.
+ * Returns { isPro: boolean, plan?, expiresAt?, email? }
+ */
+export async function getOrValidateLicense() {
+  const stored = await readLicenseFile();
+  if (!stored?.licenseKey) return { isPro: false };
+
+  const lastValidated = stored.lastValidated ? new Date(stored.lastValidated) : null;
+  const isStale = !lastValidated || Date.now() - lastValidated.getTime() > FOUR_HOURS_MS;
+
+  if (!isStale) {
+    return {
+      isPro: !!stored.isPro,
+      plan: stored.plan,
+      expiresAt: stored.expiresAt,
+      email: stored.email,
+    };
+  }
 
+  // Stale — re-validate remotely
   try {
-    const response = await fetch(`${baseUrl}/api/validate-license`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        licenseKey,
-        email,
-        hardwareId
-      })
+    const res = await fetch(
+      `${LICENSE_API}/api/license/validate?key=${encodeURIComponent(stored.licenseKey)}`,
+      { signal: AbortSignal.timeout(8000) }
+    );
+    const remote = await res.json();
+    const isPro = remote.valid === true;
+
+    await saveLicenseFile({
+      ...stored,
+      isPro,
+      plan: remote.plan ?? stored.plan,
+      expiresAt: remote.expiresAt ?? stored.expiresAt,
+      lastValidated: new Date().toISOString(),
     });
 
-    const result = await response.json();
-
-    if (!response.ok) {
-      throw new LicenseError(
-        result.message || 'License validation failed',
-        result.type || 'VALIDATION_ERROR'
-      );
-    }
-
-    return result;
-
-  } catch (error) {
-    if (error instanceof LicenseError) {
-      throw error;
-    }
-
-    if (error.name === 'TypeError' && error.message.includes('fetch')) {
-      throw new LicenseError(
-        process.env.NODE_ENV === 'development'
-          ? 'Unable to connect to local license validation service. Make sure the development server is running.'
-          : 'Unable to connect to license server. Please check your internet connection.',
-        'CONNECTION_ERROR'
-      );
-    }
-    
-    throw new LicenseError(
-      'An unexpected error occurred during license validation',
-      'VALIDATION_ERROR'
-    );
+    return { isPro, plan: remote.plan, expiresAt: remote.expiresAt, email: stored.email };
+  } catch {
+    // Network error — honour existing cached status as grace period
+    return {
+      isPro: !!stored.isPro,
+      plan: stored.plan,
+      expiresAt: stored.expiresAt,
+      email: stored.email,
+    };
   }
-}
+}

package/dist/lib/local-db.js

@@ -0,0 +1,223 @@
+// lib/local-db.js
+// Direct SQLite access for local D1 databases via better-sqlite3.
+// Falls back gracefully — callers receive null and can retry with wrangler CLI.
+
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+import Database from 'better-sqlite3';
+import logger from './logger.js';
+
+const MINIFLARE_DIR = path.join('.wrangler', 'state', 'v3', 'd1', 'miniflare-D1DatabaseObject');
+
+// Cache open Database instances: "projectDir:dbName" → Database
+const dbCache = new Map();
+
+function sha256(input) {
+  return crypto.createHash('sha256').update(input).digest('hex');
+}
+
+/**
+ * Locate the SQLite file for a given database config under projectDir.
+ * Wrangler/miniflare v3 stores D1 as:
+ *   .wrangler/state/v3/d1/miniflare-D1DatabaseObject/{hash}.sqlite
+ *
+ * The hash is SHA256 of the namespace key. We try the most common formulas
+ * then fall back to a single-file directory scan.
+ */
+function findSqliteFile(projectDir, databaseConfig) {
+  const dir = path.join(projectDir, MINIFLARE_DIR);
+  if (!fs.existsSync(dir)) return null;
+
+  const { database_id, database_name, binding } = databaseConfig;
+
+  // Try known miniflare v3 hash formulas. Wrangler/miniflare derives the SQLite
+  // filename as sha256 of a namespace key — try all known patterns.
+  const ids = [database_id, database_name, binding].filter(Boolean);
+  const prefixes = [
+    '',
+    'miniflare-D1DatabaseObject:',
+    'D1DatabaseObject:',
+    'd1:',
+  ];
+  const candidates = ids.flatMap(id =>
+    prefixes.map(prefix => sha256(`${prefix}${id}`))
+  ).map(h => path.join(dir, `${h}.sqlite`));
+
+  const found = candidates.find(p => fs.existsSync(p));
+  if (found) return found;
+
+  // Fallback: scan for .sqlite files.
+  // Only use this for single-DB projects — if multiple files exist, returning
+  // the wrong one would mix up tables from different databases. In that case
+  // return null so the caller falls back to wrangler CLI (which knows the mapping).
+  const files = fs.readdirSync(dir)
+    .filter(f => f.endsWith('.sqlite'))
+    .map(f => ({ name: f, fullPath: path.join(dir, f), mtime: fs.statSync(path.join(dir, f)).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime);
+
+  if (files.length === 1) {
+    return files[0].fullPath;
+  }
+
+  if (files.length > 1) {
+    logger.debug(`[local-db] Multiple SQLite files, no hash matched — falling back to wrangler CLI. dir=${dir}, tried ids=${JSON.stringify(ids)}`);
+  }
+
+  logger.debug(`[local-db] No SQLite files found. dir=${dir}, tried ids=${JSON.stringify(ids)}`);
+  return null;
+}
+
+/**
+ * Returns true if a local SQLite file exists for the given database config.
+ * Does NOT open the file — safe for status checks.
+ */
+export function hasLocalDb(projectDir, databaseConfig) {
+  return findSqliteFile(projectDir, databaseConfig) !== null;
+}
+
+/**
+ * Get (or create) a cached better-sqlite3 Database instance.
+ * Returns null if the SQLite file cannot be located.
+ */
+export function getLocalDb(projectDir, databaseConfig) {
+  const key = `${projectDir}:${databaseConfig.database_name}`;
+  // Always re-resolve the path so stale cache entries (wrong file) are evicted
+  const sqlitePath = findSqliteFile(projectDir, databaseConfig);
+
+  if (dbCache.has(key)) {
+    const cached = dbCache.get(key);
+    if (cached.path !== sqlitePath) {
+      // Path changed or is now null — evict stale entry
+      try { cached.db.close(); } catch {}
+      dbCache.delete(key);
+    } else {
+      // Same path — verify the connection is still responsive
+      try { cached.db.prepare('SELECT 1').get(); return cached.db; } catch { dbCache.delete(key); }
+    }
+  }
+
+  if (!sqlitePath) return null;
+
+  try {
+    const db = new Database(sqlitePath, { fileMustExist: false });
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    dbCache.set(key, { db, path: sqlitePath });
+    return db;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Execute a SQL statement via better-sqlite3 and return a JSON string
+ * matching the shape wrangler d1 execute --json returns:
+ *   [{ results: [...rows], success: true, meta: { ... } }]
+ *
+ * Returns null if the database file cannot be found (caller should fall back to wrangler CLI).
+ * Throws on SQL errors (same contract as executeSQL in sql-operations.js).
+ */
+export function executeLocalSQL(projectDir, databaseConfig, sql) {
+  const db = getLocalDb(projectDir, databaseConfig);
+  if (!db) return null;
+
+  const trimmed = sql.trim();
+  const upper = trimmed.toUpperCase().replace(/\s+/g, ' ');
+
+  // Multi-statement: split on ';' and run each — needed for DDL batches
+  const statements = trimmed
+    .split(';')
+    .map(s => s.trim())
+    .filter(Boolean);
+
+  if (statements.length > 1) {
+    // Run all statements in a single transaction, collect results
+    let allResults = [];
+    let totalChanges = 0;
+    let lastInsertRowid = 0;
+
+    const runAll = db.transaction(() => {
+      for (const stmt of statements) {
+        const u = stmt.toUpperCase().replace(/\s+/g, ' ');
+        const isRead = u.startsWith('SELECT') || u.startsWith('PRAGMA') || u.startsWith('EXPLAIN');
+        if (isRead) {
+          const rows = db.prepare(stmt).all();
+          allResults = allResults.concat(rows);
+        } else {
+          const info = db.prepare(stmt).run();
+          totalChanges += info.changes;
+          lastInsertRowid = info.lastInsertRowid;
+        }
+      }
+    });
+
+    runAll();
+    return JSON.stringify([{
+      results: allResults,
+      success: true,
+      meta: { changes: totalChanges, last_row_id: lastInsertRowid, rows_read: allResults.length, rows_written: totalChanges }
+    }]);
+  }
+
+  // Single statement
+  const isRead = upper.startsWith('SELECT') || upper.startsWith('PRAGMA') || upper.startsWith('EXPLAIN');
+
+  if (isRead) {
+    const rows = db.prepare(trimmed).all();
+    return JSON.stringify([{
+      results: rows,
+      success: true,
+      meta: { rows_read: rows.length, rows_written: 0, changed_db: false }
+    }]);
+  }
+
+  const info = db.prepare(trimmed).run();
+  return JSON.stringify([{
+    results: [],
+    success: true,
+    meta: {
+      changes: info.changes,
+      last_row_id: info.lastInsertRowid,
+      rows_read: 0,
+      rows_written: info.changes,
+      changed_db: info.changes > 0
+    }
+  }]);
+}
+
+/**
+ * Execute a batch INSERT using a better-sqlite3 transaction.
+ * rows: array of value arrays matching the columns order.
+ * Returns { changes } on success, null if DB file not found.
+ */
+export function executeLocalBatchInsert(projectDir, databaseConfig, sql, rows) {
+  const db = getLocalDb(projectDir, databaseConfig);
+  if (!db) return null;
+
+  const stmt = db.prepare(sql);
+  let totalChanges = 0;
+
+  const insertMany = db.transaction((records) => {
+    for (const row of records) {
+      const info = stmt.run(...row);
+      totalChanges += info.changes;
+    }
+  });
+
+  insertMany(rows);
+  return { changes: totalChanges };
+}
+
+/**
+ * Invalidate the cached Database instance for a given database.
+ * Call this if the SQLite file path may have changed (e.g. after wrangler reinit).
+ */
+export function invalidateLocalDb(projectDir, databaseName) {
+  const key = `${projectDir}:${databaseName}`;
+  const entry = dbCache.get(key);
+  if (entry) {
+    try { entry.db.close(); } catch { /* ignore */ }
+    dbCache.delete(key);
+  }
+}