@oxygen-agent/cli 1.1014.135 → 1.1014.618

package/dist/commands/profiles.js

@@ -0,0 +1,250 @@
+import { emitCliFailure, writeJson } from "../cli-output.js";
+import { ansi, createCredentialFingerprint, describeProfileSource, formatFingerprint, handleLogoutAction, resolveActiveProfileWithSource, shellQuote } from "../command-support.js";
+import { listCredentialProfiles, switchCredentialProfile } from "../credentials.js";
+import { OxygenError, success } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+import { stdout as output } from "node:process";
+async function handleProfilesListAction(options) {
+    try {
+        const state = await listCredentialProfiles();
+        const data = {
+            active_profile: state.activeProfile,
+            profiles: state.profiles.map((profile) => summarizeCredentialProfile(profile, profile.name === state.activeProfile)),
+        };
+        if (options.json) {
+            writeJson(success("profiles list", data));
+            return;
+        }
+        process.stdout.write(formatProfilesList(data));
+    }
+    catch (error) {
+        emitCliFailure("profiles list", error);
+    }
+}
+async function handleProfilesUseAction(profile, options) {
+    try {
+        const activeProfile = await switchCredentialProfile(profile);
+        const state = await listCredentialProfiles().catch(() => null);
+        const totalProfiles = state?.profiles.length ?? 1;
+        const data = {
+            active_profile: activeProfile.name,
+            profile: summarizeCredentialProfile(activeProfile, true),
+        };
+        if (options.json) {
+            writeJson(success("profiles use", data));
+            return;
+        }
+        process.stdout.write(formatProfileUseSuccess(data.profile, { totalProfiles }));
+    }
+    catch (error) {
+        emitCliFailure("profiles use", error);
+    }
+}
+async function handleProfilesEnvAction(profile, options) {
+    try {
+        if (options.unset) {
+            const data = {
+                profile,
+                unset: ["OXYGEN_PROFILE", "OXYGEN_API_URL"],
+            };
+            if (options.json) {
+                writeJson(success("profiles env", data));
+                return;
+            }
+            process.stdout.write("unset OXYGEN_PROFILE OXYGEN_API_URL\n");
+            return;
+        }
+        const state = await listCredentialProfiles();
+        const match = state.profiles.find((entry) => entry.name === profile);
+        if (!match) {
+            throw new OxygenError("profile_not_found", `Oxygen CLI profile "${profile}" is not stored.`, {
+                details: { profile },
+                exitCode: 1,
+            });
+        }
+        const env = {
+            OXYGEN_PROFILE: match.name,
+            OXYGEN_API_URL: match.apiUrl,
+        };
+        if (options.json) {
+            writeJson(success("profiles env", { profile: match.name, env }));
+            return;
+        }
+        process.stdout.write(`export OXYGEN_PROFILE=${shellQuote(match.name)}\n`);
+        process.stdout.write(`export OXYGEN_API_URL=${shellQuote(match.apiUrl)}\n`);
+    }
+    catch (error) {
+        emitCliFailure("profiles env", error);
+    }
+}
+async function handleProfilesCurrentAction(options) {
+    try {
+        const context = await resolveActiveProfileWithSource();
+        const credentials = context.resolution.credentials;
+        const data = {
+            profile: context.resolution.exists ? context.resolution.name : null,
+            profile_source: context.source,
+            api_url: credentials?.apiUrl ?? null,
+            organization: credentials?.identity?.organization ?? null,
+            user: credentials?.identity?.user ?? null,
+            stored: context.resolution.exists,
+        };
+        if (options.json) {
+            writeJson(success("profiles current", data));
+            return;
+        }
+        process.stdout.write(formatProfilesCurrent(context));
+    }
+    catch (error) {
+        emitCliFailure("profiles current", error);
+    }
+}
+function summarizeCredentialProfile(profile, active) {
+    return {
+        name: profile.name,
+        active,
+        api_url: profile.apiUrl,
+        token_fingerprint: formatFingerprint(createCredentialFingerprint(profile.token)),
+        organization: profile.activeOrganization ?? profile.identity?.organization ?? null,
+        user: profile.identity?.user ?? null,
+        identity_captured_at: profile.identity?.capturedAt ?? null,
+    };
+}
+function formatProfilesList(data) {
+    const styles = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    if (data.profiles.length === 0) {
+        return [
+            "",
+            `${styles.dim("No stored Oxygen CLI profiles.")}`,
+            "",
+        ].join("\n");
+    }
+    const nameWidth = Math.max(...data.profiles.map((profile) => profile.name.length));
+    const orgWidth = Math.max(...data.profiles.map((profile) => formatProfileOrgCell(profile).length));
+    const lines = [
+        "",
+        `${styles.bold("Oxygen CLI Profiles")}`,
+        "",
+        ...data.profiles.map((profile) => {
+            const marker = profile.active ? "*" : " ";
+            const orgCell = formatProfileOrgCell(profile);
+            return [
+                `${marker} ${profile.name.padEnd(nameWidth)}`,
+                orgCell.padEnd(orgWidth),
+                styles.dim(profile.api_url),
+                styles.dim(profile.token_fingerprint),
+            ].join("  ");
+        }),
+        "",
+    ];
+    if (data.profiles.length >= 2) {
+        lines.push(`  ${styles.dim("Pin a terminal:")}  ${styles.bold('eval "$(oxygen profiles env <profile>)"')}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function formatProfileOrgCell(profile) {
+    if (!profile.organization)
+        return "(unknown org — run `oxygen whoami` to refresh)";
+    const { slug, name } = profile.organization;
+    if (slug && slug !== name)
+        return `${name} (${slug})`;
+    return name || slug || profile.organization.id;
+}
+function formatProfileUseSuccess(profile, options) {
+    const styles = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    const lines = [
+        "",
+        `${styles.green("[OK]")} ${styles.bold("CLI profile selected")}`,
+        "",
+        `  ${styles.dim("Profile")}        ${profile.name}`,
+        `  ${styles.dim("Organization")}   ${formatProfileOrgCell(profile)}`,
+        `  ${styles.dim("API")}            ${profile.api_url}`,
+        `  ${styles.dim("Fingerprint")}    ${profile.token_fingerprint}`,
+        "",
+    ];
+    if (options.totalProfiles >= 2) {
+        lines.push(`  ${styles.dim("Note: this changes the active profile for every shell.")}`);
+        lines.push(`  ${styles.dim("To pin this terminal only, run:")} ${styles.bold(`eval "$(oxygen profiles env ${profile.name})"`)}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+// skipcq: JS-C1002
+function formatProfilesCurrent(context) {
+    const styles = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    const sourceLabel = describeProfileSource(context.source);
+    if (!context.resolution.exists) {
+        return [
+            "",
+            `${styles.dim("No stored profile resolves for this shell.")}`,
+            `  ${styles.dim("Source:")}  ${sourceLabel}`,
+            `  ${styles.dim("Run")} ${styles.bold("oxygen login")} ${styles.dim("to create one.")}`,
+            "",
+        ].join("\n");
+    }
+    const credentials = context.resolution.credentials;
+    if (!credentials) {
+        return [
+            "",
+            `${styles.dim("No stored profile resolves for this shell.")}`,
+            `  ${styles.dim("Source:")}  ${sourceLabel}`,
+            "",
+        ].join("\n");
+    }
+    const organization = credentials.activeOrganization ?? credentials.identity?.organization ?? null;
+    const orgCell = organization
+        ? (organization.slug && organization.slug !== organization.name
+            ? `${organization.name} (${organization.slug})`
+            : organization.name)
+        : "(unknown — run `oxygen whoami` to refresh)";
+    return [
+        "",
+        `${styles.bold("Active Oxygen CLI Profile")}`,
+        "",
+        `  ${styles.dim("Profile")}        ${context.resolution.name}`,
+        `  ${styles.dim("Source")}         ${sourceLabel}`,
+        `  ${styles.dim("Organization")}   ${orgCell}`,
+        `  ${styles.dim("API")}            ${credentials.apiUrl}`,
+        "",
+    ].join("\n");
+}
+export function registerProfilesFamily(program, handleAsyncAction) {
+    program
+        .command("profiles")
+        .description("Manage stored CLI credential profiles (switch between workspaces and hosts). `oxygen login` creates or updates the active profile.")
+        .addCommand(new Command("list")
+        .description("List stored CLI credential profiles.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleProfilesListAction(options);
+    }))
+        .addCommand(new Command("use")
+        .description("Switch the active CLI credential profile.")
+        .argument("<profile>", "Stored profile name.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (profile, options) => {
+        await handleProfilesUseAction(profile, options);
+    }))
+        .addCommand(new Command("remove")
+        .description("Remove one stored CLI credential profile.")
+        .argument("<profile>", "Stored profile name.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (profile, options) => {
+        await handleLogoutAction({ ...options, profile });
+    }))
+        .addCommand(new Command("env")
+        .description("Print shell `export` lines that pin this terminal to a stored CLI profile.")
+        .argument("<profile>", "Stored profile name.")
+        .option("--unset", "Print `unset` lines instead of `export` lines.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (profile, options) => {
+        await handleProfilesEnvAction(profile, options);
+    }))
+        .addCommand(new Command("current")
+        .description("Show the profile the next command will use, and where it came from.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleProfilesCurrentAction(options);
+    }));
+}

package/dist/commands/projects.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerProjectsFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/projects.js

@@ -0,0 +1,94 @@
+import { resolveLiveDryRunMode } from "../cli-values.js";
+import { splitCommaList } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+export function registerProjectsFamily(program, handleAsyncAction) {
+    program
+        .command("projects")
+        .description("Manage table folders (projects). Inspect contents with `oxygen tables list --project <project>`.")
+        .addCommand(new Command("list")
+        .description("List table projects (folders) with each one's active table count (`tableCount`), so empty and oversized folders show without listing every folder's tables. Free.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("projects list", options, () => requestOxygen("/api/cli/projects"));
+    }))
+        .addCommand(new Command("create")
+        .description("Create a schema-backed table project (folder). Free. Group tables into it with `oxygen tables move <tables...> --project <folder>`.")
+        .argument("<name>", "Display name for the project.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (name, options) => {
+        await handleAsyncAction("projects create", options, () => requestOxygen("/api/cli/projects", {
+            method: "POST",
+            body: { name },
+        }));
+    }))
+        .addCommand(new Command("rename")
+        .description("Rename a table project's display name and slug without changing its tables.")
+        .argument("<project>", "Project slug or id.")
+        .requiredOption("--name <name>", "New display name for the project.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (project, options) => {
+        await handleAsyncAction("projects rename", options, () => {
+            const name = readOption(options.name);
+            if (!name) {
+                throw new OxygenError("invalid_project_name", "--name is required.", {
+                    exitCode: 1,
+                });
+            }
+            return requestOxygen(`/api/cli/projects/${encodeURIComponent(project)}`, {
+                method: "PATCH",
+                body: { name },
+            });
+        });
+    }))
+        .addCommand(new Command("delete")
+        .description("Delete a non-General folder and its tables. Restoring any deleted table with `oxygen tables restore` before the purge date also restores the folder. Defaults to dry-run; --live requires --confirm and the preview's table IDs.")
+        .argument("<project>", "Project slug or id.")
+        .option("--dry-run", "Preview whether the project can be deleted without writing. Default.")
+        .option("--live", "Delete the project after inspecting the dry-run preview. Requires --confirm.")
+        .option("--confirm", "Confirm the live delete.")
+        .option("--expected-table-ids <ids>", "Comma-separated table IDs from the preview. Required for nonempty folders; refuses if contents changed.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (project, options) => {
+        await handleAsyncAction("projects delete", options, () => {
+            const mode = resolveLiveDryRunMode(options);
+            if (mode === "live" && options.confirm !== true) {
+                throw new OxygenError("confirm_required", "projects delete --live requires --confirm after inspecting the dry-run preview.", { exitCode: 1 });
+            }
+            return requestOxygen(`/api/cli/projects/${encodeURIComponent(project)}`, {
+                method: "DELETE",
+                body: {
+                    mode,
+                    ...(mode === "live" ? { confirm: true } : {}),
+                    ...(options.expectedTableIds !== undefined
+                        ? { expected_table_ids: splitCommaList(options.expectedTableIds) }
+                        : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("tag")
+        .description("Replace a project's workspace tags (whole set; `--tags \"\"` clears). See `oxygen tags list` for the vocabulary.")
+        .argument("<project>", "Project slug or id.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (project, options) => {
+        await handleAsyncAction("projects tag", options, () => requestOxygen(`/api/cli/projects/${encodeURIComponent(project)}/tags`, {
+            method: "POST",
+            body: { tags: splitCommaList(options.tags) },
+        }));
+    }))
+        .addCommand(new Command("color")
+        .description("Set a folder's colour in the Tables sidebar (rail) for everyone in the workspace. `--color auto` restores the automatic colour. Free.")
+        .argument("<project>", "Project slug or id.")
+        .requiredOption("--color <color>", "Colour name (gray, red, orange, amber, yellow, green, teal, blue, indigo, purple, pink) or `auto` to clear.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (project, options) => {
+        await handleAsyncAction("projects color", options, () => requestOxygen(`/api/cli/projects/${encodeURIComponent(project)}/color`, {
+            method: "POST",
+            body: { color: options.color?.trim().toLowerCase() ?? null },
+        }));
+    }));
+}

package/dist/commands/prompts.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerPromptsFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/prompts.js

@@ -0,0 +1,84 @@
+import { handleAsyncAction } from "../cli-output.js";
+import { isUuid } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readClearableOption, readOption } from "../util.js";
+import { Command } from "commander";
+function buildPromptTemplatesCommand(surface, description) {
+    return new Command(surface)
+        .description(description)
+        .addCommand(new Command("list")
+        .description("List prompt templates in the workspace.")
+        .option("--kind <kind>", "Filter by ai_column_system, scoring_rubric, or other.")
+        .option("--include-archived", "Include archived templates.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction(`${surface} list`, options, () => {
+            const params = new URLSearchParams();
+            const kind = readOption(options.kind);
+            if (kind)
+                params.set("kind", kind);
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/templates${qs}`);
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Read one prompt template by id or slug.")
+        .argument("<id_or_slug>", "Template UUID or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (idOrSlug, options) => {
+        await handleAsyncAction(`${surface} get`, options, () => requestOxygen("/api/cli/templates/get", {
+            method: "POST",
+            body: isUuid(idOrSlug)
+                ? { id: idOrSlug }
+                : { slug: idOrSlug },
+        }));
+    }))
+        .addCommand(new Command("upsert")
+        .description("Create or update a prompt template.")
+        .option("--id <id>", "Existing template UUID to update. Omit to create.")
+        .option("--slug <slug>", "Stable slug (kebab-case).")
+        .option("--name <name>", "Human-readable name.")
+        .option("--description <text>", "Short description.")
+        .option("--kind <kind>", "Template kind: ai_column_system, scoring_rubric, or other.")
+        .option("--body <text>", "Prompt body.")
+        .option("--body-file <path>", "Path to a file containing the prompt body.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction(`${surface} upsert`, options, async () => {
+            const body = {};
+            if (readOption(options.id))
+                body.id = readOption(options.id);
+            if (readOption(options.slug))
+                body.slug = readOption(options.slug);
+            if (readOption(options.name))
+                body.name = readOption(options.name);
+            const description = readClearableOption(options.description);
+            if (description !== undefined)
+                body.description = description;
+            if (readOption(options.kind))
+                body.kind = readOption(options.kind);
+            if (readOption(options.body))
+                body.body = readOption(options.body);
+            else {
+                const path = readOption(options.bodyFile);
+                if (path) {
+                    const fs = await import("node:fs/promises");
+                    body.body = await fs.readFile(path, "utf8");
+                }
+            }
+            return requestOxygen("/api/cli/templates/upsert", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("archive")
+        .description("Archive a prompt template. Seeded templates cannot be archived.")
+        .argument("<id>", "Template UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction(`${surface} archive`, options, () => requestOxygen("/api/cli/templates/archive", { method: "POST", body: { id } }));
+    }));
+}
+export function registerPromptsFamily(program, handleAsyncAction) {
+    program.addCommand(buildPromptTemplatesCommand("prompts", "Reusable prompt templates layered into AI columns at run time."));
+}

package/dist/commands/publishing.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerPublishingFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;