@rerout/cli 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# @rerout/cli
+
+Branded short links, QR codes, and analytics from your terminal — a thin CLI over
+[`@rerout/sdk`](https://www.npmjs.com/package/@rerout/sdk).
+
+```bash
+npm install -g @rerout/cli
+```
+
+## Authenticate
+
+Mint a project API key in the dashboard (Owner/Admin), then:
+
+```bash
+rerout login --api-key rrk_...
+```
+
+The key is verified against the API and stored at
+`$XDG_CONFIG_HOME/rerout/config.json` (default `~/.config/rerout/config.json`)
+with `0600` permissions. Alternatively set `REROUT_API_KEY` in the environment
+(it takes precedence over the saved key). Use `--base-url` / `REROUT_BASE_URL`
+for staging or self-hosted APIs.
+
+## Commands
+
+```bash
+rerout whoami                                   # show the key's project
+rerout create https://example.com/sale \        # create a link
+  --domain go.brand.com --code sale
+rerout ls --limit 20                            # list links
+rerout get sale                                 # show one link
+rerout update sale --inactive                   # patch a link
+rerout rm sale                                  # soft-delete a link
+rerout stats                                    # project stats (--days 30)
+rerout stats sale --days 7                      # per-link stats
+rerout qr sale                                  # print the QR URL
+rerout qr sale --output sale.svg                # write the QR SVG
+rerout webhooks ls
+rerout webhooks create --name "Orders" --url https://example.com/hook \
+  --events link.created,link.clicked
+rerout webhooks rm wh_...
+```
+
+Add `--json` to any command for raw, machine-readable output.
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm test          # vitest — network is stubbed via an injected fetch
+npm run build     # emits dist/ (CLI bin + ./core)
+```
+
+The reusable pieces (config, client factory, formatting) are exported from
+`@rerout/cli/core` so other surfaces — like the planned Raycast extension — can
+share one engine instead of re-implementing auth and rendering.
+
+> Note: tag management is not yet exposed here; it lands once `@rerout/sdk` adds
+> a `tags` namespace for the `/v1/projects/me/tags` endpoints.
+
+## Publishing
+
+```bash
+npm run build
+npm publish --access public
+```

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { ReroutError } from '@rerout/sdk';
+import { Command, Option } from 'commander';
+import { createClient } from './core/client.js';
+import { consoleIO } from './core/format.js';
+import { login } from './commands/login.js';
+import { createLink, getLink, listLinks, removeLink, updateLink, } from './commands/links.js';
+import { linkStats, projectStats, whoami } from './commands/project.js';
+import { qr } from './commands/qr.js';
+import { createWebhook, listWebhooks, removeWebhook } from './commands/webhooks.js';
+const program = new Command();
+program
+    .name('rerout')
+    .description('Branded short links, QR codes, and analytics from your terminal.')
+    .version('0.1.0');
+function parseIntOption(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Expected an integer, got "${value}".`);
+    }
+    return parsed;
+}
+program
+    .command('login')
+    .description('Store and verify a project API key (rrk_…).')
+    .requiredOption('--api-key <key>', 'Project API key')
+    .option('--base-url <url>', 'Override the API base URL')
+    .action(async (opts) => {
+    await login({ apiKey: opts.apiKey, baseUrl: opts.baseUrl }, consoleIO);
+});
+program
+    .command('whoami')
+    .description('Show the project that owns the current API key.')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+    await whoami(createClient(), opts, consoleIO);
+});
+program
+    .command('create')
+    .description('Create a short link.')
+    .argument('<url>', 'Destination URL')
+    .option('--domain <hostname>', 'Verified custom domain to host the link on')
+    .option('--code <code>', 'Custom path (requires --domain)')
+    .option('--expires <unix>', 'Expiry as unix seconds', parseIntOption)
+    .option('--title <title>', 'Social preview title')
+    .option('--description <text>', 'Social preview description')
+    .option('--json', 'Output raw JSON')
+    .action(async (url, opts) => {
+    await createLink(createClient(), url, opts, consoleIO);
+});
+program
+    .command('ls')
+    .alias('list')
+    .description('List links in the project.')
+    .option('--limit <n>', 'Page size', parseIntOption)
+    .option('--cursor <n>', 'Pagination cursor', parseIntOption)
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+    await listLinks(createClient(), opts, consoleIO);
+});
+program
+    .command('get')
+    .description('Show a single link.')
+    .argument('<code>', 'Link code')
+    .option('--json', 'Output raw JSON')
+    .action(async (code, opts) => {
+    await getLink(createClient(), code, opts, consoleIO);
+});
+program
+    .command('update')
+    .description('Update a link.')
+    .argument('<code>', 'Link code')
+    .option('--target <url>', 'New destination URL')
+    .addOption(new Option('--active', 'Activate the link').conflicts('inactive'))
+    .addOption(new Option('--inactive', 'Deactivate the link').conflicts('active'))
+    .option('--expires <unix>', 'Expiry as unix seconds', parseIntOption)
+    .option('--title <title>', 'Social preview title')
+    .option('--json', 'Output raw JSON')
+    .action(async (code, opts) => {
+    const active = opts.active ? true : opts.inactive ? false : undefined;
+    await updateLink(createClient(), code, {
+        target: opts.target,
+        active,
+        expires: opts.expires,
+        title: opts.title,
+        json: opts.json,
+    }, consoleIO);
+});
+program
+    .command('rm')
+    .alias('delete')
+    .description('Delete (soft) a link.')
+    .argument('<code>', 'Link code')
+    .option('--json', 'Output raw JSON')
+    .action(async (code, opts) => {
+    await removeLink(createClient(), code, opts, consoleIO);
+});
+program
+    .command('stats')
+    .description('Show project stats, or per-link stats with a code.')
+    .argument('[code]', 'Optional link code')
+    .option('--days <n>', 'Window in days', parseIntOption)
+    .option('--json', 'Output raw JSON')
+    .action(async (code, opts) => {
+    const client = createClient();
+    if (code) {
+        await linkStats(client, code, opts, consoleIO);
+    }
+    else {
+        await projectStats(client, opts, consoleIO);
+    }
+});
+program
+    .command('qr')
+    .description('Print a link QR URL, or write the SVG with --output.')
+    .argument('<code>', 'Link code')
+    .option('--size <px>', 'Module size (1–32)', parseIntOption)
+    .option('--margin <modules>', 'Quiet zone (0–16)', parseIntOption)
+    .addOption(new Option('--ecc <level>', 'Error correction').choices(['L', 'M', 'Q', 'H']))
+    .option('--domain <hostname>', 'Encode a specific verified domain')
+    .option('--output <file>', 'Write the SVG to this file')
+    .option('--json', 'Output raw JSON')
+    .action(async (code, opts) => {
+    await qr(createClient(), code, opts, consoleIO);
+});
+const webhooks = program
+    .command('webhooks')
+    .description('Manage project webhook endpoints.');
+webhooks
+    .command('ls')
+    .description('List webhook endpoints.')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+    await listWebhooks(createClient(), opts, consoleIO);
+});
+webhooks
+    .command('create')
+    .description('Create a webhook endpoint.')
+    .requiredOption('--name <name>', 'Endpoint label')
+    .requiredOption('--url <url>', 'Public https:// delivery URL')
+    .requiredOption('--events <list>', 'Comma-separated event types', (v) => v.split(',').map((e) => e.trim()).filter(Boolean))
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+    await createWebhook(createClient(), { name: opts.name, url: opts.url, events: opts.events, json: opts.json }, consoleIO);
+});
+webhooks
+    .command('rm')
+    .alias('delete')
+    .description('Delete a webhook endpoint.')
+    .argument('<endpoint_id>', 'Endpoint id')
+    .option('--json', 'Output raw JSON')
+    .action(async (endpointId, opts) => {
+    await removeWebhook(createClient(), endpointId, opts, consoleIO);
+});
+async function main() {
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        if (error instanceof ReroutError) {
+            consoleIO.err(`Error (${error.code}): ${error.message}`);
+        }
+        else if (error instanceof Error) {
+            consoleIO.err(`Error: ${error.message}`);
+        }
+        else {
+            consoleIO.err(`Unexpected error: ${String(error)}`);
+        }
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/commands/links.d.ts

@@ -0,0 +1,31 @@
+import type { Rerout } from '@rerout/sdk';
+import { type IO } from '../core/format.js';
+export interface CreateOptions {
+    domain?: string;
+    code?: string;
+    expires?: number;
+    title?: string;
+    description?: string;
+    json?: boolean;
+}
+export declare function createLink(client: Rerout, targetUrl: string, opts: CreateOptions, io: IO): Promise<void>;
+export interface ListOptions {
+    limit?: number;
+    cursor?: number;
+    json?: boolean;
+}
+export declare function listLinks(client: Rerout, opts: ListOptions, io: IO): Promise<void>;
+export declare function getLink(client: Rerout, code: string, opts: {
+    json?: boolean;
+}, io: IO): Promise<void>;
+export interface UpdateOptions {
+    target?: string;
+    active?: boolean;
+    expires?: number | null;
+    title?: string | null;
+    json?: boolean;
+}
+export declare function updateLink(client: Rerout, code: string, opts: UpdateOptions, io: IO): Promise<void>;
+export declare function removeLink(client: Rerout, code: string, opts: {
+    json?: boolean;
+}, io: IO): Promise<void>;

package/dist/commands/links.js

@@ -0,0 +1,70 @@
+import { formatLinkLine, formatLinksTable } from '../core/format.js';
+export async function createLink(client, targetUrl, opts, io) {
+    const input = { target_url: targetUrl };
+    if (opts.domain)
+        input.domain_hostname = opts.domain;
+    if (opts.code)
+        input.code = opts.code;
+    if (opts.expires !== undefined)
+        input.expires_at = opts.expires;
+    if (opts.title !== undefined)
+        input.seo_title = opts.title;
+    if (opts.description !== undefined)
+        input.seo_description = opts.description;
+    const link = await client.links.create(input);
+    if (opts.json) {
+        io.json(link);
+        return;
+    }
+    io.out(link.short_url);
+}
+export async function listLinks(client, opts, io) {
+    const result = await client.links.list({
+        ...(opts.limit !== undefined ? { limit: opts.limit } : {}),
+        ...(opts.cursor !== undefined ? { cursor: opts.cursor } : {}),
+    });
+    if (opts.json) {
+        io.json(result);
+        return;
+    }
+    io.out(formatLinksTable(result.links));
+    if (result.next_cursor != null) {
+        io.out(`\nMore results: rerout ls --cursor ${result.next_cursor}`);
+    }
+}
+export async function getLink(client, code, opts, io) {
+    const link = await client.links.get(code);
+    if (opts.json) {
+        io.json(link);
+        return;
+    }
+    io.out(formatLinkLine(link));
+}
+export async function updateLink(client, code, opts, io) {
+    const input = {};
+    if (opts.target !== undefined)
+        input.target_url = opts.target;
+    if (opts.active !== undefined)
+        input.is_active = opts.active;
+    if (opts.expires !== undefined)
+        input.expires_at = opts.expires;
+    if (opts.title !== undefined)
+        input.seo_title = opts.title;
+    if (Object.keys(input).length === 0) {
+        throw new Error('Nothing to update. Pass at least one of --target, --active, --expires, --title.');
+    }
+    const link = await client.links.update(code, input);
+    if (opts.json) {
+        io.json(link);
+        return;
+    }
+    io.out(formatLinkLine(link));
+}
+export async function removeLink(client, code, opts, io) {
+    const result = await client.links.delete(code);
+    if (opts.json) {
+        io.json(result);
+        return;
+    }
+    io.out(result.deleted ? `Deleted ${code}.` : `Nothing deleted for ${code}.`);
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,12 @@
+import { type IO } from '../core/index.js';
+export interface LoginOptions {
+    apiKey: string;
+    baseUrl?: string;
+    /** Skip the verifying API call (used in tests / offline setup). */
+    skipVerify?: boolean;
+}
+/**
+ * Store an API key after confirming it authenticates. The key is verified with
+ * a `project.me()` call so a bad key fails immediately rather than on first use.
+ */
+export declare function login(opts: LoginOptions, io: IO): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,28 @@
+import { Rerout } from '@rerout/sdk';
+import { configPath, loadConfig, saveConfig } from '../core/config.js';
+import { CLI_USER_AGENT } from '../core/index.js';
+/**
+ * Store an API key after confirming it authenticates. The key is verified with
+ * a `project.me()` call so a bad key fails immediately rather than on first use.
+ */
+export async function login(opts, io) {
+    const apiKey = opts.apiKey.trim();
+    if (!apiKey) {
+        throw new Error('An API key is required. Pass --api-key rrk_…');
+    }
+    if (!opts.skipVerify) {
+        const client = new Rerout({
+            apiKey,
+            ...(opts.baseUrl ? { baseUrl: opts.baseUrl } : {}),
+            defaultHeaders: { 'user-agent': CLI_USER_AGENT },
+        });
+        const project = await client.project.me();
+        io.out(`Authenticated as ${project.name} (${project.slug}).`);
+    }
+    const next = loadConfig();
+    next.apiKey = apiKey;
+    if (opts.baseUrl)
+        next.baseUrl = opts.baseUrl;
+    saveConfig(next);
+    io.out(`Saved credentials to ${configPath()}`);
+}

package/dist/commands/project.d.ts

@@ -0,0 +1,13 @@
+import type { Rerout } from '@rerout/sdk';
+import { type IO } from '../core/format.js';
+export declare function whoami(client: Rerout, opts: {
+    json?: boolean;
+}, io: IO): Promise<void>;
+export declare function projectStats(client: Rerout, opts: {
+    days?: number;
+    json?: boolean;
+}, io: IO): Promise<void>;
+export declare function linkStats(client: Rerout, code: string, opts: {
+    days?: number;
+    json?: boolean;
+}, io: IO): Promise<void>;

package/dist/commands/project.js

@@ -0,0 +1,34 @@
+export async function whoami(client, opts, io) {
+    const project = await client.project.me();
+    if (opts.json) {
+        io.json(project);
+        return;
+    }
+    io.out(`${project.name} (${project.slug}) · ${project.id}`);
+}
+export async function projectStats(client, opts, io) {
+    const stats = await client.project.stats(opts.days);
+    if (opts.json) {
+        io.json(stats);
+        return;
+    }
+    io.out(`Last ${stats.days} days`);
+    io.out(`  Clicks:   ${stats.total_clicks}`);
+    io.out(`  QR scans: ${stats.qr_scans}`);
+    if (stats.top_codes.length > 0) {
+        io.out('  Top links:');
+        for (const row of stats.top_codes.slice(0, 5)) {
+            io.out(`    ${row.value}  ${row.clicks}`);
+        }
+    }
+}
+export async function linkStats(client, code, opts, io) {
+    const stats = await client.links.stats(code, opts.days);
+    if (opts.json) {
+        io.json(stats);
+        return;
+    }
+    io.out(`${code} · last ${stats.days} days`);
+    io.out(`  Clicks:   ${stats.total_clicks}`);
+    io.out(`  QR scans: ${stats.qr_scans}`);
+}

package/dist/commands/qr.d.ts

@@ -0,0 +1,9 @@
+import type { QrUrlOptions, Rerout } from '@rerout/sdk';
+import { type IO } from '../core/format.js';
+export interface QrOptions extends QrUrlOptions {
+    /** Write the SVG to this file instead of printing the URL. */
+    output?: string;
+    /** Print the QR endpoint URL (default) rather than fetching the SVG. */
+    json?: boolean;
+}
+export declare function qr(client: Rerout, code: string, opts: QrOptions, io: IO): Promise<void>;

package/dist/commands/qr.js

@@ -0,0 +1,24 @@
+import { writeFile } from 'node:fs/promises';
+export async function qr(client, code, opts, io) {
+    const urlOptions = {};
+    if (opts.size !== undefined)
+        urlOptions.size = opts.size;
+    if (opts.margin !== undefined)
+        urlOptions.margin = opts.margin;
+    if (opts.ecc !== undefined)
+        urlOptions.ecc = opts.ecc;
+    if (opts.domain !== undefined)
+        urlOptions.domain = opts.domain;
+    if (opts.output) {
+        const svg = await client.qr.svg(code, urlOptions);
+        await writeFile(opts.output, svg, 'utf8');
+        io.out(`Wrote ${opts.output}`);
+        return;
+    }
+    const url = client.qr.url(code, urlOptions);
+    if (opts.json) {
+        io.json({ code, url });
+        return;
+    }
+    io.out(url);
+}

package/dist/commands/webhooks.d.ts

@@ -0,0 +1,15 @@
+import type { Rerout } from '@rerout/sdk';
+import { type IO } from '../core/format.js';
+export declare function listWebhooks(client: Rerout, opts: {
+    json?: boolean;
+}, io: IO): Promise<void>;
+export interface CreateWebhookOptions {
+    name: string;
+    url: string;
+    events: string[];
+    json?: boolean;
+}
+export declare function createWebhook(client: Rerout, opts: CreateWebhookOptions, io: IO): Promise<void>;
+export declare function removeWebhook(client: Rerout, endpointId: string, opts: {
+    json?: boolean;
+}, io: IO): Promise<void>;

package/dist/commands/webhooks.js

@@ -0,0 +1,37 @@
+export async function listWebhooks(client, opts, io) {
+    const result = await client.webhooks.list();
+    if (opts.json) {
+        io.json(result);
+        return;
+    }
+    if (result.endpoints.length === 0) {
+        io.out('No webhook endpoints yet.');
+        return;
+    }
+    for (const endpoint of result.endpoints) {
+        const state = endpoint.is_active ? 'active' : 'inactive';
+        io.out(`${endpoint.id}  ${state}  ${endpoint.url}`);
+        io.out(`  events: ${endpoint.events.join(', ')}`);
+    }
+}
+export async function createWebhook(client, opts, io) {
+    const created = await client.webhooks.create({
+        name: opts.name,
+        url: opts.url,
+        events: opts.events,
+    });
+    if (opts.json) {
+        io.json(created);
+        return;
+    }
+    io.out(`Created ${created.endpoint.id}`);
+    io.out(`Signing secret (shown once): ${created.signing_secret}`);
+}
+export async function removeWebhook(client, endpointId, opts, io) {
+    const result = await client.webhooks.delete(endpointId);
+    if (opts.json) {
+        io.json(result);
+        return;
+    }
+    io.out(result.deleted ? `Deleted ${endpointId}.` : `Nothing deleted for ${endpointId}.`);
+}

package/dist/core/client.d.ts

@@ -0,0 +1,13 @@
+import { Rerout, type ReroutClientOptions } from '@rerout/sdk';
+/** Sent on every request so the API can attribute CLI traffic. */
+export declare const CLI_USER_AGENT = "rerout-cli";
+/** Thrown when no API key can be resolved from flags, env, or config. */
+export declare class MissingApiKeyError extends Error {
+    constructor();
+}
+/**
+ * Resolve an authenticated Rerout SDK client. Key/baseUrl precedence:
+ * explicit override → environment → saved config. `fetch` and other SDK
+ * options can be injected via `overrides` (used by tests and Raycast).
+ */
+export declare function createClient(overrides?: Partial<ReroutClientOptions>): Rerout;

package/dist/core/client.js

@@ -0,0 +1,30 @@
+import { Rerout } from '@rerout/sdk';
+import { loadConfig } from './config.js';
+/** Sent on every request so the API can attribute CLI traffic. */
+export const CLI_USER_AGENT = 'rerout-cli';
+/** Thrown when no API key can be resolved from flags, env, or config. */
+export class MissingApiKeyError extends Error {
+    constructor() {
+        super('No API key found. Run `rerout login` or set the REROUT_API_KEY environment variable.');
+        this.name = 'MissingApiKeyError';
+    }
+}
+/**
+ * Resolve an authenticated Rerout SDK client. Key/baseUrl precedence:
+ * explicit override → environment → saved config. `fetch` and other SDK
+ * options can be injected via `overrides` (used by tests and Raycast).
+ */
+export function createClient(overrides = {}) {
+    const config = loadConfig();
+    const apiKey = overrides.apiKey ?? process.env.REROUT_API_KEY?.trim() ?? config.apiKey;
+    if (!apiKey) {
+        throw new MissingApiKeyError();
+    }
+    const baseUrl = overrides.baseUrl ?? process.env.REROUT_BASE_URL?.trim() ?? config.baseUrl;
+    return new Rerout({
+        apiKey,
+        ...(baseUrl ? { baseUrl } : {}),
+        defaultHeaders: { 'user-agent': CLI_USER_AGENT },
+        ...overrides,
+    });
+}

package/dist/core/config.d.ts

@@ -0,0 +1,13 @@
+/** Persisted CLI configuration. The API key is the only secret stored. */
+export interface CliConfig {
+    apiKey?: string;
+    /** Optional API base URL override (staging / self-hosted). */
+    baseUrl?: string;
+}
+/** Directory holding the config file. Respects `XDG_CONFIG_HOME`. */
+export declare function configDir(): string;
+export declare function configPath(): string;
+/** Load config, returning an empty object when the file is missing or invalid. */
+export declare function loadConfig(): CliConfig;
+/** Persist config with owner-only (0600) permissions — it holds the API key. */
+export declare function saveConfig(next: CliConfig): void;

package/dist/core/config.js

@@ -0,0 +1,37 @@
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Directory holding the config file. Respects `XDG_CONFIG_HOME`. */
+export function configDir() {
+    const base = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    return join(base, 'rerout');
+}
+export function configPath() {
+    return join(configDir(), 'config.json');
+}
+/** Load config, returning an empty object when the file is missing or invalid. */
+export function loadConfig() {
+    try {
+        const parsed = JSON.parse(readFileSync(configPath(), 'utf8'));
+        if (parsed && typeof parsed === 'object') {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Persist config with owner-only (0600) permissions — it holds the API key. */
+export function saveConfig(next) {
+    mkdirSync(configDir(), { recursive: true });
+    const path = configPath();
+    writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    // writeFileSync `mode` is ignored when the file already exists; enforce it.
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Best effort (e.g. on filesystems without POSIX perms).
+    }
+}

package/dist/core/format.d.ts

@@ -0,0 +1,15 @@
+import type { Link } from '@rerout/sdk';
+/** Sink for command output so commands stay testable (no direct console use). */
+export interface IO {
+    out(line: string): void;
+    err(line: string): void;
+    json(data: unknown): void;
+}
+/** Default IO bound to the process streams. */
+export declare const consoleIO: IO;
+/** Format a unix-seconds timestamp as an ISO date, or `—` when absent. */
+export declare function formatTimestamp(seconds: number | null | undefined): string;
+/** One-line summary of a link for human output. */
+export declare function formatLinkLine(link: Link): string;
+/** Compact, aligned table of links for `rerout ls`. */
+export declare function formatLinksTable(links: Link[]): string;

package/dist/core/format.js

@@ -0,0 +1,35 @@
+/** Default IO bound to the process streams. */
+export const consoleIO = {
+    out: (line) => process.stdout.write(`${line}\n`),
+    err: (line) => process.stderr.write(`${line}\n`),
+    json: (data) => process.stdout.write(`${JSON.stringify(data, null, 2)}\n`),
+};
+/** Format a unix-seconds timestamp as an ISO date, or `—` when absent. */
+export function formatTimestamp(seconds) {
+    if (!seconds)
+        return '—';
+    return new Date(seconds * 1000).toISOString().replace('.000Z', 'Z');
+}
+/** One-line summary of a link for human output. */
+export function formatLinkLine(link) {
+    const status = link.is_active ? '' : ' [inactive]';
+    return `${link.short_url}${status}  →  ${link.target_url}`;
+}
+/** Compact, aligned table of links for `rerout ls`. */
+export function formatLinksTable(links) {
+    if (links.length === 0)
+        return 'No links yet.';
+    const rows = links.map((l) => [
+        l.code,
+        l.short_url,
+        l.is_active ? 'active' : 'inactive',
+        truncate(l.target_url, 48),
+    ]);
+    const headers = ['CODE', 'SHORT URL', 'STATUS', 'TARGET'];
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+    const render = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join('  ').trimEnd();
+    return [render(headers), ...rows.map(render)].join('\n');
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max - 1)}…` : value;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config.js';
+export * from './client.js';
+export * from './format.js';

package/dist/core/index.js

@@ -0,0 +1,5 @@
+// Shared core re-used by the CLI binary and (phase 2) the Raycast extension.
+// Importable via `@rerout/cli/core`.
+export * from './config.js';
+export * from './client.js';
+export * from './format.js';

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@rerout/cli",
+  "version": "0.1.0",
+  "description": "Command-line interface for Rerout — branded short links, QR codes, and analytics from your terminal.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "rerout": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/cli.d.ts",
+      "import": "./dist/cli.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "rerout",
+    "url-shortener",
+    "short-links",
+    "qr-code",
+    "cli"
+  ],
+  "dependencies": {
+    "@rerout/sdk": "^0.3.0",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  }
+}