@corelayer-ai/cli 0.1.0

package/dist/commands/config.js

@@ -0,0 +1,48 @@
+import { readConfig, updateConfig } from "../lib/config.js";
+import { fail, printJson } from "../lib/output.js";
+export async function runConfig(args, ctx) {
+    const sub = args[0];
+    if (sub === "get") {
+        const key = args[1];
+        const config = readConfig();
+        if (!key) {
+            if (ctx.json) {
+                printJson(config);
+            }
+            else {
+                process.stdout.write(`${JSON.stringify(config, null, 2)}\n`);
+            }
+            return;
+        }
+        switch (key) {
+            case "api-url":
+                process.stdout.write(`${config.apiUrl}\n`);
+                return;
+            case "default-group":
+                process.stdout.write(`${config.defaults?.group || ""}\n`);
+                return;
+            default:
+                fail("Unknown key. Supported: api-url, default-group");
+        }
+    }
+    if (sub === "set") {
+        const key = args[1];
+        const value = args[2];
+        if (!key || !value) {
+            fail("Usage: corelayer config set <api-url|default-group> <value>");
+        }
+        switch (key) {
+            case "api-url":
+                updateConfig({ apiUrl: value });
+                process.stdout.write(`api-url set to ${value}\n`);
+                return;
+            case "default-group":
+                updateConfig({ defaults: { group: value } });
+                process.stdout.write(`default-group set to ${value}\n`);
+                return;
+            default:
+                fail("Unknown key. Supported: api-url, default-group");
+        }
+    }
+    fail("Usage: corelayer config <get|set> [key] [value]");
+}

package/dist/commands/groups.js

@@ -0,0 +1,27 @@
+import { CorelayerClient } from "../lib/api-client.js";
+import { readConfig } from "../lib/config.js";
+import { fail, formatDate, printJson, printTable } from "../lib/output.js";
+export async function runGroups(args, ctx) {
+    const sub = args[0];
+    if (sub !== "list") {
+        fail("Usage: corelayer groups list");
+    }
+    const config = readConfig();
+    const token = config.token;
+    if (!token) {
+        fail("Not logged in. Run: corelayer login");
+    }
+    const apiUrl = ctx.apiUrlOverride || config.apiUrl;
+    const client = new CorelayerClient(apiUrl, token);
+    const result = await client.listGroups();
+    if (ctx.json) {
+        printJson(result);
+        return;
+    }
+    const rows = result.groups.map(group => [
+        group.id,
+        group.name,
+        formatDate(group.created_at),
+    ]);
+    printTable(["ID", "NAME", "CREATED"], rows);
+}

package/dist/commands/integrations.js

@@ -0,0 +1,34 @@
+import { CorelayerClient } from "../lib/api-client.js";
+import { readConfig } from "../lib/config.js";
+import { fail, printJson, printTable } from "../lib/output.js";
+function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+export async function runIntegrations(args, ctx) {
+    const sub = args[0];
+    if (sub !== "list") {
+        fail("Usage: corelayer integrations list [--group <groupId>]");
+    }
+    const config = readConfig();
+    const token = config.token;
+    if (!token) {
+        fail("Not logged in. Run: corelayer login");
+    }
+    const groupId = readFlag(args, "--group") || config.defaults?.group;
+    const apiUrl = ctx.apiUrlOverride || config.apiUrl;
+    const client = new CorelayerClient(apiUrl, token);
+    const result = await client.listIntegrations(groupId);
+    if (ctx.json) {
+        printJson(result);
+        return;
+    }
+    const rows = result.accounts.map(account => [
+        account.id,
+        account.provider_code,
+        String(account.resources?.length || 0),
+    ]);
+    printTable(["ACCOUNT ID", "PROVIDER", "RESOURCES"], rows);
+}

package/dist/commands/issues.js

@@ -0,0 +1,166 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { CorelayerClient } from "../lib/api-client.js";
+import { readConfig } from "../lib/config.js";
+import { fail, formatDate, printJson, printTable } from "../lib/output.js";
+function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+function removeFlags(args) {
+    const out = [];
+    let skipNext = false;
+    for (const arg of args) {
+        if (skipNext) {
+            skipNext = false;
+            continue;
+        }
+        if (arg === "--group" ||
+            arg === "--status" ||
+            arg === "--severity" ||
+            arg === "--limit" ||
+            arg === "--page" ||
+            arg === "--feedback") {
+            skipNext = true;
+            continue;
+        }
+        if (arg === "--yes") {
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+async function confirmDelete() {
+    if (!process.stdin.isTTY) {
+        fail("Cannot confirm in non-interactive mode. Use --yes to skip confirmation.");
+    }
+    const rl = createInterface({ input, output });
+    const answer = await rl.question("Are you sure you want to delete this issue? (y/N) ");
+    rl.close();
+    return answer.trim().toLowerCase() === "y";
+}
+export async function runIssues(args, ctx) {
+    const sub = args[0];
+    const config = readConfig();
+    const token = config.token;
+    if (!token) {
+        fail("Not logged in. Run: corelayer login");
+    }
+    const apiUrl = ctx.apiUrlOverride || config.apiUrl;
+    const client = new CorelayerClient(apiUrl, token);
+    const commandArgs = removeFlags(args.slice(1));
+    if (sub === "list") {
+        const groupId = readFlag(args, "--group") || config.defaults?.group;
+        if (!groupId) {
+            fail("groupId is required. Use --group <groupId> or set default-group via corelayer config set default-group <groupId>");
+        }
+        const result = await client.listIssues(groupId, {
+            status: readFlag(args, "--status"),
+            severity: readFlag(args, "--severity"),
+            limit: readFlag(args, "--limit"),
+            page: readFlag(args, "--page"),
+        });
+        if (ctx.json) {
+            printJson(result);
+            return;
+        }
+        const rows = result.issues.map(issue => [
+            issue.id,
+            issue.slug || "-",
+            issue.severity || "-",
+            issue.status || "-",
+            issue.title || "-",
+            formatDate(issue.last_seen_at || issue.lastSeenAt),
+        ]);
+        printTable(["ID", "SLUG", "SEVERITY", "STATUS", "TITLE", "LAST SEEN"], rows);
+        if (!ctx.quiet) {
+            process.stdout.write(`Showing ${result.issues.length} of ${result.total} issues\n`);
+        }
+        return;
+    }
+    if (sub === "get") {
+        const issueId = commandArgs[0];
+        if (!issueId) {
+            fail("Usage: corelayer issues get <issueId>");
+        }
+        const issue = await client.getIssue(issueId);
+        if (ctx.json) {
+            printJson(issue);
+            return;
+        }
+        process.stdout.write(`Issue ${issue.slug || issue.id}: ${issue.title || ""}\n`);
+        process.stdout.write(`Status: ${issue.status || "-"}\n`);
+        process.stdout.write(`Severity: ${issue.severity || "-"}\n`);
+        process.stdout.write(`Created: ${formatDate(issue.createdAt || issue.created_at)}\n`);
+        process.stdout.write(`Last seen: ${formatDate(issue.lastSeenAt || issue.last_seen_at)}\n`);
+        process.stdout.write(`Events: ${issue.event_count || 0}\n`);
+        if (issue.whatHappened) {
+            process.stdout.write(`\nWhat happened:\n${issue.whatHappened}\n`);
+        }
+        if (issue.rootCause) {
+            process.stdout.write(`\nRoot cause:\n${issue.rootCause}\n`);
+        }
+        if (issue.nextSteps) {
+            process.stdout.write(`\nNext steps:\n${issue.nextSteps}\n`);
+        }
+        return;
+    }
+    if (sub === "close") {
+        const issueId = commandArgs[0];
+        if (!issueId) {
+            fail('Usage: corelayer issues close <issueId> [--feedback "..."]');
+        }
+        const feedback = readFlag(args, "--feedback");
+        await client.closeIssue(issueId, feedback);
+        if (!ctx.quiet) {
+            process.stdout.write(`Issue ${issueId} closed.\n`);
+        }
+        return;
+    }
+    if (sub === "reopen") {
+        const issueId = commandArgs[0];
+        if (!issueId) {
+            fail("Usage: corelayer issues reopen <issueId>");
+        }
+        await client.reopenIssue(issueId);
+        if (!ctx.quiet) {
+            process.stdout.write(`Issue ${issueId} reopened.\n`);
+        }
+        return;
+    }
+    if (sub === "delete") {
+        const issueId = commandArgs[0];
+        if (!issueId) {
+            fail("Usage: corelayer issues delete <issueId> [--yes]");
+        }
+        const yes = hasFlag(args, "--yes");
+        if (!yes) {
+            const confirmed = await confirmDelete();
+            if (!confirmed) {
+                process.stdout.write("Aborted.\n");
+                return;
+            }
+        }
+        await client.deleteIssue(issueId);
+        if (!ctx.quiet) {
+            process.stdout.write(`Issue ${issueId} deleted.\n`);
+        }
+        return;
+    }
+    if (sub === "summary") {
+        const groupId = readFlag(args, "--group") || config.defaults?.group;
+        if (!groupId) {
+            fail("groupId is required. Use --group <groupId> or set default-group via corelayer config set default-group <groupId>");
+        }
+        const summary = await client.getIssueSummary(groupId);
+        printJson(summary);
+        return;
+    }
+    fail("Usage: corelayer issues <list|get|close|reopen|delete|summary> [options]");
+}

package/dist/commands/login.js

@@ -0,0 +1,36 @@
+import { loginWithBrowser, loginWithCodeDirect } from "../lib/auth.js";
+import { fail } from "../lib/output.js";
+function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+export async function runLogin(args, ctx) {
+    const code = readFlag(args, "--code");
+    let email;
+    let orgName;
+    if (code) {
+        const result = await loginWithCodeDirect(code, ctx.apiUrlOverride);
+        email = result.email;
+        orgName = result.orgName;
+    }
+    else {
+        if (ctx.apiUrlOverride) {
+            process.stderr.write("Warning: --api-url is ignored for browser login. The server URL is determined by the auth server.\n");
+        }
+        try {
+            const result = await loginWithBrowser();
+            email = result.email;
+            orgName = result.orgName;
+        }
+        catch (err) {
+            fail(err instanceof Error
+                ? err.message
+                : "Login failed. Try: corelayer login --code <AUTH_CODE> --api-url <server-url>");
+        }
+    }
+    if (!ctx.quiet) {
+        process.stdout.write(`Logged in as ${email} (org: ${orgName})\n`);
+    }
+}

package/dist/commands/logout.js

@@ -0,0 +1,7 @@
+import { clearToken } from "../lib/config.js";
+export async function runLogout(_args, ctx) {
+    clearToken();
+    if (!ctx.quiet) {
+        process.stdout.write("Logged out.\n");
+    }
+}

package/dist/index.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { runConfig } from "./commands/config.js";
+import { runGroups } from "./commands/groups.js";
+import { runIntegrations } from "./commands/integrations.js";
+import { runIssues } from "./commands/issues.js";
+import { runLogin } from "./commands/login.js";
+import { runLogout } from "./commands/logout.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+function printHelp() {
+    process.stdout.write(`Corelayer CLI
+
+Usage:
+  corelayer login                              (opens browser)
+  corelayer login --code <CODE> --api-url <url> (manual)
+  corelayer logout
+  corelayer issues <list|get|close|reopen|delete|summary> ...
+  corelayer groups list
+  corelayer integrations list [--group <groupId>]
+  corelayer config <get|set> ...
+
+Global flags:
+  --json
+  --quiet, -q
+  --api-url <url>
+  --no-color
+`);
+}
+function parseGlobalFlags(argv) {
+    const ctx = {
+        json: false,
+        quiet: false,
+        noColor: false,
+    };
+    const args = [];
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            ctx.json = true;
+            i += 1;
+            continue;
+        }
+        if (arg === "--quiet" || arg === "-q") {
+            ctx.quiet = true;
+            i += 1;
+            continue;
+        }
+        if (arg === "--no-color") {
+            ctx.noColor = true;
+            i += 1;
+            continue;
+        }
+        if (arg === "--api-url") {
+            const val = argv[i + 1];
+            if (!val || val.startsWith("--")) {
+                process.stderr.write("Missing value for --api-url\n");
+                process.exit(1);
+            }
+            ctx.apiUrlOverride = val;
+            i += 2;
+            continue;
+        }
+        args.push(arg);
+        i += 1;
+    }
+    return { args, ctx };
+}
+async function main() {
+    const parsed = parseGlobalFlags(process.argv.slice(2));
+    const { args, ctx } = parsed;
+    const command = args[0];
+    const rest = args.slice(1);
+    if (command === "--version" || command === "-v") {
+        process.stdout.write(`${version}\n`);
+        return;
+    }
+    if (!command ||
+        command === "help" ||
+        command === "--help" ||
+        command === "-h") {
+        printHelp();
+        return;
+    }
+    switch (command) {
+        case "login":
+            await runLogin(rest, ctx);
+            return;
+        case "logout":
+            await runLogout(rest, ctx);
+            return;
+        case "issues":
+            await runIssues(rest, ctx);
+            return;
+        case "groups":
+            await runGroups(rest, ctx);
+            return;
+        case "integrations":
+            await runIntegrations(rest, ctx);
+            return;
+        case "config":
+            await runConfig(rest, ctx);
+            return;
+        default:
+            process.stderr.write(`Unknown command: ${command}\n`);
+            printHelp();
+            process.exit(1);
+    }
+}
+main().catch(error => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/lib/api-client.js

@@ -0,0 +1,118 @@
+async function parseError(res) {
+    let body = null;
+    try {
+        body = (await res.json());
+    }
+    catch {
+        body = null;
+    }
+    return (body?.error ||
+        body?.message ||
+        `${res.status} ${res.statusText || "Request failed"}`);
+}
+export class CorelayerClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    async request(method, path, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 30_000);
+        let res;
+        try {
+            res = await fetch(`${this.baseUrl}${path}`, {
+                method,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.token}`,
+                },
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            clearTimeout(timer);
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new Error("Request timed out");
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!res.ok) {
+            throw new Error(await parseError(res));
+        }
+        return (await res.json());
+    }
+    async listIssues(groupId, filters) {
+        const params = new URLSearchParams({ groupId });
+        for (const [key, value] of Object.entries(filters)) {
+            if (value !== undefined && value !== null && value !== "") {
+                params.set(key, String(value));
+            }
+        }
+        return this.request("GET", `/api/v1/issues?${params.toString()}`);
+    }
+    async getIssue(issueId) {
+        return this.request("GET", `/api/v1/issues/${issueId}`);
+    }
+    async closeIssue(issueId, feedback) {
+        await this.request("PATCH", `/api/v1/issues/${issueId}`, {
+            status: "Closed",
+            feedback,
+        });
+    }
+    async reopenIssue(issueId) {
+        await this.request("PATCH", `/api/v1/issues/${issueId}`, {
+            status: "Open",
+        });
+    }
+    async deleteIssue(issueId) {
+        await this.request("DELETE", `/api/v1/issues/${issueId}`);
+    }
+    async getIssueSummary(groupId) {
+        const params = new URLSearchParams({ groupId });
+        return this.request("GET", `/api/v1/issues/summary?${params.toString()}`);
+    }
+    async listGroups() {
+        return this.request("GET", "/api/v1/groups");
+    }
+    async listIntegrations(groupId) {
+        const params = new URLSearchParams();
+        if (groupId) {
+            params.set("groupId", groupId);
+        }
+        const suffix = params.toString() ? `?${params.toString()}` : "";
+        return this.request("GET", `/api/v1/integrations/accounts${suffix}`);
+    }
+}
+export async function exchangeCliCode(baseUrl, code) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30_000);
+    let res;
+    try {
+        res = await fetch(`${baseUrl}/api/v1/cli/exchange`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code }),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new Error("Request timed out");
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!res.ok) {
+        throw new Error(await parseError(res));
+    }
+    return (await res.json());
+}

package/dist/lib/auth.js

@@ -0,0 +1,164 @@
+import http from "node:http";
+import crypto from "node:crypto";
+import { execFile } from "node:child_process";
+import { exchangeCliCode } from "./api-client.js";
+import { readConfig, updateConfig } from "./config.js";
+const AUTH_BASE_URL = process.env.CORELAYER_AUTH_URL || "https://app.corelayer.com";
+export async function loginWithCode(code, serverUrl) {
+    const exchanged = await exchangeCliCode(serverUrl, code);
+    updateConfig({
+        apiUrl: serverUrl,
+        token: exchanged.token,
+        orgId: exchanged.orgId,
+        orgName: exchanged.orgName,
+        userEmail: exchanged.email,
+    });
+    return {
+        email: exchanged.email,
+        orgName: exchanged.orgName,
+    };
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    if (platform === "win32") {
+        execFile("cmd", ["/c", "start", "", url]);
+    }
+    else {
+        const cmd = platform === "darwin" ? "open" : "xdg-open";
+        execFile(cmd, [url]);
+    }
+}
+function findAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer();
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                server.close();
+                reject(new Error("Failed to bind to a port"));
+                return;
+            }
+            const port = addr.port;
+            server.close(() => resolve(port));
+        });
+        server.on("error", reject);
+    });
+}
+function startCallbackServer(port, state, timeout) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new Error("Login timed out. Please try again."));
+        }, timeout);
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+            if (url.pathname !== "/callback") {
+                res.writeHead(404);
+                res.end("Not found");
+                return;
+            }
+            const receivedState = url.searchParams.get("state");
+            const code = url.searchParams.get("code");
+            const serverUrl = url.searchParams.get("server_url");
+            const error = url.searchParams.get("error");
+            if (error) {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(htmlPage("Login Failed", `Error: ${escapeHtml(error)}. You can close this tab.`));
+                clearTimeout(timer);
+                server.close();
+                reject(new Error(error));
+                return;
+            }
+            if (receivedState !== state) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(htmlPage("Login Failed", "State mismatch. You can close this tab."));
+                clearTimeout(timer);
+                server.close();
+                reject(new Error("State mismatch — possible CSRF attack."));
+                return;
+            }
+            if (!code || !serverUrl) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(htmlPage("Login Failed", "Missing code or server URL. You can close this tab."));
+                clearTimeout(timer);
+                server.close();
+                reject(new Error("Callback missing required parameters."));
+                return;
+            }
+            const decodedServerUrl = decodeURIComponent(serverUrl);
+            let parsed;
+            try {
+                parsed = new URL(decodedServerUrl);
+            }
+            catch {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(htmlPage("Login Failed", "Invalid server URL. You can close this tab."));
+                clearTimeout(timer);
+                server.close();
+                reject(new Error("Invalid server URL received in callback."));
+                return;
+            }
+            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(htmlPage("Login Failed", "Unsupported server URL protocol. You can close this tab."));
+                clearTimeout(timer);
+                server.close();
+                reject(new Error(`Unsupported protocol "${parsed.protocol}" — only http: and https: are allowed.`));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(htmlPage("Login Successful", "You are now logged in. You can close this tab and return to the terminal."));
+            clearTimeout(timer);
+            server.close();
+            resolve({ code, serverUrl: decodedServerUrl });
+        });
+        server.listen(port, "127.0.0.1");
+        server.on("error", err => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function htmlPage(title, body) {
+    return `<!DOCTYPE html>
+<html>
+<head><title>${title}</title>
+<style>body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#f8f9fa}
+.card{text-align:center;padding:2rem;border-radius:8px;background:white;box-shadow:0 1px 3px rgba(0,0,0,.1)}
+h1{margin:0 0 .5rem;font-size:1.5rem}p{color:#6b7280;margin:0}</style>
+</head>
+<body><div class="card"><h1>${title}</h1><p>${body}</p></div></body>
+</html>`;
+}
+export async function loginWithBrowser() {
+    const port = await findAvailablePort();
+    const state = crypto.randomBytes(16).toString("hex");
+    const authUrl = `${AUTH_BASE_URL}/cli/auth?port=${port}&state=${state}`;
+    process.stdout.write("Opening browser for authentication...\n");
+    process.stdout.write(`If the browser doesn't open, visit:\n${authUrl}\n\n`);
+    process.stdout.write("Waiting for authorization...\n");
+    openBrowser(authUrl);
+    const { code, serverUrl } = await startCallbackServer(port, state, 120_000);
+    const result = await loginWithCode(code, serverUrl);
+    return result;
+}
+function validateServerUrl(url) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`Unsupported protocol "${parsed.protocol}" — only http: and https: are allowed.`);
+    }
+}
+export async function loginWithCodeDirect(code, apiUrlOverride) {
+    const current = readConfig();
+    const serverUrl = apiUrlOverride || current.apiUrl;
+    validateServerUrl(serverUrl);
+    return loginWithCode(code, serverUrl);
+}

package/dist/lib/config.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const CONFIG_DIR = path.join(os.homedir(), ".corelayer");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+function defaultApiUrl() {
+    return process.env.CORELAYER_API_URL || "http://localhost:3000";
+}
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+export function readConfig() {
+    if (!fs.existsSync(CONFIG_PATH)) {
+        return { apiUrl: defaultApiUrl(), defaults: {} };
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_PATH, "utf8");
+        const parsed = JSON.parse(content);
+        return {
+            apiUrl: parsed.apiUrl || defaultApiUrl(),
+            token: parsed.token,
+            orgId: parsed.orgId,
+            orgName: parsed.orgName,
+            userEmail: parsed.userEmail,
+            defaults: parsed.defaults || {},
+        };
+    }
+    catch {
+        return { apiUrl: defaultApiUrl(), defaults: {} };
+    }
+}
+export function writeConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+}
+export function updateConfig(partial) {
+    const current = readConfig();
+    const merged = {
+        ...current,
+        ...partial,
+        defaults: {
+            ...(current.defaults || {}),
+            ...(partial.defaults || {}),
+        },
+    };
+    writeConfig(merged);
+    return merged;
+}
+export function clearToken() {
+    const current = readConfig();
+    delete current.token;
+    delete current.orgId;
+    delete current.orgName;
+    delete current.userEmail;
+    writeConfig(current);
+}

package/dist/lib/output.js

@@ -0,0 +1,31 @@
+export function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export function formatDate(value) {
+    if (!value)
+        return "-";
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return value;
+    }
+    return date.toISOString().replace("T", " ").slice(0, 19);
+}
+export function printTable(headers, rows) {
+    const widths = headers.map((header, idx) => Math.max(header.length, ...rows.map(row => (row[idx] || "").length)));
+    const renderRow = (cells) => cells
+        .map((cell, idx) => cell.padEnd(widths[idx], " "))
+        .join("  ")
+        .trimEnd();
+    process.stdout.write(`${renderRow(headers)}\n`);
+    process.stdout.write(`${widths
+        .map(width => "-".repeat(width))
+        .join("  ")
+        .trimEnd()}\n`);
+    for (const row of rows) {
+        process.stdout.write(`${renderRow(row)}\n`);
+    }
+}
+export function fail(message, code = 1) {
+    process.stderr.write(`${message}\n`);
+    process.exit(code);
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@corelayer-ai/cli",
+  "version": "0.1.0",
+  "description": "Corelayer CLI",
+  "type": "module",
+  "bin": {
+    "corelayer": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.17.57",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  }
+}