lapseed 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,34 @@
-# Temporary Holding Version
+# lapseed
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Lapseed command line: view any developer's CV in your terminal and manage the leases that let recruiters try your live projects on [lapseed.app](https://lapseed.app).
+
+No dependencies. Needs Node.js 20.12 or newer.
+
+```bash
+npx lapseed <username>          # one-off, no install
+npm i -g lapseed                # installs `lseed` (and the `lapseed` alias)
+```
+
+## Usage
+
+```bash
+lseed <username>                                         # box-drawn CV with stats, projects and links
+lseed login [--key lpk_…] [--api https://lapseed.com]   # prompts for login/password if no key is given
+lseed whoami
+lseed logout
+
+lseed lease generate demo --project hello --uses 3 --time 30m --read-only
+lseed lease manage demo --add-uses 2 --time 1h --rps 10
+lseed lease pause|resume|show|revoke demo
+lseed lease ls [--project hello]
+```
+
+Lease changes apply to live sessions immediately; revoking one disconnects its visitors.
+
+## Configuration
+
+- `~/.lapseed/config.json` (mode 600) stores your API URL and key after `lseed login`.
+- `LAPSEED_API_URL` and `LAPSEED_API_KEY` override the saved config.
+- `NO_COLOR` disables colour.
+
+To expose a local app through Lapseed, use the separate [`servlink`](https://www.npmjs.com/package/servlink) package (`slink`).

package/dist/cli.js

@@ -0,0 +1,554 @@
+#!/usr/bin/env node
+/**
+ * lseed (alias: lapseed) — terminal CV viewer and lease control for Lapseed.
+ *
+ *   lseed <username>   |   npx lapseed <username>
+ *   lseed login | logout | whoami
+ *   lseed lease generate <name> --project <slug> --uses <X> --time <Ym> [--read-only] [--rps n] [--body-mb n]
+ *   lseed lease manage <name> [--add-uses n] [--time Ym] [--rps n] [--body-mb n] [--read-only|--read-write] [--pause|--resume]
+ *   lseed lease pause|resume|revoke|show <name>
+ *   lseed lease ls [--project <slug>]
+ */
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { parseArgs } from 'node:util';
+const VERSION = '1.0.0';
+// ─── terminal styling ───────────────────────────────────────────────────────
+const useColor = process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.TERM !== 'dumb';
+const esc = (code) => (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+const c = {
+    emerald: esc('38;2;16;185;129'),
+    orange: esc('38;2;255;77;0'),
+    mint: esc('38;2;110;231;183'),
+    dim: esc('2'),
+    bold: esc('1'),
+    red: esc('38;2;239;68;68'),
+};
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const visibleLength = (s) => [...s.replace(ANSI_RE, '')].length;
+const padVisible = (s, width) => s + ' '.repeat(Math.max(0, width - visibleLength(s)));
+function truncate(s, width) {
+    const chars = [...s];
+    return chars.length <= width ? s : `${chars.slice(0, Math.max(0, width - 1)).join('')}…`;
+}
+function wrap(text, width) {
+    const out = [];
+    for (const para of text.split(/\r?\n/)) {
+        let line = '';
+        for (const word of para.split(/\s+/).filter(Boolean)) {
+            const w = truncate(word, width);
+            if (!line)
+                line = w;
+            else if (visibleLength(line) + 1 + visibleLength(w) <= width)
+                line += ` ${w}`;
+            else {
+                out.push(line);
+                line = w;
+            }
+        }
+        out.push(line);
+    }
+    return out;
+}
+function fail(message, code = 1) {
+    process.stderr.write(`${c.orange('✗')} ${message}\n`);
+    process.exit(code);
+}
+const CONFIG_DIR = join(homedir(), '.lapseed');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+function loadConfig() {
+    try {
+        return existsSync(CONFIG_FILE) ? JSON.parse(readFileSync(CONFIG_FILE, 'utf8')) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(cfg) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(CONFIG_FILE, `${JSON.stringify(cfg, null, 2)}\n`, { mode: 0o600 });
+    try {
+        chmodSync(CONFIG_FILE, 0o600);
+    }
+    catch {
+        /* not supported on this filesystem */
+    }
+}
+const cfg = loadConfig();
+const apiUrl = (process.env.LAPSEED_API_URL ?? cfg.apiUrl ?? 'https://lapseed.com').replace(/\/+$/, '');
+const apiKey = process.env.LAPSEED_API_KEY ?? cfg.apiKey;
+class ApiError extends Error {
+    status;
+    code;
+    constructor(status, message, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+async function api(method, path, body, opts = {}) {
+    const headers = { accept: 'application/json', 'user-agent': `lapseed-cli/${VERSION}` };
+    if (body !== undefined)
+        headers['content-type'] = 'application/json';
+    if (opts.auth !== false && apiKey)
+        headers.authorization = `Bearer ${apiKey}`;
+    let res;
+    try {
+        res = await fetch(`${apiUrl}${path}`, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(20_000),
+        });
+    }
+    catch (err) {
+        throw new ApiError(0, `Cannot reach ${apiUrl} (${err.message})`);
+    }
+    const text = await res.text();
+    let json = null;
+    try {
+        json = text ? JSON.parse(text) : null;
+    }
+    catch {
+        /* non-JSON error body */
+    }
+    if (!res.ok) {
+        const e = json?.error;
+        throw new ApiError(res.status, e?.message ?? `HTTP ${res.status}`, e?.code);
+    }
+    return json;
+}
+function requireKey() {
+    if (!apiKey)
+        fail(`Not logged in. Run ${c.emerald('lseed login')} first (or set LAPSEED_API_KEY).`);
+}
+// ─── prompts ────────────────────────────────────────────────────────────────
+function prompt(question, hidden = false) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: process.stdin.isTTY === true });
+        let muted = false;
+        const rlInternal = rl;
+        const original = rlInternal._writeToOutput.bind(rl);
+        rlInternal._writeToOutput = (s) => {
+            if (!muted)
+                original(s);
+            else if (s.includes('\n') || s.includes('\r'))
+                original('\n');
+        };
+        rl.question(question, (answer) => {
+            rl.close();
+            if (hidden)
+                process.stdout.write('\n');
+            resolve(answer.trim());
+        });
+        muted = hidden;
+    });
+}
+const stripScheme = (u) => u.replace(/^https?:\/\//, '');
+const statusDot = (s) => (s === 'ONLINE' ? `${c.emerald('●')} ${c.emerald('ONLINE')}` : `${c.dim('○ DORMANT')}`);
+const verifiedMark = (v) => (v ? ` ${c.emerald('✓ verified')}` : ` ${c.dim('unverified')}`);
+function renderCv(cv) {
+    const W = Math.max(60, Math.min(process.stdout.columns ?? 80, 84));
+    const inner = W - 4;
+    const B = c.emerald;
+    const out = [];
+    const row = (content = '') => out.push(`${B('│')} ${padVisible(content, inner)} ${B('│')}`);
+    const section = (title) => {
+        const label = ` ${title} `;
+        out.push(B('├─') + c.orange(c.bold(label)) + B(`${'─'.repeat(Math.max(0, W - 3 - visibleLength(label)))}┤`));
+    };
+    out.push(B(`┌${'─'.repeat(W - 2)}┐`));
+    const brand = `${c.emerald(c.bold('~>'))} ${c.bold('lapseed')}`;
+    const handle = c.orange(`@${cv.username}`);
+    row(brand + ' '.repeat(Math.max(1, inner - visibleLength(brand) - visibleLength(handle))) + handle);
+    out.push(B(`├${'─'.repeat(W - 2)}┤`));
+    row(c.bold(truncate(cv.name, inner)));
+    if (cv.bio)
+        for (const l of wrap(cv.bio, inner))
+            row(l);
+    if (cv.education)
+        row(c.mint(truncate(`edu  ${cv.education}`, inner)));
+    section('ROLE TAGS');
+    const tags = cv.role_tags.map((t) => c.emerald(`[${t}]`));
+    let line = '';
+    for (const t of tags) {
+        if (line && visibleLength(line) + 1 + visibleLength(t) > inner) {
+            row(line);
+            line = t;
+        }
+        else
+            line = line ? `${line} ${t}` : t;
+    }
+    row(line || c.dim('none'));
+    section('LIVE NODE');
+    row(statusDot(cv.node.status) + c.dim(cv.node.status === 'ONLINE' ? '  slink tunnel connected' : '  slink tunnel offline'));
+    section('LEETCODE');
+    if (cv.leetcode) {
+        const lc = cv.leetcode;
+        row(`${c.bold(lc.username)}${verifiedMark(lc.verified)}`);
+        row(`${c.emerald('Easy')} ${lc.easy}   ${c.orange('Medium')} ${lc.medium}   ${c.red('Hard')} ${lc.hard}   ${c.bold('Total')} ${lc.total}`);
+        const extras = [
+            lc.contestRating !== null ? `Contest rating ${c.bold(lc.contestRating)}` : null,
+            lc.contestTopPercentage !== null ? `top ${lc.contestTopPercentage}%` : null,
+            lc.ranking !== null ? `global rank #${lc.ranking.toLocaleString('en-US')}` : null,
+        ].filter(Boolean);
+        if (extras.length)
+            row(c.dim(extras.join(' · ')));
+    }
+    else
+        row(c.dim('not linked'));
+    section('GITHUB');
+    if (cv.github) {
+        const gh = cv.github;
+        row(`${c.bold(gh.login)}${verifiedMark(gh.verified)}`);
+        row(`${gh.publicRepos} repos   ${c.orange('★')} ${gh.totalStars} stars   ${gh.followers} followers`);
+        const barWidth = Math.max(10, inner - 26);
+        for (const lang of gh.languages.slice(0, 5)) {
+            const filled = Math.max(1, Math.round((lang.percent / 100) * barWidth));
+            const bar = c.emerald('█'.repeat(filled)) + c.dim('░'.repeat(Math.max(0, barWidth - filled)));
+            row(`${padVisible(truncate(lang.name, 14), 14)} ${bar} ${String(lang.percent).padStart(5)}%`);
+        }
+    }
+    else
+        row(c.dim('not linked'));
+    section('PROJECTS');
+    if (cv.projects.length === 0)
+        row(c.dim('no projects yet'));
+    cv.projects.forEach((p, i) => {
+        if (i > 0)
+            row();
+        row(`${c.orange('▸')} ${c.bold(truncate(p.title, inner - 4))}`);
+        row(`  ${c.dim('pitch')} ${c.mint(truncate(stripScheme(p.pitch_url), inner - 8))}`);
+        const live = `  ${c.dim('live ')} ${c.mint(stripScheme(p.live_url))}`;
+        const dot = statusDot(p.node_status);
+        row(visibleLength(live) + 2 + visibleLength(dot) <= inner ? `${live}  ${dot}` : live);
+    });
+    out.push(B(`└${'─'.repeat(W - 2)}┘`));
+    out.push(`  ${c.dim(stripScheme(cv.profile_url))}`);
+    return out.join('\n');
+}
+/** Parse `30m`, `2h`, `1h30m`, `1d`, or a bare number of minutes. */
+function parseDuration(input) {
+    const s = input.trim().toLowerCase();
+    if (/^\d+$/.test(s))
+        return Number(s);
+    const re = /(\d+)\s*(d|h|m)/g;
+    let total = 0;
+    let consumed = '';
+    for (const m of s.matchAll(re)) {
+        const n = Number(m[1]);
+        total += m[2] === 'd' ? n * 1440 : m[2] === 'h' ? n * 60 : n;
+        consumed += m[0];
+    }
+    if (!total || consumed.replace(/\s/g, '') !== s.replace(/\s/g, '')) {
+        fail(`Invalid duration "${input}". Use e.g. 30m, 2h, 1h30m, 1d.`);
+    }
+    return total;
+}
+function formatMinutes(min) {
+    if (min % 1440 === 0)
+        return `${min / 1440}d`;
+    if (min >= 60)
+        return min % 60 ? `${Math.floor(min / 60)}h${min % 60}m` : `${min / 60}h`;
+    return `${min}m`;
+}
+function parseInt10(name, v) {
+    if (v === undefined)
+        return undefined;
+    if (!/^-?\d+$/.test(v))
+        fail(`--${name} must be an integer`);
+    return Number(v);
+}
+function leaseState(l) {
+    if (l.revoked)
+        return c.red('revoked');
+    if (l.paused)
+        return c.orange('paused');
+    if (l.remaining_uses === 0)
+        return c.dim('exhausted');
+    return c.emerald('active');
+}
+function printLease(l, headline) {
+    const kv = (k, v) => console.log(`  ${c.dim(k.padEnd(10))} ${v}`);
+    console.log(`${c.emerald(c.bold('~>'))} ${headline} ${c.bold(l.name)}`);
+    kv('project', l.project_slug);
+    kv('sessions', `${c.bold(l.remaining_uses)}/${l.max_uses} left · ${l.active_sessions} active now`);
+    kv('duration', `${formatMinutes(l.duration_minutes)} per session`);
+    kv('mode', l.read_only ? c.orange('read-only') : 'read-write');
+    kv('limits', `${l.max_rps} req/s · ${l.max_body_mb} MB body`);
+    kv('state', leaseState(l));
+    kv('node', `${l.node_id} ${statusDot(l.node_status)}`);
+    console.log(`\n  ${c.orange(l.link)}\n`);
+}
+function printLeaseTable(list) {
+    if (list.length === 0) {
+        console.log(c.dim('No leases yet. Create one with: lseed lease generate <name> --project <slug> --uses 3 --time 30m'));
+        return;
+    }
+    const headers = ['NAME', 'PROJECT', 'USES', 'TIME', 'MODE', 'RPS', 'LIVE', 'STATE', 'NODE'];
+    const rows = list.map((l) => [
+        c.bold(l.name),
+        l.project_slug,
+        `${l.remaining_uses}/${l.max_uses}`,
+        formatMinutes(l.duration_minutes),
+        l.read_only ? c.orange('ro') : 'rw',
+        String(l.max_rps),
+        String(l.active_sessions),
+        leaseState(l),
+        l.node_status === 'ONLINE' ? c.emerald('●') : c.dim('○'),
+    ]);
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => visibleLength(r[i]))));
+    console.log(headers.map((h, i) => c.dim(h.padEnd(widths[i]))).join('  '));
+    for (const r of rows)
+        console.log(r.map((cell, i) => padVisible(cell, widths[i])).join('  '));
+}
+// ─── commands ───────────────────────────────────────────────────────────────
+async function cmdCv(username) {
+    if (!/^[a-z0-9-]{3,32}$/i.test(username))
+        fail(`"${username}" is not a valid Lapseed username`);
+    const { cv } = await api('GET', `/api/cv/${encodeURIComponent(username.toLowerCase())}`, undefined, { auth: false });
+    console.log(renderCv(cv));
+}
+async function cmdLogin(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { key: { type: 'string' }, login: { type: 'string' }, api: { type: 'string' } },
+        allowPositionals: false,
+    });
+    const target = (values.api ?? apiUrl).replace(/\/+$/, '');
+    if (values.key) {
+        if (!values.key.startsWith('lpk_'))
+            fail('API keys start with lpk_');
+        const res = await fetch(`${target}/api/auth/me`, { headers: { authorization: `Bearer ${values.key}` } });
+        if (!res.ok)
+            fail('That API key was rejected');
+        const { user } = (await res.json());
+        saveConfig({ ...cfg, apiUrl: target, apiKey: values.key, username: user.username });
+        console.log(`${c.emerald('✓')} Logged in as ${c.bold(`@${user.username}`)}`);
+        return;
+    }
+    const login = values.login ?? (await prompt(`${c.emerald('~>')} email or username: `));
+    const password = await prompt(`${c.emerald('~>')} password: `, true);
+    if (!login || !password)
+        fail('Login and password are required');
+    const res = await fetch(`${target}/api/auth/cli-token`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ login, password, label: `lapseed-cli@${process.platform}` }),
+    });
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok || !json.api_key)
+        fail(json.error?.message ?? `Login failed (HTTP ${res.status})`);
+    saveConfig({ ...cfg, apiUrl: target, apiKey: json.api_key, username: json.username });
+    console.log(`${c.emerald('✓')} Logged in as ${c.bold(`@${json.username}`)} ${c.dim(`(key saved to ${CONFIG_FILE})`)}`);
+}
+async function cmdWhoami() {
+    requireKey();
+    const { user } = await api('GET', '/api/auth/me');
+    console.log(`${c.emerald('~>')} ${c.bold(`@${user.username}`)} ${c.dim(`${user.role} · ${user.email}`)}`);
+    if (user.server) {
+        const s = user.server;
+        console.log(`  ${c.dim('node')} ${s.node_id ?? c.dim('not bound')} ${s.node_id ? statusDot(s.status) : ''}`);
+    }
+    console.log(`  ${c.dim('api ')} ${apiUrl}`);
+}
+async function cmdLease(argv) {
+    const [sub, ...rest] = argv;
+    if (!sub || sub === 'help' || sub === '--help') {
+        printHelp();
+        return;
+    }
+    requireKey();
+    switch (sub) {
+        case 'generate':
+        case 'gen':
+        case 'create': {
+            const { values, positionals } = parseArgs({
+                args: rest,
+                allowPositionals: true,
+                options: {
+                    project: { type: 'string', short: 'p' },
+                    uses: { type: 'string', short: 'u' },
+                    time: { type: 'string', short: 't' },
+                    'read-only': { type: 'boolean', default: false },
+                    rps: { type: 'string' },
+                    'body-mb': { type: 'string' },
+                },
+            });
+            const name = positionals[0];
+            if (!name)
+                fail('Usage: lseed lease generate <name> --project <slug> --uses <X> --time <Ym> [--read-only]');
+            if (!values.project)
+                fail('--project <slug> is required');
+            if (!values.uses)
+                fail('--uses <X> is required');
+            if (!values.time)
+                fail('--time <Ym> is required (e.g. 30m)');
+            const { lease } = await api('POST', '/api/leases', {
+                name,
+                project_slug: values.project,
+                max_uses: parseInt10('uses', values.uses),
+                duration_minutes: parseDuration(values.time),
+                read_only: values['read-only'],
+                max_rps: parseInt10('rps', values.rps),
+                max_body_mb: parseInt10('body-mb', values['body-mb']),
+            });
+            printLease(lease, 'minted');
+            return;
+        }
+        case 'manage':
+        case 'update': {
+            const { values, positionals } = parseArgs({
+                args: rest,
+                allowPositionals: true,
+                options: {
+                    'add-uses': { type: 'string' },
+                    uses: { type: 'string' },
+                    time: { type: 'string', short: 't' },
+                    rps: { type: 'string' },
+                    'body-mb': { type: 'string' },
+                    'read-only': { type: 'boolean' },
+                    'read-write': { type: 'boolean' },
+                    pause: { type: 'boolean' },
+                    resume: { type: 'boolean' },
+                    rename: { type: 'string' },
+                },
+            });
+            const name = positionals[0];
+            if (!name)
+                fail('Usage: lseed lease manage <name> --add-uses <n> --time <Ym> --rps <n>');
+            if (values['read-only'] && values['read-write'])
+                fail('Choose either --read-only or --read-write');
+            if (values.pause && values.resume)
+                fail('Choose either --pause or --resume');
+            const patch = {
+                add_uses: parseInt10('add-uses', values['add-uses']),
+                max_uses: parseInt10('uses', values.uses),
+                duration_minutes: values.time ? parseDuration(values.time) : undefined,
+                max_rps: parseInt10('rps', values.rps),
+                max_body_mb: parseInt10('body-mb', values['body-mb']),
+                read_only: values['read-only'] ? true : values['read-write'] ? false : undefined,
+                paused: values.pause ? true : values.resume ? false : undefined,
+                name: values.rename,
+            };
+            for (const k of Object.keys(patch))
+                if (patch[k] === undefined)
+                    delete patch[k];
+            if (Object.keys(patch).length === 0)
+                fail('Nothing to change. Try --add-uses 2, --time 45m or --rps 10');
+            const { lease } = await api('PATCH', `/api/leases/${encodeURIComponent(name)}`, patch);
+            printLease(lease, 'updated (hot, tunnel untouched)');
+            return;
+        }
+        case 'pause':
+        case 'resume': {
+            const name = rest[0];
+            if (!name)
+                fail(`Usage: lseed lease ${sub} <name>`);
+            const { lease } = await api('PATCH', `/api/leases/${encodeURIComponent(name)}`, { paused: sub === 'pause' });
+            console.log(`${c.emerald('✓')} ${c.bold(lease.name)} is now ${leaseState(lease)}`);
+            return;
+        }
+        case 'revoke':
+        case 'rm': {
+            const name = rest[0];
+            if (!name)
+                fail('Usage: lseed lease revoke <name>');
+            await api('DELETE', `/api/leases/${encodeURIComponent(name)}`);
+            console.log(`${c.emerald('✓')} Revoked ${c.bold(name)} — link disabled and all live sessions terminated.`);
+            return;
+        }
+        case 'show':
+        case 'get': {
+            const name = rest[0];
+            if (!name)
+                fail('Usage: lseed lease show <name>');
+            const { lease } = await api('GET', `/api/leases/${encodeURIComponent(name)}`);
+            printLease(lease, 'lease');
+            return;
+        }
+        case 'ls':
+        case 'list': {
+            const { values } = parseArgs({ args: rest, options: { project: { type: 'string', short: 'p' } } });
+            const q = values.project ? `?project=${encodeURIComponent(values.project)}` : '';
+            const { leases } = await api('GET', `/api/leases${q}`);
+            printLeaseTable(leases);
+            return;
+        }
+        default:
+            fail(`Unknown lease command "${sub}". Run lseed help.`);
+    }
+}
+function printHelp() {
+    const e = c.emerald;
+    console.log(`${e(c.bold('~>'))} ${c.bold('lapseed')} ${c.dim(`v${VERSION}`)}
+
+${c.orange('VIEW')}
+  ${e('lseed <username>')}                           Render a developer's terminal CV
+
+${c.orange('ACCOUNT')}
+  ${e('lseed login')} [--key lpk_…] [--api URL]      Sign in and store a CLI API key
+  ${e('lseed logout')}                               Forget the stored key
+  ${e('lseed whoami')}                               Show the signed-in account
+
+${c.orange('LEASES')} ${c.dim('(live access links to your slink server)')}
+  ${e('lseed lease generate')} <name> --project <slug> --uses <X> --time <Ym> [--read-only] [--rps n] [--body-mb n]
+  ${e('lseed lease manage')} <name> [--add-uses n] [--uses n] [--time Ym] [--rps n] [--body-mb n]
+                         [--read-only|--read-write] [--pause|--resume] [--rename new]
+  ${e('lseed lease pause|resume')} <name>
+  ${e('lseed lease revoke')} <name>
+  ${e('lseed lease show')} <name>
+  ${e('lseed lease ls')} [--project <slug>]
+
+${c.dim('Alias: lapseed (e.g. npx lapseed <username>)')}
+${c.dim('Env: LAPSEED_API_URL (default https://lapseed.com), LAPSEED_API_KEY, NO_COLOR')}`);
+}
+async function main() {
+    const [cmd, ...rest] = process.argv.slice(2);
+    switch (cmd) {
+        case undefined:
+        case 'help':
+        case '--help':
+        case '-h':
+            printHelp();
+            return;
+        case '--version':
+        case '-v':
+        case 'version':
+            console.log(VERSION);
+            return;
+        case 'login':
+            return cmdLogin(rest);
+        case 'logout':
+            if (existsSync(CONFIG_FILE)) {
+                const { apiUrl: keepUrl } = cfg;
+                rmSync(CONFIG_FILE);
+                if (keepUrl)
+                    saveConfig({ apiUrl: keepUrl });
+            }
+            console.log(`${c.emerald('✓')} Logged out`);
+            return;
+        case 'whoami':
+            return cmdWhoami();
+        case 'lease':
+        case 'leases':
+            return cmdLease(rest);
+        default:
+            if (cmd.startsWith('-'))
+                fail(`Unknown option ${cmd}. Run lseed help.`);
+            return cmdCv(cmd.replace(/^@/, ''));
+    }
+}
+main().catch((err) => {
+    if (err instanceof ApiError) {
+        if (err.status === 401)
+            fail(`${err.message}. Run ${c.emerald('lseed login')}.`);
+        fail(err.message);
+    }
+    if (err instanceof Error && 'code' in err && String(err.code).startsWith('ERR_PARSE_ARGS')) {
+        fail(err.message);
+    }
+    fail(err instanceof Error ? err.message : String(err));
+});

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "lapseed",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "lseed: view any Lapseed developer's CV in your terminal and manage project leases",
+  "type": "module",
+  "bin": {
+    "lseed": "./dist/cli.js",
+    "lapseed": "./dist/cli.js"
+  },
+  "files": [
+    "dist/cli.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.12"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build",
+    "dev": "tsx src/cli.ts"
+  },
+  "keywords": [
+    "lapseed",
+    "cli",
+    "cv",
+    "resume",
+    "terminal"
+  ],
+  "devDependencies": {
+    "@types/node": "^26.6.6",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
+  },
+  "license": "MIT"
+}