@m6d/cortex-cli 0.19.0 → 0.21.0

package/README.md

@@ -38,7 +38,7 @@ Scaffolds `./<name>`: a backend for Cortex agents, and Cortex itself to run them
 - `bun run dev` starts Cortex (`docker compose up`), the backend and `bun cortex setup --wait --yes` in
   an mprocs dashboard. `bun run dev:agent` runs the same through `concurrently`, one labelled log for
   coding agents and CI.
-- eslint, prettier, cspell, fallow and tsconfig are inlined, so `bun run verify` works standalone.
+- oxlint, prettier, cspell, fallow and tsconfig are inlined, so `bun run verify` works standalone.
 
 It then runs `bun install`, and `git init` unless the target is already inside a work tree. An
 existing non-empty directory is an error. So is a name like `cortex` or `cortex.`, since the
@@ -62,8 +62,8 @@ as `--yes`, so a missing name is a hard error rather than a hang.
 
 The image runs at the Cortex release that was current when this CLI was published
 (`CORTEX_VERSION` in the shell picks another); the backend depends on the `@m6d/cortex` release of
-that time. A server name stops at Cortex's 120 characters, so a longer project name is
-registered cut to that length.
+that time. The server is registered under the project name as the manifest `id` takes it:
+lowercase words joined by hyphens, cut to Cortex's 64 characters.
 
 ## `cortex setup`
 
@@ -107,7 +107,7 @@ at and a new procedure needs no CLI release.
 cortex login                             # asks for the URL and a management key
 cortex status
 cortex agents list
-cortex agents create --slug support --name Support --serverId <uuid>
+cortex agents create --name support --displayName '{"en":"Support"}' --serverId <uuid>
 cortex tools create --json tool.json --publish
 cortex tools list -o json | jq '.items[].name'
 cortex logout

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@m6d/cortex-cli",
-    "version": "0.19.0",
+    "version": "0.21.0",
     "description": "Scaffold Cortex projects and manage a Cortex deployment",
     "license": "MIT",
     "type": "module",
@@ -29,8 +29,8 @@
     },
     "devDependencies": {
         "@cortex/contracts": "workspace:*",
-        "@types/bun": "1.3.14",
-        "typescript": "~6.0.3"
+        "@types/bun": "1.4.4",
+        "typescript": "npm:@typescript/typescript6@^6.0.2"
     },
     "publishConfig": {
         "access": "public"

package/src/commands/new.ts

@@ -7,7 +7,7 @@ import { CORTEX_MANIFEST_ID } from "@cortex/contracts/manifest";
 
 import pkg from "../../package.json";
 import { askProvider } from "@/commands/setup";
-import { AGENT_SLUG, manifestIdOf, scaffoldFiles } from "@/scaffold/files";
+import { AGENT_NAME, manifestIdOf, scaffoldFiles } from "@/scaffold/files";
 import { allocatePorts, type Ports } from "@/scaffold/ports";
 import { askConfirm, askName, canAsk, intro, log, outro, runSteps } from "@/ui/prompts";
 import * as report from "@/ui/report";
@@ -30,7 +30,7 @@ export function registerNew(program: Command<[], { verbose?: true }>) {
         // way and `--yes` is not the only way to say "yes". Declaring the
         // positive first leaves the value `undefined` when neither is passed,
         // which is what marks the question as still unanswered.
-        .option("--setup", `Set up the ${AGENT_SLUG} agent on the first bun run dev`)
+        .option("--setup", `Set up the ${AGENT_NAME} agent on the first bun run dev`)
         .option("--no-setup", "Leave Cortex empty; you register the backend yourself")
         .option("--yes", "Accept the defaults instead of asking");
 
@@ -151,7 +151,7 @@ async function askSetup(flag: boolean | undefined, interactive: boolean) {
         flag ??
         (!interactive ||
             (await askConfirm(
-                `Set up the ${AGENT_SLUG} agent when you first run bun run dev?`,
+                `Set up the ${AGENT_NAME} agent when you first run bun run dev?`,
                 true,
             )));
     const provider = setup && interactive ? await askProvider() : undefined;
@@ -178,7 +178,7 @@ function warnInstall(project: string, output: string, verbose: boolean) {
 /** What the first `bun run dev` sets up: the agent, the server alone (no model yet), or nothing. */
 function nextSteps(project: string, ports: Ports, setup: boolean, provider: boolean) {
     const runs = {
-        agent: step("bun run dev", `→ sets up ${AGENT_SLUG}, then prints where to chat`),
+        agent: step("bun run dev", `→ sets up ${AGENT_NAME}, then prints where to chat`),
         server:
             step("bun run dev", "→ registers the server") +
             step("bun cortex setup", "adds a model provider, then applies"),

package/src/commands/setup.ts

@@ -13,7 +13,8 @@ import {
     scrubCredentialStrings,
 } from "@cortex/contracts/egress-policy";
 import { ManagementClientError, managementPath } from "@cortex/contracts/management";
-import { MODEL_PROVIDER_LIMITS, NAME_MAX_LENGTH, SETTING_BOUNDS } from "@cortex/contracts/manifest";
+import { MODEL_PROVIDER_LIMITS, SETTING_BOUNDS } from "@cortex/contracts/manifest";
+import { displayNameSchema, NAME_MAX_LENGTH, nameSchema } from "@cortex/contracts/server";
 import { z } from "zod";
 
 import {
@@ -43,7 +44,7 @@ const POLL_MS = 2_000;
 
 /** The backend as `cortex new` writes it into .env, which Bun loads from the directory it runs in. */
 const projectSchema = z.object({
-    CORTEX_SERVER_NAME: z.string().min(1).max(NAME_MAX_LENGTH),
+    CORTEX_SERVER_NAME: nameSchema,
     CORTEX_SERVER_URL: z.url(),
     CORTEX_SERVER_KEY: z.string().min(1),
 });
@@ -57,7 +58,7 @@ const ENV_SAFE = /^[^\s$#'"`\\]+$/;
 
 /** The model provider in .env: all four values, or none. */
 const providerFields = z.object({
-    MODEL_PROVIDER_NAME: z.string().min(1).max(NAME_MAX_LENGTH),
+    MODEL_PROVIDER_NAME: nameSchema,
     MODEL_PROVIDER_URL: z
         .string()
         .max(MODEL_PROVIDER_LIMITS.urlLength)
@@ -80,12 +81,14 @@ type Profile = ReturnType<typeof requireProfile>;
 
 const namedSchema = z.object({ id: z.string(), name: z.string() });
 const providerRowSchema = namedSchema.extend({
+    displayName: displayNameSchema,
     baseUrl: z.string(),
     secretName: z.string(),
     models: z.array(z.string()),
     efforts: z.array(z.string()),
 });
 const serverSchema = namedSchema.extend({
+    displayName: displayNameSchema,
     description: z.string().nullable(),
     url: z.string().nullable(),
     keySecretName: z.string().nullable(),
@@ -270,20 +273,23 @@ async function findByName<TItem extends typeof namedSchema>(
 
 /**
  * A secret's name for one value: its owner's name, what it is to the owner,
- * and a short digest of the value, the owner's name cut so the whole is a
- * name Cortex holds. A name then holds one value only, so a secret that
- * exists is the value .env holds, and a changed key gets a secret of its own
- * while every row presenting the old one keeps it.
+ * and a short digest of the value, the owner's name cut, and stripped of the
+ * hyphens the cut leaves it ending in, so the whole is a name Cortex holds.
+ * A name then holds one value only, so a secret that exists is the value
+ * .env holds, and a changed key gets a secret of its own while every row
+ * presenting the old one keeps it.
  */
 function secretFor(owner: string, role: "api-key" | "server-key", value: string) {
     const suffix = `-${role}-${createHash("sha256").update(value).digest("hex").slice(0, 8)}`;
-    return `${owner.slice(0, NAME_MAX_LENGTH - suffix.length)}${suffix}`;
+    return `${owner.slice(0, NAME_MAX_LENGTH - suffix.length).replace(/-+$/, "")}${suffix}`;
 }
 
 async function ensureSecret(profile: Profile, name: string, value: string) {
     const found = await findByName(profile, "secrets", name, namedSchema);
     if (!found) {
-        await callOrFail(profile, () => managementClient(profile).secrets.set({ name, value }));
+        await callOrFail(profile, () =>
+            managementClient(profile).secrets.set({ name, displayName: {}, value }),
+        );
     }
 }
 
@@ -333,6 +339,7 @@ async function ensureProvider(profile: Profile, provider: Provider) {
         await callOrFail(profile, () =>
             managementClient(profile).modelProviders.create({
                 name: provider.name,
+                displayName: {},
                 baseUrl: provider.baseUrl,
                 secretName,
                 models,
@@ -349,6 +356,7 @@ async function ensureProvider(profile: Profile, provider: Provider) {
     await callOrFail(profile, () =>
         managementClient(profile).modelProviders.update({
             id: found.id,
+            displayName: found.displayName,
             baseUrl: found.baseUrl,
             secretName,
             models,
@@ -395,6 +403,7 @@ async function ensureServer(
             await callOrFail(profile, () =>
                 managementClient(profile).servers.create({
                     name,
+                    displayName: {},
                     description: "",
                     url,
                     keySecretName,
@@ -417,7 +426,7 @@ async function ensureServer(
         await callOrFail(profile, () =>
             managementClient(profile).servers.update({
                 id: server.id,
-                name,
+                displayName: server.displayName,
                 description: server.description ?? "",
                 url,
                 keySecretName,

package/src/contracts/datasets/dataset-sql.ts

@@ -1030,7 +1030,7 @@ class Parser {
     }
 
     /** `a + b * (c - 1)`: `*` and `/` bind before `+` and `-`; a date plus or minus an INTERVAL folds to the date it names. */
-    // eslint-disable-next-line m6d/no-explicit-return-type -- mutually recursive with factor and unit
+    // oxlint-disable-next-line m6d/no-explicit-return-type -- mutually recursive with factor and unit
     private term(message: string): Term {
         let left = this.factor(message);
         while (this.peekPunct("+") || this.peekPunct("-")) {

package/src/contracts/management/index.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 
 import { isRecord } from "../json/index";
+import { TIMEZONE_HEADER } from "../wire/index";
 import { managementProcedureKinds } from "./procedures.generated";
 import type { ManagementProcedures } from "./procedures.generated";
 
@@ -75,10 +76,19 @@ export class ManagementClientError extends Error {
     }
 }
 
-/** Where management calls go: a console's origin and a management key (`cortex_mgmt_…`); a test hands in its own `fetch`. */
+/**
+ * Where management calls go: a console's origin and a management key
+ * (`cortex_mgmt_…`); a test hands in its own `fetch`. `locale` (`ar`) and
+ * `timeZone` (an IANA zone, `Asia/Dubai`) are the caller's, sent as
+ * `Accept-Language` and `X-Cortex-Timezone`: Cortex words its refusals in
+ * the one and reads a day range in the other, else English and UTC days. A
+ * host acting for many users builds a client per request.
+ */
 export type ManagementTarget = {
     url: string;
     key: string;
+    locale?: string;
+    timeZone?: string;
     fetch?: (url: string, init: RequestInit) => Promise<Response>;
 };
 
@@ -100,6 +110,8 @@ export async function callManagement(
         headers: {
             Authorization: `Bearer ${target.key}`,
             ...(method === "post" ? { "Content-Type": "application/json" } : {}),
+            ...(target.locale ? { "Accept-Language": target.locale } : {}),
+            ...(target.timeZone ? { [TIMEZONE_HEADER]: target.timeZone } : {}),
         },
         body: method === "post" && input !== undefined ? JSON.stringify(input) : undefined,
         signal,