@oxygen-agent/cli 1.987.20 → 1.1003.12

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.987.20
+Version: 1.1003.12

package/dist/admin-primary-providers-render.d.ts

@@ -1,5 +1,3 @@
-/** Age of an ISO stamp as a short human span, measured against `now`. */
-export declare function ago(iso: unknown, now?: Date): string;
 export type RenderOptions = {
     /** Binary name to print inside suggested commands. */
     binary?: string;

package/dist/admin-primary-providers-render.js

@@ -47,7 +47,7 @@ function pct(value) {
     return `${Math.round(parsed * 100)}%`;
 }
 /** Age of an ISO stamp as a short human span, measured against `now`. */
-export function ago(iso, now = new Date()) {
+function ago(iso, now = new Date()) {
     const raw = str(iso);
     if (!raw)
         return "never";

package/dist/browser-login.js

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
 import { hostname } from "node:os";
-import { OXYGEN_VERSION, OxygenError, deriveCliLoginConfirmationCode } from "@oxygen/shared";
+import { OXYGEN_VERSION, OxygenError, deriveCliLoginConfirmationCode, sleep } from "@oxygen/shared";
 import { requestOxygen } from "./http-client.js";
 import { readErrorMessage } from "./util.js";
 const CALLBACK_HOST = "127.0.0.1";
@@ -133,9 +133,6 @@ function safeHostname() {
         return undefined;
     }
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 export async function createBrowserLoginSession(apiUrl) {
     const state = randomBytes(32).toString("base64url");
     let settled = false;

package/dist/command-manifest.d.ts

@@ -1,10 +1,10 @@
 import type { Command } from "commander";
-export type CommandManifestFlag = {
+type CommandManifestFlag = {
     flags: string;
     description: string;
     required: boolean;
 };
-export type CommandManifestArgument = {
+type CommandManifestArgument = {
     name: string;
     required: boolean;
     description: string;
@@ -46,3 +46,4 @@ export declare function getCommandManifestEntry(manifest: CommandManifest, exact
     invoke: string;
 }) | null;
 export declare function suggestCommandNames(manifest: CommandManifest, query: string, limit?: number): string[];
+export {};

package/dist/command-manifest.js

@@ -37,6 +37,16 @@ const MUTATING_VERBS = new Set([
     // recurring write, and --run can connect newly eligible mailboxes immediately.
     "auto-enroll",
     "backfill",
+    // `dashboards widgets refresh` calls a provider and bills the workspace. It is
+    // currently the only `refresh` leaf; the default (mutates:false) would
+    // advertise the one dashboard command that spends money as a read, to every
+    // agent and in the public CLI reference.
+    "refresh",
+    // Exact hyphenated leaf, because the `backfill` entry above matches the whole
+    // leaf token and never `crm-backfill`. `suppressions crm-backfill --live`
+    // creates CRM person records for everyone on the do-not-contact list, so the
+    // default (mutates:false) would advertise a bulk workspace write as a read.
+    "crm-backfill",
     // A noun leaf, so the default would advertise `projects color` — a tenant
     // write — to every agent as a read. `decide` is the same case.
     "color",

package/dist/credentials.d.ts

@@ -34,7 +34,7 @@ export declare function defaultApiUrl(env?: NodeJS.ProcessEnv): string;
  * look identical, and a drifted profile turns a prod-labelled binary into a report
  * about dev that reads as a production outage (OXY-4091).
  */
-export type CliEndpointContext = {
+type CliEndpointContext = {
     apiUrl: string;
     /** Active profile name, or null when no named profile supplied the credentials. */
     profile: string | null;

package/dist/functions-commands.js

@@ -47,11 +47,15 @@ export function registerFunctionsCommands(program, handle) {
     functions.command("rename <function> <name>").description("Rename a Function while preserving its identity, callers and published execution.")
         .option("--json", "Print a JSON envelope.")
         .action((ref, name, options) => handle("functions rename", options, () => requestOxygen("/api/cli/functions", { method: "POST", body: { operation: "rename", function: ref, display_name: name } })));
-    functions.command("delete <function>").description("Preview removal from the Function library; preserves backing tables, rows and run history. Connected callers or active runs block deletion.")
-        .addHelpText("after", "\nDeletion is final: there is no restore, unlike `tables delete`. To reuse the logic, `tables duplicate` the backing Table and draft a new Function from the copy.\n")
+    functions.command("delete <function>").description("Preview removal from the Function library, then remove it with --yes; preserves backing tables, rows and run history. Connected callers or active runs block deletion. Works on an OXYGEN-managed Function too: it leaves this workspace's library and is not seeded back.")
+        .addHelpText("after", "\nDeleting your own Function is final: there is no restore, unlike `tables delete`. To reuse the logic, `tables duplicate` the backing Table and draft a new Function from the copy.\nDeleting an OXYGEN-managed Function only removes it from THIS workspace; `functions restore` brings OXYGEN's ready-made Functions back.\n")
         .option("--yes", "Confirm removal of this Function after reviewing its callers.")
         .option("--json", "Print a JSON envelope.")
         .action((ref, options) => handle("functions delete", options, () => requestOxygen("/api/cli/functions", { method: "POST", body: { operation: "delete", function: ref, approved: options.yes === true } })));
+    functions.command("restore").description("Put back the OXYGEN-managed Functions this workspace deleted. They are rebuilt at the current catalog version in the background; `functions list --managed` shows them as they land.")
+        .option("--catalog-id <id...>", "Restore only these catalog entries (the managed.catalogId from `functions describe`). Defaults to every removed one.")
+        .option("--json", "Print a JSON envelope.")
+        .action((options) => handle("functions restore", options, () => requestOxygen("/api/cli/functions", { method: "POST", body: { operation: "restore_managed", ...(options.catalogId?.length ? { catalog_ids: options.catalogId } : {}) } })));
     functions.command("bind <table> <function>").description("Add a Function column with explicit input/output mappings and a caller credit cap. Create each mapped output column on the caller table first with `columns add`; bind rejects an output mapped to a column the caller table does not have.")
         .requiredOption("--inputs-json <json>", "Object mapping Function input keys to caller column keys.")
         .requiredOption("--outputs-json <json>", "Object mapping Function output keys to existing caller column keys.")

package/dist/help.d.ts

@@ -20,4 +20,12 @@ export declare function enableCommandSuggestions(command: Command): void;
  * lists the real subcommands. Returns null when argv does not describe an
  * unknown subcommand (an unknown OPTION has its own handling).
  */
+/**
+ * Hint for `error: unknown option '--filter'`. Commander's own suggester stops
+ * at three edits, so `--filter` never reaches `--filter-json`; a flag that is a
+ * prefix of exactly one option on that command (or of which exactly one option
+ * is a prefix) names it. Returns null when commander's output already says it
+ * all, or when the flag is not a long option.
+ */
+export declare function unknownOptionHint(program: Command, argv: readonly string[], message: string): string | null;
 export declare function unknownCommandHint(program: Command, argv: readonly string[]): string | null;

package/dist/help.js

@@ -214,6 +214,52 @@ const COMMAND_SYNONYMS = {
  * lists the real subcommands. Returns null when argv does not describe an
  * unknown subcommand (an unknown OPTION has its own handling).
  */
+/**
+ * Hint for `error: unknown option '--filter'`. Commander's own suggester stops
+ * at three edits, so `--filter` never reaches `--filter-json`; a flag that is a
+ * prefix of exactly one option on that command (or of which exactly one option
+ * is a prefix) names it. Returns null when commander's output already says it
+ * all, or when the flag is not a long option.
+ */
+export function unknownOptionHint(program, argv, message) {
+    const flag = /unknown option '(--[^']+)'/.exec(message)?.[1];
+    if (!flag)
+        return null;
+    const [command, path] = resolveCommandPath(program, argv);
+    const longs = new Set();
+    for (let current = command; current; current = current.parent) {
+        for (const option of current.options)
+            if (option.long)
+                longs.add(option.long);
+    }
+    const bare = flag.split("=")[0].toLowerCase();
+    if (longs.has(bare))
+        return null;
+    const candidates = [...longs].filter((long) => long.startsWith(bare) || bare.startsWith(long));
+    const helpLine = `Run \`${path} --help\` for its options.`;
+    if (candidates.length === 1) {
+        return `Hint: \`${path}\` has no \`${bare}\`. Did you mean \`${candidates[0]}\`? ${helpLine}`;
+    }
+    if (candidates.length > 1 && candidates.length <= 4) {
+        return `Hint: \`${path}\` has no \`${bare}\`. Did you mean one of ${candidates.map((c) => `\`${c}\``).join(", ")}? ${helpLine}`;
+    }
+    return `Hint: \`${path}\` has no \`${bare}\`. ${helpLine}`;
+}
+/** Walk the command path in argv (stopping at the first option) and return the deepest command with its printable path. */
+function resolveCommandPath(program, argv) {
+    let current = program;
+    let path = program.name();
+    for (const token of argv) {
+        if (token.startsWith("-"))
+            break;
+        const child = current.commands.find((candidate) => candidate.name() === token || candidate.aliases().includes(token));
+        if (!child)
+            break;
+        current = child;
+        path = `${path} ${token}`;
+    }
+    return [current, path];
+}
 export function unknownCommandHint(program, argv) {
     let current = program;
     let path = program.name();