@corelayer-ai/cli 0.5.1 → 0.5.3

package/README.md

@@ -0,0 +1,3 @@
+# Corelayer CLI
+
+Source and packaging for the `@corelayer-ai/cli` command-line client. Provides authentication, production issue investigation and actions, organization memory queries, schedules, preflight checks, and MCP integration. The `skill/` folder contains the agent instructions distributed with the CLI.

package/dist/commands/anomalies.js

@@ -0,0 +1,76 @@
+import { CorelayerClient } from "../lib/api-client.js";
+import { readFlag } from "../lib/args.js";
+import { readConfig, resolveApiUrl, resolveToken } from "../lib/config.js";
+import { fail, printJson, printTable } from "../lib/output.js";
+function printHelp() {
+    process.stdout
+        .write(`corelayer anomalies - Inspect configured anomaly monitors
+
+USAGE:
+  corelayer anomalies <subcommand> [options]
+
+SUBCOMMANDS:
+  list                  List anomaly monitors for a group
+  get <configId>        Get one anomaly monitor
+
+OPTIONS:
+  --group <id>          Group ID (or set default-group via 'corelayer config set')
+  --limit <n>           Maximum results (default: 20, max: 100)
+  --offset <n>          Results to skip (default: 0)
+  --json                Output as JSON
+
+EXAMPLES:
+  corelayer anomalies list --group g_123
+  corelayer anomalies list --json
+  corelayer anomalies get 550e8400-e29b-41d4-a716-446655440000
+`);
+}
+export async function runAnomalies(args, ctx) {
+    if (args.includes("--help") || args.includes("-h")) {
+        printHelp();
+        return;
+    }
+    const token = resolveToken();
+    if (!token) {
+        fail("Not authenticated. Set CORELAYER_API_KEY or run: corelayer login");
+    }
+    const client = new CorelayerClient(resolveApiUrl(ctx.apiUrlOverride), token);
+    if (args[0] === "get") {
+        const configId = args[1];
+        if (!configId)
+            fail("Usage: corelayer anomalies get <configId>");
+        const config = await client.anomalies.get(configId);
+        if (ctx.json)
+            return printJson(config);
+        printTable(["ID", "METRIC", "RESOURCE ID", "FREQUENCY", "TIME COLUMN"], [
+            [
+                config.id,
+                config.metric_name || "-",
+                config.resource_id,
+                config.frequency || "-",
+                config.time_column,
+            ],
+        ]);
+        return;
+    }
+    if (args[0] !== "list") {
+        fail("Usage: corelayer anomalies <list|get> [options]");
+    }
+    const groupId = readFlag(args, "--group") || readConfig().defaults?.group;
+    if (!groupId) {
+        fail("Group ID required. Use --group <id> or: corelayer config set default-group <id>");
+    }
+    const limit = Math.min(Math.max(Number.parseInt(readFlag(args, "--limit") || "20", 10) || 20, 1), 100);
+    const offset = Math.max(Number.parseInt(readFlag(args, "--offset") || "0", 10) || 0, 0);
+    const result = await client.anomalies.listOffset(groupId, limit, offset);
+    if (ctx.json)
+        return printJson(result);
+    printTable(["ID", "METRIC", "RESOURCE ID", "FREQUENCY", "PARTITIONS"], result.configs.map((config) => [
+        config.id,
+        config.metric_name || "-",
+        config.resource_id,
+        config.frequency || "-",
+        config.partition_columns.join(", ") || "-",
+    ]));
+    process.stdout.write(`Showing ${result.configs.length} of ${result.total} anomaly monitors\n`);
+}

package/dist/commands/api-keys.js

@@ -1,12 +1,7 @@
 import { CorelayerClient } from "../lib/api-client.js";
+import { readFlag } from "../lib/args.js";
 import { resolveApiUrl, resolveToken } from "../lib/config.js";
 import { fail, printJson } from "../lib/output.js";
-function readFlag(args, flag) {
-    const index = args.indexOf(flag);
-    if (index === -1)
-        return undefined;
-    return args[index + 1];
-}
 function printHelp() {
     process.stdout.write(`corelayer api-keys - Manage Corelayer API keys
 

package/dist/commands/config.js

@@ -34,11 +34,12 @@ export async function runConfig(args, ctx) {
         const key = args[1];
         const config = readConfig();
         if (!key) {
+            const { token: _token, ...publicConfig } = config;
             if (ctx.json) {
-                printJson(config);
+                printJson(publicConfig);
             }
             else {
-                process.stdout.write(`${JSON.stringify(config, null, 2)}\n`);
+                process.stdout.write(`${JSON.stringify(publicConfig, null, 2)}\n`);
             }
             return;
         }

package/dist/commands/integrations.js

@@ -1,12 +1,7 @@
 import { CorelayerClient } from "../lib/api-client.js";
-import { readConfig, resolveToken, resolveApiUrl } from "../lib/config.js";
+import { readFlag } from "../lib/args.js";
+import { readConfig, resolveApiUrl, resolveToken } 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];
-}
 function printHelp() {
     process.stdout.write(`corelayer integrations - List integrations for a group
 
@@ -48,7 +43,7 @@ export async function runIntegrations(args, ctx) {
         printJson(result);
         return;
     }
-    const rows = result.accounts.map(account => [
+    const rows = result.accounts.map((account) => [
         account.id,
         account.provider_code,
         String(account.resources?.length || 0),

package/dist/commands/issue-tickets.js

@@ -0,0 +1,163 @@
+import { randomUUID } from "node:crypto";
+import { readFlag } from "../lib/args.js";
+import { fail, printJson } from "../lib/output.js";
+function ticketInput(args, config) {
+    const provider = readFlag(args, "--provider");
+    if (provider !== "jira" && provider !== "linear")
+        fail("--provider jira|linear is required.");
+    const groupId = readFlag(args, "--group") || config.defaults?.group;
+    if (!groupId)
+        fail("--group is required (or configure default-group).");
+    const input = { groupId, provider };
+    for (const [flag, key] of [
+        ["--account", "accountId"],
+        ["--project", "projectId"],
+        ["--team", "teamId"],
+        ["--type", "issueTypeId"],
+        ["--query", "query"],
+        ["--ticket", "ticketId"],
+    ]) {
+        const value = readFlag(args, flag);
+        if (value)
+            input[key] = value;
+    }
+    const revision = readFlag(args, "--revision");
+    if (revision) {
+        const value = Number(revision);
+        if (!Number.isSafeInteger(value) || value < 1)
+            fail("--revision must be a positive integer from ticket destinations.");
+        input.expectedRevision = value;
+    }
+    const fields = readFlag(args, "--fields");
+    if (fields) {
+        try {
+            const parsed = JSON.parse(fields);
+            if (!parsed || Array.isArray(parsed) || typeof parsed !== "object")
+                fail("--fields must be a JSON object.");
+            input.fields = parsed;
+        }
+        catch {
+            fail("--fields must be a JSON object.");
+        }
+    }
+    return input;
+}
+function ticketIdentity(args, mutating) {
+    const suppliedId = readFlag(args, "--request-id");
+    const requestId = suppliedId || (mutating ? randomUUID() : undefined);
+    if ((mutating || suppliedId !== undefined) &&
+        (!requestId ||
+            !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(requestId)))
+        fail("A valid --request-id UUID is required.");
+    return requestId;
+}
+function mutationInput(action, input, requestId) {
+    if (!input.accountId)
+        fail("--account is required; use ticket destinations to discover accounts.");
+    if (action === "link" && !input.ticketId)
+        fail("--ticket is required for link.");
+    input.requestId = requestId;
+    input.intent =
+        action === "create"
+            ? "create_new"
+            : action === "link"
+                ? "link_existing"
+                : "find_or_create";
+    process.stderr.write(`Ticket request: ${requestId}\n`);
+}
+function interruptedRequest(error) {
+    return (error instanceof Error &&
+        (/timed out|fetch failed|socket|network/i.test(error.message) ||
+            ("status" in error &&
+                typeof error.status === "number" &&
+                error.status >= 500)));
+}
+function resultExitCode(status) {
+    const codes = {
+        needs_input: 2,
+        pending: 3,
+        in_progress: 3,
+        recovery_required: 4,
+        blocked: 4,
+        stale_request: 2,
+        failed: 1,
+        error: 1,
+    };
+    return typeof status === "string" ? codes[status] || 0 : 0;
+}
+function shellArgument(value) {
+    return `'${String(value).replaceAll("'", "'\"'\"'")}'`;
+}
+function resumeFlags(input, requestId) {
+    const flags = [
+        ["groupId", "--group"],
+        ["provider", "--provider"],
+        ["accountId", "--account"],
+        ["projectId", "--project"],
+        ["teamId", "--team"],
+        ["issueTypeId", "--type"],
+        ["expectedRevision", "--revision"],
+    ];
+    const values = flags
+        .filter(([key]) => input[key] !== undefined)
+        .map(([key, flag]) => `${flag} ${shellArgument(input[key])}`);
+    if (input.fields)
+        values.push(`--fields ${shellArgument(JSON.stringify(input.fields))}`);
+    values.push(`--request-id ${shellArgument(requestId)}`);
+    return values.join(" ");
+}
+function humanTicketResult(result, issueId, input, requestId) {
+    const lines = [
+        String(result.message || result.status || JSON.stringify(result, null, 2)),
+    ];
+    const candidates = Array.isArray(result.candidates)
+        ? result.candidates.filter((candidate) => candidate !== null && typeof candidate === "object")
+        : [];
+    for (const [index, candidate] of candidates.entries()) {
+        lines.push(`${index + 1}. ${candidate.identifier || candidate.id}: ${candidate.title || ""}${candidate.evidence ? ` — ${candidate.evidence}` : ""}`);
+        if (candidate.url)
+            lines.push(`   ${candidate.url}`);
+    }
+    const resumeId = typeof result.requestId === "string" ? result.requestId : requestId;
+    if (result.status === "needs_input" && resumeId) {
+        const flags = resumeFlags(input, resumeId);
+        const firstTicket = candidates[0]?.id;
+        if (firstTicket)
+            lines.push(`Link an existing ticket: corelayer issues ticket link ${shellArgument(issueId)} ${flags} --ticket ${shellArgument(firstTicket)}`);
+        lines.push(`Create a new ticket: corelayer issues ticket create ${shellArgument(issueId)} ${flags}`);
+        if (result.requirements)
+            lines.push(`Required ticket details: ${JSON.stringify(result.requirements, null, 2)}`);
+    }
+    return lines.join("\n");
+}
+export async function runIssueTickets(args, client, config, ctx) {
+    const [action, issueId] = args;
+    if (!issueId ||
+        !["destinations", "search", "ensure", "create", "link", "status"].includes(action))
+        fail("Usage: corelayer issues ticket <destinations|search|ensure|create|link|status> <id|slug> --provider jira|linear --group <id>");
+    const input = ticketInput(args, config);
+    const mutating = ["ensure", "create", "link"].includes(action);
+    const requestId = ticketIdentity(args, mutating);
+    if (mutating)
+        mutationInput(action, input, requestId);
+    const suffixes = {
+        destinations: "/destinations",
+        search: "/search",
+        status: `/requests/${encodeURIComponent(requestId || "current")}`,
+    };
+    let result;
+    try {
+        result = await client.ticketRequest(mutating || action === "search" ? "POST" : "GET", issueId, suffixes[action] || "", input);
+    }
+    catch (error) {
+        if (!mutating || !interruptedRequest(error))
+            throw error;
+        process.stderr.write("Response interrupted; checking the same ticket request.\n");
+        result = await client.ticketRequest("GET", issueId, `/requests/${encodeURIComponent(requestId)}`, { groupId: input.groupId, provider: input.provider });
+    }
+    if (ctx.json)
+        printJson(result);
+    else
+        process.stdout.write(`${humanTicketResult(result, issueId, input, requestId)}\n`);
+    process.exitCode = resultExitCode(result.status);
+}