@skrr-ai/cli 0.1.8

package/dist/lib/format.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayWidth = displayWidth;
+exports.pad = pad;
+exports.truncate = truncate;
+exports.formatCell = formatCell;
+exports.renderTable = renderTable;
+exports.localStamp = localStamp;
+exports.localZone = localZone;
+/**
+ * Code points that occupy TWO terminal columns (Unicode East Asian Wide and
+ * Fullwidth), plus the emoji blocks terminals render double-width.
+ *
+ * Ranges rather than a dependency: this is the set that actually appears in
+ * this product's data — CJK, kana, Hangul, fullwidth punctuation, emoji.
+ */
+const WIDE_RANGES = [
+    [0x1100, 0x115f], // Hangul Jamo
+    [0x2e80, 0x303e], // CJK Radicals, Kangxi, CJK Symbols and Punctuation
+    [0x3041, 0x33ff], // Kana, Bopomofo, Hangul Compat Jamo, Enclosed CJK
+    [0x3400, 0x4dbf], // CJK Extension A
+    [0x4e00, 0x9fff], // CJK Unified Ideographs
+    [0xa000, 0xa4cf], // Yi
+    [0xac00, 0xd7a3], // Hangul Syllables
+    [0xf900, 0xfaff], // CJK Compatibility Ideographs
+    [0xfe10, 0xfe19], // Vertical forms
+    [0xfe30, 0xfe6f], // CJK Compatibility Forms, Small Form Variants
+    [0xff00, 0xff60], // Fullwidth forms
+    [0xffe0, 0xffe6], // Fullwidth signs
+    [0x1f300, 0x1f6ff], // Misc Symbols, Emoticons, Transport and Map
+    [0x1f900, 0x1f9ff], // Supplemental Symbols and Pictographs
+    [0x1fa70, 0x1faff], // Symbols and Pictographs Extended-A
+    [0x20000, 0x3fffd], // CJK Extension B and beyond
+];
+/** Code points that occupy NO columns: combining marks and joiners. */
+const ZERO_RANGES = [
+    [0x0300, 0x036f], // Combining Diacritical Marks
+    [0x200b, 0x200f], // Zero-width space/joiner and bidi marks
+    [0xfe00, 0xfe0f], // Variation selectors
+];
+function inRanges(cp, ranges) {
+    for (const [lo, hi] of ranges) {
+        if (cp >= lo && cp <= hi)
+            return true;
+        if (cp < lo)
+            break;
+    }
+    return false;
+}
+/**
+ * How many terminal columns a string occupies.
+ *
+ * NOT `s.length`, which counts UTF-16 code units. `'改过的标题'.length` is 5 and
+ * the string occupies 10 columns, so every table containing Chinese was laid
+ * out to the wrong width and its later columns no longer lined up with their
+ * headers (OSK-4941). It stayed invisible because ASCII makes the two numbers
+ * equal, and the samples, tests and docs are all ASCII — the same way
+ * `-- npm test` hid the argv-joining bug.
+ *
+ * Astral characters are the other half: a surrogate pair is `.length` 2 and one
+ * or two columns, so iterating by code point is what makes emoji measurable at
+ * all.
+ */
+function displayWidth(s) {
+    let width = 0;
+    for (const ch of s) {
+        const cp = ch.codePointAt(0) ?? 0;
+        if (inRanges(cp, ZERO_RANGES))
+            continue;
+        width += inRanges(cp, WIDE_RANGES) ? 2 : 1;
+    }
+    return width;
+}
+/** Right-pad with spaces to a fixed column width. */
+function pad(s, width) {
+    const actual = displayWidth(s);
+    if (actual >= width)
+        return s;
+    return s + ' '.repeat(width - actual);
+}
+/**
+ * Truncate a string to a column budget, ellipsizing if needed.
+ *
+ * Iterates by code point, so a wide character is never half-included and a
+ * surrogate pair is never split down the middle into two replacement glyphs.
+ */
+function truncate(s, max) {
+    if (displayWidth(s) <= max)
+        return s;
+    if (max <= 1)
+        return '…';
+    const budget = max - 1; // room for the ellipsis
+    let width = 0;
+    let out = '';
+    for (const ch of s) {
+        const cp = ch.codePointAt(0) ?? 0;
+        const w = inRanges(cp, ZERO_RANGES) ? 0 : inRanges(cp, WIDE_RANGES) ? 2 : 1;
+        if (width + w > budget)
+            break;
+        out += ch;
+        width += w;
+    }
+    return `${out}…`;
+}
+/**
+ * Render an arbitrary API value as a single table cell.
+ *
+ * `renderTable` takes rows that are already strings, so callers reached for
+ * `String(value)` — which renders every object as the literal `[object Object]`
+ * (OSK-2044: `tasks activity` printed six of them and nothing else). Objects
+ * are flattened to `key=value` pairs and arrays to a comma list so a details
+ * blob stays on one line and survives the column clip, and anything
+ * empty/absent collapses to the table's `-` placeholder so a missing field
+ * reads as missing instead of as the string `undefined`.
+ */
+function formatCell(value, placeholder = '-') {
+    return stringifyCell(value, 0) || placeholder;
+}
+function stringifyCell(value, depth) {
+    if (value === null || value === undefined)
+        return '';
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? '' : value.toISOString();
+    if (typeof value !== 'object')
+        return collapseWhitespace(String(value));
+    // Nested containers are rare in list payloads and unreadable as flattened
+    // pairs (`k=a=1 b=2` is ambiguous), so past the first level emit compact JSON.
+    if (depth > 0)
+        return collapseWhitespace(JSON.stringify(value) ?? '');
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => stringifyCell(entry, depth + 1))
+            .filter(Boolean)
+            .join(', ');
+    }
+    return Object.entries(value)
+        .map(([key, entry]) => {
+        const rendered = stringifyCell(entry, depth + 1);
+        return rendered ? `${key}=${rendered}` : '';
+    })
+        .filter(Boolean)
+        .join(' ');
+}
+/** Collapse newlines/runs of whitespace so a value cannot break the table grid. */
+function collapseWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function renderTable(rows, columns, log) {
+    if (rows.length === 0)
+        return;
+    const widths = {};
+    for (const col of columns) {
+        const key = String(col.key);
+        const headerWidth = displayWidth(col.header);
+        const dataWidth = Math.max(...rows.map((r) => displayWidth(String(r[col.key] ?? ''))));
+        const natural = Math.max(headerWidth, dataWidth);
+        widths[key] = col.maxWidth && !col.verbatim ? Math.min(natural, col.maxWidth) : natural;
+    }
+    const header = columns.map((col) => pad(col.header, widths[String(col.key)])).join('  ');
+    log(header);
+    for (const row of rows) {
+        const line = columns
+            .map((col) => {
+            const raw = String(row[col.key] ?? '');
+            const width = widths[String(col.key)];
+            return pad(col.verbatim ? raw : truncate(raw, width), width);
+        })
+            .join('  ');
+        log(line);
+    }
+}
+/**
+ * Local wall-clock, `2026-08-21 17:54`.
+ *
+ * Deliberately not `toISOString()`. A UTC stamp printed with no marker is read
+ * as local time, so `harnesses list` saying LAST SEEN 2026-08-22 00:54 while
+ * the user's clock reads 17:54 looks like a seven-hour-old daemon rather than
+ * one seen a minute ago (OSK-4868). Every command that prints a wall clock
+ * should print it in the reader's zone and name that zone once.
+ */
+function localStamp(value) {
+    if (!value)
+        return '-';
+    // A number is epoch milliseconds. `new Date(String(1755...))` is an Invalid
+    // Date, so stringifying first silently breaks every millisecond caller.
+    const date = value instanceof Date ? value : new Date(typeof value === 'number' ? value : String(value));
+    if (Number.isNaN(date.getTime()))
+        return String(value);
+    const pad = (n) => `${n}`.padStart(2, '0');
+    return (`${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
+        `${pad(date.getHours())}:${pad(date.getMinutes())}`);
+}
+/**
+ * `PDT` — the zone `localStamp` renders in, to be named once per command
+ * rather than repeated on every row.
+ *
+ * Falls back to a UTC offset where the runtime reports no short name, and to
+ * an empty string if even that is unavailable; a caller must tolerate both
+ * rather than print an empty parenthesis.
+ */
+function localZone(at = new Date()) {
+    try {
+        const parts = new Intl.DateTimeFormat(undefined, { timeZoneName: 'short' }).formatToParts(at);
+        const named = parts.find((part) => part.type === 'timeZoneName')?.value;
+        if (named)
+            return named;
+    }
+    catch {
+        // Intl is present in every runtime this CLI supports, but a zone database
+        // can be absent in a stripped container; the offset below still orients.
+    }
+    const offset = -at.getTimezoneOffset();
+    if (Number.isNaN(offset))
+        return '';
+    const sign = offset < 0 ? '-' : '+';
+    const abs = Math.abs(offset);
+    return `UTC${sign}${`${Math.floor(abs / 60)}`.padStart(2, '0')}:${`${abs % 60}`.padStart(2, '0')}`;
+}

package/dist/lib/git-task.d.ts

@@ -0,0 +1,25 @@
+export type GitTaskBranch = {
+    branch: string;
+    taskRef: string;
+};
+export declare class GitTaskError extends Error {
+    readonly code: 'GIT_REPOSITORY_REQUIRED' | 'TASK_BRANCH_CONTEXT_MISSING' | 'GIT_BRANCH_SWITCH_FAILED';
+    constructor(message: string, code: 'GIT_REPOSITORY_REQUIRED' | 'TASK_BRANCH_CONTEXT_MISSING' | 'GIT_BRANCH_SWITCH_FAILED');
+}
+/** The checked-out local branch, or null for a detached HEAD/non-git directory. */
+export declare function currentGitBranch(cwd?: string): string | null;
+/**
+ * Resolve the task identifier encoded in the current branch without touching
+ * the network. This is intentionally usable in a normal terminal with no
+ * daemon process running.
+ */
+export declare function currentGitTaskBranch(cwd?: string): GitTaskBranch | null;
+/**
+ * Create the task branch at HEAD if needed, then check it out. All git values
+ * come from `taskBranchName`, so the argv invocation never evaluates a user
+ * task string as a git revision or shell fragment.
+ */
+export declare function checkoutTaskBranch(taskRef: string, cwd?: string): {
+    branch: string;
+    created: boolean;
+};

package/dist/lib/git-task.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitTaskError = void 0;
+exports.currentGitBranch = currentGitBranch;
+exports.currentGitTaskBranch = currentGitTaskBranch;
+exports.checkoutTaskBranch = checkoutTaskBranch;
+const node_child_process_1 = require("node:child_process");
+const taskReferences = __importStar(require("@skrr-ai/data-provider"));
+class GitTaskError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'GitTaskError';
+    }
+}
+exports.GitTaskError = GitTaskError;
+// `cli`'s source-level Jest runs can load a previously-built data-provider
+// artifact while this workspace is being edited. Production CLI builds run
+// data-provider first, so they use the exported shared functions. The narrow
+// fallback merely preserves that same grammar for an unbuilt local checkout;
+// it is intentionally proven-equal to `packages/data-provider/src/tasks/branch.ts`.
+const TASK_REF_RE = /^([A-Za-z][A-Za-z0-9]{1,31}-[0-9]{1,12})$/i;
+const TASK_BRANCH_RE = /^oversky\/task\/([A-Za-z][A-Za-z0-9]{1,31}-[0-9]{1,12})(?:\/|$)/i;
+function parseBranchTaskReference(branch) {
+    const parser = taskReferences
+        .parseTaskReferenceBranch;
+    if (typeof parser === 'function')
+        return parser(branch);
+    const match = TASK_BRANCH_RE.exec(branch || '');
+    return match?.[1].toUpperCase() ?? null;
+}
+function canonicalTaskBranchName(taskRef) {
+    const builder = taskReferences.taskBranchName;
+    if (typeof builder === 'function')
+        return builder(taskRef);
+    const match = TASK_REF_RE.exec(taskRef.trim());
+    if (!match)
+        throw new TypeError('A task branch requires an identifier like OSK-123.');
+    return `oversky/task/${match[1].toUpperCase()}`;
+}
+function git(cwd, args) {
+    try {
+        return (0, node_child_process_1.execFileSync)('git', args, {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** The checked-out local branch, or null for a detached HEAD/non-git directory. */
+function currentGitBranch(cwd = process.cwd()) {
+    const branch = git(cwd, ['branch', '--show-current']);
+    return branch || null;
+}
+/**
+ * Resolve the task identifier encoded in the current branch without touching
+ * the network. This is intentionally usable in a normal terminal with no
+ * daemon process running.
+ */
+function currentGitTaskBranch(cwd = process.cwd()) {
+    const branch = currentGitBranch(cwd);
+    const taskRef = parseBranchTaskReference(branch);
+    return branch && taskRef ? { branch, taskRef } : null;
+}
+function isGitRepository(cwd) {
+    return git(cwd, ['rev-parse', '--is-inside-work-tree']) === 'true';
+}
+function localBranchExists(cwd, branch) {
+    return git(cwd, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]) !== null;
+}
+function switchBranch(cwd, args) {
+    const result = (0, node_child_process_1.spawnSync)('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status === 0)
+        return;
+    const detail = [result.stdout, result.stderr]
+        .filter((value) => typeof value === 'string' && Boolean(value.trim()))
+        .join('\n')
+        .trim();
+    throw new GitTaskError(`Could not check out task branch${detail ? `: ${detail}` : '.'}`, 'GIT_BRANCH_SWITCH_FAILED');
+}
+/**
+ * Create the task branch at HEAD if needed, then check it out. All git values
+ * come from `taskBranchName`, so the argv invocation never evaluates a user
+ * task string as a git revision or shell fragment.
+ */
+function checkoutTaskBranch(taskRef, cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        throw new GitTaskError('`skrr tasks start --branch` must run inside a git working tree.', 'GIT_REPOSITORY_REQUIRED');
+    }
+    const branch = canonicalTaskBranchName(taskRef);
+    if (currentGitBranch(cwd) === branch)
+        return { branch, created: false };
+    const exists = localBranchExists(cwd, branch);
+    switchBranch(cwd, exists ? ['switch', branch] : ['switch', '-c', branch]);
+    return { branch, created: !exists };
+}

package/dist/lib/github-tools.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnection, IntegrationTool } from '@skrr-ai/data-provider';
+export declare const GITHUB_TOOLKIT = "github";
+export declare const DEFAULT_INTEGRATION_PROVIDER = "composio";
+export declare function resolveIntegrationProvider(flagValue?: string): string | undefined;
+export declare function normalizeGitHubToolSlug(value: string): string;
+export declare function normalizeGitHubToolList(value: string): string[];
+export declare function isFatalIntegrationPollError(err: unknown): boolean;
+export declare function assertTrustedIntegrationRedirectUrl(redirectUrl: string): void;
+export declare function isGitHubTool(tool: Pick<IntegrationTool, 'name'>): boolean;
+export declare function filterGitHubTools<T extends Pick<IntegrationTool, 'name'>>(tools: T[]): T[];
+export declare function isGitHubConnection(connection: Pick<IntegrationConnection, 'appName'>): boolean;
+export declare function filterGitHubConnections<T extends Pick<IntegrationConnection, 'appName'>>(connections: T[]): T[];

package/dist/lib/github-tools.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_INTEGRATION_PROVIDER = exports.GITHUB_TOOLKIT = void 0;
+exports.resolveIntegrationProvider = resolveIntegrationProvider;
+exports.normalizeGitHubToolSlug = normalizeGitHubToolSlug;
+exports.normalizeGitHubToolList = normalizeGitHubToolList;
+exports.isFatalIntegrationPollError = isFatalIntegrationPollError;
+exports.assertTrustedIntegrationRedirectUrl = assertTrustedIntegrationRedirectUrl;
+exports.isGitHubTool = isGitHubTool;
+exports.filterGitHubTools = filterGitHubTools;
+exports.isGitHubConnection = isGitHubConnection;
+exports.filterGitHubConnections = filterGitHubConnections;
+exports.GITHUB_TOOLKIT = 'github';
+exports.DEFAULT_INTEGRATION_PROVIDER = 'composio';
+const FATAL_POLL_STATUSES = new Set([401, 403, 503]);
+const FATAL_POLL_CODES = new Set(['integration_disabled', 'unauthorized', 'forbidden']);
+const TRUSTED_REDIRECT_SUFFIXES = ['composio.dev', 'composio.ai'];
+function resolveIntegrationProvider(flagValue) {
+    return flagValue ?? process.env.OVERSKY_INTEGRATION_PROVIDER;
+}
+function normalizeGitHubToolSlug(value) {
+    const raw = String(value || '').trim();
+    if (!raw) {
+        throw new Error('GitHub tool slug is required.');
+    }
+    const withoutPrefix = raw.replace(/^github[._:-]+/i, '');
+    const normalized = withoutPrefix.replace(/[\s.:-]+/g, '_').toUpperCase();
+    return normalized.startsWith('GITHUB_') ? normalized : `GITHUB_${normalized}`;
+}
+function normalizeGitHubToolList(value) {
+    const tools = String(value || '')
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .map(normalizeGitHubToolSlug);
+    return Array.from(new Set(tools));
+}
+function isFatalIntegrationPollError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const e = err;
+    const status = e.status ?? e.response?.status;
+    const code = e.response?.data?.error?.code;
+    if (status !== undefined && FATAL_POLL_STATUSES.has(status))
+        return true;
+    if (code !== undefined && FATAL_POLL_CODES.has(code))
+        return true;
+    return false;
+}
+function assertTrustedIntegrationRedirectUrl(redirectUrl) {
+    const parsedUrl = new URL(redirectUrl);
+    const hostOk = TRUSTED_REDIRECT_SUFFIXES.some((suffix) => parsedUrl.hostname === suffix || parsedUrl.hostname.endsWith(`.${suffix}`));
+    if (!hostOk) {
+        throw new Error(`Refusing to print untrusted redirect URL host: ${parsedUrl.hostname}`);
+    }
+}
+function isGitHubTool(tool) {
+    return /^GITHUB(_|$)/i.test(tool.name || '');
+}
+function filterGitHubTools(tools) {
+    return tools.filter(isGitHubTool);
+}
+function isGitHubConnection(connection) {
+    return String(connection.appName || '').toLowerCase() === exports.GITHUB_TOOLKIT;
+}
+function filterGitHubConnections(connections) {
+    return connections.filter(isGitHubConnection);
+}

package/dist/lib/grants.d.ts

@@ -0,0 +1,57 @@
+export declare const GRANT_PRINCIPAL_KINDS: readonly ["agent", "commitment"];
+export declare const GRANT_CREDENTIAL_KINDS: readonly ["env", "bearer", "basic", "json"];
+export interface GrantPrincipal {
+    kind: 'agent' | 'commitment';
+    agentId?: string;
+    commitmentId?: string;
+}
+export interface Grant {
+    id: string;
+    principal: GrantPrincipal;
+    label: string;
+    description?: string;
+    provider: string;
+    capabilities: string[];
+    /** Names only — never values. */
+    credential: {
+        configured: boolean;
+        kind?: string;
+        envKeys: string[];
+        fingerprint?: string;
+    } | null;
+    tools: string[];
+    runtime: {
+        sandbox: boolean;
+        daemon: boolean;
+    };
+    expiresAt?: string;
+    revokedAt?: string;
+    active: boolean;
+    lastUsedAt?: string;
+    useCount: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare const grantApi: {
+    list: (path: string) => Promise<{
+        grants: Grant[];
+    }>;
+    get: (id: string) => Promise<Grant>;
+    create: (body: unknown) => Promise<Grant>;
+    rotate: (id: string, credential: unknown) => Promise<Grant>;
+    setRevoked: (id: string, revoked: boolean) => Promise<Grant>;
+    remove: (id: string) => Promise<{
+        ok: boolean;
+        id: string;
+    }>;
+};
+/**
+ * Parse repeated `--env NAME=VALUE` flags.
+ *
+ * Splits on the FIRST `=` only, so a value may contain `=` (base64 secrets
+ * routinely do). Name validation and the code-execution denylist live
+ * server-side in `GrantService`, so the CLI never becomes a second, weaker
+ * gate that could drift.
+ */
+export declare function parseEnvPairs(pairs: string[]): Record<string, string>;
+export declare function renderGrantList(grants: Grant[], log: (line: string) => void): void;

package/dist/lib/grants.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grantApi = exports.GRANT_CREDENTIAL_KINDS = exports.GRANT_PRINCIPAL_KINDS = void 0;
+exports.parseEnvPairs = parseEnvPairs;
+exports.renderGrantList = renderGrantList;
+/**
+ * grants.ts — client for the Grant vault (`/api/grants/*`).
+ *
+ * Gap analysis 2026-07-28 §B3. A **Grant** is a scoped, revocable capability
+ * envelope: `{principal, scope, credential?, tools?, runtime?, ttl}`. The same
+ * noun covers "this user authorized this automation" (no credential) and "this
+ * agent holds an AWS key" (credential attached) — which is why one object buys
+ * consent, capability, and per-task blast-radius isolation at once.
+ *
+ * SECRET HANDLING: a credential value is WRITE-ONLY. The server has no
+ * read-back endpoint, and `Grant` below carries no field that could hold one.
+ * What you can audit is `credential.envKeys` — the variable NAMES you approved.
+ */
+const data_provider_1 = require("@skrr-ai/data-provider");
+const format_1 = require("./format");
+exports.GRANT_PRINCIPAL_KINDS = ['agent', 'commitment'];
+exports.GRANT_CREDENTIAL_KINDS = ['env', 'bearer', 'basic', 'json'];
+exports.grantApi = {
+    list: (path) => data_provider_1.request.get(path),
+    get: (id) => data_provider_1.request.get(`/api/grants/${id}`),
+    create: (body) => data_provider_1.request.post('/api/grants', body),
+    rotate: (id, credential) => data_provider_1.request.put(`/api/grants/${id}/credential`, { credential }),
+    setRevoked: (id, revoked) => data_provider_1.request.patch(`/api/grants/${id}/revocation`, { revoked }),
+    remove: (id) => data_provider_1.request.delete(`/api/grants/${id}`),
+};
+/**
+ * Parse repeated `--env NAME=VALUE` flags.
+ *
+ * Splits on the FIRST `=` only, so a value may contain `=` (base64 secrets
+ * routinely do). Name validation and the code-execution denylist live
+ * server-side in `GrantService`, so the CLI never becomes a second, weaker
+ * gate that could drift.
+ */
+function parseEnvPairs(pairs) {
+    const out = {};
+    for (const raw of pairs) {
+        const idx = raw.indexOf('=');
+        if (idx <= 0) {
+            throw new Error(`--env expects NAME=VALUE, received "${raw}"`);
+        }
+        out[raw.slice(0, idx).trim()] = raw.slice(idx + 1);
+    }
+    return out;
+}
+function renderGrantList(grants, log) {
+    if (grants.length === 0) {
+        log('No grants.');
+        return;
+    }
+    (0, format_1.renderTable)(grants.map((g) => ({
+        id: g.id,
+        label: g.label,
+        provider: g.provider,
+        principal: g.principal.agentId || g.principal.commitmentId || g.principal.kind,
+        // NAMES only. This is the audit surface; a value never reaches the CLI.
+        credential: g.credential?.configured
+            ? g.credential.envKeys.join(',') || g.credential.kind || 'set'
+            : '-',
+        runtime: [g.runtime.sandbox ? 'sandbox' : null, g.runtime.daemon ? 'daemon' : null]
+            .filter(Boolean)
+            .join('+') || 'none',
+        state: g.revokedAt ? 'revoked' : g.active ? 'active' : 'expired',
+    })), [
+        { key: 'label', header: 'LABEL', maxWidth: 26 },
+        { key: 'provider', header: 'PROVIDER', maxWidth: 12 },
+        { key: 'principal', header: 'PRINCIPAL', maxWidth: 24 },
+        { key: 'credential', header: 'VARIABLES', maxWidth: 34 },
+        { key: 'runtime', header: 'RUNTIME', maxWidth: 16 },
+        { key: 'state', header: 'STATE', maxWidth: 8 },
+        { key: 'id', header: 'ID', verbatim: true },
+    ], log);
+}