clipy-kit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Clipy contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# Clipy (`clp`)
+
+Local CLI for humans and coding agents. One binary on PATH, **intent commands** (not raw Google/Jira JSON), CLI-only login. Agents should never rewrite API or OAuth code.
+
+This is not a hosted 1,000-app catalog (see Composio). v1 ships **Google Sheets** only. Other plugins are listed as planned.
+
+## Install
+
+```bash
+npm i -g clipy-kit
+clp doctor --json
+clp setup          # if `clp` is not on PATH (common with macOS npm prefixes)
+```
+
+Or without a global install: `npx --package clipy-kit clp doctor --json`
+
+From a clone:
+
+```bash
+npm install
+npm run build
+node dist/cli.js setup
+```
+
+Skills:
+
+```bash
+npx skills add /path/to/this/repo --skill clipy -g
+npx skills add /path/to/this/repo --skill clipy-sheet -g
+```
+
+## Auth (Sheets)
+
+```bash
+clp sheet auth login --credentials ./client_secret.json
+clp sheet auth login --service-account ./sa.json
+clp sheet auth status --pretty
+```
+
+Credentials: `~/.config/clipy/sheet/` (override `CLIPY_CONFIG_DIR` / `GSHEET_CONFIG_DIR`). Enable **Sheets API** and **Drive API** on the Google Cloud project.
+
+## Usage
+
+```bash
+clp --help --json
+clp plugin list --json
+clp sheet read <id> --tab Sheet1 --limit 20
+clp sheet upsert <id> --tab Sheet1 --key-col Name --rows '[{"Name":"Kopi"}]' --dry-run
+clp sheet format header <id> --tab Sheet1
+```
+
+Data commands print JSON on stdout (`{ ok, cmd, result }`). Host commands (`setup`, `doctor`, `--help`) use color on a TTY; pass `--json` for agents. `NO_COLOR=1` disables ANSI.
+
+## Programmatic
+
+```ts
+import { createOps, GoogleClient, getAccessToken } from 'clipy-kit';
+
+const ops = createOps(new GoogleClient(() => getAccessToken()));
+await ops.readTable(id, { tab: 'Sheet1', limit: 20 });
+```
+
+## License
+
+MIT

package/dist/auth.d.ts

@@ -0,0 +1,53 @@
+export declare const SCOPES: string[];
+export type AuthMethod = 'oauth' | 'service_account' | 'token' | 'adc';
+export type AccountFile = {
+    method: AuthMethod;
+    email?: string;
+    scopes: string[];
+    createdAt: string;
+    oauth?: {
+        client_id: string;
+        client_secret: string;
+        refresh_token?: string;
+        access_token?: string;
+        expiry_date?: number;
+    };
+    serviceAccount?: Record<string, unknown>;
+    token?: string;
+};
+export type AuthStatus = {
+    loggedIn: boolean;
+    method?: AuthMethod;
+    email?: string;
+    scopes?: string[];
+    expiresAt?: string;
+    account: string;
+    configDir: string;
+};
+type ConfigFile = {
+    defaultAccount: string;
+};
+export declare function clipyHome(): string;
+export declare function configDir(): string;
+export declare function accountPath(name: string): string;
+export declare function loadConfig(): ConfigFile;
+export declare function resolveAccountName(flag?: string): string;
+export declare function loadAccount(name: string): AccountFile | undefined;
+export declare function saveAccount(name: string, account: AccountFile, makeDefault?: boolean): void;
+export declare function deleteAccount(name: string): boolean;
+export type LoginOpts = {
+    account: string;
+    credentials?: string;
+    serviceAccount?: string;
+    token?: string;
+    tokenFile?: string;
+    adc?: boolean;
+};
+export declare function login(opts: LoginOpts): Promise<AuthStatus>;
+export declare function status(accountName?: string): Promise<AuthStatus>;
+export declare function logout(accountName?: string): Promise<{
+    removed: boolean;
+    account: string;
+}>;
+export declare function getAccessToken(accountName?: string): Promise<string>;
+export {};

package/dist/auth.js

@@ -0,0 +1,314 @@
+import fs from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { GoogleAuth, JWT, OAuth2Client } from 'google-auth-library';
+import { CliError, EXIT } from './output.js';
+export const SCOPES = [
+    'https://www.googleapis.com/auth/spreadsheets',
+    'https://www.googleapis.com/auth/drive',
+    'https://www.googleapis.com/auth/userinfo.email',
+];
+export function clipyHome() {
+    return process.env.CLIPY_CONFIG_DIR || path.join(os.homedir(), '.config', 'clipy');
+}
+export function configDir() {
+    return process.env.GSHEET_CONFIG_DIR || process.env.CLIPY_SHEET_CONFIG_DIR || path.join(clipyHome(), 'sheet');
+}
+function accountsDir() {
+    return path.join(configDir(), 'accounts');
+}
+function configPath() {
+    return path.join(configDir(), 'config.json');
+}
+function oauthClientPath() {
+    return path.join(configDir(), 'oauth-client.json');
+}
+export function accountPath(name) {
+    return path.join(accountsDir(), `${name}.json`);
+}
+function ensureDir() {
+    fs.mkdirSync(accountsDir(), { recursive: true, mode: 0o700 });
+}
+function readJson(file) {
+    if (!fs.existsSync(file))
+        return undefined;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+function writeSecret(file, data) {
+    ensureDir();
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+export function loadConfig() {
+    return readJson(configPath()) ?? { defaultAccount: 'default' };
+}
+function saveConfig(cfg) {
+    writeSecret(configPath(), cfg);
+}
+export function resolveAccountName(flag) {
+    return flag || process.env.GSHEET_ACCOUNT || loadConfig().defaultAccount || 'default';
+}
+export function loadAccount(name) {
+    return readJson(accountPath(name));
+}
+export function saveAccount(name, account, makeDefault = false) {
+    writeSecret(accountPath(name), account);
+    const cfg = loadConfig();
+    if (makeDefault || !cfg.defaultAccount) {
+        saveConfig({ defaultAccount: name });
+    }
+}
+export function deleteAccount(name) {
+    const file = accountPath(name);
+    if (!fs.existsSync(file))
+        return false;
+    fs.unlinkSync(file);
+    return true;
+}
+function extractOAuthClient(raw) {
+    const obj = raw;
+    const nested = (obj.installed || obj.web || obj);
+    const client_id = String(nested.client_id ?? '');
+    const client_secret = String(nested.client_secret ?? '');
+    if (!client_id || !client_secret) {
+        throw new CliError('VALIDATION_ERROR', 'OAuth credentials JSON must include client_id and client_secret');
+    }
+    return { client_id, client_secret };
+}
+function loadStoredOAuthClient() {
+    const fromEnv = process.env.GSHEET_CLIENT_ID && process.env.GSHEET_CLIENT_SECRET
+        ? { client_id: process.env.GSHEET_CLIENT_ID, client_secret: process.env.GSHEET_CLIENT_SECRET }
+        : undefined;
+    return fromEnv ?? readJson(oauthClientPath());
+}
+function saveOAuthClient(client) {
+    writeSecret(oauthClientPath(), client);
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    if (platform === 'darwin')
+        spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
+    else if (platform === 'win32')
+        spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true }).unref();
+    else
+        spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+}
+async function fetchEmail(token) {
+    try {
+        const res = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return undefined;
+        const body = (await res.json());
+        return body.email;
+    }
+    catch {
+        return undefined;
+    }
+}
+function countLoginMethods(opts) {
+    return [opts.credentials, opts.serviceAccount, opts.token || opts.tokenFile, opts.adc].filter(Boolean).length;
+}
+export async function login(opts) {
+    if (countLoginMethods(opts) > 1) {
+        throw new CliError('VALIDATION_ERROR', 'Use only one of --credentials, --service-account, --token/--token-file, or --adc');
+    }
+    const name = opts.account;
+    let account;
+    if (opts.adc) {
+        const auth = new GoogleAuth({ scopes: SCOPES });
+        const client = await auth.getClient();
+        const tokenRes = await client.getAccessToken();
+        const token = typeof tokenRes === 'string' ? tokenRes : tokenRes?.token;
+        if (!token) {
+            throw new CliError('AUTH_ERROR', 'ADC did not return an access token. Run: gcloud auth application-default login', undefined, EXIT.AUTH);
+        }
+        const email = (await auth.getCredentials().catch(() => undefined))?.client_email ?? (await fetchEmail(token));
+        account = { method: 'adc', email, scopes: SCOPES, createdAt: new Date().toISOString() };
+    }
+    else if (opts.serviceAccount) {
+        const raw = JSON.parse(fs.readFileSync(opts.serviceAccount, 'utf8'));
+        if (raw.type !== 'service_account' || !raw.client_email || !raw.private_key) {
+            throw new CliError('VALIDATION_ERROR', 'Service account JSON is missing type/client_email/private_key');
+        }
+        account = {
+            method: 'service_account',
+            email: String(raw.client_email),
+            scopes: SCOPES,
+            createdAt: new Date().toISOString(),
+            serviceAccount: raw,
+        };
+    }
+    else if (opts.token || opts.tokenFile) {
+        const token = opts.token || fs.readFileSync(opts.tokenFile, 'utf8').trim();
+        if (!token)
+            throw new CliError('VALIDATION_ERROR', 'Token is empty');
+        const email = await fetchEmail(token);
+        account = { method: 'token', email, scopes: SCOPES, createdAt: new Date().toISOString(), token };
+    }
+    else {
+        let clientJson;
+        if (opts.credentials) {
+            clientJson = extractOAuthClient(JSON.parse(fs.readFileSync(opts.credentials, 'utf8')));
+            saveOAuthClient(clientJson);
+        }
+        else {
+            clientJson = loadStoredOAuthClient();
+        }
+        if (!clientJson) {
+            throw new CliError('AUTH_REQUIRED', 'No OAuth client stored. Run: clp sheet auth login --credentials ./client_secret.json', undefined, EXIT.AUTH);
+        }
+        account = await oauthLogin(clientJson);
+    }
+    saveAccount(name, account, true);
+    return status(name);
+}
+async function oauthLogin(clientJson) {
+    const server = http.createServer();
+    const port = await new Promise((resolve, reject) => {
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            resolve(typeof addr === 'object' && addr ? addr.port : 0);
+        });
+        server.on('error', reject);
+    });
+    const redirectUri = `http://127.0.0.1:${port}/callback`;
+    const oauth = new OAuth2Client(clientJson.client_id, clientJson.client_secret, redirectUri);
+    const url = oauth.generateAuthUrl({
+        access_type: 'offline',
+        prompt: 'consent',
+        scope: SCOPES,
+    });
+    const code = await new Promise((resolve, reject) => {
+        server.on('request', (req, res) => {
+            const parsed = new URL(req.url ?? '/', `http://127.0.0.1:${port}`);
+            if (parsed.pathname !== '/callback' && parsed.pathname !== '/') {
+                res.statusCode = 404;
+                res.end();
+                return;
+            }
+            const err = parsed.searchParams.get('error');
+            const value = parsed.searchParams.get('code');
+            res.setHeader('Content-Type', 'text/html; charset=utf-8');
+            if (err || !value) {
+                res.end('<p>clp sheet login failed. You can close this tab.</p>');
+                reject(new CliError('AUTH_ERROR', `OAuth error: ${err || 'missing code'}`, undefined, EXIT.AUTH));
+                return;
+            }
+            res.end('<p>clp sheet login OK. You can close this tab and return to the terminal.</p>');
+            resolve(value);
+        });
+        openBrowser(url);
+    });
+    await new Promise((resolve) => server.close(() => resolve()));
+    const { tokens } = await oauth.getToken(code);
+    oauth.setCredentials(tokens);
+    const access = tokens.access_token ?? '';
+    const email = access ? await fetchEmail(access) : undefined;
+    return {
+        method: 'oauth',
+        email,
+        scopes: SCOPES,
+        createdAt: new Date().toISOString(),
+        oauth: {
+            client_id: clientJson.client_id,
+            client_secret: clientJson.client_secret,
+            refresh_token: tokens.refresh_token ?? undefined,
+            access_token: tokens.access_token ?? undefined,
+            expiry_date: tokens.expiry_date ?? undefined,
+        },
+    };
+}
+export async function status(accountName) {
+    const name = resolveAccountName(accountName);
+    const dir = configDir();
+    if (process.env.GSHEET_TOKEN) {
+        const email = await fetchEmail(process.env.GSHEET_TOKEN);
+        return {
+            loggedIn: true,
+            method: 'token',
+            email,
+            scopes: SCOPES,
+            account: name,
+            configDir: dir,
+        };
+    }
+    const account = loadAccount(name);
+    if (!account) {
+        return { loggedIn: false, account: name, configDir: dir };
+    }
+    let expiresAt;
+    if (account.oauth?.expiry_date)
+        expiresAt = new Date(account.oauth.expiry_date).toISOString();
+    return {
+        loggedIn: true,
+        method: account.method,
+        email: account.email,
+        scopes: account.scopes,
+        expiresAt,
+        account: name,
+        configDir: dir,
+    };
+}
+export async function logout(accountName) {
+    const name = resolveAccountName(accountName);
+    const removed = deleteAccount(name);
+    return { removed, account: name };
+}
+export async function getAccessToken(accountName) {
+    if (process.env.GSHEET_TOKEN)
+        return process.env.GSHEET_TOKEN;
+    const name = resolveAccountName(accountName);
+    const account = loadAccount(name);
+    if (!account) {
+        throw new CliError('AUTH_REQUIRED', 'Run: clp sheet auth login', { account: name }, EXIT.AUTH);
+    }
+    if (account.method === 'token') {
+        if (!account.token)
+            throw new CliError('AUTH_REQUIRED', 'Run: clp sheet auth login --token <token>', undefined, EXIT.AUTH);
+        return account.token;
+    }
+    if (account.method === 'service_account') {
+        const sa = account.serviceAccount;
+        const jwt = new JWT({
+            email: sa.client_email,
+            key: sa.private_key,
+            scopes: SCOPES,
+        });
+        const token = await jwt.getAccessToken();
+        const value = typeof token === 'string' ? token : token?.token;
+        if (!value) {
+            throw new CliError('AUTH_ERROR', 'Service account did not return an access token', undefined, EXIT.AUTH);
+        }
+        return value;
+    }
+    if (account.method === 'adc') {
+        const auth = new GoogleAuth({ scopes: SCOPES });
+        const token = await auth.getAccessToken();
+        if (!token) {
+            throw new CliError('AUTH_ERROR', 'ADC did not return an access token. Run: clp sheet auth login --adc', undefined, EXIT.AUTH);
+        }
+        return token;
+    }
+    if (account.method === 'oauth' && account.oauth) {
+        const oauth = new OAuth2Client(account.oauth.client_id, account.oauth.client_secret);
+        oauth.setCredentials({
+            refresh_token: account.oauth.refresh_token,
+            access_token: account.oauth.access_token,
+            expiry_date: account.oauth.expiry_date,
+        });
+        const token = await oauth.getAccessToken();
+        const value = typeof token === 'string' ? token : token?.token;
+        if (!value) {
+            throw new CliError('AUTH_REQUIRED', 'OAuth token expired. Run: clp sheet auth login', undefined, EXIT.AUTH);
+        }
+        const creds = oauth.credentials;
+        account.oauth.access_token = creds.access_token ?? account.oauth.access_token;
+        account.oauth.expiry_date = creds.expiry_date ?? account.oauth.expiry_date;
+        saveAccount(name, account);
+        return value;
+    }
+    throw new CliError('AUTH_REQUIRED', 'Run: clp sheet auth login', { account: name }, EXIT.AUTH);
+}

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+export declare function jsonHelpRequested(argv: string[]): boolean;
+export declare function commandPath(argv: string[]): string[];
+export declare function buildProgram(): Command;
+export declare function main(argv?: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import { pathToFileURL } from 'node:url';
+import { Command, CommanderError } from 'commander';
+import { CliError, envelopeErr, envelopeOk, EXIT, exitCodeFor, stringifyEnvelope } from './output.js';
+import { allPlugins, findPlugin } from './plugins/catalog.js';
+import { sheetPlugin } from './plugins/sheet/plugin.js';
+import { doctor, doctorErrorCode } from './host/doctor.js';
+import { hostHelpJson, printDoctorHuman, printHumanHelp, printPluginListHuman, printSetupHuman, sheetHelpJson } from './host/help.js';
+import { setup } from './host/setup.js';
+import { c } from './color.js';
+import { run, takeGlobals } from './run.js';
+export function jsonHelpRequested(argv) {
+    return argv.includes('--json') && (argv.includes('--help') || argv.includes('-h'));
+}
+export function commandPath(argv) {
+    return argv.filter((a) => a !== '--' && !a.startsWith('-'));
+}
+function isHumanHostCommand(path) {
+    if (path[0] === 'setup' || path[0] === 'doctor')
+        return true;
+    if (path[0] === 'plugin' && (path[1] === 'list' || !path[1]))
+        return true;
+    return false;
+}
+function useJson(argv, path) {
+    if (argv.includes('--json'))
+        return true;
+    if (jsonHelpRequested(argv))
+        return true;
+    if (isHumanHostCommand(path) && process.stdout.isTTY)
+        return false;
+    if ((argv.includes('--help') || argv.includes('-h')) && process.stdout.isTTY)
+        return false;
+    return true;
+}
+export function buildProgram() {
+    const program = new Command();
+    program
+        .name('clp')
+        .description('Clipy. Plugins for Sheets and more. Never write API or OAuth code.')
+        .option('--pretty', 'Pretty-print JSON')
+        .option('--json', 'JSON envelope (always used for data commands)')
+        .option('--account <name>', 'Credential profile')
+        .option('--spreadsheet <id>', 'Default spreadsheet ID or URL')
+        .option('--dry-run', 'Preview writes without applying')
+        .helpOption('-h, --help', 'Show help. Combine with --json for machine schema.')
+        .showHelpAfterError(false)
+        .exitOverride();
+    program
+        .command('setup')
+        .description('Install clp on PATH')
+        .option('--undo', 'Remove shim and PATH block')
+        .action(async (opts, cmd) => {
+        const g = takeGlobals(cmd);
+        const argv = process.argv.slice(2);
+        const result = setup({ undo: Boolean(opts.undo) });
+        if (useJson(argv, ['setup']) || g.json) {
+            await run('setup', g.pretty, async () => ({ result }));
+            return;
+        }
+        printSetupHuman(result);
+    });
+    program
+        .command('doctor')
+        .description('Check PATH, Node, config, plugins')
+        .action(async (_opts, cmd) => {
+        const g = takeGlobals(cmd);
+        const argv = process.argv.slice(2);
+        const result = doctor();
+        const code = doctorErrorCode(result);
+        if (useJson(argv, ['doctor']) || g.json) {
+            if (!result.ok && code === 'PATH_REQUIRED') {
+                process.stdout.write(stringifyEnvelope(envelopeErr('doctor', new CliError('PATH_REQUIRED', 'Run: clp setup', result, EXIT.VALIDATION)), g.pretty) + '\n');
+                process.exitCode = EXIT.VALIDATION;
+                return;
+            }
+            await run('doctor', g.pretty, async () => ({ result }));
+            if (!result.ok)
+                process.exitCode = EXIT.VALIDATION;
+            return;
+        }
+        printDoctorHuman(result);
+        if (!result.ok)
+            process.exitCode = EXIT.VALIDATION;
+    });
+    const plugin = program.command('plugin').description('List or add plugins');
+    plugin.command('list').description('Built-in and planned plugins').action(async (_opts, cmd) => {
+        const g = takeGlobals(cmd);
+        const argv = process.argv.slice(2);
+        const result = { plugins: allPlugins() };
+        if (useJson(argv, ['plugin', 'list']) || g.json) {
+            await run('plugin list', g.pretty, async () => ({ result }));
+            return;
+        }
+        printPluginListHuman();
+    });
+    plugin
+        .command('add')
+        .description('Enable a plugin')
+        .argument('<name>', 'Plugin name')
+        .action(async (name, _opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('plugin add', g.pretty, async () => {
+            const info = findPlugin(name);
+            if (info?.status === 'built-in') {
+                return { result: { name, status: 'built-in', message: `${name} is already built into clipy` } };
+            }
+            throw new CliError('PLUGIN_UNAVAILABLE', info?.status === 'planned'
+                ? `${name} is planned, not shipped. See: clp plugin list`
+                : `Unknown plugin: ${name}`, { name, status: info?.status });
+        });
+    });
+    const sheet = program.command(sheetPlugin.name).description(sheetPlugin.description);
+    sheetPlugin.register(sheet);
+    return program;
+}
+export async function main(argv = process.argv.slice(2)) {
+    const path = commandPath(argv);
+    const pretty = argv.includes('--pretty');
+    if (jsonHelpRequested(argv)) {
+        const body = path[0] === 'sheet' ? sheetHelpJson(path.slice(1)) : hostHelpJson(path);
+        process.stdout.write(stringifyEnvelope(envelopeOk('help', body), pretty) + '\n');
+        return;
+    }
+    if (argv.includes('--help') || argv.includes('-h')) {
+        if (!useJson(argv, path)) {
+            printHumanHelp(path);
+            return;
+        }
+        const body = path[0] === 'sheet' ? sheetHelpJson(path.slice(1)) : hostHelpJson(path);
+        process.stdout.write(stringifyEnvelope(envelopeOk('help', body), pretty) + '\n');
+        return;
+    }
+    const program = buildProgram();
+    try {
+        await program.parseAsync(['node', 'clp', ...argv]);
+    }
+    catch (err) {
+        if (err instanceof CommanderError && (err.code === 'commander.helpDisplayed' || err.code === 'commander.version')) {
+            if (!useJson(argv, path) && process.stdout.isTTY) {
+                printHumanHelp(path);
+                return;
+            }
+            return;
+        }
+        const cmd = path.join(' ') || 'clp';
+        const wrapped = err instanceof CliError ? err : new CliError('VALIDATION_ERROR', err instanceof Error ? err.message : String(err));
+        if (!useJson(argv, path) && wrapped.code !== 'AUTH_REQUIRED' && isHumanHostCommand(path)) {
+            console.error(c.err(wrapped.message));
+            process.exitCode = exitCodeFor(wrapped);
+            return;
+        }
+        process.stdout.write(stringifyEnvelope(envelopeErr(cmd, wrapped), pretty) + '\n');
+        process.exitCode = err instanceof CommanderError ? EXIT.VALIDATION : exitCodeFor(wrapped);
+    }
+}
+const isDirectRun = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isDirectRun) {
+    void main();
+}

package/dist/color.d.ts

@@ -0,0 +1,12 @@
+export declare function colorEnabled(stream?: {
+    isTTY?: boolean;
+}): boolean;
+export declare const c: {
+    plugin: (s: string) => string;
+    ok: (s: string) => string;
+    warn: (s: string) => string;
+    err: (s: string) => string;
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+    title: (s: string) => string;
+};

package/dist/color.js

@@ -0,0 +1,19 @@
+import pc from 'picocolors';
+export function colorEnabled(stream = process.stdout) {
+    if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '')
+        return false;
+    if (process.env.FORCE_COLOR === '0')
+        return false;
+    if (process.env.FORCE_COLOR)
+        return true;
+    return Boolean(stream.isTTY);
+}
+export const c = {
+    plugin: (s) => (colorEnabled() ? pc.cyan(s) : s),
+    ok: (s) => (colorEnabled() ? pc.green(s) : s),
+    warn: (s) => (colorEnabled() ? pc.yellow(s) : s),
+    err: (s) => (colorEnabled() ? pc.red(s) : s),
+    dim: (s) => (colorEnabled() ? pc.dim(s) : s),
+    bold: (s) => (colorEnabled() ? pc.bold(s) : s),
+    title: (s) => (colorEnabled() ? pc.bold(pc.white(s)) : s),
+};

package/dist/colors.d.ts

@@ -0,0 +1,6 @@
+export type Rgb = {
+    red: number;
+    green: number;
+    blue: number;
+};
+export declare function parseColor(input: string): Rgb;