@ornncompute/cli 0.2.18 → 0.2.20

package/src/color.mjs

@@ -0,0 +1,71 @@
+// SGR open/close pairs for the four styles the CLI uses.
+const CODES = { red: [31, 39], green: [32, 39], bold: [1, 22], dim: [2, 22] };
+
+function createColors(enabled) {
+  return Object.fromEntries(
+    Object.entries(CODES).map(([name, [open, close]]) => [
+      name,
+      enabled ? (text) => `\x1b[${open}m${text}\x1b[${close}m` : (text) => text,
+    ])
+  );
+}
+
+const NO_COLOR_FLAG = "--no-color";
+
+// Structured-error label prefixes that get dim/bold styling. Matched at the
+// start of a line; the remainder of the line (the value) is left untouched.
+const LABEL_PREFIX_RE = /^(Code|Reason|Next steps?):/;
+
+// `--no-color` is global: strip it anywhere in argv so per-command parsing
+// never sees it as an unknown option.
+export function extractNoColorFlag(argv) {
+  return {
+    argv: argv.filter((arg) => arg !== NO_COLOR_FLAG),
+    noColor: argv.includes(NO_COLOR_FLAG),
+  };
+}
+
+function streamSupportsColor(stream, env, noColorFlag) {
+  if (noColorFlag || Object.hasOwn(env ?? {}, "NO_COLOR")) {
+    return false;
+  }
+  if (Object.hasOwn(env ?? {}, "FORCE_COLOR")) {
+    return String(env.FORCE_COLOR) !== "0";
+  }
+  return Boolean(stream.isTTY);
+}
+
+// stdout and stderr are evaluated independently: one can be a TTY while the
+// other is piped.
+export function attachStreamColors({ env, noColorFlag, stdout, stderr }) {
+  stdout.pc = createColors(streamSupportsColor(stdout, env, noColorFlag));
+  stderr.pc = createColors(streamSupportsColor(stderr, env, noColorFlag));
+}
+
+export function writeColored(stream, variant, text) {
+  const colorize = stream.pc?.[variant];
+  stream.write(`${colorize ? colorize(text) : text}\n`);
+}
+
+// First line is the error summary (red); later `Code:`/`Reason:`/`Next step:`
+// label prefixes are dim/bold, their values left plain.
+export function colorizeErrorMessage(message, stream) {
+  const pc = stream?.pc;
+  if (!pc) {
+    return message;
+  }
+  return message
+    .split("\n")
+    .map((line, index) => {
+      if (index === 0) {
+        return line ? pc.red(line) : line;
+      }
+      const match = line.match(LABEL_PREFIX_RE);
+      if (!match) {
+        return line;
+      }
+      const label = match[0];
+      return `${pc.bold(pc.dim(label))}${line.slice(label.length)}`;
+    })
+    .join("\n");
+}

package/vendor/capabilities/capabilities/listings.d.ts

@@ -44,6 +44,7 @@ export declare const listingCreateInput: z.ZodObject<{
 }, z.core.$strip>;
 export declare const listCatalogTermsCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const listListingsCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const forecastListingsCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const createListingCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const listingCapabilities: import("../capability.ts").Capability<unknown, unknown>[];
 /** @deprecated Use createListingCapability. */

package/vendor/capabilities/capabilities/listings.js

@@ -1,6 +1,14 @@
 import { z } from "zod";
 import { defineCapability, preview } from "../capability.js";
 import { bindHardwareFields, HARDWARE_LISTING_FIELDS, HARDWARE_LISTING_FILTERS, loadHardwareCatalog, projectCatalogTerms, } from "../spec-catalog.js";
+function queryPath(path, params) {
+    const parts = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (value?.trim())
+            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value.trim())}`);
+    }
+    return parts.length ? `${path}?${parts.join("&")}` : path;
+}
 export const listingCreateInput = z.object({
     operatorId: z.string().optional(),
     operator_id: z.string().optional(),
@@ -46,6 +54,10 @@ export const listingCreateInput = z.object({
     confirm: z.boolean().optional(),
 });
 const catalogTermsInput = z.object({ kind: z.enum(["gpu", "cpu", "node", "link"]).optional() });
+const listingForecastInput = z.object({
+    limit: z.number().int().min(1).max(500).optional(),
+    cursor: z.string().min(1).optional(),
+});
 const slackListingCreateParams = {
     type: "object",
     properties: {
@@ -135,6 +147,23 @@ export const listListingsCapability = defineCapability({
         return ctx.fetch("/listings/available", { method: "GET", body: bound.payload });
     },
 });
+export const forecastListingsCapability = defineCapability({
+    id: "listings.forecast",
+    domain: "listings",
+    roles: ["user"],
+    description: "List the next 48 hourly availability buckets for customer-visible compute listings.",
+    mutation: "read",
+    http: { method: "GET", path: "/v1/cli/compute/listings/forecast" },
+    slack: false,
+    input: listingForecastInput,
+    execute: async (ctx, input) => {
+        const parsed = listingForecastInput.parse(input);
+        return ctx.fetch(queryPath("/v1/cli/compute/listings/forecast", {
+            limit: parsed.limit?.toString(),
+            cursor: parsed.cursor,
+        }), { method: "GET" });
+    },
+});
 /** Commerce parses listing windows as RFC3339 timestamps, not bare dates. */
 function rfc3339(value) {
     const trimmed = value.trim();
@@ -317,6 +346,7 @@ export const createListingCapability = defineCapability({
 export const listingCapabilities = [
     listCatalogTermsCapability,
     listListingsCapability,
+    forecastListingsCapability,
     createListingCapability,
 ];
 /** @deprecated Use createListingCapability. */

package/vendor/capabilities/capabilities/staff-gtm.d.ts

@@ -0,0 +1,171 @@
+import { z } from "zod";
+export declare const gtmCompanyListInput: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const gtmCompanyListCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmCompanyWriteInput: z.ZodObject<{
+    confirm: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    ownerTags: z.ZodDefault<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    companyId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const gtmCompanyWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmDealListInput: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const gtmDealListCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmDealWriteInput: z.ZodObject<{
+    listingId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"">]>>;
+    currentBid: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+    customer: z.ZodString;
+    owner: z.ZodString;
+    supplier: z.ZodString;
+    gpuType: z.ZodString;
+    dealId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const gtmDealWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmCommentListInput: z.ZodObject<{
+    dealId: z.ZodOptional<z.ZodNumber>;
+    companyId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const gtmCommentListCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmCommentWriteInput: z.ZodObject<{
+    dealId: z.ZodOptional<z.ZodNumber>;
+    companyId: z.ZodOptional<z.ZodNumber>;
+    commentId: z.ZodOptional<z.ZodNumber>;
+    parentId: z.ZodOptional<z.ZodNumber>;
+    body: z.ZodString;
+    bid: z.ZodDefault<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmCommentWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmMentionDismissInput: z.ZodObject<{
+    commentId: z.ZodNumber;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmMentionDismissCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmWorkspaceShowInput: z.ZodObject<{}, z.core.$strip>;
+export declare const gtmWorkspaceShowCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmTaskListInput: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const gtmTaskListCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmTaskWriteInput: z.ZodObject<{
+    taskId: z.ZodOptional<z.ZodNumber>;
+    title: z.ZodString;
+    body: z.ZodDefault<z.ZodString>;
+    companyId: z.ZodNumber;
+    dealId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    assignee: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        done: "done";
+    }>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmTaskWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmCompanyDeleteInput: z.ZodObject<{
+    [x: string]: z.ZodNumber | z.ZodOptional<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmCompanyDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmDealDeleteInput: z.ZodObject<{
+    [x: string]: z.ZodNumber | z.ZodOptional<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmDealDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmCommentDeleteInput: z.ZodObject<{
+    [x: string]: z.ZodNumber | z.ZodOptional<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmCommentDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmTaskDeleteInput: z.ZodObject<{
+    [x: string]: z.ZodNumber | z.ZodOptional<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmTaskDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
+/**
+ * Listing verbs. GTM never touches a Commerce table directly: these call
+ * Commerce's own listing routes through the gateway, exactly as the staff app
+ * does. Nothing here writes a gtm_ row, and nothing in the CRM constrains a
+ * listing.
+ */
+export declare const gtmListingListInput: z.ZodObject<{
+    gpuType: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const gtmListingListCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmListingUpdateInput: z.ZodObject<{
+    listingId: z.ZodString;
+    buyNowRatePerGpuHour: z.ZodOptional<z.ZodString>;
+    costPerGpuHour: z.ZodOptional<z.ZodString>;
+    monthToMonth: z.ZodOptional<z.ZodBoolean>;
+    allowsDepositPlan: z.ZodOptional<z.ZodBoolean>;
+    downPaymentPct: z.ZodOptional<z.ZodString>;
+    capacityNodes: z.ZodOptional<z.ZodNumber>;
+    state: z.ZodOptional<z.ZodEnum<{
+        delisted: "delisted";
+        draft: "draft";
+        listed: "listed";
+    }>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmListingUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmTaskActivityListInput: z.ZodObject<{
+    taskId: z.ZodNumber;
+}, z.core.$strip>;
+export declare const gtmTaskActivityListCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmTaskActivityWriteInput: z.ZodObject<{
+    taskId: z.ZodNumber;
+    body: z.ZodString;
+    parentId: z.ZodOptional<z.ZodNumber>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmTaskActivityWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmCellCommentListInput: z.ZodObject<{
+    companyId: z.ZodNumber;
+    field: z.ZodEnum<{
+        name: "name";
+        notes: "notes";
+        owner_tags: "owner_tags";
+        tickets: "tickets";
+    }>;
+}, z.core.$strip>;
+export declare const gtmCellCommentListCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmCellCommentWriteInput: z.ZodObject<{
+    companyId: z.ZodOptional<z.ZodNumber>;
+    field: z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        notes: "notes";
+        owner_tags: "owner_tags";
+        tickets: "tickets";
+    }>>;
+    commentId: z.ZodOptional<z.ZodNumber>;
+    parentId: z.ZodOptional<z.ZodNumber>;
+    body: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmCellCommentWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const gtmCellCommentDeleteInput: z.ZodObject<{
+    [x: string]: z.ZodNumber | z.ZodOptional<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmCellCommentDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
+/**
+ * Bulk owner-tag reassignment. This is the one GTM edit that is genuinely
+ * N-at-a-time — a book of companies moving to a new owner — and doing it one
+ * confirmation at a time is both slow and easy to half-finish. Every other
+ * bulk case is a loop over the single-record verbs.
+ */
+export declare const gtmCompanyBulkRetagInput: z.ZodObject<{
+    companyIds: z.ZodArray<z.ZodNumber>;
+    ownerTags: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const gtmCompanyBulkRetagCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const staffGTMCapabilities: import("../capability.ts").Capability<unknown, unknown>[];