@bussolabs/closeyourit-cli 0.17.0 → 0.17.1

package/dist/commands/login.js

@@ -14,12 +14,17 @@ class Login extends base_1.BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(Login);
-        if (flags['api-url']) {
-            this.cfg.apiUrl = flags['api-url'];
-            (0, config_1.saveConfig)(this.cfg);
-        }
+        // Persist from the on-disk config so a temporary CLOSEYOURIT_API_URL override is never written to
+        // config.json. Only an explicit --api-url is persisted (that is its documented purpose).
+        const stored = (0, config_1.loadStoredConfig)();
+        if (flags['api-url'])
+            stored.apiUrl = flags['api-url'];
+        // Runtime URL to authenticate against: --api-url wins, otherwise the resolved config (env override included).
+        const apiUrl = flags['api-url'] ?? this.cfg.apiUrl;
+        if (flags['api-url'])
+            (0, config_1.saveConfig)(stored);
         const clientName = `closeyourit-cli/${this.config.version} (${process.platform} ${process.arch})`;
-        const authorization = await (0, device_flow_1.startDeviceFlow)(this.cfg.apiUrl, clientName);
+        const authorization = await (0, device_flow_1.startDeviceFlow)(apiUrl, clientName);
         if (!this.jsonEnabled()) {
             this.log('');
             this.log('To authorize this CLI, open:');
@@ -32,7 +37,7 @@ class Login extends base_1.BaseCommand {
             this.log('Opening your browser…');
         }
         (0, browser_1.openUrl)(authorization.verification_uri_complete);
-        const result = await (0, device_flow_1.pollDeviceToken)(this.cfg.apiUrl, authorization.device_code, {
+        const result = await (0, device_flow_1.pollDeviceToken)(apiUrl, authorization.device_code, {
             interval: authorization.interval,
             expiresIn: authorization.expires_in,
             onPending: () => {
@@ -40,24 +45,24 @@ class Login extends base_1.BaseCommand {
                     process.stderr.write('.');
             },
         });
-        this.cfg.token = result.access_token;
-        (0, config_1.saveConfig)(this.cfg);
-        // Enrich the local config with identity (account + organization).
-        this.api = new api_1.CliApi(this.cfg);
+        stored.token = result.access_token;
+        (0, config_1.saveConfig)(stored);
+        // Enrich the local config with identity (account + organization). Use the runtime apiUrl for the call.
+        this.api = new api_1.CliApi({ ...stored, apiUrl });
         const who = await this.api.get('/cli/v1/whoami');
         const account = who.data.account;
         const organization = who.data.organization;
         if (account)
-            this.cfg.account = { id: account.id, name: account.name, email: account.email };
+            stored.account = { id: account.id, name: account.name, email: account.email };
         if (organization) {
-            this.cfg.organization = { id: organization.id, name: organization.name, slug: organization.slug };
+            stored.organization = { id: organization.id, name: organization.name, slug: organization.slug };
         }
-        (0, config_1.saveConfig)(this.cfg);
+        (0, config_1.saveConfig)(stored);
         if (!this.jsonEnabled()) {
             this.log('');
-            this.log(`Logged in as ${this.cfg.account?.email ?? 'unknown'} · ${this.cfg.organization?.name ?? 'no organization'}`);
+            this.log(`Logged in as ${stored.account?.email ?? 'unknown'} · ${stored.organization?.name ?? 'no organization'}`);
         }
-        return { account: this.cfg.account, organization: this.cfg.organization, token: result.token };
+        return { account: stored.account, organization: stored.organization, token: result.token };
     }
 }
 exports.default = Login;

package/dist/lib/config.d.ts

@@ -14,7 +14,14 @@ export interface CliConfig {
 }
 export declare function configPath(): string;
 export declare function defaultApiUrl(): string;
+/**
+ * Config exactly as stored on disk, ignoring env overrides. This is the base for mutations that get
+ * re-saved (login, clearToken): a temporary CLOSEYOURIT_API_URL / CLOSEYOURIT_TOKEN must never be
+ * written back to config.json, otherwise a one-off override would silently become permanent.
+ */
+export declare function loadStoredConfig(): CliConfig;
+/** Runtime config: env overrides win over the stored values, symmetrically for apiUrl and token. */
 export declare function loadConfig(): CliConfig;
 export declare function saveConfig(cfg: CliConfig): void;
-/** Remove token + identity, keep apiUrl. */
+/** Remove token + identity, keep the on-disk apiUrl (never a temporary env override). */
 export declare function clearToken(): void;

package/dist/lib/config.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configPath = configPath;
 exports.defaultApiUrl = defaultApiUrl;
+exports.loadStoredConfig = loadStoredConfig;
 exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
 exports.clearToken = clearToken;
@@ -52,9 +53,16 @@ function configDir() {
 function configPath() {
     return path.join(configDir(), 'config.json');
 }
-function defaultApiUrl() {
+/**
+ * API URL from CLOSEYOURIT_API_URL env (overrides the stored config apiUrl), for pointing the CLI
+ * at another server on the fly — symmetric with envToken(), so URL and token behave the same way.
+ */
+function envApiUrl() {
     const fromEnv = process.env.CLOSEYOURIT_API_URL;
-    return fromEnv && fromEnv.trim() !== '' ? fromEnv : DEFAULT_API_URL;
+    return fromEnv && fromEnv.trim() !== '' ? fromEnv.trim() : undefined;
+}
+function defaultApiUrl() {
+    return envApiUrl() ?? DEFAULT_API_URL;
 }
 /**
  * Token from CLOSEYOURIT_TOKEN env, for headless/CI/agent use (overrides the stored config token).
@@ -65,7 +73,12 @@ function envToken() {
     const fromEnv = process.env.CLOSEYOURIT_TOKEN;
     return fromEnv && fromEnv.trim() !== '' ? fromEnv.trim() : undefined;
 }
-function loadConfig() {
+/**
+ * Config exactly as stored on disk, ignoring env overrides. This is the base for mutations that get
+ * re-saved (login, clearToken): a temporary CLOSEYOURIT_API_URL / CLOSEYOURIT_TOKEN must never be
+ * written back to config.json, otherwise a one-off override would silently become permanent.
+ */
+function loadStoredConfig() {
     const file = configPath();
     let parsed = {};
     try {
@@ -78,12 +91,21 @@ function loadConfig() {
         parsed = {};
     }
     return {
-        apiUrl: parsed.apiUrl && parsed.apiUrl.trim() !== '' ? parsed.apiUrl : defaultApiUrl(),
-        token: envToken() ?? parsed.token,
+        apiUrl: parsed.apiUrl && parsed.apiUrl.trim() !== '' ? parsed.apiUrl : DEFAULT_API_URL,
+        token: parsed.token,
         account: parsed.account,
         organization: parsed.organization,
     };
 }
+/** Runtime config: env overrides win over the stored values, symmetrically for apiUrl and token. */
+function loadConfig() {
+    const stored = loadStoredConfig();
+    return {
+        ...stored,
+        apiUrl: envApiUrl() ?? stored.apiUrl,
+        token: envToken() ?? stored.token,
+    };
+}
 function saveConfig(cfg) {
     const dir = configDir();
     fs.mkdirSync(dir, { recursive: true });
@@ -92,9 +114,9 @@ function saveConfig(cfg) {
     // Ensure perms even if the file pre-existed with a looser mode.
     fs.chmodSync(file, 0o600);
 }
-/** Remove token + identity, keep apiUrl. */
+/** Remove token + identity, keep the on-disk apiUrl (never a temporary env override). */
 function clearToken() {
-    const cfg = loadConfig();
+    const cfg = loadStoredConfig();
     delete cfg.token;
     delete cfg.account;
     delete cfg.organization;

package/dist/lib/opencli.d.ts

@@ -0,0 +1,107 @@
+/** Flag di un comando, così come lo espone `oclif.manifest.json`. */
+export interface OclifFlag {
+    name: string;
+    type: 'boolean' | 'option';
+    char?: string;
+    description?: string;
+    required?: boolean;
+    options?: string[];
+    hidden?: boolean;
+    helpGroup?: string;
+}
+/** Argomento posizionale di un comando, dal manifest oclif. */
+export interface OclifArg {
+    name: string;
+    description?: string;
+    required?: boolean;
+    options?: string[];
+    hidden?: boolean;
+}
+/** Comando risolto dal manifest oclif. */
+export interface OclifCommand {
+    id: string;
+    description?: string;
+    summary?: string;
+    aliases?: string[];
+    hidden?: boolean;
+    flags?: Record<string, OclifFlag>;
+    args?: Record<string, OclifArg>;
+    examples?: Array<string | {
+        command: string;
+        description?: string;
+    }>;
+}
+/** Il manifest oclif (`oclif.manifest.json`). */
+export interface OclifManifest {
+    version: string;
+    commands: Record<string, OclifCommand>;
+}
+export interface OpenCliArgument {
+    name: string;
+    required?: boolean;
+    description?: string;
+    acceptedValues?: string[];
+    hidden?: boolean;
+}
+export interface OpenCliOption {
+    name: string;
+    aliases?: string[];
+    description?: string;
+    required?: boolean;
+    recursive?: boolean;
+    hidden?: boolean;
+    arguments?: OpenCliArgument[];
+}
+export interface OpenCliExitCode {
+    code: number;
+    description?: string;
+}
+export interface OpenCliCommand {
+    name: string;
+    description?: string;
+    aliases?: string[];
+    hidden?: boolean;
+    options?: OpenCliOption[];
+    arguments?: OpenCliArgument[];
+    exitCodes?: OpenCliExitCode[];
+    examples?: string[];
+    commands?: OpenCliCommand[];
+}
+export interface OpenCliInfo {
+    title: string;
+    version: string;
+    summary?: string;
+    description?: string;
+    license?: {
+        name?: string;
+        identifier?: string;
+        url?: string;
+    };
+}
+export interface OpenCliDocument {
+    $schema: string;
+    opencli: string;
+    info: OpenCliInfo;
+    conventions: {
+        groupOptions: boolean;
+        optionSeparator: string;
+    };
+    command: OpenCliCommand;
+}
+export interface BuildOpenCliInput {
+    manifest: OclifManifest;
+    bin: string;
+    description?: string;
+    summary?: string;
+    license?: {
+        name?: string;
+        identifier?: string;
+        url?: string;
+    };
+    /** Descrizioni dei topic (contenitori senza comando proprio), indicizzate per id oclif. */
+    topics?: Record<string, {
+        description?: string;
+    }>;
+}
+/** Costruisce il documento OpenCLI completo dal manifest oclif e dai metadati di package.json. */
+export declare function buildOpenCliDocument(input: BuildOpenCliInput): OpenCliDocument;

package/dist/lib/opencli.js

@@ -0,0 +1,149 @@
+"use strict";
+// Genera un documento OpenCLI (https://opencli.org) a partire dal manifest oclif.
+//
+// Perché: `opencli.json` scritto a mano driftava — dichiarava una versione e un elenco di comandi
+// fermi a mesi prima. Qui la fonte è il manifest oclif, che è sempre allineato ai comandi reali,
+// così il file non può più restare indietro. La parte di I/O (leggere il manifest, scrivere il
+// file) vive in `scripts/generate-opencli.mjs`; qui c'è solo la trasformazione pura, testabile.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOpenCliDocument = buildOpenCliDocument;
+// Versione della specifica OpenCLI a cui il documento si conforma.
+const OPENCLI_VERSION = '0.1';
+const SCHEMA_URL = 'https://opencli.org/draft.json';
+// oclif separa i segmenti dell'id con ':' nel manifest (indipendentemente dal topicSeparator).
+const ID_SEPARATOR = ':';
+// Opzioni globali: iniettate da oclif su ogni comando, quindi dichiarate una volta sola sul
+// comando radice come `recursive`. Sono invarianti strutturali del runtime, non comandi che
+// driftano, perciò vivono qui come costante e non nel manifest.
+const GLOBAL_OPTIONS = [
+    { name: '--help', aliases: ['-h'], description: 'Show help.', recursive: true },
+    { name: '--version', aliases: ['-V'], description: 'Show CLI version.' },
+    { name: '--json', description: 'Format output as json.', recursive: true },
+];
+// Codici di uscita del CLI: convenzione stabile, condivisa da tutti i comandi.
+const EXIT_CODES = [
+    { code: 0, description: 'Success' },
+    { code: 1, description: 'Runtime or API error' },
+    { code: 2, description: 'Invalid usage (bad flags/arguments)' },
+];
+const upper = (name) => name.toUpperCase();
+const mapArgument = (arg) => {
+    const out = { name: upper(arg.name) };
+    if (arg.required)
+        out.required = true;
+    if (arg.description)
+        out.description = arg.description;
+    if (arg.options && arg.options.length > 0)
+        out.acceptedValues = arg.options;
+    if (arg.hidden)
+        out.hidden = true;
+    return out;
+};
+const mapFlag = (flag) => {
+    const out = { name: `--${flag.name}` };
+    if (flag.char)
+        out.aliases = [`-${flag.char}`];
+    if (flag.description)
+        out.description = flag.description;
+    if (flag.required)
+        out.required = true;
+    if (flag.hidden)
+        out.hidden = true;
+    if (flag.type === 'option') {
+        const argument = { name: upper(flag.name), required: true };
+        if (flag.options && flag.options.length > 0)
+            argument.acceptedValues = flag.options;
+        out.arguments = [argument];
+    }
+    return out;
+};
+const substituteBin = (text, bin) => text.replaceAll('<%= config.bin %>', bin);
+const mapExamples = (examples, bin) => {
+    if (!examples || examples.length === 0)
+        return undefined;
+    return examples.map((ex) => substituteBin(typeof ex === 'string' ? ex : ex.command, bin));
+};
+// Applica al nodo-comando i dati del suo comando oclif. Il flag globale --json (helpGroup GLOBAL)
+// non viene ripetuto: è già dichiarato ricorsivo sul comando radice.
+const applyCommand = (node, cmd, bin) => {
+    node.description = cmd.summary ?? cmd.description;
+    if (cmd.hidden)
+        node.hidden = true;
+    if (cmd.aliases && cmd.aliases.length > 0)
+        node.aliases = cmd.aliases;
+    const flags = Object.values(cmd.flags ?? {}).filter((f) => f.helpGroup !== 'GLOBAL');
+    if (flags.length > 0)
+        node.options = flags.map((f) => mapFlag(f));
+    const args = Object.values(cmd.args ?? {});
+    if (args.length > 0)
+        node.arguments = args.map((a) => mapArgument(a));
+    const examples = mapExamples(cmd.examples, bin);
+    if (examples)
+        node.examples = examples;
+};
+const buildTree = (manifest) => {
+    const root = { name: '', path: [], children: new Map() };
+    for (const id of Object.keys(manifest.commands)) {
+        const segments = id.split(ID_SEPARATOR);
+        let node = root;
+        const path = [];
+        for (const segment of segments) {
+            path.push(segment);
+            let child = node.children.get(segment);
+            if (!child) {
+                child = { name: segment, path: [...path], children: new Map() };
+                node.children.set(segment, child);
+            }
+            node = child;
+        }
+        node.command = manifest.commands[id];
+    }
+    return root;
+};
+const toOpenCliCommand = (node, bin, topics) => {
+    const out = { name: node.name };
+    if (node.command) {
+        applyCommand(out, node.command, bin);
+    }
+    else {
+        // Topic contenitore: nessun comando proprio, la descrizione arriva da package.json (se c'è).
+        const topic = topics[node.path.join(ID_SEPARATOR)];
+        if (topic?.description)
+            out.description = topic.description;
+    }
+    if (node.children.size > 0) {
+        out.commands = [...node.children.values()]
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((child) => toOpenCliCommand(child, bin, topics));
+    }
+    return out;
+};
+/** Costruisce il documento OpenCLI completo dal manifest oclif e dai metadati di package.json. */
+function buildOpenCliDocument(input) {
+    const { manifest, bin, topics = {} } = input;
+    const info = { title: bin, version: manifest.version };
+    if (input.summary)
+        info.summary = input.summary;
+    if (input.description)
+        info.description = input.description;
+    if (input.license && (input.license.name || input.license.identifier || input.license.url)) {
+        info.license = input.license;
+    }
+    const tree = buildTree(manifest);
+    const command = {
+        name: bin,
+        ...(input.description ? { description: input.description } : {}),
+        options: GLOBAL_OPTIONS,
+        exitCodes: EXIT_CODES,
+        commands: [...tree.children.values()]
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((child) => toOpenCliCommand(child, bin, topics)),
+    };
+    return {
+        $schema: SCHEMA_URL,
+        opencli: OPENCLI_VERSION,
+        info,
+        conventions: { groupOptions: true, optionSeparator: ' ' },
+        command,
+    };
+}