@masslessai/push-todo 3.0.0

package/lib/config.js

@@ -0,0 +1,279 @@
+/**
+ * Configuration file helpers for Push CLI.
+ *
+ * Reads/writes config from ~/.config/push/config
+ * Format: bash-style exports (export PUSH_KEY="value")
+ *
+ * Compatible with the Python version's config format.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+
+const CONFIG_DIR = join(homedir(), '.config', 'push');
+const CONFIG_FILE = join(CONFIG_DIR, 'config');
+
+/**
+ * Get a configuration value from the config file.
+ *
+ * @param {string} key - Config key name (without PUSH_ prefix)
+ * @param {string} defaultValue - Default value if not found
+ * @returns {string} The config value or default
+ */
+export function getConfigValue(key, defaultValue = '') {
+  const fullKey = `PUSH_${key}`;
+
+  if (!existsSync(CONFIG_FILE)) {
+    return defaultValue;
+  }
+
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf8');
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith(`export ${fullKey}=`)) {
+        // Extract value after = and remove quotes
+        let value = trimmed.split('=')[1] || '';
+        value = value.trim();
+        // Remove surrounding quotes (single or double)
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+        return value;
+      }
+    }
+  } catch {
+    // Config file exists but couldn't read
+  }
+
+  return defaultValue;
+}
+
+/**
+ * Set a configuration value in the config file.
+ *
+ * @param {string} key - Config key name (without PUSH_ prefix)
+ * @param {string} value - Value to set
+ * @returns {boolean} True if successful
+ */
+export function setConfigValue(key, value) {
+  const fullKey = `PUSH_${key}`;
+
+  // Ensure config directory exists
+  mkdirSync(CONFIG_DIR, { recursive: true });
+
+  // Read existing config
+  let lines = [];
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      lines = readFileSync(CONFIG_FILE, 'utf8').split('\n');
+    } catch {
+      lines = [];
+    }
+  }
+
+  // Update or add the key
+  let found = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().startsWith(`export ${fullKey}=`)) {
+      lines[i] = `export ${fullKey}="${value}"`;
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) {
+    lines.push(`export ${fullKey}="${value}"`);
+  }
+
+  // Write back
+  try {
+    writeFileSync(CONFIG_FILE, lines.join('\n') + '\n');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the API key from environment or config file.
+ *
+ * Priority:
+ * 1. PUSH_API_KEY environment variable
+ * 2. Config file at ~/.config/push/config
+ *
+ * @returns {string} The API key
+ * @throws {Error} If API key is not found
+ */
+export function getApiKey() {
+  // 1. Try environment first (for CI/testing)
+  const envKey = process.env.PUSH_API_KEY;
+  if (envKey) {
+    return envKey;
+  }
+
+  // 2. Try config file
+  const configKey = getConfigValue('API_KEY');
+  if (configKey) {
+    return configKey;
+  }
+
+  // 3. Not found
+  throw new Error(
+    'PUSH_API_KEY not configured.\n' +
+    'Run: push-todo connect\n' +
+    'Or manually add to ~/.config/push/config:\n' +
+    '  export PUSH_API_KEY="your-key-here"'
+  );
+}
+
+/**
+ * Check if auto-commit is enabled.
+ * Default: true (enabled by default)
+ *
+ * @returns {boolean}
+ */
+export function getAutoCommitEnabled() {
+  const value = getConfigValue('AUTO_COMMIT', 'true');
+  return value.toLowerCase() === 'true' || value === '1' || value.toLowerCase() === 'yes';
+}
+
+/**
+ * Set auto-commit setting.
+ *
+ * @param {boolean} enabled
+ * @returns {boolean} True if successful
+ */
+export function setAutoCommitEnabled(enabled) {
+  return setConfigValue('AUTO_COMMIT', enabled ? 'true' : 'false');
+}
+
+/**
+ * Get the maximum batch size for queuing tasks.
+ * Default: 5
+ *
+ * @returns {number}
+ */
+export function getMaxBatchSize() {
+  const value = getConfigValue('MAX_BATCH_SIZE', '5');
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? 5 : parsed;
+}
+
+/**
+ * Set the maximum batch size.
+ *
+ * @param {number} size - Must be 1-20
+ * @returns {boolean} True if successful
+ */
+export function setMaxBatchSize(size) {
+  if (size < 1 || size > 20) {
+    return false;
+  }
+  return setConfigValue('MAX_BATCH_SIZE', String(size));
+}
+
+/**
+ * Get the email from config.
+ *
+ * @returns {string|null}
+ */
+export function getEmail() {
+  const email = getConfigValue('EMAIL');
+  return email || null;
+}
+
+/**
+ * Save API key and email to config.
+ *
+ * @param {string} apiKey
+ * @param {string} email
+ */
+export function saveCredentials(apiKey, email) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  setConfigValue('API_KEY', apiKey);
+  setConfigValue('EMAIL', email);
+}
+
+/**
+ * Clear all credentials from config.
+ */
+export function clearCredentials() {
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      const content = readFileSync(CONFIG_FILE, 'utf8');
+      const lines = content.split('\n').filter(line => {
+        const trimmed = line.trim();
+        return !trimmed.startsWith('export PUSH_API_KEY=') &&
+               !trimmed.startsWith('export PUSH_EMAIL=');
+      });
+      writeFileSync(CONFIG_FILE, lines.join('\n'));
+    } catch {
+      // Ignore errors
+    }
+  }
+}
+
+/**
+ * Show all settings.
+ */
+export function showSettings() {
+  console.log();
+  console.log('  Push Settings');
+  console.log('  ' + '='.repeat(40));
+  console.log();
+
+  const autoCommit = getAutoCommitEnabled();
+  const batchSize = getMaxBatchSize();
+
+  console.log(`  auto-commit:  ${autoCommit ? 'ON' : 'OFF'}`);
+  console.log('                Auto-commit when task completes');
+  console.log();
+  console.log(`  batch-size:   ${batchSize}`);
+  console.log('                Max tasks for batch queue (1-20)');
+  console.log();
+  console.log('  Toggle with: push-todo setting <name>');
+  console.log('  Example:     push-todo setting auto-commit');
+  console.log();
+}
+
+/**
+ * Toggle a setting by name.
+ *
+ * @param {string} settingName
+ * @returns {boolean} True if setting was toggled
+ */
+export function toggleSetting(settingName) {
+  const normalized = settingName.toLowerCase().replace(/_/g, '-');
+
+  if (normalized === 'auto-commit') {
+    const current = getAutoCommitEnabled();
+    const newValue = !current;
+    if (setAutoCommitEnabled(newValue)) {
+      console.log(`Auto-commit is now ${newValue ? 'ON' : 'OFF'}`);
+      if (newValue) {
+        console.log('Tasks will be auto-committed (without push) when completed.');
+      } else {
+        console.log('Tasks will NOT be auto-committed when completed.');
+      }
+      return true;
+    }
+    console.error('Failed to update setting');
+    return false;
+  }
+
+  if (normalized === 'batch-size') {
+    const batchSize = getMaxBatchSize();
+    console.log(`Current batch size: ${batchSize}`);
+    console.log('Change with: push-todo --set-batch-size N');
+    return true;
+  }
+
+  console.error(`Unknown setting: ${settingName}`);
+  console.error('Available settings: auto-commit, batch-size');
+  return false;
+}
+
+export { CONFIG_DIR, CONFIG_FILE };

package/lib/connect.js

@@ -0,0 +1,380 @@
+/**
+ * Connect and authentication module for Push CLI.
+ *
+ * Handles the "doctor" flow for setting up and validating
+ * the CLI connection to Push backend.
+ */
+
+import { execSync } from 'child_process';
+import { setTimeout } from 'timers/promises';
+import * as api from './api.js';
+import { getApiKey, saveCredentials, getConfigValue } from './config.js';
+import { getMachineId, getMachineName } from './machine-id.js';
+import { getRegistry } from './project-registry.js';
+import { getGitRemote, isGitRepo, getGitRoot } from './utils/git.js';
+import { isE2EEAvailable } from './encryption.js';
+import { bold, green, yellow, red, cyan, dim, muted } from './utils/colors.js';
+
+// Supabase anonymous key for auth flow
+const ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imp4dXpxY2JxaGlheG1maXR6eGxvIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzI0ODA5MjIsImV4cCI6MjA0ODA1NjkyMn0.Qxov5qJTVLWmseyFNhBQBJN7-t5sXlHZyzFKhSN_e5g';
+
+const VERSION = '3.0.0';
+
+/**
+ * Check if a newer version is available.
+ *
+ * @returns {Promise<Object>} Version check result
+ */
+async function checkVersion() {
+  const latest = await api.getLatestVersion();
+
+  if (!latest) {
+    return { current: VERSION, latest: null, updateAvailable: false };
+  }
+
+  const currentParts = VERSION.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+
+  let updateAvailable = false;
+  for (let i = 0; i < 3; i++) {
+    if (latestParts[i] > currentParts[i]) {
+      updateAvailable = true;
+      break;
+    } else if (latestParts[i] < currentParts[i]) {
+      break;
+    }
+  }
+
+  return { current: VERSION, latest, updateAvailable };
+}
+
+/**
+ * Validate the current API key.
+ *
+ * @returns {Promise<Object>} Validation result
+ */
+async function validateApiKeyStatus() {
+  const apiKey = getApiKey();
+
+  if (!apiKey) {
+    return { status: 'missing', message: 'No API key configured' };
+  }
+
+  const result = await api.validateApiKey();
+
+  if (result.valid) {
+    return { status: 'valid', email: result.email, userId: result.userId };
+  }
+
+  return { status: 'invalid', message: result.reason };
+}
+
+/**
+ * Validate machine registration.
+ *
+ * @returns {Promise<Object>} Validation result
+ */
+async function validateMachineStatus() {
+  const machineId = getMachineId();
+  const machineName = getMachineName();
+
+  try {
+    const result = await api.validateMachine(machineId);
+    return {
+      status: 'valid',
+      machineId,
+      machineName,
+      ...result
+    };
+  } catch (error) {
+    return {
+      status: 'error',
+      machineId,
+      machineName,
+      message: error.message
+    };
+  }
+}
+
+/**
+ * Validate project registration.
+ *
+ * @returns {Object} Validation result
+ */
+function validateProjectStatus() {
+  if (!isGitRepo()) {
+    return { status: 'not_git', message: 'Not in a git repository' };
+  }
+
+  const gitRemote = getGitRemote();
+  if (!gitRemote) {
+    return { status: 'no_remote', message: 'No git remote configured' };
+  }
+
+  const registry = getRegistry();
+  const isRegistered = registry.isRegistered(gitRemote);
+  const localPath = registry.getPathWithoutUpdate(gitRemote);
+
+  return {
+    status: isRegistered ? 'registered' : 'unregistered',
+    gitRemote,
+    localPath,
+    gitRoot: getGitRoot()
+  };
+}
+
+/**
+ * Generate a random auth code for the authentication flow.
+ *
+ * @returns {string} 6-character alphanumeric code
+ */
+function generateAuthCode() {
+  const chars = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'; // Omit confusing chars
+  let code = '';
+  for (let i = 0; i < 6; i++) {
+    code += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return code;
+}
+
+/**
+ * Open a URL in the default browser.
+ *
+ * @param {string} url - URL to open
+ */
+function openBrowser(url) {
+  try {
+    if (process.platform === 'darwin') {
+      execSync(`open "${url}"`, { stdio: 'ignore' });
+    } else if (process.platform === 'linux') {
+      execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+    } else if (process.platform === 'win32') {
+      execSync(`start "" "${url}"`, { stdio: 'ignore' });
+    }
+  } catch {
+    console.log(`Please open this URL manually: ${url}`);
+  }
+}
+
+/**
+ * Poll for authentication completion.
+ *
+ * @param {string} authCode - The auth code to poll for
+ * @param {number} timeout - Timeout in seconds
+ * @returns {Promise<Object|null>} Credentials or null if timeout
+ */
+async function pollForAuth(authCode, timeout = 300) {
+  const startTime = Date.now();
+  const pollInterval = 2000; // 2 seconds
+
+  while ((Date.now() - startTime) < timeout * 1000) {
+    try {
+      const response = await fetch(
+        `https://jxuzqcbqhiaxmfitzxlo.supabase.co/functions/v1/poll-auth?code=${authCode}`,
+        {
+          headers: {
+            'Authorization': `Bearer ${ANON_KEY}`,
+            'Content-Type': 'application/json'
+          }
+        }
+      );
+
+      if (response.ok) {
+        const data = await response.json();
+        if (data.api_key) {
+          return data;
+        }
+      }
+    } catch {
+      // Ignore errors during polling
+    }
+
+    await setTimeout(pollInterval);
+  }
+
+  return null;
+}
+
+/**
+ * Run the authentication flow.
+ *
+ * @returns {Promise<boolean>} True if successful
+ */
+async function runAuthFlow() {
+  const authCode = generateAuthCode();
+  const authUrl = `https://pushto.do/connect?code=${authCode}`;
+
+  console.log('');
+  console.log(bold('Authentication Required'));
+  console.log('');
+  console.log(`Opening browser to: ${cyan(authUrl)}`);
+  console.log('');
+  console.log(`Or enter this code manually: ${bold(authCode)}`);
+  console.log('');
+  console.log(dim('Waiting for authentication...'));
+
+  openBrowser(authUrl);
+
+  const credentials = await pollForAuth(authCode);
+
+  if (!credentials) {
+    console.log(red('Authentication timed out. Please try again.'));
+    return false;
+  }
+
+  // Save credentials
+  saveCredentials(credentials.api_key, credentials.user_id, credentials.email);
+
+  console.log('');
+  console.log(green('✓ Authentication successful!'));
+  console.log(`  Logged in as: ${credentials.email}`);
+
+  return true;
+}
+
+/**
+ * Register the current project.
+ *
+ * @param {string[]} keywords - Project keywords
+ * @param {string} description - Project description
+ * @returns {Promise<boolean>} True if successful
+ */
+async function registerCurrentProject(keywords = [], description = '') {
+  const gitRemote = getGitRemote();
+  const gitRoot = getGitRoot();
+
+  if (!gitRemote || !gitRoot) {
+    console.log(yellow('Cannot register: not in a git repository with a remote.'));
+    return false;
+  }
+
+  // Register locally
+  const registry = getRegistry();
+  const isNew = registry.register(gitRemote, gitRoot);
+
+  // Register with backend
+  try {
+    await api.registerProject(gitRemote, keywords, description);
+    console.log(green(`✓ Project registered: ${gitRemote}`));
+    return true;
+  } catch (error) {
+    console.log(yellow(`Local registration OK, but backend registration failed: ${error.message}`));
+    return false;
+  }
+}
+
+/**
+ * Print a status line with icon.
+ *
+ * @param {string} icon - Status icon
+ * @param {string} label - Status label
+ * @param {string} value - Status value
+ */
+function printStatus(icon, label, value) {
+  console.log(`  ${icon} ${label}: ${value}`);
+}
+
+/**
+ * Run the connect/doctor flow.
+ *
+ * @param {Object} options - Options from CLI
+ * @returns {Promise<void>}
+ */
+export async function runConnect(options = {}) {
+  console.log('');
+  console.log(bold('Push Connect - Diagnostic Check'));
+  console.log(dim('=' .repeat(40)));
+  console.log('');
+
+  let allPassed = true;
+
+  // Step 1: Version check
+  console.log(bold('1. Version Check'));
+  const versionStatus = await checkVersion();
+  if (versionStatus.updateAvailable) {
+    printStatus(yellow('⚠'), 'Version', `${versionStatus.current} → ${versionStatus.latest} available`);
+    console.log(dim(`   Update: npm update -g @masslessai/push-todo`));
+    allPassed = false;
+  } else {
+    printStatus(green('✓'), 'Version', `${versionStatus.current} (latest)`);
+  }
+  console.log('');
+
+  // Step 2: API Key validation
+  console.log(bold('2. API Key'));
+  let keyStatus = await validateApiKeyStatus();
+
+  if (keyStatus.status === 'missing' || keyStatus.status === 'invalid') {
+    printStatus(red('✗'), 'API Key', keyStatus.message || 'Invalid');
+    console.log('');
+
+    // Run auth flow
+    const authSuccess = await runAuthFlow();
+    if (authSuccess) {
+      keyStatus = await validateApiKeyStatus();
+    } else {
+      allPassed = false;
+    }
+  }
+
+  if (keyStatus.status === 'valid') {
+    printStatus(green('✓'), 'API Key', `Valid (${keyStatus.email})`);
+  }
+  console.log('');
+
+  // Step 3: Machine validation
+  console.log(bold('3. Machine'));
+  const machineStatus = await validateMachineStatus();
+  if (machineStatus.status === 'valid') {
+    printStatus(green('✓'), 'Machine', machineStatus.machineName);
+    printStatus(dim('·'), 'ID', machineStatus.machineId);
+  } else {
+    printStatus(yellow('⚠'), 'Machine', machineStatus.message || 'Not validated');
+    allPassed = false;
+  }
+  console.log('');
+
+  // Step 4: Project validation
+  console.log(bold('4. Project'));
+  const projectStatus = validateProjectStatus();
+
+  if (projectStatus.status === 'registered') {
+    printStatus(green('✓'), 'Project', projectStatus.gitRemote);
+    printStatus(dim('·'), 'Path', projectStatus.localPath);
+  } else if (projectStatus.status === 'unregistered') {
+    printStatus(yellow('⚠'), 'Project', `${projectStatus.gitRemote} (not registered)`);
+    console.log('');
+
+    // Offer to register
+    if (keyStatus.status === 'valid') {
+      const keywords = options.keywords ? options.keywords.split(',') : [];
+      const description = options.description || '';
+      await registerCurrentProject(keywords, description);
+    }
+  } else if (projectStatus.status === 'no_remote') {
+    printStatus(yellow('⚠'), 'Project', 'No git remote configured');
+    allPassed = false;
+  } else {
+    printStatus(dim('·'), 'Project', 'Not in a git repository');
+  }
+  console.log('');
+
+  // Step 5: E2EE check
+  console.log(bold('5. E2EE (End-to-End Encryption)'));
+  const [e2eeAvailable, e2eeMessage] = isE2EEAvailable();
+  if (e2eeAvailable) {
+    printStatus(green('✓'), 'E2EE', 'Available');
+  } else {
+    printStatus(yellow('⚠'), 'E2EE', e2eeMessage);
+  }
+  console.log('');
+
+  // Summary
+  console.log(dim('=' .repeat(40)));
+  if (allPassed) {
+    console.log(green(bold('All checks passed!')));
+  } else {
+    console.log(yellow('Some checks need attention. See above for details.'));
+  }
+  console.log('');
+}