checkpoint-cli 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+export declare const SUPABASE_URL = "https://uxunzukbuaffsnavvxub.supabase.co";
+export declare const SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InV4dW56dWtidWFmZnNuYXZ2eHViIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA5MTE3NzMsImV4cCI6MjA4NjQ4Nzc3M30.XYQNXTfqClvcr9jwdH2e8ySiG5Ue85YQAoWd1c7CxVk";
+/** Default app URL — can be overridden per environment */
+export declare const DEFAULT_APP_URL = "https://checkpoint.build";
+export interface StoredConfig {
+    access_token: string;
+    refresh_token: string;
+    app_url?: string;
+}
+export declare function loadConfig(): StoredConfig | null;
+export declare function saveConfig(config: StoredConfig): void;
+export declare function clearConfig(): void;
+export declare function getAppUrl(): string;

package/dist/config.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_APP_URL = exports.SUPABASE_ANON_KEY = exports.SUPABASE_URL = void 0;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.clearConfig = clearConfig;
+exports.getAppUrl = getAppUrl;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+/* ── Baked-in public config ── */
+exports.SUPABASE_URL = 'https://uxunzukbuaffsnavvxub.supabase.co';
+exports.SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InV4dW56dWtidWFmZnNuYXZ2eHViIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA5MTE3NzMsImV4cCI6MjA4NjQ4Nzc3M30.XYQNXTfqClvcr9jwdH2e8ySiG5Ue85YQAoWd1c7CxVk';
+/** Default app URL — can be overridden per environment */
+exports.DEFAULT_APP_URL = 'https://checkpoint.build';
+/* ── Local token storage (~/.checkpoint/config.json) ── */
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.checkpoint');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+function loadConfig() {
+    try {
+        if (!fs_1.default.existsSync(CONFIG_FILE))
+            return null;
+        const raw = fs_1.default.readFileSync(CONFIG_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.access_token || !parsed.refresh_token)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function saveConfig(config) {
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
+        mode: 0o600, // Owner read/write only
+    });
+}
+function clearConfig() {
+    try {
+        if (fs_1.default.existsSync(CONFIG_FILE))
+            fs_1.default.unlinkSync(CONFIG_FILE);
+    }
+    catch {
+        // Ignore
+    }
+}
+function getAppUrl() {
+    // Allow override via env var or stored config, fallback to default
+    return (process.env.CHECKPOINT_APP_URL ||
+        loadConfig()?.app_url ||
+        exports.DEFAULT_APP_URL);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,666 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const child_process_1 = require("child_process");
+const http_1 = __importDefault(require("http"));
+const chalk_1 = __importDefault(require("chalk"));
+const supabase_js_1 = require("@supabase/supabase-js");
+const config_js_1 = require("./config.js");
+/* ── Authenticated Supabase Client ── */
+function getSupabase() {
+    const config = (0, config_js_1.loadConfig)();
+    if (!config)
+        return null;
+    return (0, supabase_js_1.createClient)(config_js_1.SUPABASE_URL, config_js_1.SUPABASE_ANON_KEY, {
+        global: {
+            headers: {
+                Authorization: `Bearer ${config.access_token}`,
+            },
+        },
+        auth: {
+            autoRefreshToken: false,
+            persistSession: false,
+        },
+    });
+}
+/** Get an authenticated Supabase client, refreshing the token if needed. */
+async function getAuthenticatedClient() {
+    const config = (0, config_js_1.loadConfig)();
+    if (!config)
+        return null;
+    const sb = (0, supabase_js_1.createClient)(config_js_1.SUPABASE_URL, config_js_1.SUPABASE_ANON_KEY, {
+        auth: { autoRefreshToken: false, persistSession: false },
+    });
+    // Set the session from stored tokens
+    const { data, error } = await sb.auth.setSession({
+        access_token: config.access_token,
+        refresh_token: config.refresh_token,
+    });
+    if (error || !data.session) {
+        // Try refreshing
+        const { data: refreshData, error: refreshError } = await sb.auth.refreshSession({
+            refresh_token: config.refresh_token,
+        });
+        if (refreshError || !refreshData.session) {
+            return null;
+        }
+        // Save refreshed tokens
+        (0, config_js_1.saveConfig)({
+            ...config,
+            access_token: refreshData.session.access_token,
+            refresh_token: refreshData.session.refresh_token,
+        });
+        return sb;
+    }
+    // Update tokens if they changed
+    if (data.session.access_token !== config.access_token) {
+        (0, config_js_1.saveConfig)({
+            ...config,
+            access_token: data.session.access_token,
+            refresh_token: data.session.refresh_token,
+        });
+    }
+    return sb;
+}
+function requireAuth() {
+    const config = (0, config_js_1.loadConfig)();
+    if (!config) {
+        console.log('');
+        console.log(chalk_1.default.red('  Not logged in.'));
+        console.log('');
+        console.log(`  Run ${chalk_1.default.cyan('checkpoint login')} first.`);
+        console.log('');
+        process.exit(1);
+    }
+}
+/* ── Checkpoint Tracking Script (injected into HTML responses) ── */
+function trackingScript(checkpointOrigin) {
+    return `
+<script data-checkpoint>
+(function(){
+  var origin=${JSON.stringify(checkpointOrigin)};
+  function report(){
+    try{
+      window.parent.postMessage({
+        type:'checkpoint:navigate',
+        path:location.pathname+location.search
+      },origin);
+    }catch(e){}
+  }
+  report();
+  var _ps=history.pushState,_rs=history.replaceState;
+  history.pushState=function(){_ps.apply(this,arguments);report();};
+  history.replaceState=function(){_rs.apply(this,arguments);report();};
+  window.addEventListener('popstate',report);
+})();
+</script>`.trim();
+}
+/* ── Injection Proxy ── */
+function startInjectionProxy(targetPort) {
+    const APP_URL = (0, config_js_1.getAppUrl)();
+    const SCRIPT = trackingScript(APP_URL);
+    return new Promise((resolve, reject) => {
+        const server = http_1.default.createServer((req, res) => {
+            const fwdHeaders = { ...req.headers, host: `localhost:${targetPort}` };
+            delete fwdHeaders['accept-encoding'];
+            const proxyReq = http_1.default.request({
+                hostname: 'localhost',
+                port: targetPort,
+                path: req.url,
+                method: req.method,
+                headers: fwdHeaders,
+            }, (proxyRes) => {
+                const contentType = proxyRes.headers['content-type'] || '';
+                const isHtml = contentType.includes('text/html');
+                if (!isHtml) {
+                    res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+                    proxyRes.pipe(res);
+                    return;
+                }
+                const chunks = [];
+                proxyRes.on('data', (chunk) => chunks.push(chunk));
+                proxyRes.on('end', () => {
+                    let body = Buffer.concat(chunks).toString('utf-8');
+                    if (!body.includes('data-checkpoint')) {
+                        if (body.includes('</head>')) {
+                            body = body.replace('</head>', SCRIPT + '\n</head>');
+                        }
+                        else if (body.includes('</body>')) {
+                            body = body.replace('</body>', SCRIPT + '\n</body>');
+                        }
+                        else {
+                            body += SCRIPT;
+                        }
+                    }
+                    const headers = { ...proxyRes.headers };
+                    delete headers['content-length'];
+                    delete headers['transfer-encoding'];
+                    headers['content-length'] = String(Buffer.byteLength(body));
+                    res.writeHead(proxyRes.statusCode || 200, headers);
+                    res.end(body);
+                });
+            });
+            proxyReq.on('error', (err) => {
+                res.writeHead(502);
+                res.end(`Checkpoint proxy error: ${err.message}`);
+            });
+            req.pipe(proxyReq);
+        });
+        server.on('upgrade', (req, socket, head) => {
+            const proxyReq = http_1.default.request({
+                hostname: 'localhost',
+                port: targetPort,
+                path: req.url,
+                method: req.method,
+                headers: { ...req.headers, host: `localhost:${targetPort}` },
+            });
+            proxyReq.on('upgrade', (_proxyRes, proxySocket, proxyHead) => {
+                socket.write(`HTTP/1.1 101 Switching Protocols\r\n` +
+                    Object.entries(_proxyRes.headers)
+                        .map(([k, v]) => `${k}: ${v}`)
+                        .join('\r\n') +
+                    '\r\n\r\n');
+                if (proxyHead.length)
+                    socket.write(proxyHead);
+                proxySocket.pipe(socket);
+                socket.pipe(proxySocket);
+            });
+            proxyReq.on('error', () => socket.destroy());
+            socket.on('error', () => proxyReq.destroy());
+            proxyReq.end(head);
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (!addr || typeof addr === 'string') {
+                reject(new Error('Failed to start injection proxy'));
+                return;
+            }
+            resolve({ proxyPort: addr.port, close: () => server.close() });
+        });
+        server.on('error', reject);
+    });
+}
+/* ── Helpers ── */
+function generateShareId() {
+    const chars = 'abcdefghijkmnpqrstuvwxyz23456789';
+    let result = '';
+    for (let i = 0; i < 8; i++) {
+        result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+}
+function hasBinary(name) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(name))
+        return false;
+    try {
+        (0, child_process_1.execSync)(`which ${name}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const VALID_PROVIDERS = ['cloudflared', 'ngrok'];
+function isValidProvider(provider) {
+    return VALID_PROVIDERS.includes(provider);
+}
+function isValidUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === 'https:' || parsed.protocol === 'http:';
+    }
+    catch {
+        return false;
+    }
+}
+function detectProvider() {
+    if (hasBinary('cloudflared'))
+        return 'cloudflared';
+    if (hasBinary('ngrok'))
+        return 'ngrok';
+    return null;
+}
+/* ── Tunnel Launchers ── */
+function launchCloudflared(port) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)('cloudflared', ['tunnel', '--url', `http://localhost:${port}`], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let resolved = false;
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                reject(new Error('Timed out waiting for cloudflared (30s)'));
+                child.kill();
+            }
+        }, 30000);
+        const handleOutput = (data) => {
+            const match = data.toString().match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+            if (match && !resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                resolve({ url: match[0], kill: () => child.kill('SIGTERM') });
+            }
+        };
+        child.stdout.on('data', handleOutput);
+        child.stderr.on('data', handleOutput);
+        child.on('error', (err) => { clearTimeout(timeout); reject(new Error(`cloudflared: ${err.message}`)); });
+        child.on('exit', (code) => { if (!resolved) {
+            clearTimeout(timeout);
+            reject(new Error(`cloudflared exited ${code}`));
+        } });
+    });
+}
+function launchNgrok(port) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)('ngrok', ['http', String(port), '--log', 'stdout', '--log-format', 'json'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let resolved = false;
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                reject(new Error('Timed out waiting for ngrok (15s)'));
+                child.kill();
+            }
+        }, 15000);
+        child.stdout.on('data', (data) => {
+            const match = data.toString().match(/https:\/\/[a-z0-9-]+\.ngrok[a-z.-]*\.(?:io|app|dev)[^\s"]*/);
+            if (match && !resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                resolve({ url: match[0], kill: () => child.kill('SIGTERM') });
+            }
+        });
+        child.on('error', (err) => { clearTimeout(timeout); reject(new Error(`ngrok: ${err.message}`)); });
+        child.on('exit', (code) => { if (!resolved) {
+            clearTimeout(timeout);
+            reject(new Error(`ngrok exited ${code}`));
+        } });
+    });
+}
+async function registerTunnel(sb, opts) {
+    if (!isValidUrl(opts.tunnelUrl)) {
+        console.log(chalk_1.default.yellow('  ⚠ Invalid tunnel URL'));
+        return null;
+    }
+    const { data: userData } = await sb.auth.getUser();
+    if (!userData.user) {
+        console.log(chalk_1.default.yellow('  ⚠ Session expired. Run `checkpoint login` again.'));
+        return null;
+    }
+    const APP_URL = (0, config_js_1.getAppUrl)();
+    const shareId = generateShareId();
+    const { data, error } = await sb.from('tunnels').insert({
+        name: opts.name,
+        local_port: opts.port,
+        tunnel_url: opts.tunnelUrl,
+        share_id: shareId,
+        status: 'active',
+        user_id: userData.user.id,
+        last_seen_at: new Date().toISOString(),
+    }).select('id').single();
+    if (error || !data) {
+        console.log(chalk_1.default.yellow(`  ⚠ Could not register: ${error?.message ?? 'unknown'}`));
+        return null;
+    }
+    return { shareUrl: `${APP_URL}/share/${shareId}`, tunnelId: data.id };
+}
+async function deactivateTunnel(sb, tunnelId) {
+    try {
+        await sb.from('tunnels')
+            .update({ status: 'inactive', last_seen_at: new Date().toISOString() })
+            .eq('id', tunnelId);
+    }
+    catch { /* best-effort */ }
+}
+function startHeartbeat(sb, tunnelId) {
+    return setInterval(async () => {
+        try {
+            await sb.from('tunnels')
+                .update({ last_seen_at: new Date().toISOString() })
+                .eq('id', tunnelId);
+        }
+        catch { /* silent */ }
+    }, 30000);
+}
+/* ── Browser-based Login Flow ── */
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    (0, child_process_1.spawn)(cmd, [url], { stdio: 'ignore', detached: true }).unref();
+}
+function loginWithBrowser() {
+    return new Promise((resolve, reject) => {
+        const server = http_1.default.createServer((req, res) => {
+            const url = new URL(req.url || '/', `http://localhost`);
+            if (url.pathname === '/callback') {
+                const access_token = url.searchParams.get('access_token');
+                const refresh_token = url.searchParams.get('refresh_token');
+                if (access_token && refresh_token) {
+                    // Success page
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(`
+            <html>
+              <body style="font-family: system-ui; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #0a0e17; color: #f1f3f5;">
+                <div style="text-align: center;">
+                  <h1 style="font-size: 24px;">✓ Logged in to Checkpoint</h1>
+                  <p style="color: #9ca3af;">You can close this tab and return to your terminal.</p>
+                </div>
+              </body>
+            </html>
+          `);
+                    server.close();
+                    resolve({ access_token, refresh_token });
+                }
+                else {
+                    res.writeHead(400, { 'Content-Type': 'text/html' });
+                    res.end(`
+            <html>
+              <body style="font-family: system-ui; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #0a0e17; color: #f1f3f5;">
+                <div style="text-align: center;">
+                  <h1 style="font-size: 24px; color: #ef4444;">Login failed</h1>
+                  <p style="color: #9ca3af;">Missing tokens. Please try again.</p>
+                </div>
+              </body>
+            </html>
+          `);
+                    server.close();
+                    reject(new Error('Missing tokens in callback'));
+                }
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (!addr || typeof addr === 'string') {
+                reject(new Error('Failed to start callback server'));
+                return;
+            }
+            const callbackUrl = `http://localhost:${addr.port}/callback`;
+            const APP_URL = (0, config_js_1.getAppUrl)();
+            const loginUrl = `${APP_URL}/cli/auth?callback=${encodeURIComponent(callbackUrl)}`;
+            console.log(chalk_1.default.gray(`  Opening browser...`));
+            console.log(`  ${chalk_1.default.cyan(loginUrl)}`);
+            console.log('');
+            openBrowser(loginUrl);
+        });
+        // Timeout after 5 minutes
+        setTimeout(() => {
+            server.close();
+            reject(new Error('Login timed out (5 minutes). Please try again.'));
+        }, 5 * 60 * 1000);
+    });
+}
+/* ── CLI ── */
+const program = new commander_1.Command();
+program
+    .name('checkpoint')
+    .description('Share your localhost with reviewers — get visual feedback directly on the page')
+    .version('0.1.0');
+// ── checkpoint login ──
+program
+    .command('login')
+    .description('Authenticate with Checkpoint via the browser')
+    .action(async () => {
+    console.log('');
+    console.log(chalk_1.default.blue.bold('  ⚡ Checkpoint'));
+    console.log('');
+    // Check if already logged in
+    const existing = (0, config_js_1.loadConfig)();
+    if (existing) {
+        const sb = await getAuthenticatedClient();
+        if (sb) {
+            const { data } = await sb.auth.getUser();
+            if (data.user) {
+                console.log(chalk_1.default.green(`  Already logged in as ${chalk_1.default.white(data.user.email)}`));
+                console.log(chalk_1.default.gray(`  Run ${chalk_1.default.cyan('checkpoint logout')} to switch accounts.`));
+                console.log('');
+                return;
+            }
+        }
+    }
+    try {
+        const tokens = await loginWithBrowser();
+        (0, config_js_1.saveConfig)({
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token,
+            app_url: (0, config_js_1.getAppUrl)(),
+        });
+        // Verify the session
+        const sb = await getAuthenticatedClient();
+        if (sb) {
+            const { data } = await sb.auth.getUser();
+            console.log(chalk_1.default.green(`  ✓ Logged in as ${chalk_1.default.white(data.user?.email)}`));
+        }
+        else {
+            console.log(chalk_1.default.green('  ✓ Logged in'));
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`  ${err.message}`));
+        console.log('');
+        process.exit(1);
+    }
+});
+// ── checkpoint logout ──
+program
+    .command('logout')
+    .description('Sign out and remove stored credentials')
+    .action(() => {
+    console.log('');
+    console.log(chalk_1.default.blue.bold('  ⚡ Checkpoint'));
+    console.log('');
+    (0, config_js_1.clearConfig)();
+    console.log(chalk_1.default.green('  ✓ Logged out'));
+    console.log('');
+});
+// ── checkpoint start ──
+program
+    .command('start')
+    .description('Tunnel a local port and create a Checkpoint share link')
+    .requiredOption('-p, --port <port>', 'Local port to tunnel', '3000')
+    .option('-n, --name <name>', 'Name for this tunnel', 'My Tunnel')
+    .option('--provider <provider>', 'Tunnel provider: cloudflared (default) or ngrok')
+    .action(async (opts) => {
+    requireAuth();
+    const port = parseInt(opts.port, 10);
+    console.log('');
+    console.log(chalk_1.default.blue.bold('  ⚡ Checkpoint'));
+    console.log('');
+    // Authenticate
+    const sb = await getAuthenticatedClient();
+    if (!sb) {
+        console.log(chalk_1.default.red('  Session expired. Run `checkpoint login` again.'));
+        console.log('');
+        process.exit(1);
+    }
+    // Detect provider
+    if (opts.provider && !isValidProvider(opts.provider)) {
+        console.log(chalk_1.default.red(`  Unknown provider: ${opts.provider}`));
+        console.log(chalk_1.default.gray(`  Valid: ${VALID_PROVIDERS.join(', ')}`));
+        console.log('');
+        process.exit(1);
+    }
+    const provider = opts.provider || detectProvider();
+    if (!provider) {
+        console.log(chalk_1.default.red('  No tunnel provider found.'));
+        console.log('');
+        console.log('  Install one of:');
+        console.log(chalk_1.default.cyan('    brew install cloudflared') + chalk_1.default.gray('   (recommended, free)'));
+        console.log(chalk_1.default.cyan('    brew install ngrok'));
+        console.log('');
+        process.exit(1);
+    }
+    console.log(chalk_1.default.gray(`  Provider: ${provider}`));
+    console.log(chalk_1.default.gray(`  Tunneling localhost:${port}...`));
+    console.log('');
+    try {
+        const proxy = await startInjectionProxy(port);
+        console.log(chalk_1.default.green('  ✓ Proxy started') + chalk_1.default.gray(` (localhost:${proxy.proxyPort} → :${port})`));
+        const launcher = provider === 'cloudflared' ? launchCloudflared : launchNgrok;
+        const tunnel = await launcher(proxy.proxyPort);
+        console.log(chalk_1.default.green('  ✓ Tunnel established'));
+        console.log(`  ${chalk_1.default.gray('Tunnel URL:')}  ${chalk_1.default.cyan(tunnel.url)}`);
+        const registered = await registerTunnel(sb, { name: opts.name, port, tunnelUrl: tunnel.url });
+        let heartbeatTimer;
+        if (registered) {
+            console.log(`  ${chalk_1.default.gray('Share URL:')}   ${chalk_1.default.green.bold(registered.shareUrl)}`);
+            console.log('');
+            console.log(chalk_1.default.gray('  Share this URL with reviewers — they can comment directly on the page.'));
+            heartbeatTimer = startHeartbeat(sb, registered.tunnelId);
+        }
+        console.log('');
+        console.log(chalk_1.default.gray('  Press Ctrl+C to stop.'));
+        console.log('');
+        const cleanup = async () => {
+            console.log('');
+            console.log(chalk_1.default.gray('  Shutting down...'));
+            if (heartbeatTimer)
+                clearInterval(heartbeatTimer);
+            if (registered) {
+                await deactivateTunnel(sb, registered.tunnelId);
+                console.log(chalk_1.default.gray('  ✓ Tunnel deactivated'));
+            }
+            tunnel.kill();
+            proxy.close();
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`  ${err.message}`));
+        process.exit(1);
+    }
+});
+// ── checkpoint share ──
+program
+    .command('share')
+    .description('Register an existing tunnel URL with Checkpoint')
+    .requiredOption('-u, --url <url>', 'Your tunnel URL')
+    .option('-n, --name <name>', 'Name for this tunnel', 'My Tunnel')
+    .option('-p, --port <port>', 'Local port (for reference)', '3000')
+    .action(async (opts) => {
+    requireAuth();
+    console.log('');
+    console.log(chalk_1.default.blue.bold('  ⚡ Checkpoint'));
+    console.log('');
+    const sb = await getAuthenticatedClient();
+    if (!sb) {
+        console.log(chalk_1.default.red('  Session expired. Run `checkpoint login` again.'));
+        console.log('');
+        process.exit(1);
+    }
+    if (!isValidUrl(opts.url)) {
+        console.log(chalk_1.default.red('  Invalid URL — must start with http:// or https://'));
+        console.log('');
+        process.exit(1);
+    }
+    const { data: userData } = await sb.auth.getUser();
+    if (!userData.user) {
+        console.log(chalk_1.default.red('  Session expired. Run `checkpoint login` again.'));
+        process.exit(1);
+    }
+    const APP_URL = (0, config_js_1.getAppUrl)();
+    const shareId = generateShareId();
+    const { data, error } = await sb.from('tunnels').insert({
+        name: opts.name,
+        local_port: parseInt(opts.port, 10),
+        tunnel_url: opts.url,
+        share_id: shareId,
+        status: 'active',
+        user_id: userData.user.id,
+        last_seen_at: new Date().toISOString(),
+    }).select('id').single();
+    if (error || !data) {
+        console.log(chalk_1.default.red(`  Failed: ${error?.message ?? 'unknown error'}`));
+        process.exit(1);
+    }
+    const shareUrl = `${APP_URL}/share/${shareId}`;
+    console.log(chalk_1.default.green('  ✓ Registered'));
+    console.log(`  ${chalk_1.default.gray('Tunnel URL:')}  ${chalk_1.default.cyan(opts.url)}`);
+    console.log(`  ${chalk_1.default.gray('Share URL:')}   ${chalk_1.default.green.bold(shareUrl)}`);
+    console.log('');
+    console.log(chalk_1.default.gray('  Press Ctrl+C to deactivate.'));
+    console.log('');
+    const heartbeatTimer = startHeartbeat(sb, data.id);
+    const cleanup = async () => {
+        console.log('');
+        clearInterval(heartbeatTimer);
+        await deactivateTunnel(sb, data.id);
+        console.log(chalk_1.default.gray('  ✓ Tunnel deactivated'));
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    await new Promise(() => { });
+});
+// ── checkpoint status ──
+program
+    .command('status')
+    .description('Check setup status')
+    .action(async () => {
+    console.log('');
+    console.log(chalk_1.default.blue.bold('  ⚡ Checkpoint — Status'));
+    console.log('');
+    // Auth status
+    const config = (0, config_js_1.loadConfig)();
+    if (config) {
+        const sb = await getAuthenticatedClient();
+        if (sb) {
+            const { data } = await sb.auth.getUser();
+            if (data.user) {
+                console.log(`  ${chalk_1.default.green('✓')} ${chalk_1.default.white('Logged in'.padEnd(20))} ${chalk_1.default.green(data.user.email)}`);
+            }
+            else {
+                console.log(`  ${chalk_1.default.yellow('!')} ${chalk_1.default.white('Auth'.padEnd(20))} ${chalk_1.default.yellow('session expired — run `checkpoint login`')}`);
+            }
+        }
+    }
+    else {
+        console.log(`  ${chalk_1.default.gray('✗')} ${chalk_1.default.white('Auth'.padEnd(20))} ${chalk_1.default.gray('not logged in — run `checkpoint login`')}`);
+    }
+    // Providers
+    const providers = [
+        { name: 'cloudflared', label: 'Cloudflare Tunnel', install: 'brew install cloudflared' },
+        { name: 'ngrok', label: 'ngrok', install: 'brew install ngrok' },
+    ];
+    for (const p of providers) {
+        const installed = hasBinary(p.name);
+        const icon = installed ? chalk_1.default.green('✓') : chalk_1.default.gray('✗');
+        const status = installed ? chalk_1.default.green('installed') : chalk_1.default.gray(`not found — ${chalk_1.default.cyan(p.install)}`);
+        console.log(`  ${icon} ${chalk_1.default.white(p.label.padEnd(20))} ${status}`);
+    }
+    console.log('');
+});
+// ── checkpoint whoami ──
+program
+    .command('whoami')
+    .description('Show the currently logged in user')
+    .action(async () => {
+    const config = (0, config_js_1.loadConfig)();
+    if (!config) {
+        console.log('');
+        console.log(chalk_1.default.gray('  Not logged in. Run `checkpoint login` first.'));
+        console.log('');
+        process.exit(1);
+    }
+    const sb = await getAuthenticatedClient();
+    if (!sb) {
+        console.log('');
+        console.log(chalk_1.default.yellow('  Session expired. Run `checkpoint login` again.'));
+        console.log('');
+        process.exit(1);
+    }
+    const { data } = await sb.auth.getUser();
+    console.log('');
+    console.log(`  ${chalk_1.default.white(data.user?.email ?? 'Unknown')}`);
+    console.log('');
+});
+program.parse();

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "checkpoint-cli",
+  "version": "0.1.0",
+  "description": "Share your localhost with reviewers — get visual feedback directly on the page",
+  "keywords": ["checkpoint", "tunnel", "localhost", "share", "feedback", "review", "cloudflare", "ngrok"],
+  "license": "MIT",
+  "bin": {
+    "checkpoint": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.95.3",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}