@zeniai/client-epic-state 5.2.4 → 5.2.5

package/lib/view/aiCfoView/aiCfoViewState.d.ts

@@ -29,6 +29,15 @@ export interface AiCfoViewUIState {
      */
     aiCfoSidePanelHostPageKey?: string;
     currentChatSessionId?: ID;
+    /**
+     * Whether the AI CFO page body shows the Skills browser instead of the chat.
+     *
+     * In Redux rather than component state because the entry that opens it lives in the
+     * app drawer's rail (`AiCfoMenuContent`, reached via both `AppDrawer` on desktop and
+     * the sidebar drawer on mobile) while the browser renders in `AiCfoPage` — sibling
+     * subtrees with no common owner below the store.
+     */
+    isSkillsBrowserOpen?: boolean;
     lastContextMessage?: string;
     lastContextStatus?: ContextStatus;
 }
@@ -47,12 +56,137 @@ export interface Skill {
      */
     exampleHints: string[];
     hasScripts: boolean;
+    /**
+     * Whether the signed-in user authored this skill. Distinct from `isOwnedByTenant`, and
+     * the stricter of the two: writes require ownership, so a colleague's shared skill is
+     * `isOwnedByTenant: true` and `isMine: false`. False for a Zeni default.
+     */
+    isMine: boolean;
+    /** False for a Zeni default, true for a skill this tenant owns. */
+    isOwnedByTenant: boolean;
     macroId: string;
     name: string;
     semver: string | null;
+    /** ISO timestamp of the latest version, for the list's "last updated" column. */
+    updatedAt: string | null;
+    /**
+     * 'private' (author-only) or 'tenant' (everyone). Null for Zeni defaults, where it does
+     * not apply — and also null for a value this client does not recognise, which is
+     * deliberate: consumers render no audience badge rather than a wrong one, and adding a
+     * third tier server-side then surfaces here as a code change instead of silently
+     * matching none of the branches.
+     *
+     * The same union as {@link SkillDraft.visibility}. It was `string | null`, which left
+     * every consumer comparing against bare literals with no compile-time backing on the
+     * READ path while the write path had it.
+     */
+    visibility: SkillVisibility | null;
+}
+/** One skill's prompt plus the rendered card, from GET /1.0/skills/<macroId>. */
+export interface SkillDetail {
+    artifact: string;
+    artifactTitle: string;
+    instructions: string;
+    instructionsCharCount: number;
+    skill: Skill;
 }
 export interface SkillsState extends FetchStateAndError {
+    /**
+     * Whether the signed-in user may publish a skill tenant-wide. From the server, which
+     * is the only place that knows: it is a scope granted to admin roles. Starts false so
+     * the control is withheld until the server grants it.
+     */
+    canPublish: boolean;
+    /**
+     * Skills deleted locally, so a list response that was already in flight cannot put
+     * them back.
+     *
+     * The delete and the refetch race by construction — a save emits `fetchSkills`, and a
+     * delete can land while that is outstanding — and `fetchSkillsSuccess` replaces the
+     * array wholesale. Without this the row reappears, which reads as the delete having
+     * failed. Entries are dropped once a response arrives that no longer contains them,
+     * so this cannot grow without bound or outlive the server agreeing.
+     */
+    deletedMacroIds: string[];
     skills: Skill[];
+    /**
+     * Whether the feature is on for this tenant. Starts false so the Skills entry
+     * stays hidden until the server says otherwise — an empty `skills` list is not
+     * evidence either way.
+     */
+    skillsEnabled: boolean;
+}
+/**
+ * What the editor submits. Mirrors the server's write model, which is deliberately
+ * narrower than a skill: `scripts`, `tenantId`, `macroId` and menu-visibility are all
+ * rejected there, so they have no place here either.
+ */
+/** Who can see a skill. 'private' is its author only, 'tenant' is everyone. */
+export type SkillVisibility = 'private' | 'tenant';
+export interface SkillDraft {
+    /** One line under the name in the menu. What makes a list browsable. */
+    description: string | null;
+    /** The prompt. Multi-paragraph — this is the skill, functionally. */
+    instructions: string;
+    /** The `/` command and the menu row's title. */
+    name: string;
+    /**
+     * The audience to SET, or null to leave it exactly as it is.
+     *
+     * Required, and null is a real choice rather than an oversight, because the two are
+     * not interchangeable on the wire: the server treats an omitted visibility as
+     * "unchanged" and an explicit 'private' as "make this private". A caller who cannot
+     * publish must therefore send null — sending 'private' would unpublish a tenant-wide
+     * skill on every unrelated edit, silently and with a 200.
+     */
+    visibility: SkillVisibility | null;
+}
+/** One row of a skill's history. Metadata only — bodies are read per version. */
+export interface SkillVersion {
+    /** Menu name AT this version, so a rename is visible in the list. */
+    displayName: string | null;
+    instructionsCharCount: number;
+    isActive: boolean;
+    /** Whether this is the version the `/` menu runs. */
+    isLatest: boolean;
+    semver: string | null;
+    updatedAt: string | null;
+    version: number;
+}
+/**
+ * One historical version's prompt, fetched on demand for a restore.
+ *
+ * Separate from `skillDetail`, which holds the LIVE version: a restore needs both at once
+ * — the old body to seed the form, the current skill for its name and id — so writing the
+ * pinned body into `skillDetail` would lose the thing being restored onto.
+ */
+export interface SkillVersionBodyState extends FetchStateAndError {
+    instructions: string | undefined;
+    /** Which (skill, version) `instructions` belongs to, so a stale response is dropped. */
+    macroId: string | undefined;
+    version: number | undefined;
+}
+export interface SkillVersionsState extends FetchStateAndError {
+    /** Which skill `versions` belongs to, so a stale response is never rendered. */
+    macroId: string | undefined;
+    versions: SkillVersion[];
+}
+/**
+ * In-flight state for authoring. Separate from `skillDetail` because a save keeps the
+ * skill on screen while it runs — the form needs to disable itself and show the error
+ * without the prompt it is editing disappearing underneath.
+ */
+export interface SkillMutationState extends FetchStateAndError {
+    /**
+     * The skill the last successful save produced, so the caller can select it without
+     * refetching the list. Undefined until a save succeeds.
+     */
+    savedMacroId: string | undefined;
+}
+export interface SkillDetailState extends FetchStateAndError {
+    detail: SkillDetail | undefined;
+    /** Which skill `detail` belongs to, so a stale response is never rendered. */
+    macroId: string | undefined;
 }
 export interface AiCfoViewState extends FetchStateAndError {
     allChatSessionIds: ID[];
@@ -67,8 +201,16 @@ export interface AiCfoViewState extends FetchStateAndError {
         reasoning: FetchStateAndError;
         thought: FetchStateAndError;
     }>;
-    /** Chat-visible skills for the `/` menu. */
+    /** The skill whose prompt is open in the Skills browser. */
+    skillDetail: SkillDetailState;
+    /** Create / save-new-version / delete, while one is in flight. */
+    skillMutation: SkillMutationState;
+    /** Chat-visible skills for the `/` menu and the Skills browser. */
     skills: SkillsState;
+    /** A historical version's prompt, while a restore is being set up. */
+    skillVersionBody: SkillVersionBodyState;
+    /** Version history for the skill open in the browser. */
+    skillVersions: SkillVersionsState;
     stopSubmitStateByChatSessionId: Record<ID, FetchStateAndError>;
     /** Keyed by `page_context` query value (e.g. balance_sheet). */
     suggestedQuestionsByPageContext: Partial<Record<AiCfoSuggestedQuestionsPageContext, SuggestedQuestionsForPageContext>>;

package/lib/view/aiCfoView/epics/deleteSkillEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { deleteSkill, deleteSkillFailure, deleteSkillSuccess } from '../aiCfoViewReducer';
+export type ActionType = ReturnType<typeof deleteSkill> | ReturnType<typeof deleteSkillSuccess> | ReturnType<typeof deleteSkillFailure>;
+/** DELETE /1.0/skills/{macroId} — soft-deletes every version, frees the name. */
+export declare const deleteSkillEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/aiCfoView/epics/deleteSkillEpic.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSkillEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const aiCfoViewReducer_1 = require("../aiCfoViewReducer");
+/** DELETE /1.0/skills/{macroId} — soft-deletes every version, frees the name. */
+const deleteSkillEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiCfoViewReducer_1.deleteSkill.match), 
+// mergeMap for the same reason as the save: cancelling a delete does not un-delete
+// it, and two deletes are for different skills anyway.
+(0, operators_1.mergeMap)((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}`;
+    return zeniAPI.deleteAndGetJSON(url).pipe((0, operators_1.mergeMap)((response) => {
+        // isSuccessStatus, NOT isSuccessResponse: the latter also requires a non-null
+        // `data`, and a successful DELETE here is a 204 with no body. Using it reported
+        // every completed delete as a failure — the row stayed on screen and a retry
+        // 404'd on a skill that was already gone. deleteChatSessionEpic uses the status
+        // check for the same reason.
+        if ((0, responsePayload_1.isSuccessStatus)(response)) {
+            return (0, rxjs_1.of)((0, aiCfoViewReducer_1.deleteSkillSuccess)({ macroId }));
+        }
+        return (0, rxjs_1.of)((0, aiCfoViewReducer_1.deleteSkillFailure)(response.status));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, aiCfoViewReducer_1.deleteSkillFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Delete skill REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));
+exports.deleteSkillEpic = deleteSkillEpic;

package/lib/view/aiCfoView/epics/fetchSkillDetailEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { fetchSkillDetail, fetchSkillDetailFailure, fetchSkillDetailSuccess } from '../aiCfoViewReducer';
+export type ActionType = ReturnType<typeof fetchSkillDetail> | ReturnType<typeof fetchSkillDetailSuccess> | ReturnType<typeof fetchSkillDetailFailure>;
+/** GET {aiCfoMicroServiceBaseUrl}/1.0/skills/{macroId} — one skill's prompt + card. */
+export declare const fetchSkillDetailEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/aiCfoView/epics/fetchSkillDetailEpic.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSkillDetailEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const aiCfoViewReducer_1 = require("../aiCfoViewReducer");
+const toSkillDetail_1 = require("./toSkillDetail");
+// Deliberately minimal: the browser already holds the full Skill from the list, and
+// this response's `skill` block exists so a deep link can open a detail view without
+// the list ever having been fetched.
+/** GET {aiCfoMicroServiceBaseUrl}/1.0/skills/{macroId} — one skill's prompt + card. */
+const fetchSkillDetailEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiCfoViewReducer_1.fetchSkillDetail.match), 
+// switchMap: clicking through the list fires one of these per skill, and only the
+// one the user is currently looking at matters. The reducer also drops responses
+// whose macroId no longer matches, so a cancelled-but-in-flight request cannot
+// render the wrong prompt under the right title.
+(0, operators_1.switchMap)((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}`;
+    return zeniAPI.getJSON(url).pipe((0, operators_1.mergeMap)((response) => {
+        // Shared mapper and shared guard. This epic used to keep its own `toSkill`
+        // and default a missing prompt to '', so the same malformed body showed an
+        // empty prompt here and failed the read elsewhere — and `isMine` was nearly
+        // added to only two of the three copies.
+        if ((0, responsePayload_1.isSuccessResponse)(response) &&
+            (0, toSkillDetail_1.isSkillDetailPayload)(response.data)) {
+            return (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillDetailSuccess)({
+                detail: (0, toSkillDetail_1.toSkillDetail)(response.data),
+                macroId,
+            }));
+        }
+        return (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillDetailFailure)({ error: response.status, macroId }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillDetailFailure)({
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch skill detail REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+        macroId,
+    }))));
+}));
+exports.fetchSkillDetailEpic = fetchSkillDetailEpic;

package/lib/view/aiCfoView/epics/fetchSkillVersionBodyEpic.d.ts

@@ -0,0 +1,13 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { fetchSkillVersionBody, fetchSkillVersionBodyFailure, fetchSkillVersionBodySuccess } from '../aiCfoViewReducer';
+export type ActionType = ReturnType<typeof fetchSkillVersionBody> | ReturnType<typeof fetchSkillVersionBodySuccess> | ReturnType<typeof fetchSkillVersionBodyFailure>;
+/**
+ * GET /1.0/skills/{macroId}?version=N — one historical version's prompt.
+ *
+ * Only used to seed a restore. The history list carries metadata only, deliberately: a
+ * 20-version history would otherwise be a 240kB response for a panel that shows dates.
+ */
+export declare const fetchSkillVersionBodyEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/aiCfoView/epics/fetchSkillVersionBodyEpic.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSkillVersionBodyEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const aiCfoViewReducer_1 = require("../aiCfoViewReducer");
+const toSkillDetail_1 = require("./toSkillDetail");
+/**
+ * GET /1.0/skills/{macroId}?version=N — one historical version's prompt.
+ *
+ * Only used to seed a restore. The history list carries metadata only, deliberately: a
+ * 20-version history would otherwise be a 240kB response for a panel that shows dates.
+ */
+const fetchSkillVersionBodyEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiCfoViewReducer_1.fetchSkillVersionBody.match), 
+// switchMap: a read, and only the version the user last clicked matters. The reducer
+// also drops a response whose (macroId, version) no longer matches, so a
+// cancelled-but-in-flight request cannot seed the form with the wrong body.
+(0, operators_1.switchMap)((action) => {
+    const { macroId, version } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}?version=${encodeURIComponent(String(version))}`;
+    return zeniAPI.getJSON(url).pipe((0, operators_1.mergeMap)((response) => {
+        // `instructions` checked, not just `data`: the payload TYPE says the field is
+        // required, and the network is under no obligation to agree. Without this the
+        // epic reported success with `instructions: undefined`, and the browser — which
+        // holds the editor closed until a body arrives — showed "Loading this version…"
+        // for ever, with no error and no way forward.
+        if ((0, responsePayload_1.isSuccessResponse)(response) && (0, toSkillDetail_1.hasPromptBody)(response.data)) {
+            return (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillVersionBodySuccess)({
+                macroId,
+                version,
+                instructions: response.data.instructions,
+            }));
+        }
+        // A malformed 2xx is a failure. An empty STRING is not malformed and is allowed
+        // through: the editor's own minimum-length rule refuses to save it, so the user
+        // sees a validation message on a form they can fix rather than a dead end.
+        return (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillVersionBodyFailure)({
+            macroId,
+            version,
+            error: response.status,
+        }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillVersionBodyFailure)({
+        macroId,
+        version,
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch skill version body REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+    }))));
+}));
+exports.fetchSkillVersionBodyEpic = fetchSkillVersionBodyEpic;

package/lib/view/aiCfoView/epics/fetchSkillVersionsEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { fetchSkillVersions, fetchSkillVersionsFailure, fetchSkillVersionsSuccess } from '../aiCfoViewReducer';
+export type ActionType = ReturnType<typeof fetchSkillVersions> | ReturnType<typeof fetchSkillVersionsSuccess> | ReturnType<typeof fetchSkillVersionsFailure>;
+/** GET /1.0/skills/{macroId}/versions — the history panel. */
+export declare const fetchSkillVersionsEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/aiCfoView/epics/fetchSkillVersionsEpic.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSkillVersionsEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const aiCfoViewReducer_1 = require("../aiCfoViewReducer");
+const toVersion = (payload) => ({
+    version: payload.version,
+    semver: payload.semver ?? null,
+    displayName: payload.display_name ?? null,
+    updatedAt: payload.updated_at ?? null,
+    // Defaulted defensively: these are booleans the server always sends, but a malformed
+    // 2xx should render a row as inactive-and-not-latest rather than as the live one.
+    isActive: payload.is_active === true,
+    isLatest: payload.is_latest === true,
+    instructionsCharCount: payload.instructions_char_count ?? 0,
+});
+/** GET /1.0/skills/{macroId}/versions — the history panel. */
+const fetchSkillVersionsEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiCfoViewReducer_1.fetchSkillVersions.match), 
+// switchMap: a read, and only the skill currently open matters. The reducer also
+// drops responses whose macroId no longer matches, so a cancelled-but-in-flight
+// request cannot render one skill's history under another's title.
+(0, operators_1.switchMap)((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}/versions`;
+    return zeniAPI.getJSON(url).pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            return (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillVersionsSuccess)({
+                macroId,
+                // Guard the array: a malformed 2xx without `versions` must not crash .map.
+                versions: (response.data.versions ?? []).map(toVersion),
+            }));
+        }
+        return (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillVersionsFailure)({ macroId, error: response.status }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillVersionsFailure)({
+        macroId,
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch skill versions REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+    }))));
+}));
+exports.fetchSkillVersionsEpic = fetchSkillVersionsEpic;

package/lib/view/aiCfoView/epics/fetchSkillsEpic.js

@@ -5,6 +5,7 @@ const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const responsePayload_1 = require("../../../responsePayload");
 const aiCfoViewReducer_1 = require("../aiCfoViewReducer");
+const toSkillDetail_1 = require("./toSkillDetail");
 const isNonBlankString = (value) => typeof value === 'string' && value.trim() !== '';
 // parameter_hints is a free-form {param: exampleValue(s)} map; flatten its non-blank
 // string values (a single string or an array of them) into display-ready "try: …"
@@ -30,14 +31,12 @@ const toExampleHints = (parameterHints) => {
     // a broken duplicate to the user — dedupe across parameter keys and array entries.
     return Array.from(new Set(hints));
 };
+// Only the LIST route returns parameter_hints, so this is the one call site that has
+// hints to spread in. Everything else about a summary comes from the shared base mapper,
+// so a new `Skill` field cannot land here and be missed on the detail path.
 const toSkill = (skillSummaryPayload) => ({
-    macroId: skillSummaryPayload.macro_id,
-    name: skillSummaryPayload.name,
-    displayName: skillSummaryPayload.display_name,
-    description: skillSummaryPayload.description,
-    semver: skillSummaryPayload.semver,
+    ...(0, toSkillDetail_1.toBaseSkill)(skillSummaryPayload),
     exampleHints: toExampleHints(skillSummaryPayload.parameter_hints),
-    hasScripts: skillSummaryPayload.has_scripts,
 });
 /** GET {aiCfoMicroServiceBaseUrl}/1.0/skills — chat-visible skills for the `/` menu. */
 const fetchSkillsEpic = (actions$, 
@@ -55,6 +54,12 @@ _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiCfoViewReducer_1.fe
             // Guard the array: a malformed 2xx body without `skills` must not crash .map.
             return (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillsSuccess)({
                 skills: (response.data.skills ?? []).map(toSkill),
+                // === true, not a truthy check: a body missing the field entirely
+                // must read as "off" so the Skills entry stays hidden by default.
+                skillsEnabled: response.data.skills_enabled === true,
+                // Same discipline: a body without the field must withhold the publish
+                // control, not grant it.
+                canPublish: response.data.can_publish === true,
             }));
         }
         return (0, rxjs_1.of)((0, aiCfoViewReducer_1.fetchSkillsFailure)(response.status));

package/lib/view/aiCfoView/epics/saveSkillEpic.d.ts

@@ -0,0 +1,14 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { fetchSkillVersions, fetchSkills, saveSkill, saveSkillFailure, saveSkillSuccess } from '../aiCfoViewReducer';
+export type ActionType = ReturnType<typeof saveSkill> | ReturnType<typeof saveSkillSuccess> | ReturnType<typeof saveSkillFailure> | ReturnType<typeof fetchSkills> | ReturnType<typeof fetchSkillVersions>;
+/**
+ * POST /1.0/skills (create) or PUT /1.0/skills/{macroId} (new version).
+ *
+ * One epic for both because they are the same action to a user — "save what I wrote" —
+ * and the server answers both with the detail payload. Splitting them would duplicate
+ * the payload mapping and the error handling for a difference the form does not have.
+ */
+export declare const saveSkillEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/aiCfoView/epics/saveSkillEpic.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSkillEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const aiCfoViewReducer_1 = require("../aiCfoViewReducer");
+const aiCfoViewSelector_1 = require("../aiCfoViewSelector");
+const toSkillDetail_1 = require("./toSkillDetail");
+/**
+ * POST /1.0/skills (create) or PUT /1.0/skills/{macroId} (new version).
+ *
+ * One epic for both because they are the same action to a user — "save what I wrote" —
+ * and the server answers both with the detail payload. Splitting them would duplicate
+ * the payload mapping and the error handling for a difference the form does not have.
+ */
+const saveSkillEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiCfoViewReducer_1.saveSkill.match), 
+// mergeMap, NOT switchMap: a save is a write. Cancelling an in-flight one because
+// another started does not un-send it, it just hides the outcome — and for a
+// create that means a skill exists that the user was never told about.
+(0, operators_1.mergeMap)((action) => {
+    const { draft, macroId } = action.payload;
+    const base = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills`;
+    const body = {
+        name: draft.name,
+        instructions: draft.instructions,
+        description: draft.description,
+        // Sent as the menu name too. The server derives the unique `/` slug from it, so
+        // letting the two drift would make the command stop matching the row's title.
+        display_name: draft.name,
+        // Spread, not `visibility: draft.visibility`: the server distinguishes an ABSENT
+        // visibility ("leave it alone") from an explicit null or 'private' ("make it
+        // private"). Sending the key with a null value would unpublish a tenant-wide
+        // skill on any edit by someone who cannot publish.
+        //
+        // `!= null`, not `!== null`: the type says this is always present, but the value
+        // arrives from a component, and an untyped caller omitting it would spread
+        // `{visibility: undefined}` — a key present with no value, which is the one shape
+        // the rule above is about. The looser check costs nothing and closes it.
+        ...(draft.visibility != null && { visibility: draft.visibility }),
+    };
+    const request$ = macroId != null && macroId !== ''
+        ? zeniAPI.putAndGetJSON(`${base}/${encodeURIComponent(macroId)}`, body)
+        : zeniAPI.postAndGetJSON(base, body);
+    return request$.pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) &&
+            (0, toSkillDetail_1.isSkillDetailPayload)(response.data)) {
+            const saved = response.data;
+            const savedMacroId = saved.skill.macro_id;
+            const emitted = [
+                (0, aiCfoViewReducer_1.saveSkillSuccess)({
+                    macroId: savedMacroId,
+                    // The response is a full detail read — carried through so an editor left
+                    // on this skill shows what it just saved rather than the previous prompt.
+                    detail: (0, toSkillDetail_1.toSkillDetail)(saved),
+                }),
+                // Refetch rather than splice the response in: a create changes the list's
+                // ordering and an update can change the name it is sorted by, so a local
+                // insert would put the row somewhere the next load moves it away from.
+                (0, aiCfoViewReducer_1.fetchSkills)(),
+            ];
+            // A save adds a version, so the history panel is one behind — but only
+            // refetch when this skill is still the one on screen. `fetchSkillVersions`
+            // takes ownership of the versions slice, so firing it for a skill the user
+            // has already left would cancel the history of whatever they opened next.
+            if ((0, aiCfoViewSelector_1.getSkillDetail)(state$.value).macroId === savedMacroId) {
+                emitted.push((0, aiCfoViewReducer_1.fetchSkillVersions)({ macroId: savedMacroId }));
+            }
+            return (0, rxjs_1.of)(...emitted);
+        }
+        // A malformed 2xx is a failure, not a silent success: reporting "saved" when
+        // no skill came back leaves the user believing work was persisted.
+        return (0, rxjs_1.of)((0, aiCfoViewReducer_1.saveSkillFailure)(response.status));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, aiCfoViewReducer_1.saveSkillFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Save skill REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));
+exports.saveSkillEpic = saveSkillEpic;

package/lib/view/aiCfoView/epics/setSkillVisibilityEpic.d.ts

@@ -0,0 +1,14 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { fetchSkills, setSkillVisibility, setSkillVisibilityFailure, setSkillVisibilitySuccess } from '../aiCfoViewReducer';
+export type ActionType = ReturnType<typeof setSkillVisibility> | ReturnType<typeof setSkillVisibilitySuccess> | ReturnType<typeof setSkillVisibilityFailure> | ReturnType<typeof fetchSkills>;
+/**
+ * PUT /1.0/skills/{macroId}/visibility — publish or unpublish, without a new version.
+ *
+ * Its own route rather than the prompt PUT: that one requires name and instructions, so a
+ * visibility-only change cannot be expressed through it, and sending the whole prompt back
+ * to flip one field would create a version whose prompt is identical to its parent's.
+ */
+export declare const setSkillVisibilityEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/aiCfoView/epics/setSkillVisibilityEpic.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSkillVisibilityEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const aiCfoViewReducer_1 = require("../aiCfoViewReducer");
+const toSkillDetail_1 = require("./toSkillDetail");
+/**
+ * PUT /1.0/skills/{macroId}/visibility — publish or unpublish, without a new version.
+ *
+ * Its own route rather than the prompt PUT: that one requires name and instructions, so a
+ * visibility-only change cannot be expressed through it, and sending the whole prompt back
+ * to flip one field would create a version whose prompt is identical to its parent's.
+ */
+const setSkillVisibilityEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiCfoViewReducer_1.setSkillVisibility.match), 
+// mergeMap, like the other writes: cancelling a write in flight does not un-send it,
+// it only hides the outcome — and for a publish that means a skill sitting in every
+// colleague's menu with nobody told it got there.
+(0, operators_1.mergeMap)((action) => {
+    const { macroId, visibility } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}/visibility`;
+    return zeniAPI.putAndGetJSON(url, { visibility }).pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) &&
+            (0, toSkillDetail_1.isSkillDetailPayload)(response.data)) {
+            return (0, rxjs_1.of)((0, aiCfoViewReducer_1.setSkillVisibilitySuccess)({
+                macroId,
+                detail: (0, toSkillDetail_1.toSkillDetail)(response.data),
+            }), 
+            // The list carries the badge that shows the audience, so it is now stale.
+            (0, aiCfoViewReducer_1.fetchSkills)());
+        }
+        return (0, rxjs_1.of)((0, aiCfoViewReducer_1.setSkillVisibilityFailure)(response.status));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, aiCfoViewReducer_1.setSkillVisibilityFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Set skill visibility REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));
+exports.setSkillVisibilityEpic = setSkillVisibilityEpic;