antigravity-seo-kit 1.0.0

package/lib/downloader.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const https = require('https');
+const http = require('http');
+const zlib = require('zlib');
+const fs = require('fs');
+const path = require('path');
+
+// ─── Download ───────────────────────────────────────────────────────────────
+
+/**
+ * Download a file from URL and return as Buffer.
+ * Supports HTTP redirects (up to 5).
+ */
+function downloadBuffer(url, headers = {}, { timeout = 60000, maxRedirects = 5 } = {}) {
+  return new Promise((resolve, reject) => {
+    if (maxRedirects <= 0) {
+      return reject(new Error('Too many redirects'));
+    }
+
+    const parsed = new URL(url);
+    const transport = parsed.protocol === 'https:' ? https : http;
+
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method: 'GET',
+      headers: {
+        'User-Agent': 'antigravity-seo-kit',
+        ...headers,
+      },
+      timeout,
+    };
+
+    const req = transport.request(options, (res) => {
+      // Follow redirects
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return downloadBuffer(res.headers.location, headers, { timeout, maxRedirects: maxRedirects - 1 })
+          .then(resolve)
+          .catch(reject);
+      }
+
+      if (res.statusCode !== 200) {
+        let body = '';
+        res.on('data', (chunk) => { body += chunk; });
+        res.on('end', () => {
+          reject(new Error(`Download failed: HTTP ${res.statusCode} – ${body.substring(0, 300)}`));
+        });
+        return;
+      }
+
+      const chunks = [];
+      let totalSize = 0;
+      const maxSize = 50 * 1024 * 1024; // 50 MB safety limit
+
+      res.on('data', (chunk) => {
+        totalSize += chunk.length;
+        if (totalSize > maxSize) {
+          req.destroy();
+          reject(new Error('Download too large (>50 MB). Aborting.'));
+          return;
+        }
+        chunks.push(chunk);
+      });
+
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+
+    req.on('error', (err) => {
+      if (err.code === 'ECONNREFUSED') {
+        reject(new Error('Cannot connect to asset server. Check your internet connection.'));
+      } else if (err.code === 'ENOTFOUND') {
+        reject(new Error('Asset server not found. DNS resolution failed.'));
+      } else {
+        reject(new Error(`Download error: ${err.message}`));
+      }
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Download timed out. Please try again.'));
+    });
+
+    req.end();
+  });
+}
+
+// ─── Tar.gz Extraction (pure Node.js, zero dependencies) ────────────────────
+
+/**
+ * Extract a .tar.gz buffer into targetDir.
+ * Returns { count, files } where files is the list of extracted relative paths.
+ */
+function extractTarGz(gzBuffer, targetDir) {
+  const tarBuffer = zlib.gunzipSync(gzBuffer);
+
+  let offset = 0;
+  let count = 0;
+  const files = [];
+
+  while (offset + 512 <= tarBuffer.length) {
+    const header = tarBuffer.subarray(offset, offset + 512);
+
+    // End-of-archive: two consecutive 512-byte zero blocks
+    if (isZeroBlock(header)) break;
+
+    const name = readString(header, 0, 100);
+    const sizeOctal = readString(header, 124, 12);
+    const typeFlag = header[156];
+    const prefix = readString(header, 345, 155);
+
+    const fullName = (prefix ? `${prefix}/${name}` : name).replace(/\\/g, '/');
+    const size = parseInt(sizeOctal, 8) || 0;
+
+    offset += 512; // skip past header
+
+    if (!fullName || fullName === '.' || fullName === './') {
+      offset += Math.ceil(size / 512) * 512;
+      continue;
+    }
+
+    const targetPath = path.join(targetDir, fullName);
+
+    // Security: block path traversal attacks
+    const resolved = path.resolve(targetPath);
+    if (!resolved.startsWith(path.resolve(targetDir))) {
+      throw new Error(`Blocked path traversal in archive: ${fullName}`);
+    }
+
+    const ASCII_5 = 53; // '5' = directory
+    const ASCII_0 = 48; // '0' = regular file
+
+    if (typeFlag === ASCII_5 || fullName.endsWith('/')) {
+      // Directory entry
+      fs.mkdirSync(targetPath, { recursive: true });
+    } else if (typeFlag === ASCII_0 || typeFlag === 0) {
+      // Regular file
+      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+      fs.writeFileSync(targetPath, tarBuffer.subarray(offset, offset + size));
+      files.push(fullName);
+      count++;
+    }
+    // Skip padding to next 512-byte boundary
+    offset += Math.ceil(size / 512) * 512;
+  }
+
+  return { count, files };
+}
+
+function isZeroBlock(buf) {
+  for (let i = 0; i < 512; i++) {
+    if (buf[i] !== 0) return false;
+  }
+  return true;
+}
+
+function readString(buf, offset, length) {
+  let end = offset;
+  while (end < offset + length && buf[end] !== 0) end++;
+  return buf.subarray(offset, end).toString('utf8').trim();
+}
+
+// ─── High-level API ─────────────────────────────────────────────────────────
+
+/**
+ * Download SEO Kit assets from server and extract to workspace.
+ *
+ * @param {string} downloadUrl  Full URL of the .tar.gz endpoint
+ * @param {string} licenseKey   License key for authentication
+ * @param {string} targetDir    Workspace root where .agent/ will be created
+ * @returns {Promise<{ count: number, files: string[] }>}
+ */
+async function downloadAndExtract(downloadUrl, licenseKey, targetDir) {
+  const buffer = await downloadBuffer(downloadUrl, {
+    'X-License-Key': licenseKey,
+    'Accept': 'application/gzip, application/octet-stream',
+  });
+
+  return extractTarGz(buffer, targetDir);
+}
+
+module.exports = {
+  downloadBuffer,
+  extractTarGz,
+  downloadAndExtract,
+};

package/lib/fingerprint.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const os = require('os');
+const crypto = require('crypto');
+
+/**
+ * Generate a unique device fingerprint based on hardware characteristics.
+ *
+ * Combines hostname, platform, architecture, CPU model, total memory,
+ * and primary MAC address into a SHA-256 hash (truncated to 16 chars).
+ *
+ * This is not tamper-proof but sufficient for license device tracking.
+ */
+function generateFingerprint() {
+  const components = [
+    os.hostname(),
+    os.platform(),
+    os.arch(),
+    getCpuModel(),
+    os.totalmem().toString(),
+    getPrimaryMacAddress(),
+  ];
+
+  const raw = components.join('|');
+  return crypto.createHash('sha256').update(raw).digest('hex').substring(0, 16);
+}
+
+/**
+ * Get a human-readable device name for display purposes.
+ * Example: "DESKTOP-ABC (win32 x64)"
+ */
+function getDeviceName() {
+  const hostname = os.hostname();
+  const platform = os.platform();
+  const arch = os.arch();
+  const release = os.release().split('.').slice(0, 2).join('.');
+  return `${hostname} (${platform} ${arch}, ${release})`;
+}
+
+/**
+ * Get CPU model string.
+ */
+function getCpuModel() {
+  const cpus = os.cpus();
+  return cpus.length > 0 ? cpus[0].model.trim() : 'unknown-cpu';
+}
+
+/**
+ * Get the MAC address of the first non-internal network interface.
+ * Falls back to 'no-mac' if none found.
+ */
+function getPrimaryMacAddress() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      // Skip internal (loopback) and link-local interfaces
+      if (!iface.internal && iface.mac && iface.mac !== '00:00:00:00:00:00') {
+        return iface.mac;
+      }
+    }
+  }
+  return 'no-mac';
+}
+
+module.exports = {
+  generateFingerprint,
+  getDeviceName,
+};

package/lib/installer.js

@@ -0,0 +1,446 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  success, error, warn, info, step, file, dir,
+  spinner, removeRecursive,
+  writeLicenseFile, removeLicenseFile, readLicenseFile,
+  colorize, PACKAGE_VERSION,
+} = require('./utils');
+const { generateFingerprint, getDeviceName } = require('./fingerprint');
+const api = require('./api');
+const { downloadAndExtract } = require('./downloader');
+
+// ─── Legacy arrays (for uninstall/status of older installs without manifest) ─
+
+const SEO_SKILL_DIRS = [
+  'seo', 'seo-agentic', 'seo-answer', 'seo-audience', 'seo-audit',
+  'seo-authority', 'seo-backlink', 'seo-brand-sentiment', 'seo-citemet',
+  'seo-coccoc-optimizer', 'seo-competitor-pages', 'seo-content',
+  'seo-content-gap', 'seo-dataforseo', 'seo-entity', 'seo-fan-out-generator',
+  'seo-fix', 'seo-geo', 'seo-geo-monitor', 'seo-google', 'seo-hreflang',
+  'seo-image-gen', 'seo-images', 'seo-keyword', 'seo-llmstxt', 'seo-local',
+  'seo-logs', 'seo-maps', 'seo-migration', 'seo-page', 'seo-plan',
+  'seo-programmatic', 'seo-prompt-research', 'seo-reddit-scraper',
+  'seo-schema', 'seo-sitemap', 'seo-social-zalo', 'seo-source-context',
+  'seo-technical', 'seo-test', 'seo-topical-authority', 'seo-video',
+  'seo-video-transcript', 'seo-visual-search',
+];
+
+const SEO_WORKFLOW_FILES = [
+  'seo-audit.md', 'seo-auto-run.md', 'seo-execute.md',
+  'seo-llm-visibility.md', 'seo-local-suite.md', 'seo-monitor.md',
+  'seo-onboard.md', 'seo-page.md', 'seo-research.md', 'seo-run.md',
+  'seo-social-commerce.md', 'seo-strategy.md',
+];
+
+const SEO_RULE_FILES = [
+  'seo-agent-security.md', 'seo-anti-hallucination.md',
+  'seo-auto-routing.md', 'seo-domain-project.md',
+  'seo-output-convention.md', 'seo-provider-priority.md',
+  'seo-report-format.md',
+];
+
+const SEO_AGENT_FILES = [
+  'seo-auditor.md', 'seo-strategist.md', 'seo-content-writer.md',
+  'seo-ai-specialist.md', 'seo-local-expert.md', 'seo-growth-hacker.md',
+  'seo-data-analyst.md', 'seo-migration-expert.md',
+];
+
+// ─── Install Command ────────────────────────────────────────────────────────
+
+async function install(licenseKey, cwd) {
+  const deviceId = generateFingerprint();
+  const deviceName = getDeviceName();
+
+  // Step 1: Verify license
+  const spin = spinner('Verifying license key...').start();
+  let verifyResult;
+  try {
+    verifyResult = await api.verifyLicense(licenseKey, deviceId, deviceName);
+    spin.succeed('License verified!');
+  } catch (err) {
+    spin.fail('License verification failed');
+    const errCode = err.responseData?.error?.code || '';
+    if (errCode.includes('DeviceLimitReached') || err.message.includes('Device limit')) {
+      console.log('');
+      error(`Device limit reached. You have ${err.responseData?.error?.data?.current || '?'}/${err.responseData?.error?.data?.max || 3} devices activated.`);
+      console.log('');
+      info('Run the following to manage your devices:');
+      console.log(`  ${colorize('gray', 'npx antigravity-seo-kit devices')}`);
+      console.log(`  ${colorize('gray', 'npx antigravity-seo-kit devices remove <deviceId>')}`);
+    } else if (err.isNotFound || errCode.includes('LicenseNotFound')) {
+      error('Invalid license key. Please check your key and try again.');
+      console.log(`  Purchase: ${colorize('cyan', 'https://antigravitykit.solann.io/')}`);
+    } else if (errCode.includes('LicenseExpired')) {
+      error('License has expired. Please renew your license.');
+      console.log(`  Renew: ${colorize('cyan', 'https://antigravitykit.solann.io/')}`);
+    } else if (errCode.includes('LicenseSuspended') || errCode.includes('LicenseRevoked')) {
+      error('License has been suspended or revoked. Contact support.');
+    } else {
+      error(err.message);
+    }
+    process.exit(1);
+  }
+
+  // Step 2: Download assets from server
+  console.log('');
+  const spinDl = spinner('Downloading SEO Kit assets...').start();
+  let downloadResult;
+  try {
+    const downloadUrl = api.getAssetsDownloadUrl(PACKAGE_VERSION);
+    downloadResult = await downloadAndExtract(downloadUrl, licenseKey, cwd);
+    spinDl.succeed(`Downloaded and installed ${downloadResult.count} files`);
+  } catch (err) {
+    spinDl.fail('Asset download failed');
+    error(err.message);
+    info('If this persists, contact support@solann.io');
+    process.exit(1);
+  }
+
+  // Step 3: Save license info + manifest
+  writeLicenseFile(cwd, {
+    key: licenseKey,
+    deviceId,
+    deviceName,
+    version: PACKAGE_VERSION,
+    installedAt: new Date().toISOString(),
+    plan: verifyResult?.license?.planName || verifyResult?.license?.plan || 'unknown',
+    installedFiles: downloadResult.files,
+  });
+
+  // Done!
+  console.log('');
+  console.log(colorize('green', '═══════════════════════════════════════════════════════'));
+  success(`SEO Kit v${PACKAGE_VERSION} installed successfully! (${downloadResult.count} files)`);
+  console.log(colorize('green', '═══════════════════════════════════════════════════════'));
+  console.log('');
+
+  info('Next steps:');
+  console.log(`  ${colorize('yellow', '1.')} Open this folder in ${colorize('bold', 'Google Antigravity')}`);
+  console.log(`  ${colorize('yellow', '2.')} Use commands: ${colorize('cyan', '/seo-audit')}, ${colorize('cyan', '/seo-page')}, ${colorize('cyan', '/seo-technical')}, etc.`);
+  console.log('');
+
+  if (verifyResult?.devicesUsed != null) {
+    info(`Devices: ${verifyResult.devicesUsed}/${verifyResult.maxDevices} activated`);
+  }
+  console.log('');
+}
+
+// ─── Update Command ─────────────────────────────────────────────────────────
+
+async function update(cwd) {
+  const config = readLicenseFile(cwd);
+  if (!config) {
+    error('SEO Kit is not installed in this directory.');
+    info('Run: npx antigravity-seo-kit install --key=YOUR_KEY');
+    process.exit(1);
+  }
+
+  const deviceId = generateFingerprint();
+  const deviceName = getDeviceName();
+
+  // Re-verify license
+  const spin = spinner('Verifying license...').start();
+  try {
+    await api.verifyLicense(config.key, deviceId, deviceName);
+    spin.succeed('License valid');
+  } catch (err) {
+    spin.fail('License verification failed');
+    error(err.message);
+    process.exit(1);
+  }
+
+  // Download latest assets from server
+  console.log('');
+  const spinDl = spinner('Downloading latest SEO Kit assets...').start();
+  let downloadResult;
+  try {
+    const downloadUrl = api.getAssetsDownloadUrl(PACKAGE_VERSION);
+    downloadResult = await downloadAndExtract(downloadUrl, config.key, cwd);
+    spinDl.succeed(`Updated ${downloadResult.count} files`);
+  } catch (err) {
+    spinDl.fail('Update download failed');
+    error(err.message);
+    process.exit(1);
+  }
+
+  // Update license file
+  config.version = PACKAGE_VERSION;
+  config.updatedAt = new Date().toISOString();
+  config.installedFiles = downloadResult.files;
+  writeLicenseFile(cwd, config);
+
+  console.log('');
+  success(`SEO Kit updated to v${PACKAGE_VERSION}! (${downloadResult.count} files)`);
+  console.log('');
+}
+
+// ─── Uninstall Command ──────────────────────────────────────────────────────
+
+async function uninstall(cwd) {
+  const config = readLicenseFile(cwd);
+  if (!config) {
+    error('SEO Kit is not installed in this directory.');
+    process.exit(1);
+  }
+
+  step('Removing SEO Kit files...');
+  let totalRemoved = 0;
+
+  if (config.installedFiles && config.installedFiles.length > 0) {
+    // New approach: use manifest from license file
+    for (const filePath of config.installedFiles) {
+      const target = path.join(cwd, filePath);
+      if (fs.existsSync(target)) {
+        fs.unlinkSync(target);
+        totalRemoved++;
+      }
+    }
+    // Clean up empty directories
+    cleanEmptyDirsUp(path.join(cwd, '.agent'));
+  } else {
+    // Legacy fallback: use hardcoded arrays
+    totalRemoved += legacyUninstall(cwd);
+  }
+
+  // Remove license file
+  removeLicenseFile(cwd);
+
+  console.log('');
+  success(`SEO Kit removed. (${totalRemoved} files deleted)`);
+  console.log('');
+}
+
+/**
+ * Legacy uninstall for installs before v1.0.0 (without manifest).
+ */
+function legacyUninstall(cwd) {
+  let totalRemoved = 0;
+
+  // Remove skills
+  const skillsDir = path.join(cwd, '.agent', 'skills');
+  for (const skillDir of SEO_SKILL_DIRS) {
+    const target = path.join(skillsDir, skillDir);
+    totalRemoved += removeRecursive(target);
+  }
+
+  // Remove workflows
+  const workflowsDir = path.join(cwd, '.agent', 'workflows');
+  for (const wfFile of SEO_WORKFLOW_FILES) {
+    const target = path.join(workflowsDir, wfFile);
+    if (fs.existsSync(target)) {
+      fs.unlinkSync(target);
+      totalRemoved++;
+    }
+  }
+
+  // Remove rules
+  const rulesDir = path.join(cwd, '.agent', 'rules');
+  for (const ruleFile of SEO_RULE_FILES) {
+    const target = path.join(rulesDir, ruleFile);
+    if (fs.existsSync(target)) {
+      fs.unlinkSync(target);
+      totalRemoved++;
+    }
+  }
+
+  // Remove agents
+  const agentsDir = path.join(cwd, '.agent', 'agents');
+  for (const agentFile of SEO_AGENT_FILES) {
+    const target = path.join(agentsDir, agentFile);
+    if (fs.existsSync(target)) {
+      fs.unlinkSync(target);
+      totalRemoved++;
+    }
+  }
+
+  return totalRemoved;
+}
+
+/**
+ * Recursively remove empty directories bottom-up.
+ */
+function cleanEmptyDirsUp(dirPath) {
+  if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return;
+
+  const entries = fs.readdirSync(dirPath);
+  for (const entry of entries) {
+    const full = path.join(dirPath, entry);
+    if (fs.statSync(full).isDirectory()) {
+      cleanEmptyDirsUp(full);
+    }
+  }
+
+  // Re-check after cleaning children
+  if (fs.readdirSync(dirPath).length === 0) {
+    fs.rmdirSync(dirPath);
+  }
+}
+
+// ─── Status Command ─────────────────────────────────────────────────────────
+
+async function status(cwd) {
+  const config = readLicenseFile(cwd);
+  if (!config) {
+    error('SEO Kit is not installed in this directory.');
+    info('Run: npx antigravity-seo-kit install --key=YOUR_KEY');
+    process.exit(1);
+  }
+
+  console.log(`${colorize('bold', 'SEO Kit Installation Status')}`);
+  console.log('');
+  console.log(`  ${colorize('cyan', 'Version:')}      ${config.version || 'unknown'}`);
+  console.log(`  ${colorize('cyan', 'License Key:')}  ${maskKey(config.key)}`);
+  console.log(`  ${colorize('cyan', 'Device ID:')}    ${config.deviceId}`);
+  console.log(`  ${colorize('cyan', 'Device Name:')}  ${config.deviceName}`);
+  console.log(`  ${colorize('cyan', 'Installed:')}    ${config.installedAt || 'unknown'}`);
+  console.log(`  ${colorize('cyan', 'Plan:')}         ${config.plan || 'unknown'}`);
+  console.log('');
+
+  // Count installed files
+  if (config.installedFiles && config.installedFiles.length > 0) {
+    // New: count from manifest
+    let existingFiles = 0;
+    for (const f of config.installedFiles) {
+      if (fs.existsSync(path.join(cwd, f))) existingFiles++;
+    }
+    console.log(`  ${colorize('cyan', 'Files:')}        ${existingFiles}/${config.installedFiles.length} present`);
+  } else {
+    // Legacy: check from hardcoded arrays
+    const skillsDir = path.join(cwd, '.agent', 'skills');
+    let installedSkills = 0;
+    for (const s of SEO_SKILL_DIRS) {
+      if (fs.existsSync(path.join(skillsDir, s))) installedSkills++;
+    }
+    console.log(`  ${colorize('cyan', 'Skills:')}       ${installedSkills}/${SEO_SKILL_DIRS.length} installed`);
+
+    const workflowsDir = path.join(cwd, '.agent', 'workflows');
+    let installedWorkflows = 0;
+    for (const w of SEO_WORKFLOW_FILES) {
+      if (fs.existsSync(path.join(workflowsDir, w))) installedWorkflows++;
+    }
+    console.log(`  ${colorize('cyan', 'Workflows:')}    ${installedWorkflows}/${SEO_WORKFLOW_FILES.length} installed`);
+  }
+  console.log('');
+
+  // Server status
+  try {
+    const spin = spinner('Fetching license status from server...').start();
+    const serverStatus = await api.getLicenseStatus(config.key);
+    spin.succeed('Server status fetched');
+    console.log('');
+    console.log(`  ${colorize('cyan', 'Server Status:')} ${colorize('green', serverStatus.status || 'active')}`);
+    if (serverStatus.expiresAt) {
+      console.log(`  ${colorize('cyan', 'Expires:')}       ${serverStatus.expiresAt}`);
+    }
+    if (serverStatus.devicesUsed != null) {
+      console.log(`  ${colorize('cyan', 'Devices:')}       ${serverStatus.devicesUsed}/${serverStatus.maxDevices}`);
+    }
+  } catch {
+    warn('Could not reach license server (offline mode).');
+  }
+
+  console.log('');
+}
+
+// ─── Devices Command ────────────────────────────────────────────────────────
+
+async function devices(cwd) {
+  const config = readLicenseFile(cwd);
+  if (!config) {
+    error('SEO Kit is not installed in this directory.');
+    process.exit(1);
+  }
+
+  const spin = spinner('Fetching device list...').start();
+  try {
+    const result = await api.listDevices(config.key);
+    spin.succeed('Device list retrieved');
+    console.log('');
+
+    const deviceList = result.devices || [];
+    const maxDevices = result.maxDevices || 3;
+    const currentDeviceId = generateFingerprint();
+
+    console.log(`${colorize('bold', `Activated Devices (${deviceList.length}/${maxDevices})`)}`);
+    console.log('');
+
+    if (deviceList.length === 0) {
+      info('No devices activated.');
+    } else {
+      for (let i = 0; i < deviceList.length; i++) {
+        const d = deviceList[i];
+        const isCurrent = d.deviceId === currentDeviceId;
+        const marker = isCurrent ? colorize('green', ' ← this device') : '';
+        console.log(`  ${colorize('yellow', `${i + 1}.`)} ${colorize('bold', d.deviceName || 'Unknown')}${marker}`);
+        console.log(`     ${colorize('gray', 'ID:')}        ${d.deviceId}`);
+        console.log(`     ${colorize('gray', 'Activated:')} ${d.activatedAt || 'unknown'}`);
+        console.log(`     ${colorize('gray', 'Last seen:')} ${d.lastSeenAt || 'unknown'}`);
+        console.log('');
+      }
+    }
+
+    if (deviceList.length >= maxDevices) {
+      warn(`Device limit reached (${deviceList.length}/${maxDevices}).`);
+      info('Remove a device: npx antigravity-seo-kit devices remove <deviceId>');
+    }
+  } catch (err) {
+    spin.fail('Failed to fetch devices');
+    error(err.message);
+    process.exit(1);
+  }
+  console.log('');
+}
+
+// ─── Remove Device Command ─────────────────────────────────────────────────
+
+async function deviceRemove(cwd, deviceId) {
+  const config = readLicenseFile(cwd);
+  if (!config) {
+    error('SEO Kit is not installed in this directory.');
+    process.exit(1);
+  }
+
+  if (!deviceId) {
+    error('Device ID required.');
+    info('Usage: npx antigravity-seo-kit devices remove <deviceId>');
+    info('Run "npx antigravity-seo-kit devices" to see device IDs.');
+    process.exit(1);
+  }
+
+  const currentDeviceId = generateFingerprint();
+  if (deviceId === currentDeviceId) {
+    warn('You are removing the current device. You will need to re-activate.');
+  }
+
+  const spin = spinner(`Removing device ${deviceId}...`).start();
+  try {
+    await api.removeDevice(config.key, deviceId);
+    spin.succeed(`Device ${deviceId} removed successfully`);
+  } catch (err) {
+    spin.fail('Failed to remove device');
+    error(err.message);
+    process.exit(1);
+  }
+  console.log('');
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function maskKey(key) {
+  if (!key || key.length < 8) return '****';
+  return key.substring(0, 7) + '*'.repeat(key.length - 11) + key.substring(key.length - 4);
+}
+
+// ─── Exports ────────────────────────────────────────────────────────────────
+
+module.exports = {
+  install,
+  update,
+  uninstall,
+  status,
+  devices,
+  deviceRemove,
+};