@m6d/cortex-cli 0.22.0 → 0.24.0

package/src/management/flags.ts

@@ -10,6 +10,8 @@ export type Flag = {
     description: string;
     /** A secret: never an argv flag (argv is world-readable), prompted masked or read from stdin. */
     sensitive: boolean;
+    /** Takes `null`, which a blank prompted answer sends. */
+    nullable: boolean;
 };
 
 /** Follows a local `$ref` into `components/schemas`; anything else is returned as is. */
@@ -36,6 +38,12 @@ function isSensitive(property: JsonSchema, document: OpenApiDocument): boolean {
     );
 }
 
+/** Whether `null` is allowed, as a type list or as zod's `anyOf` alternative for a nullable property. */
+function isNullable(property: JsonSchema) {
+    if (Array.isArray(property.type)) return property.type.includes("null");
+    return (property.anyOf ?? []).some((alternative) => alternative.type === "null");
+}
+
 /** The flag kind a property's schema maps to; scalars and scalar arrays get typed flags, the rest is JSON. */
 function kindOf(property: JsonSchema, document: OpenApiDocument) {
     if (property.enum) return "enum" as const;
@@ -71,19 +79,21 @@ export function flagsFor(input: JsonSchema, document: OpenApiDocument) {
             choices: property.enum?.map(String),
             description: property.description ?? "",
             sensitive: isSensitive(property, document),
+            nullable: isNullable(property),
         } satisfies Flag;
     });
 }
 
 /**
  * A prompted answer, parsed and checked exactly as the flag's option would
- * be; `undefined` when it does not fit, so the caller can ask again.
+ * be; `undefined` when it does not fit, so the caller can ask again. A blank
+ * answer is `null` for a nullable flag.
  */
 export function parseAnswer(flag: Flag, answer: string) {
-    // A string is taken verbatim: a secret's whitespace is part of it. Every
-    // other kind is lexical and trimmed before parsing.
+    // A secret's whitespace is part of it; any other answer of only spaces is blank.
+    if ((flag.sensitive ? answer : answer.trim()) === "") return flag.nullable ? null : undefined;
+    // A string is taken verbatim. Every other kind is lexical and trimmed before parsing.
     const text = flag.kind === "string" ? answer : answer.trim();
-    if (text === "") return undefined;
     return ANSWER_PARSERS[flag.kind](text, flag);
 }
 

package/src/scaffold/files.ts

@@ -28,7 +28,7 @@ import { applyPorts, type Ports } from "@/scaffold/ports";
  * `@m6d/cortex` range below are stamped by scripts/sync-package-versions.ts
  * before the CLI publishes, so a scaffold pins what was current then.
  */
-const CORTEX_VERSION = "0.21.0";
+const CORTEX_VERSION = "0.23.0";
 
 /** This machine as Cortex's containers name it: the one private host the stack's egress policy admits. */
 export const DOCKER_HOST = "host.docker.internal";
@@ -147,7 +147,7 @@ function packageJson({ name, datasets, setup }: Project) {
                 verify: "bun run format:check && bun run lint && bun run spellcheck && bun run check && bun run audit",
             },
             dependencies: {
-                "@m6d/cortex": "~0.9.0",
+                "@m6d/cortex": "~0.11.0",
                 // drizzle 1.0 is in beta; this is the build `@m6d/cortex/drizzle` is tested against.
                 ...(datasets ? { "drizzle-orm": "1.0.0-beta.15-859cf75" } : {}),
                 hono: "^4.12.3",
@@ -246,6 +246,9 @@ COMPOSE_PROJECT_NAME=
 DEFAULT_ADMIN_EMAIL=admin@example.com
 DEFAULT_ADMIN_PASSWORD=
 BOOTSTRAP_MANAGEMENT_KEY=
+# The Cortex license key you were given. Without one Cortex serves no console
+# and runs no agent.
+CORTEX_LICENSE_KEY=
 # Session signing, the key the secrets store is encrypted with, and object
 # storage's password (storage is published on this machine for uploads).
 BETTER_AUTH_SECRET=
@@ -497,7 +500,9 @@ A backend for Cortex agents, and Cortex itself to run them on.
 
 ## Getting started
 
-On a fresh clone, run \`bun install\` first (\`cortex new\` already did): it writes \`.env\`.
+On a fresh clone, run \`bun install\` first (\`cortex new\` already did): it writes \`.env\`. Put
+your Cortex license key in its \`CORTEX_LICENSE_KEY\`: without one Cortex serves no console and runs no
+agent.
 
 \`\`\`sh
 bun run dev

package/src/ui/prompts.ts

@@ -84,40 +84,34 @@ export async function askToProceed(message: string) {
 }
 
 /**
- * A required value a command was not given: asked by name, re-asked while
- * empty or while `check` returns a complaint about the trimmed value.
+ * How an asked value is checked: re-asked while `check` complains about it,
+ * and while empty unless `blank` accepts an empty answer.
  */
-export function askValue(
-    name: string,
-    hint?: string,
-    check: (value: string) => string | undefined = () => undefined,
-) {
+type AskOptions = { check?: (value: string) => string | undefined; blank?: boolean };
+
+function validator(name: string, { check = () => undefined, blank = false }: AskOptions) {
+    return function (value: string | undefined) {
+        if (value) return check(value);
+        return blank ? undefined : `${name} is required.`;
+    };
+}
+
+/** A value a command was not given: asked by name and checked trimmed. */
+export function askValue(name: string, { hint, ...options }: AskOptions & { hint?: string } = {}) {
+    const validate = validator(name, options);
     return orExit(
         text({
             message: name,
             placeholder: hint,
             output,
-            validate: function (value) {
-                const candidate = (value ?? "").trim();
-                return candidate.length === 0 ? `${name} is required.` : check(candidate);
-            },
+            validate: (value) => validate(value?.trim()),
         }),
     );
 }
 
-/** A credential: typed masked, never echoed, and re-asked while `check` complains. */
-export function askSecret(
-    name: string,
-    check: (value: string) => string | undefined = () => undefined,
-) {
-    return orExit(
-        password({
-            message: name,
-            output,
-            validate: (value) =>
-                (value ?? "").length === 0 ? `${name} is required.` : check(value ?? ""),
-        }),
-    );
+/** A credential: typed masked, never echoed, and checked as typed. */
+export function askSecret(name: string, options: AskOptions = {}) {
+    return orExit(password({ message: name, output, validate: validator(name, options) }));
 }
 
 type Step = { title: string; run: () => string | undefined | Promise<string | undefined> };