@bussolabs/closeyourit-cli 0.0.2

package/dist/commands/tokens/revoke.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class TokensRevoke extends base_1.BaseCommand {
+    static description = 'Revoke an ingest token';
+    static examples = ['<%= config.bin %> tokens revoke <token-id> --project acme-api'];
+    static args = {
+        id: core_1.Args.string({ description: 'Token id', required: true }),
+    };
+    static flags = { ...base_1.projectFlag };
+    async run() {
+        const { args, flags } = await this.parse(TokensRevoke);
+        const projectId = await this.resolveProjectId(flags.project);
+        const res = await this.api.delete(`/cli/v1/projects/${projectId}/tokens/${args.id}`);
+        if (!this.jsonEnabled()) {
+            this.log(`Token ${args.id} revoked.`);
+        }
+        return res;
+    }
+}
+exports.default = TokensRevoke;

package/dist/commands/tokens/rotate.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base';
+export default class TokensRotate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/tokens/rotate.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class TokensRotate extends base_1.BaseCommand {
+    static description = 'Rotate an ingest token (the new secret is shown only once)';
+    static examples = ['<%= config.bin %> tokens rotate <token-id> --project acme-api'];
+    static args = {
+        id: core_1.Args.string({ description: 'Token id', required: true }),
+    };
+    static flags = { ...base_1.projectFlag };
+    async run() {
+        const { args, flags } = await this.parse(TokensRotate);
+        const projectId = await this.resolveProjectId(flags.project);
+        const res = await this.api.put(`/cli/v1/projects/${projectId}/tokens/${args.id}/rotation`);
+        const token = res.data ?? {};
+        if (!this.jsonEnabled()) {
+            this.log('Token rotated. Store the new credentials now — they are shown only once:');
+            this.log('');
+            this.log(`  secret: ${token.secret ?? '-'}`);
+            this.log(`  dsn:    ${token.dsn ?? '-'}`);
+            this.log('');
+            this.warn('The previous secret is now invalid and the new one cannot be retrieved again.');
+        }
+        return res;
+    }
+}
+exports.default = TokensRotate;

package/dist/commands/whoami.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '../base';
+export default class Whoami extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<unknown>;
+}

package/dist/commands/whoami.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+class Whoami extends base_1.BaseCommand {
+    static description = 'Show the authenticated account, organization, token and permissions';
+    static examples = ['<%= config.bin %> whoami', '<%= config.bin %> whoami --json'];
+    async run() {
+        const res = await this.api.get('/cli/v1/whoami');
+        const who = res.data;
+        if (!this.jsonEnabled()) {
+            this.log(`Account:     ${who.account?.name ?? '-'} <${who.account?.email ?? '-'}>`);
+            this.log(`Organization: ${who.organization?.name ?? '-'} (${who.organization?.slug ?? '-'})`);
+            this.log(`Token:       ${who.token?.prefix ?? '-'}`);
+            this.log(`Permissions: ${(who.permissions ?? []).join(', ') || '-'}`);
+        }
+        return who;
+    }
+}
+exports.default = Whoami;

package/dist/errors/error-codes.d.ts

@@ -0,0 +1,35 @@
+export declare const ErrorCodes: {
+    readonly Auth: {
+        readonly notLoggedIn: "C401-AUT-001";
+    };
+    readonly Config: {
+        readonly notFound: "C000-CFG-001";
+        readonly corrupted: "C000-CFG-002";
+    };
+    readonly Network: {
+        readonly requestFailed: "C000-NET-001";
+        readonly parseFailed: "C000-NET-003";
+    };
+    readonly Project: {
+        readonly notFound: "C404-PRJ-001";
+    };
+    readonly Role: {
+        readonly notFound: "C404-ROL-001";
+    };
+    readonly Group: {
+        readonly notFound: "C404-GRP-001";
+    };
+    readonly Team: {
+        readonly notFound: "C404-TEM-001";
+    };
+    readonly Member: {
+        readonly notFound: "C404-MBR-001";
+    };
+    readonly Device: {
+        readonly expired: "C408-DEV-001";
+        readonly failed: "C400-DEV-002";
+    };
+    readonly System: {
+        readonly unexpected: "C500-SYS-001";
+    };
+};

package/dist/errors/error-codes.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCodes = void 0;
+// Local CLI error codes — C{STATUS}-{DOMAIN}-{SEQ}.
+// Backend codes (R*/G*) are propagated as-is from the response envelope; never remap them here.
+exports.ErrorCodes = {
+    Auth: {
+        notLoggedIn: 'C401-AUT-001',
+    },
+    Config: {
+        notFound: 'C000-CFG-001',
+        corrupted: 'C000-CFG-002',
+    },
+    Network: {
+        requestFailed: 'C000-NET-001',
+        parseFailed: 'C000-NET-003',
+    },
+    Project: {
+        notFound: 'C404-PRJ-001',
+    },
+    Role: {
+        notFound: 'C404-ROL-001',
+    },
+    Group: {
+        notFound: 'C404-GRP-001',
+    },
+    Team: {
+        notFound: 'C404-TEM-001',
+    },
+    Member: {
+        notFound: 'C404-MBR-001',
+    },
+    Device: {
+        expired: 'C408-DEV-001',
+        failed: 'C400-DEV-002',
+    },
+    System: {
+        unexpected: 'C500-SYS-001',
+    },
+};

package/dist/lib/api.d.ts

@@ -0,0 +1,28 @@
+import type { CliConfig } from './config';
+/** Error carrying the HTTP status and the structured code from the backend envelope (R/G prefix) or a local C-prefix fallback. */
+export declare class ApiRequestError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(status: number, code: string, message: string, details?: unknown | undefined);
+}
+export interface RequestOptions {
+    body?: unknown;
+    /** Defaults to true; set false for unauthenticated endpoints. */
+    auth?: boolean;
+}
+export interface Envelope<T = unknown> {
+    data: T;
+    meta?: Record<string, unknown>;
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export declare class CliApi {
+    private readonly config;
+    constructor(config: CliConfig);
+    request<T = unknown>(method: HttpMethod, path: string, opts?: RequestOptions): Promise<Envelope<T>>;
+    get<T = unknown>(path: string, opts?: RequestOptions): Promise<Envelope<T>>;
+    post<T = unknown>(path: string, body?: unknown, opts?: RequestOptions): Promise<Envelope<T>>;
+    put<T = unknown>(path: string, body?: unknown, opts?: RequestOptions): Promise<Envelope<T>>;
+    delete<T = unknown>(path: string, opts?: RequestOptions): Promise<Envelope<T>>;
+}
+export {};

package/dist/lib/api.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliApi = exports.ApiRequestError = void 0;
+const error_codes_1 = require("../errors/error-codes");
+/** Error carrying the HTTP status and the structured code from the backend envelope (R/G prefix) or a local C-prefix fallback. */
+class ApiRequestError extends Error {
+    status;
+    code;
+    details;
+    constructor(status, code, message, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        this.name = 'ApiRequestError';
+    }
+}
+exports.ApiRequestError = ApiRequestError;
+class CliApi {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async request(method, path, opts = {}) {
+        const auth = opts.auth !== false;
+        const headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        };
+        if (auth) {
+            if (!this.config.token) {
+                throw new ApiRequestError(401, error_codes_1.ErrorCodes.Auth.notLoggedIn, 'Not logged in. Run "closeyourit login".');
+            }
+            headers.Authorization = `Bearer ${this.config.token}`;
+        }
+        const url = this.config.apiUrl.replace(/\/+$/, '') + path;
+        let res;
+        try {
+            res = await fetch(url, {
+                method,
+                headers,
+                body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
+            });
+        }
+        catch (err) {
+            throw new ApiRequestError(0, error_codes_1.ErrorCodes.Network.requestFailed, `Request to ${url} failed: ${err.message}`);
+        }
+        const text = await res.text();
+        let json = {};
+        if (text.length > 0) {
+            try {
+                json = JSON.parse(text);
+            }
+            catch {
+                if (!res.ok) {
+                    throw new ApiRequestError(res.status, error_codes_1.ErrorCodes.Network.requestFailed, `Request failed (${res.status})`);
+                }
+                throw new ApiRequestError(res.status, error_codes_1.ErrorCodes.Network.parseFailed, 'Failed to parse server response');
+            }
+        }
+        if (!res.ok) {
+            const envelope = (json ?? {});
+            const error = envelope.error ?? {};
+            throw new ApiRequestError(res.status, error.code ?? `C${res.status}-API-000`, error.message ?? res.statusText ?? `Request failed (${res.status})`, error.details);
+        }
+        return (json ?? {});
+    }
+    get(path, opts) {
+        return this.request('GET', path, opts);
+    }
+    post(path, body, opts) {
+        return this.request('POST', path, { ...opts, body });
+    }
+    put(path, body, opts) {
+        return this.request('PUT', path, { ...opts, body });
+    }
+    delete(path, opts) {
+        return this.request('DELETE', path, opts);
+    }
+}
+exports.CliApi = CliApi;

package/dist/lib/browser.d.ts

@@ -0,0 +1,2 @@
+/** Best-effort: open a URL in the default browser. Never throws. */
+export declare function openUrl(url: string): void;

package/dist/lib/browser.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openUrl = openUrl;
+const node_child_process_1 = require("node:child_process");
+/** Best-effort: open a URL in the default browser. Never throws. */
+function openUrl(url) {
+    try {
+        let command;
+        let args;
+        switch (process.platform) {
+            case 'darwin':
+                command = 'open';
+                args = [url];
+                break;
+            case 'win32':
+                command = 'cmd';
+                args = ['/c', 'start', '', url];
+                break;
+            default:
+                command = 'xdg-open';
+                args = [url];
+        }
+        const child = (0, node_child_process_1.spawn)(command, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => {
+            // Swallow: opening a browser is a convenience, not a requirement.
+        });
+        child.unref();
+    }
+    catch {
+        // Never throw from a convenience helper.
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,20 @@
+export interface CliConfig {
+    apiUrl: string;
+    token?: string;
+    account?: {
+        id: string;
+        name: string;
+        email: string;
+    };
+    organization?: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+}
+export declare function configPath(): string;
+export declare function defaultApiUrl(): string;
+export declare function loadConfig(): CliConfig;
+export declare function saveConfig(cfg: CliConfig): void;
+/** Remove token + identity, keep apiUrl. */
+export declare function clearToken(): void;

package/dist/lib/config.js

@@ -0,0 +1,93 @@
+"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.configPath = configPath;
+exports.defaultApiUrl = defaultApiUrl;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.clearToken = clearToken;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const DEFAULT_API_URL = 'https://www.closeyour.it';
+/** Directory holding config.json. Overridable via CLOSEYOURIT_CONFIG_DIR (read at call time). */
+function configDir() {
+    const override = process.env.CLOSEYOURIT_CONFIG_DIR;
+    if (override && override.trim() !== '')
+        return override;
+    return path.join(os.homedir(), '.config', 'closeyourit');
+}
+function configPath() {
+    return path.join(configDir(), 'config.json');
+}
+function defaultApiUrl() {
+    const fromEnv = process.env.CLOSEYOURIT_API_URL;
+    return fromEnv && fromEnv.trim() !== '' ? fromEnv : DEFAULT_API_URL;
+}
+function loadConfig() {
+    const file = configPath();
+    let parsed = {};
+    try {
+        if (fs.existsSync(file)) {
+            parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+    }
+    catch {
+        // Corrupted/unreadable config falls back to defaults rather than crashing.
+        parsed = {};
+    }
+    return {
+        apiUrl: parsed.apiUrl && parsed.apiUrl.trim() !== '' ? parsed.apiUrl : defaultApiUrl(),
+        token: parsed.token,
+        account: parsed.account,
+        organization: parsed.organization,
+    };
+}
+function saveConfig(cfg) {
+    const dir = configDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = configPath();
+    fs.writeFileSync(file, `${JSON.stringify(cfg, null, 2)}\n`, { mode: 0o600 });
+    // Ensure perms even if the file pre-existed with a looser mode.
+    fs.chmodSync(file, 0o600);
+}
+/** Remove token + identity, keep apiUrl. */
+function clearToken() {
+    const cfg = loadConfig();
+    delete cfg.token;
+    delete cfg.account;
+    delete cfg.organization;
+    saveConfig(cfg);
+}

package/dist/lib/device-flow.d.ts

@@ -0,0 +1,28 @@
+export interface DeviceAuthorization {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete: string;
+    interval: number;
+    expires_in: number;
+}
+export interface DeviceTokenResult {
+    access_token: string;
+    token: {
+        id: string;
+        name: string;
+        prefix: string;
+    };
+}
+export interface PollOptions {
+    /** Seconds between polls (from the authorize response). */
+    interval: number;
+    /** Lifetime of the device_code in seconds. */
+    expiresIn: number;
+    /** Called on each authorization_pending / slow_down tick. */
+    onPending?: () => void;
+    /** Injectable for tests; defaults to setTimeout-based sleep. */
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare function startDeviceFlow(apiUrl: string, clientName: string): Promise<DeviceAuthorization>;
+export declare function pollDeviceToken(apiUrl: string, deviceCode: string, opts: PollOptions): Promise<DeviceTokenResult>;

package/dist/lib/device-flow.js

@@ -0,0 +1,62 @@
+"use strict";
+// OAuth 2.0 Device Authorization Grant against the CloseYourIt /cli backend.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDeviceFlow = startDeviceFlow;
+exports.pollDeviceToken = pollDeviceToken;
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function postJson(url, body) {
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    let json = {};
+    if (text.length > 0) {
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            json = {};
+        }
+    }
+    return { ok: res.ok, status: res.status, json };
+}
+function base(apiUrl) {
+    return apiUrl.replace(/\/+$/, '');
+}
+async function startDeviceFlow(apiUrl, clientName) {
+    const { ok, status, json } = await postJson(`${base(apiUrl)}/cli/device/authorize`, { client_name: clientName });
+    if (!ok) {
+        throw new Error(json?.error?.message ?? `Device authorization failed (${status})`);
+    }
+    return json.data;
+}
+async function pollDeviceToken(apiUrl, deviceCode, opts) {
+    const sleep = opts.sleep ?? defaultSleep;
+    let interval = opts.interval > 0 ? opts.interval : 5;
+    const deadline = Date.now() + opts.expiresIn * 1000;
+    for (;;) {
+        if (Date.now() > deadline) {
+            throw new Error('Device authorization expired. Run "closeyourit login" again.');
+        }
+        await sleep(interval * 1000);
+        const { ok, json } = await postJson(`${base(apiUrl)}/cli/device/token`, { device_code: deviceCode });
+        if (ok) {
+            return json.data;
+        }
+        const oauthError = json?.error?.details?.oauth_error;
+        if (oauthError === 'authorization_pending') {
+            opts.onPending?.();
+            continue;
+        }
+        if (oauthError === 'slow_down') {
+            interval += 5;
+            opts.onPending?.();
+            continue;
+        }
+        throw new Error(json?.error?.message ?? 'Device authorization failed');
+    }
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,4 @@
+/** Minimal dependency-free table renderer for human output. */
+export declare function renderTable(headers: string[], rows: string[][]): string;
+/** Pretty-print the scalar fields of a record as `key: value` lines. */
+export declare function renderRecord(obj: Record<string, unknown>): string;

package/dist/lib/output.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTable = renderTable;
+exports.renderRecord = renderRecord;
+/** Minimal dependency-free table renderer for human output. */
+function renderTable(headers, rows) {
+    if (rows.length === 0) {
+        return `${headers.join('  ')}\n(no results)`;
+    }
+    const widths = headers.map((header, col) => Math.max(header.length, ...rows.map((row) => String(row[col] ?? '').length)));
+    const line = (cols) => cols.map((cell, col) => String(cell ?? '').padEnd(widths[col])).join('  ').trimEnd();
+    const separator = widths.map((width) => '-'.repeat(width));
+    return [line(headers), line(separator), ...rows.map(line)].join('\n');
+}
+/** Pretty-print the scalar fields of a record as `key: value` lines. */
+function renderRecord(obj) {
+    const lines = Object.entries(obj)
+        .filter(([, value]) => value === null || ['string', 'number', 'boolean'].includes(typeof value))
+        .map(([key, value]) => `${key}: ${value === null ? '-' : value}`);
+    return lines.length > 0 ? lines.join('\n') : JSON.stringify(obj, null, 2);
+}