clipy-kit 0.1.0

package/dist/output.js

@@ -0,0 +1,67 @@
+export const EXIT = {
+    OK: 0,
+    VALIDATION: 10,
+    AUTH: 20,
+    PERMISSION: 30,
+    API: 40,
+};
+export class CliError extends Error {
+    code;
+    details;
+    exitCode;
+    constructor(code, message, details, exitCode = EXIT.VALIDATION) {
+        super(message);
+        this.name = 'CliError';
+        this.code = code;
+        this.details = details;
+        this.exitCode = exitCode;
+    }
+}
+export function compact(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (Array.isArray(value))
+        return value.map(compact).filter((v) => v !== undefined);
+    if (typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            const c = compact(v);
+            if (c !== undefined)
+                out[k] = c;
+        }
+        return out;
+    }
+    return value;
+}
+export function envelopeOk(cmd, result, extra = {}) {
+    return compact({
+        ok: true,
+        cmd,
+        spreadsheetId: extra.spreadsheetId,
+        sheet: extra.sheet,
+        result,
+    });
+}
+export function envelopeErr(cmd, err) {
+    if (err instanceof CliError) {
+        return {
+            ok: false,
+            cmd,
+            error: compact({
+                code: err.code,
+                message: err.message,
+                details: err.details,
+            }),
+        };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, cmd, error: { code: 'UNEXPECTED', message } };
+}
+export function exitCodeFor(err) {
+    if (err instanceof CliError)
+        return err.exitCode;
+    return EXIT.API;
+}
+export function stringifyEnvelope(body, pretty) {
+    return JSON.stringify(body, null, pretty ? 2 : undefined);
+}

package/dist/plugins/catalog.d.ts

@@ -0,0 +1,11 @@
+export type PluginStatus = 'built-in' | 'planned';
+export type PluginInfo = {
+    name: string;
+    description: string;
+    status: PluginStatus;
+    when?: string;
+};
+export declare const BUILTIN: PluginInfo[];
+export declare const PLANNED: PluginInfo[];
+export declare function allPlugins(): PluginInfo[];
+export declare function findPlugin(name: string): PluginInfo | undefined;

package/dist/plugins/catalog.js

@@ -0,0 +1,31 @@
+export const BUILTIN = [
+    {
+        name: 'sheet',
+        description: 'Google Sheets — intent read, upsert, format, share',
+        status: 'built-in',
+        when: 'v1',
+    },
+];
+export const PLANNED = [
+    { name: 'linear', description: 'Issues, projects, comments', status: 'planned', when: 'next' },
+    { name: 'github', description: 'PRs, issues, checks', status: 'planned', when: 'next' },
+    { name: 'jira', description: 'Enterprise issues and projects', status: 'planned', when: 'next' },
+    { name: 'slack', description: 'Post, search, threads', status: 'planned', when: 'later' },
+    { name: 'notion', description: 'Docs and databases', status: 'planned', when: 'later' },
+    { name: 'confluence', description: 'Enterprise wiki', status: 'planned', when: 'later' },
+    { name: 'google-gmail', description: 'Mail next to sheet (extra OAuth scopes)', status: 'planned', when: 'later' },
+    { name: 'google-calendar', description: 'Events next to sheet', status: 'planned', when: 'later' },
+    { name: 'google-drive', description: 'Files next to sheet', status: 'planned', when: 'later' },
+    { name: 'figma', description: 'File metadata and comments', status: 'planned', when: 'later' },
+    { name: 'stripe', description: 'Payments and invoices (read-heavy)', status: 'planned', when: 'later' },
+    { name: 'sentry', description: 'Error lookup without a full observability MCP', status: 'planned', when: 'later' },
+    { name: 'postgres', description: 'Intent SQL, read-only by default', status: 'planned', when: 'later' },
+    { name: 'vercel', description: 'Deployments and logs', status: 'planned', when: 'later' },
+    { name: 'whatsapp', description: 'Business messaging (only if a real workflow appears)', status: 'planned', when: 'maybe' },
+];
+export function allPlugins() {
+    return [...BUILTIN, ...PLANNED];
+}
+export function findPlugin(name) {
+    return allPlugins().find((p) => p.name === name);
+}

package/dist/plugins/sheet/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { ClipyPlugin } from '../types.js';
+export declare const sheetPlugin: ClipyPlugin;

package/dist/plugins/sheet/plugin.js

@@ -0,0 +1,8 @@
+import { registerSheet } from './register.js';
+import { helpJson } from './specs.js';
+export const sheetPlugin = {
+    name: 'sheet',
+    description: 'Google Sheets — intent read, upsert, format, share',
+    register: registerSheet,
+    helpJson,
+};

package/dist/plugins/sheet/register.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerSheet(sheet: Command): void;

package/dist/plugins/sheet/register.js

@@ -0,0 +1,529 @@
+import { login, logout, status } from '../../auth.js';
+import { resolveSpreadsheetId } from '../../ids.js';
+import { asGrid, asObject, asObjectArray, parseJsonInput } from '../../json-input.js';
+import { CliError } from '../../output.js';
+import { idOf, need, opsFor, run, takeGlobals } from '../../run.js';
+export function registerSheet(sheet) {
+    const auth = sheet.command('auth').description('CLI-only login');
+    auth
+        .command('login')
+        .description('Start login from the CLI')
+        .option('--credentials <file>', 'OAuth client_secret.json')
+        .option('--service-account <file>', 'Service account JSON')
+        .option('--token <token>', 'Access token')
+        .option('--token-file <file>', 'File containing an access token')
+        .option('--adc', 'Use Application Default Credentials')
+        .action(async (opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet auth login', g.pretty, async () => ({
+            result: await login({
+                account: g.account || 'default',
+                credentials: opts.credentials,
+                serviceAccount: opts.serviceAccount,
+                token: opts.token,
+                tokenFile: opts.tokenFile,
+                adc: Boolean(opts.adc),
+            }),
+        }));
+    });
+    auth.command('status').description('Show login status').action(async (_opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet auth status', g.pretty, async () => ({ result: await status(g.account) }));
+    });
+    auth.command('logout').description('Delete stored credentials').action(async (_opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet auth logout', g.pretty, async () => ({ result: await logout(g.account) }));
+    });
+    sheet
+        .command('find')
+        .description('Search Drive for spreadsheets by name')
+        .option('--name <query>', 'Name substring')
+        .option('--limit <n>', 'Max results', (v) => Number(v))
+        .action(async (opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet find', g.pretty, async () => ({
+            result: await opsFor(g.account).findSpreadsheets(need(opts.name, '--name'), opts.limit),
+        }));
+    });
+    sheet
+        .command('info')
+        .description('Spreadsheet metadata')
+        .argument('[spreadsheet]', 'ID or URL')
+        .action(async (spreadsheet, _opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet info', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return { spreadsheetId, result: await opsFor(g.account).info(spreadsheetId) };
+        });
+    });
+    sheet
+        .command('tabs')
+        .description('List tabs')
+        .command('list')
+        .description('List tabs')
+        .argument('[spreadsheet]', 'ID or URL')
+        .action(async (spreadsheet, _opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet tabs list', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return { spreadsheetId, result: await opsFor(g.account).listTabs(spreadsheetId) };
+        });
+    });
+    const read = sheet.command('read').description('Read a tab as objects');
+    read
+        .command('range')
+        .description('Read a raw A1 range')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--range <a1>', 'A1 range')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet read range', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).readRange(spreadsheetId, need(opts.range, '--range')),
+            };
+        });
+    });
+    read
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Tab name')
+        .option('--range <a1>', 'A1 range')
+        .option('--limit <n>', 'Max data rows', (v) => Number(v))
+        .option('--header-row <n>', '1-based header row', (v) => Number(v))
+        .option('--raw', 'Return 2D values')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet read', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                sheet: opts.tab,
+                result: await opsFor(g.account).readTable(spreadsheetId, {
+                    tab: opts.tab,
+                    range: opts.range,
+                    limit: opts.limit,
+                    headerRow: opts.headerRow,
+                    raw: Boolean(opts.raw),
+                }),
+            };
+        });
+    });
+    sheet
+        .command('append')
+        .description('Append object rows')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Tab name')
+        .option('--rows <json>', 'JSON object(s) or @file.json')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet append', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            const rows = asObjectArray(parseJsonInput(need(opts.rows, '--rows'), '--rows'), '--rows');
+            return {
+                spreadsheetId,
+                sheet: opts.tab,
+                result: await opsFor(g.account).append(spreadsheetId, {
+                    tab: need(opts.tab, '--tab'),
+                    rows,
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('update')
+        .description('Update rows by key column')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Tab name')
+        .option('--key-col <name>', 'Key column')
+        .option('--key <value>', 'Key value')
+        .option('--set <json>', 'JSON object or @file.json')
+        .option('--allow-multi', 'Update every match')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet update', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                sheet: opts.tab,
+                result: await opsFor(g.account).update(spreadsheetId, {
+                    tab: need(opts.tab, '--tab'),
+                    keyCol: need(opts.keyCol, '--key-col'),
+                    key: need(opts.key, '--key'),
+                    set: asObject(parseJsonInput(need(opts.set, '--set'), '--set'), '--set'),
+                    allowMulti: Boolean(opts.allowMulti),
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('upsert')
+        .description('Update by key or append')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Tab name')
+        .option('--key-col <name>', 'Key column')
+        .option('--rows <json>', 'JSON object(s) or @file.json')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet upsert', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                sheet: opts.tab,
+                result: await opsFor(g.account).upsert(spreadsheetId, {
+                    tab: need(opts.tab, '--tab'),
+                    keyCol: need(opts.keyCol, '--key-col'),
+                    rows: asObjectArray(parseJsonInput(need(opts.rows, '--rows'), '--rows'), '--rows'),
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('set')
+        .description('Overwrite an A1 range')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--range <a1>', 'A1 range')
+        .option('--values <json>', '2D JSON array or @file.json')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet set', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).setRange(spreadsheetId, {
+                    range: need(opts.range, '--range'),
+                    values: asGrid(parseJsonInput(need(opts.values, '--values'), '--values'), '--values'),
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('clear')
+        .description('Clear a range')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--range <a1>', 'A1 range')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet clear', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).clear(spreadsheetId, need(opts.range, '--range'), g.dryRun),
+            };
+        });
+    });
+    sheet
+        .command('batch')
+        .description('Run several write ops')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--ops <json>', 'JSON array or @file.json')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet batch', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            const raw = parseJsonInput(need(opts.ops, '--ops'), '--ops');
+            if (!Array.isArray(raw))
+                throw new CliError('VALIDATION_ERROR', '--ops must be a JSON array');
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).batch(spreadsheetId, raw, g.dryRun),
+            };
+        });
+    });
+    sheet
+        .command('create')
+        .description('Create a spreadsheet')
+        .option('--title <title>', 'Title')
+        .option('--tabs <names>', 'Comma-separated tab names')
+        .action(async (opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet create', g.pretty, async () => {
+            const result = await opsFor(g.account).create({
+                title: need(opts.title, '--title'),
+                tabs: opts.tabs ? String(opts.tabs).split(',').map((s) => s.trim()).filter(Boolean) : undefined,
+                dryRun: g.dryRun,
+            });
+            return { spreadsheetId: result.spreadsheetId, result };
+        });
+    });
+    const tab = sheet.command('tab').description('Tab structure');
+    tab
+        .command('add')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--title <name>', 'New tab title')
+        .option('--index <n>', 'Insert index', (v) => Number(v))
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet tab add', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).tabAdd(spreadsheetId, {
+                    title: need(opts.title, '--title'),
+                    index: opts.index,
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    tab
+        .command('rename')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Current name')
+        .option('--title <name>', 'New name')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet tab rename', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).tabRename(spreadsheetId, {
+                    tab: need(opts.tab, '--tab'),
+                    title: need(opts.title, '--title'),
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    tab
+        .command('delete')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Tab to delete')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet tab delete', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).tabDelete(spreadsheetId, { tab: need(opts.tab, '--tab'), dryRun: g.dryRun }),
+            };
+        });
+    });
+    tab
+        .command('duplicate')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Tab to copy')
+        .option('--title <name>', 'Name for the copy')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet tab duplicate', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).tabDuplicate(spreadsheetId, {
+                    tab: need(opts.tab, '--tab'),
+                    title: opts.title,
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    const format = sheet.command('format').description('Format a range with intent flags');
+    format
+        .command('header')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Tab name')
+        .option('--bg <color>', 'Header background')
+        .option('--fg <color>', 'Header text color')
+        .option('--no-freeze', 'Do not freeze row 1')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet format header', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                sheet: opts.tab,
+                result: await opsFor(g.account).formatHeader(spreadsheetId, {
+                    tab: need(opts.tab, '--tab'),
+                    bg: opts.bg,
+                    fg: opts.fg,
+                    freeze: opts.freeze,
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    format
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--range <a1>', 'A1 range')
+        .option('--tab <name>', 'Tab if range has no sheet name')
+        .option('--bold', 'Bold')
+        .option('--italic', 'Italic')
+        .option('--bg <color>', 'Background')
+        .option('--fg <color>', 'Foreground')
+        .option('--align <dir>', 'left | center | right')
+        .option('--valign <dir>', 'top | middle | bottom')
+        .option('--wrap', 'Wrap text')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet format', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).format(spreadsheetId, {
+                    range: need(opts.range, '--range'),
+                    tab: opts.tab,
+                    bold: opts.bold ? true : undefined,
+                    italic: opts.italic ? true : undefined,
+                    bg: opts.bg,
+                    fg: opts.fg,
+                    align: opts.align,
+                    valign: opts.valign,
+                    wrap: opts.wrap ? true : undefined,
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('freeze')
+        .description('Freeze rows/columns')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--tab <name>', 'Tab name')
+        .option('--rows <n>', 'Frozen rows', (v) => Number(v))
+        .option('--columns <n>', 'Frozen columns', (v) => Number(v))
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet freeze', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                sheet: opts.tab,
+                result: await opsFor(g.account).freeze(spreadsheetId, {
+                    tab: need(opts.tab, '--tab'),
+                    rows: opts.rows,
+                    columns: opts.columns,
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('number-format')
+        .description('Apply a number pattern')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--range <a1>', 'A1 range')
+        .option('--tab <name>', 'Tab if range has no sheet name')
+        .option('--pattern <pattern>', 'Number pattern')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet number-format', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).numberFormat(spreadsheetId, {
+                    range: need(opts.range, '--range'),
+                    pattern: need(opts.pattern, '--pattern'),
+                    tab: opts.tab,
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('formula')
+        .description('Write a formula into a cell')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--cell <a1>', 'Target cell')
+        .option('--expr <formula>', 'Formula')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet formula', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).formula(spreadsheetId, {
+                    cell: need(opts.cell, '--cell'),
+                    expr: need(opts.expr, '--expr'),
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('fill-down')
+        .description('Write a formula down a range')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--range <a1>', 'A1 range')
+        .option('--expr <formula>', 'Formula')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet fill-down', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).fillDown(spreadsheetId, {
+                    range: need(opts.range, '--range'),
+                    expr: need(opts.expr, '--expr'),
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('share')
+        .description('Share with a user')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--email <email>', 'User email')
+        .option('--role <role>', 'reader or writer')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet share', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).share(spreadsheetId, {
+                    email: need(opts.email, '--email'),
+                    role: need(opts.role, '--role'),
+                    dryRun: g.dryRun,
+                }),
+            };
+        });
+    });
+    sheet
+        .command('unshare')
+        .description('Remove a user permission')
+        .argument('[spreadsheet]', 'ID or URL')
+        .option('--email <email>', 'User email')
+        .action(async (spreadsheet, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet unshare', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).unshare(spreadsheetId, need(opts.email, '--email'), g.dryRun),
+            };
+        });
+    });
+    sheet
+        .command('permissions')
+        .description('List permissions')
+        .argument('[spreadsheet]', 'ID or URL')
+        .action(async (spreadsheet, _opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet permissions', g.pretty, async () => {
+            const spreadsheetId = idOf(spreadsheet, g);
+            return { spreadsheetId, result: await opsFor(g.account).permissions(spreadsheetId) };
+        });
+    });
+    sheet
+        .command('api')
+        .description('Raw method escape hatch')
+        .argument('<method>', 'Method name')
+        .option('--json <json>', 'JSON body or @file.json')
+        .action(async (method, opts, cmd) => {
+        const g = takeGlobals(cmd);
+        await run('sheet api', g.pretty, async () => {
+            const json = opts.json ? parseJsonInput(opts.json, '--json') : {};
+            const spreadsheetId = g.spreadsheet ? resolveSpreadsheetId(g.spreadsheet) : undefined;
+            return {
+                spreadsheetId,
+                result: await opsFor(g.account).api(method, spreadsheetId, json),
+            };
+        });
+    });
+}

package/dist/plugins/sheet/specs.d.ts

@@ -0,0 +1,20 @@
+export type FlagSpec = {
+    flags: string;
+    description: string;
+    type?: string;
+};
+export type ArgSpec = {
+    name: string;
+    required: boolean;
+    description: string;
+};
+export type CommandSpec = {
+    name: string;
+    description: string;
+    args?: ArgSpec[];
+    options?: FlagSpec[];
+    subcommands?: CommandSpec[];
+};
+export declare const COMMANDS: CommandSpec[];
+export declare function findSpec(path: string[]): CommandSpec | undefined;
+export declare function helpJson(path?: string[]): unknown;