@hiveku-apps/sync 0.3.3 → 0.3.6

package/README.md

@@ -8,6 +8,8 @@ Local sync CLI for a Hiveku account. Pairs with the Hiveku MCP server at
 2. **`hiveku-sync pull`** — fetch the account's memory/rules/skills via the
    `memory_list` MCP tool and write each entry as a Markdown file with
    YAML frontmatter (name, type, domain, department, version, updated_at).
+   It also writes the account memory (see "Account memory" below) to
+   `hiveku-data/account/ACCOUNT_MEMORY.md`, read-only.
 
 The goal: open one folder per Hiveku tenant in VS Code with Claude Code,
 and the local `.md` files become the source-of-truth Claude reads. Tools
@@ -106,9 +108,52 @@ This writes, merge-safely (only Hiveku-managed regions are touched):
   and deprecated).
 
 Pass `--trust` to pre-trust the folder in `~/.codex/config.toml` (so Codex loads
-the repo config without its first-run trust prompt). Codex ignores repo-level
-approval/sandbox config, so the safe-work rules ship as instructions in
-`AGENTS.md`, not enforced permissions.
+the repo config without its first-run trust prompt).
+
+**Approvals.** Codex asks first only for a **fixed list** of high-risk Hiveku
+tools: the 246 names in `src/codex-prompt-tools.json`, the same list as the
+Hiveku Codex plugin 0.1.16. It includes `deploy_site`, `site_delete`,
+`project_files_bulk_save` and every `hiveku_batch`, and it is written as
+`[mcp_servers.hiveku.tools.<tool>] approval_mode = "prompt"`. **Every other tool
+on the `hiveku` server runs without asking** (`default_tools_approval_mode =
+"approve"`), and that includes many deletes and sends, for example
+`crm_delete_contact`, `content_delete` and `survey_send`. So the safe-work rules
+in `AGENTS.md` still apply to every tool: they are instructions, not enforced
+permissions.
+
+**Your own setting wins.** When `.codex/config.toml` already has your own
+`[mcp_servers.hiveku.tools.<tool>]` table for a listed tool, outside the
+hiveku-sync block, hiveku-sync leaves that tool out of its block (TOML does not
+allow a table to be declared twice) and prints a line naming it. If your table
+sets no `approval_mode`, Codex uses the server default, `approve`, so that tool
+runs without asking, and the line says so. Add `approval_mode = "prompt"` to
+your table to have it ask first.
+
+hiveku-sync checks the updated file before it writes anything. It stops only
+when its own block would declare a table or key that another line of the file
+also declares, for example your own copy of `[mcp_servers.hiveku]`. Then it
+writes nothing in the folder and names that line by its number. It reads the
+file as Codex does, so TOML 1.1 syntax and a byte-order mark at the start are
+fine, and it leaves the rest of the file, including any line it cannot read,
+to you and Codex.
+
+The folder has to carry the list itself: Codex uses the folder's
+`[mcp_servers.hiveku]` instead of the plugin's, including for approvals, so the
+plugin's prompts do not apply here.
+
+Headless and bypass modes:
+
+- **`codex exec` never stops to ask.** Under a `read-only` or `workspace-write`
+  sandbox it cancels the listed calls and runs the rest.
+- **The bypass flag skips every prompt.** With
+  `--dangerously-bypass-approvals-and-sandbox` (`--yolo`), in `codex exec` or in
+  interactive `codex`, and with `danger-full-access` in `codex exec`
+  (`-s danger-full-access` or `sandbox_mode = "danger-full-access"`), the listed
+  tools run unattended too, like every other Hiveku tool.
+
+Folders set up by a hiveku-sync without these prompts (0.3.5 and earlier)
+approve every tool: run `hiveku-sync codex` in them once, with a release that has
+them, to add the prompts.
 
 > **This vs. the plugin.** For a single account, you can instead install the
 > published [Hiveku Codex plugin](https://github.com/locus2012/hiveku-codex-plugin)
@@ -182,3 +227,25 @@ For **projects**, `hiveku-sync push` / `deploy` write straight back to Hiveku
 (see "Coder projects" above). For **memory/rules/skills**, `pull` is read-only —
 persist changes with the `memory_create` / `memory_update` / `memory_delete` MCP
 tools through Claude, then `hiveku-sync pull` to refresh the local copies.
+
+## Account memory
+
+The account memory is the business facts every Hiveku department agent reads.
+Owners and admins edit it on the Hiveku dashboard, under Account memory
+(`https://app.hiveku.com/<account id>/dashboard/memory`); no tool sets it.
+
+`pull` reads it with `account_memory_get` and writes one file,
+`hiveku-data/account/ACCOUNT_MEMORY.md`, the same file, byte for byte, that the
+Hiveku plugin and the VS Code extension write. The file is read-only on disk and
+starts with a note saying where it is edited, with the link (the unscoped
+`https://app.hiveku.com/dashboard/memory` when the account id cannot be read),
+and that it is internal to the team. The owners' text comes first, then the suggestions
+agents and team members made that an owner has not reviewed yet, each with who
+suggested it and when. The two account-memory rows (`account` and
+`account-suggestions`) are never written under `memory/`, even when an older
+server still lists them.
+
+Nothing uploads this file: `push`, `commit` and `status` leave any
+`hiveku-data/account/` folder out, and the next `pull` replaces it. To add a
+fact, suggest it with the `account_memory_append` tool; an owner keeps or
+removes it on the dashboard.

package/bin/hiveku-sync.mjs

@@ -116,6 +116,30 @@ Ship a project (the agent-native deploy loop):
 Profiles: full, sales, marketing, helpdesk, pm, dev
 `;
 
+/**
+ * Plain lines naming the listed tools whose own config.toml table hiveku-sync
+ * left alone. A table that sets no approval_mode gets the server default
+ * ("approve"), so those tools are said to run without asking.
+ */
+function userToolTablesLines({ userToolTables = [], userTablesWithoutApprovalMode = [] }) {
+  const lines = [];
+  const kept = userToolTables.filter((tool) => !userTablesWithoutApprovalMode.includes(tool));
+  if (kept.length) {
+    const them = kept.length === 1 ? 'it' : 'them';
+    lines.push(
+      `your own setting kept for ${kept.join(', ')}: .codex/config.toml sets ${them} outside the hiveku-sync block, so hiveku-sync did not add its "ask first" setting for ${them}.`,
+    );
+  }
+  const bare = userTablesWithoutApprovalMode;
+  if (bare.length) {
+    const one = bare.length === 1;
+    lines.push(
+      `${bare.join(', ')} ${one ? 'runs' : 'run'} without asking: your own ${one ? 'table' : 'tables'} for ${one ? 'it' : 'them'} in .codex/config.toml, outside the hiveku-sync block, ${one ? 'sets' : 'set'} no approval_mode, so Codex uses the server default ("approve"). To have ${one ? 'it' : 'them'} ask first, add approval_mode = "prompt" to ${one ? 'that table' : 'those tables'}.`,
+    );
+  }
+  return lines;
+}
+
 function commitMessageFrom(flags) {
   // --commit "msg" | --commit=msg | -m "msg" | --message "msg". A bare --commit
   // (boolean true) means "commit with no message" → fall back to the default.
@@ -163,6 +187,7 @@ async function main() {
             ? `    MCP auth: inlined your OLYMPUS_API_KEY`
             : `    MCP auth: reads the OLYMPUS_API_KEY env var — after pasting your key into .env, run \`hiveku-sync codex\` to inline it, or \`export OLYMPUS_API_KEY=...\``,
         );
+        for (const line of userToolTablesLines(result.codex)) console.log(`    ${line}`);
         if (result.codex.trust === 'added') console.log(`    trust: pre-trusted this folder in ~/.codex/config.toml`);
       }
       console.log(`  then: cd ${result.folder} && hiveku-sync pull`);
@@ -172,6 +197,7 @@ async function main() {
       const result = await runCodex({ folder: positional[0], trust: !!flags['trust'] });
       console.log(`Codex lane ready in ${result.folder} (profile=${result.profile})`);
       console.log(`  AGENTS.md + .codex/config.toml written (git-ignored).`);
+      for (const line of userToolTablesLines(result)) console.log(`  ${line}`);
       console.log(
         result.inlinedKey
           ? `  MCP auth: inlined OLYMPUS_API_KEY from .env.`
@@ -189,6 +215,13 @@ async function main() {
       for (const [type, count] of Object.entries(summary.by_type)) {
         console.log(`  ${type}: ${count}`);
       }
+      if (summary.account_memory) {
+        const am = summary.account_memory;
+        console.log(
+          `  account memory: ${am.file} (read-only; ${am.version > 0 ? `version ${am.version}` : 'not written yet'}, ` +
+            `${am.suggestions} suggestion${am.suggestions === 1 ? '' : 's'} waiting). Owners edit it on the dashboard.`,
+        );
+      }
       if (summary.removed_remotely.length > 0) {
         console.log('\nNote: these files were present in the last sync but are no longer in Olympus:');
         for (const f of summary.removed_remotely) console.log(`  ${f}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiveku-apps/sync",
-  "version": "0.3.3",
+  "version": "0.3.6",
   "description": "Sync a Hiveku account's memory/rules/skills + coder projects into a local folder, and ship projects (push/deploy/pull-env) from the terminal. Pairs with the Hiveku MCP at core.hiveku.com/mcp so Claude Code can drive Hiveku tools per-folder.",
   "type": "module",
   "license": "MIT",

package/src/account-memory.mjs

@@ -0,0 +1,240 @@
+/**
+ * The account memory, pulled read-only.
+ *
+ * The account memory is the business facts every Hiveku department agent reads.
+ * It lives in two rows of account_ai_memory, and neither is a department:
+ *
+ *   domain `account`              the owner's document (owners and admins edit
+ *                                 it on the dashboard, nowhere else);
+ *   domain `account-suggestions`  one-line suggestions from agents, MCP clients
+ *                                 and team members, waiting for an owner's
+ *                                 Keep or Remove (JSON Lines).
+ *
+ * Neither row may land in the memory/ tree as if it were a department's
+ * document: `account-suggestions` would be raw JSON Lines, and a local edit to
+ * either would look like something `memory_update` could write back, which the
+ * server refuses. So `hiveku-sync pull` classifies both domains explicitly and
+ * writes one read-only file instead, in the same place the Hiveku plugin does:
+ *
+ *   hiveku-data/account/ACCOUNT_MEMORY.md
+ *
+ * from `account_memory_get`. Nothing in hiveku-sync ever uploads that file:
+ * there is no tool that sets the account memory, and `push` leaves the folder
+ * out (see isAccountMemoryPath).
+ */
+
+import { chmod } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+
+import { writeFileAtomic } from './util.mjs';
+
+export const ACCOUNT_MEMORY_DOMAIN = 'account';
+export const ACCOUNT_SUGGESTIONS_DOMAIN = 'account-suggestions';
+export const ACCOUNT_MEMORY_DOMAINS = new Set([ACCOUNT_MEMORY_DOMAIN, ACCOUNT_SUGGESTIONS_DOMAIN]);
+
+/** Folder and file, relative to the account folder (same layout as the plugin). */
+export const ACCOUNT_DATA_DIR = 'hiveku-data/account';
+export const ACCOUNT_MEMORY_FILE = `${ACCOUNT_DATA_DIR}/ACCOUNT_MEMORY.md`;
+
+export const APP_URL = 'https://app.hiveku.com';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export function isAccountMemoryDomain(domain) {
+  return typeof domain === 'string' && ACCOUNT_MEMORY_DOMAINS.has(domain.trim());
+}
+
+/**
+ * Where a memory_list row belongs. The two account domains are named
+ * explicitly, before any folder or department tag is looked at: they carry no
+ * department tag, so a generic rule would file them under memory/ (or, in a
+ * by-department layout, invent an "account" department).
+ *
+ *   { kind: 'account' }              the owner document (written from account_memory_get)
+ *   { kind: 'account-suggestions' }  the suggestions row (listed under the document)
+ *   { kind: 'knowledge', folder }    everything else, in its type's folder
+ */
+export function classifyMemoryEntry(entry, folder) {
+  const domain = typeof entry?.domain === 'string' ? entry.domain.trim() : '';
+  if (domain === ACCOUNT_MEMORY_DOMAIN) return { kind: 'account' };
+  if (domain === ACCOUNT_SUGGESTIONS_DOMAIN) return { kind: 'account-suggestions' };
+  return { kind: 'knowledge', folder };
+}
+
+/**
+ * True for a path (relative, forward or back slashes) inside the pulled
+ * account-memory folder, wherever that folder sits. `push` drops these paths,
+ * so the read-only copy can never be uploaded as site code.
+ */
+export function isAccountMemoryPath(relPath) {
+  const p = String(relPath || '').replace(/\\/g, '/').replace(/^\.?\//, '');
+  return p === ACCOUNT_DATA_DIR || p.startsWith(`${ACCOUNT_DATA_DIR}/`) || p.includes(`/${ACCOUNT_DATA_DIR}/`);
+}
+
+export const ACCOUNT_MEMORY_TOOL = 'account_memory_get';
+
+/** The builder's dashboard page (src/app/dashboard/memory, scoped mirror under /[accountId]). */
+const DASHBOARD_PATH = 'dashboard/memory';
+
+/*
+ * ONE FILE, THREE WRITERS. The Claude Code plugin (lib/account-memory.mjs),
+ * the VS Code extension (src/accountMemory.ts) and hiveku-sync all write
+ * hiveku-data/account/ACCOUNT_MEMORY.md, and the plugin reads its front matter
+ * back (`fetched_at`, for `pull --list` and `--stale`). So everything from here
+ * to writeReadOnly is a port of the plugin's normalizeAccountMemory,
+ * accountMemoryDashboardUrl and renderAccountMemoryFile, and
+ * test/account-memory.test.mjs compares the two byte for byte whenever a plugin
+ * checkout sits beside this repo. Change them together.
+ */
+
+/**
+ * The page where owners and admins edit it. Account-scoped when the account id
+ * is a real UUID (the scoped route opens on the right account for a person in
+ * several); the unscoped page otherwise, never a half-built URL.
+ */
+export function accountMemoryDashboardUrl(accountId, appUrl = APP_URL) {
+  const base = String(appUrl || APP_URL).replace(/\/+$/, '');
+  return typeof accountId === 'string' && UUID_RE.test(accountId)
+    ? `${base}/${accountId.toLowerCase()}/${DASHBOARD_PATH}`
+    : `${base}/${DASHBOARD_PATH}`;
+}
+
+/**
+ * The tool result, checked. account_memory_get returns the builder's
+ * `{ data: { content, version, updated_at, bytes, suggestions, suggestions_version,
+ * injected, truncated } }`. Anything else is an error, not an empty memory:
+ * writing "nothing written yet" over a real document because the shape moved
+ * would be a lie on disk.
+ */
+export function normalizeAccountMemory(payload) {
+  const inner = payload && typeof payload === 'object' && !Array.isArray(payload) && 'data' in payload ? payload.data : payload;
+  if (!inner || typeof inner !== 'object' || Array.isArray(inner)) {
+    throw new Error(`${ACCOUNT_MEMORY_TOOL} returned an unexpected shape (no object)`);
+  }
+  if (typeof inner.content !== 'string' || !Number.isFinite(Number(inner.version))) {
+    throw new Error(`${ACCOUNT_MEMORY_TOOL} returned an unexpected shape (no content or version)`);
+  }
+  const suggestions = Array.isArray(inner.suggestions) ? inner.suggestions : [];
+  return {
+    content: inner.content,
+    version: Number(inner.version),
+    updated_at: typeof inner.updated_at === 'string' ? inner.updated_at : null,
+    suggestions: suggestions
+      .filter((s) => s && typeof s === 'object' && typeof s.text === 'string' && s.text.trim())
+      .map((s) => ({
+        id: typeof s.id === 'string' ? s.id : '',
+        at: typeof s.at === 'string' ? s.at : '',
+        source: typeof s.source === 'string' && s.source.trim() ? s.source : 'Unknown',
+        text: s.text,
+      })),
+    suggestions_version: Number.isFinite(Number(inner.suggestions_version)) ? Number(inner.suggestions_version) : 0,
+    truncated: inner.truncated === true,
+  };
+}
+
+/** "2026-09-23 14:02 UTC", or the raw value when it is not a date. */
+function readableTime(value) {
+  if (!value) return 'unknown time';
+  const d = new Date(value);
+  if (Number.isNaN(d.getTime())) return String(value);
+  return `${d.toISOString().slice(0, 16).replace('T', ' ')} UTC`;
+}
+
+/** One line, no line breaks: a suggestion is one line on the server too. */
+function oneLine(value) {
+  return String(value).replace(/[\r\n\u2028\u2029]+/g, ' ').trim();
+}
+
+function yamlString(value) {
+  return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+/**
+ * The file text. Plain language: the person reading it may be the owner.
+ * Held suggestions (from the agents that talk to customers, and onboarding)
+ * are never in the tool's answer, so they are never here either.
+ */
+export function renderAccountMemoryFile({ memory, accountId, fetchedAt, appUrl = APP_URL }) {
+  const editUrl = accountMemoryDashboardUrl(accountId, appUrl);
+  const fm = [
+    '---',
+    `read_only: true`,
+    `source_tool: ${ACCOUNT_MEMORY_TOOL}`,
+    `version: ${memory.version}`,
+    ...(memory.updated_at ? [`updated_at: ${yamlString(memory.updated_at)}`] : []),
+    `suggestions: ${memory.suggestions.length}`,
+    `suggestions_version: ${memory.suggestions_version}`,
+    `fetched_at: ${yamlString(fetchedAt)}`,
+    `edit_url: ${yamlString(editUrl)}`,
+    '---',
+    '',
+  ];
+  const lines = [
+    '# Account memory',
+    '',
+    '> This is a read-only copy of the account memory, the facts about the business that every',
+    '> Hiveku department agent reads. Owners and admins edit it on the Hiveku dashboard:',
+    `> ${editUrl}`,
+    '>',
+    '> Changes made to this file are not saved to Hiveku. The next pull replaces this file, and',
+    '> nothing uploads it. To add a fact, suggest it with account_memory_append (an owner or admin',
+    '> reviews it on the dashboard), or ask an owner or admin to change the document there.',
+    '> It is internal to the team: do not quote it to customers.',
+    '',
+  ];
+  if (memory.version > 0 && memory.content.trim()) {
+    lines.push(`Version ${memory.version}, last changed ${readableTime(memory.updated_at)}.`);
+    if (memory.truncated) {
+      lines.push(
+        'Agents see a shortened version: with the suggestions, it is longer than the 8,000 characters they read.',
+      );
+    }
+    lines.push('', '---', '', memory.content.replace(/\s+$/, ''), '', '---', '');
+  } else {
+    lines.push('Nothing has been written yet. An owner or admin can start it on the dashboard.', '');
+  }
+
+  lines.push('# Suggestions from agents, not reviewed yet', '');
+  if (memory.suggestions.length) {
+    lines.push(
+      'These lines are not part of the account memory until an owner or admin keeps them on the dashboard.',
+      '',
+    );
+    for (const s of memory.suggestions) {
+      lines.push(`- ${oneLine(s.text)} (suggested by ${oneLine(s.source)}, ${readableTime(s.at)})`);
+    }
+  } else {
+    lines.push('None waiting.');
+  }
+  lines.push('');
+  return fm.join('\n') + lines.join('\n');
+}
+
+/** Write the file read-only (0444), replacing any earlier read-only copy. */
+export async function writeReadOnly(path, contents) {
+  if (existsSync(path)) {
+    // A 0444 file can be renamed over on POSIX, but not on Windows; open it up
+    // for the replace, then lock it again.
+    await chmod(path, 0o644).catch(() => {});
+  }
+  await writeFileAtomic(path, contents);
+  await chmod(path, 0o444);
+}
+
+/**
+ * The account id for the dashboard link, from get_account_info. The key is
+ * pinned to one account, so the first row is it. Any failure (a narrowed
+ * profile without the tool, an older server) gives null, and the link falls
+ * back to the unscoped dashboard page.
+ */
+export async function resolveAccountId(client) {
+  try {
+    const result = await client.callToolJson('get_account_info', {});
+    const data = result?.data ?? result;
+    const row = Array.isArray(data) ? data[0] : data;
+    const id = typeof row?.id === 'string' ? row.id.trim() : '';
+    return UUID_RE.test(id) ? id : null;
+  } catch {
+    return null;
+  }
+}

package/src/codex-prompt-tools.json

@@ -0,0 +1,252 @@
+{
+  "source": "locus2012/hiveku-codex-plugin 0.1.16 (5b4e580), plugins/hiveku/.mcp.json: every hiveku.tools entry (all approval_mode \"prompt\")",
+  "why": "hiveku-sync writes its own [mcp_servers.hiveku] into a Codex folder. Codex then uses that entry, not the plugin's, for the server's connection and for every tool's approval mode, so these prompts must be written here too. Refresh this list whenever the Codex plugin's prompt list changes.",
+  "tools": [
+    "deploy_site",
+    "deploy_run",
+    "project_files_bulk_save",
+    "project_vcs_commit",
+    "project_vcs_merge",
+    "project_vcs_pr_merge",
+    "project_vcs_env_bind",
+    "project_vcs_branch_delete",
+    "project_vcs_stash",
+    "project_vcs_prune",
+    "project_vcs_branch_preview_teardown",
+    "project_vcs_revert",
+    "hiveku_batch",
+    "project_checkpoint_restore",
+    "checkpoint_restore",
+    "history_restore_to_time",
+    "checkpoint_delete",
+    "site_delete",
+    "site_firewall_allow",
+    "site_firewall_remove",
+    "project_indexing_set",
+    "account_memory_append",
+    "memory_update",
+    "memory_delete",
+    "memory_restore_version",
+    "memory_bulk_create",
+    "content_publish_to_site",
+    "content_schedule",
+    "email_campaign_send_now",
+    "email_campaign_schedule",
+    "email_campaign_resend_non_openers",
+    "email_campaign_test_send",
+    "crm_envelope_send",
+    "crm_estimate_send",
+    "helpdesk_ticket_send_reply",
+    "marketing_report_send",
+    "ppc_budget_update",
+    "ppc_platform_budget_update",
+    "ppc_bid_modifier_update",
+    "ppc_keyword_bid_update",
+    "ppc_platform_keyword_bid_update",
+    "ppc_bidding_strategy_update",
+    "ppc_platform_bidding_strategy_update",
+    "ppc_campaign_create",
+    "ppc_google_auto_apply_set",
+    "ppc_google_campaign_settings_set",
+    "ppc_google_ad_schedule_set",
+    "ppc_google_audience_exclusions_set",
+    "ppc_google_call_settings_set",
+    "ppc_google_campaign_ai_settings_set",
+    "ppc_bing_campaign_ai_settings_set",
+    "ppc_google_ad_text_update",
+    "ppc_google_ads_text_replace",
+    "ppc_negatives_remove",
+    "ppc_bing_url_tracking_set",
+    "ppc_bing_ad_extension_update",
+    "ppc_bing_ad_extension_remove",
+    "ppc_bing_experiment_create",
+    "ppc_bing_experiment_update",
+    "ppc_experiment_promote",
+    "ppc_experiment_treatment_set",
+    "ppc_conversion_adjustments_run",
+    "ppc_conversion_adjustments_set",
+    "ppc_meta_lead_quality_test",
+    "ppc_experiment_schedule",
+    "ppc_experiment_graduate",
+    "ppc_offline_conversion_upload",
+    "ppc_customer_match_upload",
+    "ppc_goals_set",
+    "ppc_budget_target_set",
+    "ppc_connection_update",
+    "agent_approval_approve",
+    "seo_ga4_key_event_update",
+    "seo_ga4_event_create_rule_update",
+    "accounting_bill_record_payment",
+    "accounting_invoice_record_payment",
+    "crm_contact_email_send",
+    "crm_enroll_sequence",
+    "crm_sequence_enroll_bulk",
+    "email_sequence_enroll",
+    "email_sequence_activate",
+    "voice_sms_send",
+    "voice_sms_send_to_contact",
+    "voice_sms_thread_reply",
+    "crm_remove_dnc",
+    "outbound_campaign_status_set",
+    "outbound_campaign_sequences_save",
+    "outbound_reply_draft_send",
+    "voice_number_purchase",
+    "voice_number_release",
+    "voice_e911_address_create",
+    "voice_extension_delete",
+    "voice_ivr_create",
+    "voice_ivr_update",
+    "voice_ivr_delete",
+    "voice_ring_group_delete",
+    "voice_queue_delete",
+    "voice_pool_delete",
+    "voice_call_tracking_setup",
+    "voice_call_originate",
+    "voice_sms_bulk_send",
+    "voice_sms_brand_submit",
+    "voice_sms_campaign_submit",
+    "voice_sms_campaign_resubmit",
+    "voice_sms_campaign_delete",
+    "voice_sms_number_assign_campaign",
+    "voice_sms_toll_free_verification_submit",
+    "voice_port_order_create",
+    "voice_port_order_action",
+    "voice_settings_update",
+    "voice_number_update",
+    "voice_blocked_numbers_remove",
+    "voice_tenant_repair",
+    "voice_swap_test",
+    "voice_call_tracking_live_probe",
+    "voice_phone_tracking_config_set",
+    "voice_phone_tracking_config_delete",
+    "voice_pool_update",
+    "voice_pool_create",
+    "voice_pool_numbers_add",
+    "voice_pool_numbers_remove",
+    "voice_pool_e911_apply",
+    "voice_webhook_create",
+    "voice_webhook_update",
+    "voice_webhook_delete",
+    "voice_sms_registration_share_link_create",
+    "voice_sms_registration_share_link_revoke",
+    "voice_port_order_share_link_create",
+    "voice_port_order_share_link_revoke",
+    "voice_ivrs_reprovision",
+    "voice_ai_agent_config_update",
+    "voice_number_cnam_set",
+    "voice_sms_campaign_appeal",
+    "voice_port_order_verification_codes_send",
+    "voice_sms_scheduled_cancel",
+    "voice_numbers_search",
+    "seo_gbp_review_reply",
+    "seo_gbp_review_reply_delete",
+    "seo_gbp_location_update",
+    "seo_gbp_attributes_update",
+    "seo_gsc_delete_sitemap",
+    "seo_report_clear",
+    "seo_deliverable_delete",
+    "seo_task_implement",
+    "seo_connection_delete",
+    "seo_gbp_services_update",
+    "seo_gbp_media_add",
+    "seo_gbp_media_delete",
+    "seo_gtm_publish",
+    "seo_gtm_install",
+    "seo_ga4_key_event_delete",
+    "seo_ga4_event_create_rule_delete",
+    "seo_tracking_project_delete",
+    "seo_rankings_platforms_set",
+    "seo_listings_scan",
+    "seo_connection_test",
+    "seo_competitor_delete",
+    "seo_keyword_cluster_delete",
+    "seo_topic_cluster_delete",
+    "seo_backlink_tracker_delete",
+    "seo_backlink_opportunity_delete",
+    "seo_automated_report_delete",
+    "seo_page_schema_delete",
+    "workflow_run",
+    "workflow_enable",
+    "workflow_trigger_update",
+    "workflow_delete",
+    "workflow_delete_schedule",
+    "workflow_stranded_replay",
+    "workflow_run_replay",
+    "workflow_run_retry",
+    "workflow_dead_letter_resolve",
+    "workflow_set_recipient",
+    "hiveboard_restore_version",
+    "hiveboard_delete",
+    "hiveboard_elements_prune",
+    "customer_avatar_version_restore",
+    "before_after_grid_version_restore",
+    "customer_journey_version_restore",
+    "customer_avatar_delete",
+    "customer_journey_delete",
+    "before_after_grid_delete",
+    "customer_journey_stage_delete",
+    "media_delete",
+    "media_folder_delete",
+    "brand_guide_delete",
+    "brand_guide_purge",
+    "marketing_storyboard_delete",
+    "marketing_generate_video",
+    "marketing_video_pipeline_retry_scene",
+    "design_voiceover_create",
+    "generate_image_set",
+    "media_upscale",
+    "marketing_testimonial_media_replace",
+    "marketing_form_upload_settings_update",
+    "marketing_form_capture_settings_update",
+    "marketing_form_capture_purge",
+    "social_publish_post",
+    "social_delete_post",
+    "social_comment_reply",
+    "social_linkedin_comment_add",
+    "social_linkedin_reaction_add",
+    "social_linkedin_comment_delete",
+    "social_post_reject",
+    "social_pillar_delete",
+    "social_hashtags_delete",
+    "social_calendar_delete",
+    "social_schedule_slot_delete",
+    "social_post_retry",
+    "webflow_project_cms_provider_set",
+    "webflow_site_publish",
+    "webflow_cms_item_publish",
+    "webflow_cms_item_unpublish",
+    "webflow_cms_item_delete",
+    "webflow_page_customcode_set",
+    "webflow_page_customcode_delete",
+    "webflow_cms_collection_delete",
+    "webflow_cms_field_delete",
+    "webflow_cms_item_unpublish_bulk",
+    "webflow_cms_item_delete_bulk",
+    "webflow_asset_delete",
+    "webflow_site_customcode_set",
+    "webflow_site_customcode_delete",
+    "webflow_hiveku_snippet_install",
+    "webflow_google_tag_upsert",
+    "webflow_google_tag_delete",
+    "webflow_form_submission_delete",
+    "webflow_webhook_create",
+    "webflow_webhook_update",
+    "webflow_webhook_delete",
+    "webflow_order_fulfill",
+    "webflow_order_refund",
+    "webflow_redirect_create",
+    "webflow_redirect_delete",
+    "webflow_robots_update",
+    "webflow_robots_replace",
+    "webflow_robots_delete",
+    "webflow_wellknown_create",
+    "webflow_wellknown_delete",
+    "webflow_llms_txt_set",
+    "webflow_llms_txt_delete",
+    "cms_publish",
+    "cms_delete_entry",
+    "cms_bulk_delete",
+    "cms_delete_collection",
+    "cms_remove_field"
+  ]
+}