@tgcloud/cli 0.1.0

package/src/core/credentials.js

@@ -0,0 +1,229 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { askPassword } from '../utils/prompt.js';
+import { ensureTgcloudDir } from './state.js';
+import { request } from '../api/client.js';
+import { error, warn, fatal } from '../utils/logger.js';
+
+const TGCLOUD_DIR = '.tgcloud';
+const CREDENTIALS_FILE = path.join(TGCLOUD_DIR, 'credentials');
+const ENV_VAR = 'TGCLOUD_TOKEN';
+
+const TOKEN_FORMAT = /^app\d+:[A-Za-z0-9_-]+$/;
+
+/**
+ * Read token from .tgcloud/credentials. Returns null if missing or malformed.
+ */
+export function loadCredentials() {
+  if (!fs.existsSync(CREDENTIALS_FILE)) return null;
+  try {
+    const raw = fs.readFileSync(CREDENTIALS_FILE, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.token === 'string') {
+      return { token: parsed.token };
+    }
+  } catch {
+    // fall through
+  }
+  return null;
+}
+
+/**
+ * Save token to .tgcloud/credentials as a JSON object.
+ */
+export function saveCredentials(token) {
+  ensureTgcloudDir();
+  // The file holds the bot secret — keep it owner-only. `mode` only applies when
+  // the file is created, so chmod an already-existing file down as well.
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify({ token }, null, 2) + '\n', { mode: 0o600 });
+  try { fs.chmodSync(CREDENTIALS_FILE, 0o600); } catch { /* best-effort; e.g. Windows */ }
+}
+
+/**
+ * Remove .tgcloud/credentials. No-op if missing.
+ */
+export function deleteCredentials() {
+  if (fs.existsSync(CREDENTIALS_FILE)) fs.unlinkSync(CREDENTIALS_FILE);
+}
+
+/**
+ * Classify an error thrown by api/client.js as an authentication failure.
+ */
+export function isAuthError(err) {
+  return err?.status === 401 || err?.status === 403;
+}
+
+/**
+ * Run a network-bound command body, turning an auth failure into a clear,
+ * non-interactive error.
+ *
+ * On 401/403 we never prompt mid-command (that would surprise scripts/CI):
+ *   - env-provided token  → report it is invalid and exit.
+ *   - saved-file token    → delete the stale file, tell the user to re-link with
+ *                           `tgcloud login`, and exit.
+ *
+ * Re-authentication is an explicit step (`tgcloud login`), not a side effect of
+ * another command.
+ */
+export async function retryOnAuthError(fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    if (!isAuthError(err)) throw err;
+
+    // Prefer the server's human reason (e.g. "Cloud is not enabled for this
+    // bot") over the generic fallback.
+    const reason = err.description || 'token is invalid or expired';
+
+    if (process.env[ENV_VAR]) {
+      console.error('');
+      fatal(`${ENV_VAR} (${maskToken(process.env[ENV_VAR])}): ${reason}.`);
+    }
+
+    const creds = loadCredentials();
+    const who = creds?.token ? ` for ${maskToken(creds.token)}` : '';
+    deleteCredentials();
+    console.error('');
+    fatal(`Saved token${who} rejected: ${reason}.\n  Run "tgcloud login" to re-link this project.`);
+  }
+}
+
+/**
+ * Return the public-safe representation of a token (the app-id part before ':').
+ * Used in any output where the token might otherwise leak.
+ */
+export function maskToken(token) {
+  if (!token) return '';
+  const i = token.indexOf(':');
+  if (i <= 0) {
+    // Fallback: last 4 chars
+    return '...' + token.slice(-4);
+  }
+  return token.slice(0, i);
+}
+
+/**
+ * Validate a token against the server by calling a known endpoint.
+ * Returns { ok: boolean, networkError: boolean, statusText?: string }.
+ */
+export async function validateToken(token) {
+  try {
+    await request('GET', '/get', token);
+    return { ok: true, networkError: false };
+  } catch (err) {
+    if (err.status === 401 || err.status === 403) {
+      return { ok: false, networkError: false, statusText: err.message };
+    }
+    // Treat missing status as network error; other server errors (500) we
+    // optimistically treat as "token probably fine, server is having issues"
+    // so we don't force the user to re-enter.
+    if (!err.status) {
+      return { ok: false, networkError: true, statusText: err.message };
+    }
+    return { ok: true, networkError: false };
+  }
+}
+
+function isValidFormat(token) {
+  return TOKEN_FORMAT.test(token);
+}
+
+/**
+ * Interactive login: prompt for a token (hidden input), validate its format,
+ * validate it against the server, and save it to `.tgcloud/credentials` on
+ * success. This is the ONLY place the CLI prompts for a token — it is reached
+ * via the explicit `tgcloud login` command, never mid-command.
+ *
+ * Loops on invalid input until the user provides a working token or aborts (Ctrl-C).
+ */
+export async function loginInteractive() {
+  console.log('Link this project to a bot.');
+  console.log('Get your CLI access token from @BotFather: your bot → Serverless → CLI Access → Access token.');
+
+  while (true) {
+    const token = await askPassword('? Paste token (hidden): ');
+
+    if (token === null) {
+      // stdin closed with no input (piped/CI). Stop instead of looping on EOF,
+      // and signal failure so the command exits non-zero.
+      console.error('\n' + chalk.red('Error: ') + 'No token provided (input closed).');
+      console.error('  For CI, set the TGCLOUD_TOKEN environment variable instead.');
+      return null;
+    }
+
+    if (!token) {
+      error('Token is required.');
+      continue;
+    }
+
+    if (!isValidFormat(token)) {
+      error('Token format looks wrong. Expected "app<id>:<secret>".');
+      continue;
+    }
+
+    const result = await validateToken(token);
+
+    if (result.ok) {
+      saveCredentials(token);
+      console.log(`Linked to ${maskToken(token)}.`);
+      return token;
+    }
+
+    if (result.networkError) {
+      // Save anyway, will revalidate on next command.
+      saveCredentials(token);
+      warn(
+        'Could not reach tgcloud servers. Token saved but not verified.\n' +
+        '  Will retry on next command.'
+      );
+      return token;
+    }
+
+    // 401/403 — invalid token
+    error('Token invalid or expired.');
+    console.log(
+      '  Get a fresh CLI access token from @BotFather:\n' +
+      '  your bot → Serverless → CLI Access → Access token'
+    );
+  }
+}
+
+/**
+ * Resolve a usable token for the current command. Priority:
+ *   1. TGCLOUD_TOKEN environment variable (CI/CD)
+ *   2. .tgcloud/credentials (project-local, written by `tgcloud login`)
+ *
+ * If neither is present this exits with a clear error pointing at `tgcloud
+ * login`. It deliberately does NOT prompt — a surprise interactive prompt in
+ * the middle of an arbitrary command would hang scripts and CI. Linking is an
+ * explicit step.
+ */
+export async function resolveToken() {
+  const envToken = process.env[ENV_VAR];
+  if (envToken) {
+    if (!isValidFormat(envToken)) {
+      fatal(`${ENV_VAR} has invalid format. Expected "app<id>:<secret>".`);
+    }
+    return envToken;
+  }
+
+  const creds = loadCredentials();
+  if (creds?.token) {
+    return creds.token;
+  }
+
+  fatal('No CLI access token found for this project.\n  Run "tgcloud login" to link a bot, or set TGCLOUD_TOKEN (for CI).');
+}
+
+/**
+ * Non-exiting token lookup for best-effort/offline callers (e.g. the webhook
+ * health line in `status`). Returns the usable token or null — never prints,
+ * never exits. Unlike resolveToken(), a missing/malformed token here is not an
+ * error: the caller simply skips its networked bit.
+ */
+export function peekToken() {
+  const envToken = process.env[ENV_VAR];
+  if (envToken) return isValidFormat(envToken) ? envToken : null;
+  return loadCredentials()?.token || null;
+}

package/src/core/db-changes.js

@@ -0,0 +1,221 @@
+import chalk from 'chalk';
+
+/**
+ * Deterministic identifier for a change. Computed purely from structural
+ * fields — the CLI and server compute the same string without any shared
+ * state. `kind:entity` where entity depends on the kind.
+ */
+export function changeId(change) {
+  const { kind, table, column, index } = change;
+  if (column) return `${kind}:${table}.${column}`;
+  if (index)  return `${kind}:${table}.${index}`;
+  return `${kind}:${table}`;
+}
+
+/**
+ * Human-readable label generated from `kind`. Used in headers so we don't
+ * rely on a `description` field from the server (which would duplicate the
+ * target name we already have in `table` / `column` / `index`).
+ *
+ * Regular 3×4 grid: every level (table / column / index) has create / drop
+ * / change / undocumented. Server classifies each via `status`:
+ *   create_* → good (or warning if large/blocking)
+ *   drop_*   → warning
+ *   change_* → manual (always; needs human action)
+ *   undocumented_* → undocumented
+ */
+const LABELS = {
+  create_table:        'new table',
+  drop_table:          'drop table',
+  change_table:        'change table',
+  undocumented_table:  'not in schema',
+
+  create_column:       'new column',
+  drop_column:         'drop column',
+  change_column:       'change column',
+  undocumented_column: 'not in schema',
+
+  create_index:        'new index',
+  drop_index:          'drop index',
+  change_index:        'change index',
+  undocumented_index:  'not in schema',
+};
+
+export function kindLabel(change) {
+  return LABELS[change.kind] || change.description || change.kind;
+}
+
+/**
+ * Operation-kind → marker char + chalk color, used in the brief summary.
+ * The marker reflects what the change does (add / delete / modify / found),
+ * not the severity status — severity surfaces in the per-card warning text.
+ */
+const KIND_STYLE = {
+  create:       { mark: '+', color: chalk.green },
+  drop:         { mark: '✗', color: chalk.red },
+  change:       { mark: '!', color: chalk.yellow },
+  undocumented: { mark: '?', color: chalk.dim },
+};
+
+function styleFor(change) {
+  // kind shape: "<verb>_<level>" (e.g. create_table, drop_column, change_index,
+  // undocumented_table). First underscored token = verb.
+  const verb = (change.kind || '').split('_')[0];
+  return KIND_STYLE[verb] || { mark: '·', color: (s) => s };
+}
+
+/**
+ * Compact one-line-per-change summary. Used in `push` (after schema deploy)
+ * and at the top of `migrate` before the walk-through.
+ *
+ * Format:
+ *   +  users.score                  add column
+ *   !  old_sessions                 drop table
+ *   ✗  users                        change table
+ *   ?  legacy_logs                  not in schema
+ *
+ * Whole line is colored by status. No extra annotations — the marker carries
+ * the severity.
+ */
+export function formatBriefSummary(dbChanges) {
+  if (!dbChanges?.length) return '';
+
+  const rows = dbChanges.map((change) => ({
+    style: styleFor(change),
+    target: headerTarget(change),
+    label: kindLabel(change),
+  }));
+
+  const targetWidth = Math.max(...rows.map((r) => r.target.length));
+
+  return rows
+    .map((r) => r.style.color(`  ${r.style.mark}  ${r.target.padEnd(targetWidth)}    ${r.label}`))
+    .join('\n');
+}
+
+/**
+ * Render a single change as a card (header + body). Used in the migration
+ * walk-through where each change is shown individually.
+ */
+export function formatChange(change) {
+  return formatBlock(change);
+}
+
+function formatBlock(change) {
+  const lines = [];
+  lines.push(formatHeader(change));
+
+  const body = formatBody(change);
+  if (body.length) {
+    lines.push(...body);
+  }
+
+  // Server-provided explanation, rendered for ANY kind — not just change_*.
+  // A normally-"good" kind can be classified manual/warning with a reason/action
+  // (e.g. a UNIQUE column can't be added via ALTER TABLE, so create_column comes
+  // back manual). formatBody only prints the SQL for create_*/drop_*, so the
+  // reason must surface here or the user never sees why it's manual.
+  if (change.reason || change.action) {
+    lines.push('');
+    if (change.reason) lines.push(` Reason: ${change.reason}`);
+    if (change.action) lines.push(` Action: ${change.action}`);
+  }
+
+  // Warning text (status==='warning') — e.g. the data-loss warning on drops.
+  // Warning: convention — only the label is colored, the message stays default.
+  if (change.status === 'warning' && change.warning) {
+    lines.push('');
+    lines.push('  ' + chalk.yellow('Warning: ') + change.warning);
+  }
+
+  return lines.join('\n');
+}
+
+function formatHeader(change) {
+  const target = headerTarget(change);
+  const label = kindLabel(change);
+  return chalk.cyan(`@@ ${target}: ${label} @@`);
+}
+
+function headerTarget(change) {
+  if (change.column) return `${change.table}.${change.column}`;
+  if (change.index)  return `${change.table}.${change.index}`;
+  return change.table;
+}
+
+function formatBody(change) {
+  const lines = [];
+
+  switch (change.kind) {
+    // ── Create: SQL that will be executed (no diff prefix) ─────────────────
+    case 'create_table':
+      for (const line of splitLines(change.sql)) {
+        lines.push(chalk.green(' ' + line));
+      }
+      break;
+
+    case 'create_column':
+    case 'create_index':
+      if (change.sql) lines.push(chalk.green(' ' + change.sql));
+      break;
+
+    // ── Drop: SQL that will be executed (no diff prefix) ───────────────────
+    case 'drop_table':
+    case 'drop_column':
+    case 'drop_index':
+      if (change.sql) lines.push(chalk.red(' ' + change.sql));
+      break;
+
+    // ── Change: real diff — keep -/+ prefixes ──────────────────────────────
+    case 'change_table':
+    case 'change_column':
+    case 'change_index':
+      if (change.diff) {
+        lines.push(chalk.red('-' + change.diff.current));
+        lines.push(chalk.green('+' + change.diff.expected));
+      }
+      // reason/action rendered by formatBlock (applies to all kinds)
+      break;
+
+    // ── Undocumented: show what's in the DB as context ─────────────────────
+    case 'undocumented_table':
+      for (const line of splitLines(change.existing_schema)) {
+        lines.push(' ' + line);
+      }
+      if (typeof change.row_count === 'number') {
+        lines.push(` Contents: ${change.row_count} row${change.row_count === 1 ? '' : 's'}`);
+      }
+      break;
+
+    case 'undocumented_column':
+      if (change.diff?.current) {
+        lines.push(' ' + change.diff.current);
+      }
+      break;
+
+    case 'undocumented_index':
+      for (const line of splitLines(change.existing_schema)) {
+        lines.push(' ' + line);
+      }
+      break;
+
+    // ── Forward-compat fallback for unknown kinds ──────────────────────────
+    default:
+      if (change.diff) {
+        lines.push(chalk.red('-' + change.diff.current));
+        lines.push(chalk.green('+' + change.diff.expected));
+      }
+      // reason/action rendered by formatBlock (applies to all kinds)
+      if (change.sql) {
+        lines.push(chalk.dim('  ' + change.sql));
+      }
+  }
+
+  return lines;
+}
+
+function splitLines(sql) {
+  if (!sql) return [];
+  const trimmed = sql.endsWith('\n') ? sql.slice(0, -1) : sql;
+  return trimmed.split('\n');
+}

package/src/core/file-diff.js

@@ -0,0 +1,11 @@
+import { createTwoFilesPatch } from 'diff';
+
+export function computeDiff(oldContent, newContent, filename) {
+  if (oldContent === newContent) return null;
+  return createTwoFilesPatch(
+    `a/${filename}`,
+    `b/${filename}`,
+    oldContent || '',
+    newContent || '',
+  );
+}

package/src/core/hasher.js

@@ -0,0 +1,11 @@
+import { createHash } from 'crypto';
+import fs from 'fs';
+
+export function hashFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return hashContent(content);
+}
+
+export function hashContent(content) {
+  return createHash('md5').update(content).digest('hex');
+}

package/src/core/local-diff.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import { scanFiles } from './scanner.js';
+import { listSnapshotPaths, readSnapshotFile } from './snapshot.js';
+
+/**
+ * Compare working directory files against the local snapshot (.tgcloud/remote/).
+ *
+ * Returns:
+ *   {
+ *     modified:    [{ path, localContent, remoteContent }],
+ *     newLocal:    [{ path, localContent }],               // exists locally, not in snapshot
+ *     remoteOnly:  [{ path, remoteContent }],              // exists in snapshot, not locally
+ *     matched:     [{ path, localContent }],               // identical
+ *   }
+ *
+ * Comparison is byte-level on file content.
+ */
+export function localDiff() {
+  const localFiles = scanFiles();
+  const snapshotFiles = listSnapshotPaths();
+
+  const localSet = new Set(localFiles);
+  const snapshotSet = new Set(snapshotFiles);
+  const allPaths = new Set([...localFiles, ...snapshotFiles]);
+
+  const modified = [];
+  const newLocal = [];
+  const remoteOnly = [];
+  const matched = [];
+
+  for (const p of allPaths) {
+    const hasLocal = localSet.has(p);
+    const hasRemote = snapshotSet.has(p);
+
+    if (hasLocal && !hasRemote) {
+      newLocal.push({
+        path: p,
+        localContent: fs.readFileSync(p, 'utf-8'),
+      });
+    } else if (!hasLocal && hasRemote) {
+      remoteOnly.push({
+        path: p,
+        remoteContent: readSnapshotFile(p) ?? '',
+      });
+    } else {
+      const localContent = fs.readFileSync(p, 'utf-8');
+      const remoteContent = readSnapshotFile(p) ?? '';
+      if (localContent === remoteContent) {
+        matched.push({ path: p, localContent });
+      } else {
+        modified.push({ path: p, localContent, remoteContent });
+      }
+    }
+  }
+
+  return { modified, newLocal, remoteOnly, matched };
+}