@indigoai-us/hq-cli 5.14.0 → 5.15.0

package/.github/workflows/ci.yml

@@ -0,0 +1,21 @@
+name: CI
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: npm ci
+      # generate-dsn.mjs only fatals when GITHUB_JOB=publish, so CI builds with
+      # an empty BUNDLED_DSN. That's intentional — the DSN is publish-only.
+      - run: npm run build --if-present
+      - run: npm run typecheck --if-present
+      - run: npm test --if-present

package/.github/workflows/publish.yml

@@ -0,0 +1,86 @@
+name: Publish to npm
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          # Node 24 ships npm 11.x, required for npm's trusted-publisher OIDC
+          # token-exchange flow. See hq-cloud's publish.yml for the full
+          # rationale (npm 10.x produces masked-404 failures on publish PUT).
+          node-version: 24
+          registry-url: https://registry.npmjs.org
+
+      - run: node --version && npm --version
+      - run: npm ci
+
+      - name: Build
+        run: npm run build --if-present
+        env:
+          # generate-dsn.mjs fatals when GITHUB_JOB=publish and this var is
+          # missing. Set this as a repo secret to bundle a Sentry DSN into the
+          # published binary.
+          HQ_CLI_PUBLISH_SENTRY_DSN: ${{ secrets.HQ_CLI_PUBLISH_SENTRY_DSN }}
+
+      # Inject Sentry debug IDs into compiled JS + map files. Must run after
+      # tsc and BEFORE publish so the installed binary carries the same debugId
+      # as the artifacts uploaded to Sentry, enabling debugId-based source-map
+      # resolution for globally-installed CLI users.
+      - name: Inject Sentry source map debug IDs
+        run: npx -y @sentry/cli@^2 sourcemaps inject dist/
+
+      # Pre-publish cross-package smoke test (Bug A guard).
+      #
+      # @indigoai-us/hq-cli depends on @indigoai-us/hq-cloud via a caret range
+      # (^5.1.0). The smoke installs a freshly-packed tarball into an isolated
+      # tmpdir — outside this repo — so transitive @indigoai-us/* deps resolve
+      # from the npm registry, NOT from a local checkout. Booting `hq --version`
+      # then exercises the full module-load graph. If hq-cloud removed or
+      # renamed a symbol hq-cli imports, this catches it BEFORE the publish PUT.
+      #
+      # Bypass: set repo-or-workflow variable WORKFLOW_ALLOW_BROKEN_PUBLISH=1.
+      - name: Pre-publish smoke test
+        if: ${{ vars.WORKFLOW_ALLOW_BROKEN_PUBLISH != '1' }}
+        run: bash .github/workflows/scripts/smoke-test-pkg.sh hq
+
+      - name: WARN — pre-publish smoke bypassed
+        if: ${{ vars.WORKFLOW_ALLOW_BROKEN_PUBLISH == '1' }}
+        run: |
+          echo "::warning::WORKFLOW_ALLOW_BROKEN_PUBLISH=1 — pre-publish cross-package smoke test was BYPASSED. This release may ship a DOA package."
+
+      # Trusted-publisher OIDC; no NODE_AUTH_TOKEN. No --provenance (private
+      # repo limitation since npm 2026-05-10). Pre-release versions (with '-')
+      # get --tag rc to keep latest dist-tag pointing at stable releases only.
+      - name: Publish to npm
+        id: publish
+        run: |
+          NAME=$(jq -r .name package.json)
+          VER=$(jq -r .version package.json)
+          if npm view "$NAME@$VER" version >/dev/null 2>&1; then
+            echo "$NAME@$VER already on npm — skipping"
+          else
+            if echo "$VER" | grep -q '-'; then
+              npm publish --access public --tag rc
+            else
+              npm publish --access public
+            fi
+            echo "published=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Upload sourcemaps to Sentry
+        if: steps.publish.outputs.published == 'true'
+        run: |
+          VER=$(jq -r .version package.json)
+          npx -y @sentry/cli@^2 sourcemaps upload --release "hq-cli@$VER" dist/
+        env:
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+          SENTRY_ORG: indigo-d0
+          SENTRY_PROJECT: hq

package/.github/workflows/scripts/smoke-test-pkg.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+# smoke-test-pkg.sh — pre-publish cross-package import smoke test (Bug A guard).
+#
+# Single-package adaptation of the same script used in the legacy hq monorepo.
+# The monorepo version operated on `packages/$PKG/package.json`; this version
+# reads `./package.json` because each extracted repo is a single package at
+# its root.
+#
+# Install the package in an isolated tmpdir — using a freshly-packed tarball
+# when the package.json version is new, or fetching the existing name@version
+# from npm when it is already published — then boot the binary with
+# `--version`. The boot exercises the full module-load graph and the
+# transitive `@indigoai-us/*` resolution path a customer's `npm install`
+# would take. If the boot fails the script exits non-zero and the workflow
+# aborts before any further publish steps run.
+#
+# Why we don't skip when the consumer's version is already on npm:
+#   @indigoai-us/hq-cli depends on @indigoai-us/hq-cloud via a caret range
+#   (^5.1.0). A producer bump (published from indigoai-us/hq-cloud) re-resolves
+#   this consumer's transitive deps on the next fresh install, so an already-
+#   published consumer is NOT actually "locked." If the new producer drops or
+#   renames a symbol the published consumer imports, `hq --version` crashes
+#   on every fresh install starting the moment the producer publishes.
+#
+# Usage:
+#   smoke-test-pkg.sh <bin-name>
+# Example:
+#   smoke-test-pkg.sh hq
+
+set -uo pipefail
+
+BIN=${1:?usage: smoke-test-pkg.sh <bin-name>}
+
+PKG_JSON="package.json"
+if [ ! -f "$PKG_JSON" ]; then
+  echo "::error::smoke-test-pkg.sh: $PKG_JSON not found (cwd: $(pwd))"
+  exit 2
+fi
+
+NAME=$(jq -r .name "$PKG_JSON")
+VER=$(jq -r .version "$PKG_JSON")
+
+# Pick the install target. Already on npm → install by name@version so the
+# smoke matches what a customer would actually receive. Not yet on npm →
+# pack the local repo; the next publish step will push that exact byte-for-
+# byte content. Either way, `npm install` happens OUTSIDE this repo so
+# transitive @indigoai-us/* deps resolve from the registry.
+INSTALL_SOURCE=""
+if npm view "$NAME@$VER" version >/dev/null 2>&1; then
+  INSTALL_TARGET="$NAME@$VER"
+  INSTALL_SOURCE="npm registry (consumer version already published)"
+else
+  TARBALL_RELATIVE=$(npm pack --silent --pack-destination /tmp)
+  if [ -z "$TARBALL_RELATIVE" ]; then
+    echo "::error::npm pack produced no tarball for $NAME"
+    exit 1
+  fi
+  INSTALL_TARGET="/tmp/$TARBALL_RELATIVE"
+  if [ ! -f "$INSTALL_TARGET" ]; then
+    echo "::error::expected tarball at $INSTALL_TARGET not found"
+    exit 1
+  fi
+  INSTALL_SOURCE="packed tarball ($TARBALL_RELATIVE)"
+fi
+
+echo "::group::smoke test: $NAME@$VER via $INSTALL_SOURCE"
+
+SMOKE=$(mktemp -d)
+pushd "$SMOKE" >/dev/null
+
+printf '%s' '{"name":"smoke","version":"0.0.0","private":true}' > package.json
+
+if ! npm install --no-audit --no-fund --no-package-lock "$INSTALL_TARGET" >/tmp/smoke-install.log 2>&1; then
+  echo "::error::pre-publish smoke install FAILED for $NAME@$VER:"
+  tail -50 /tmp/smoke-install.log
+  popd >/dev/null
+  echo "::endgroup::"
+  exit 1
+fi
+
+set +e
+OUT=$("./node_modules/.bin/$BIN" --version 2>&1)
+CODE=$?
+set -e
+
+popd >/dev/null
+
+if [ "$CODE" -ne 0 ]; then
+  echo "::error::pre-publish smoke FAILED for $NAME@$VER (exit $CODE):"
+  echo "::error::$OUT"
+  echo "::error::Likely cause: a cross-package symbol was changed (added, removed, renamed) in another @indigoai-us/* package without keeping this consumer's import in sync. Bump this consumer (or revert the producer change) and re-tag, OR set the repo/workflow variable WORKFLOW_ALLOW_BROKEN_PUBLISH=1 to override (audited)."
+  echo "::endgroup::"
+  exit 1
+fi
+
+echo "✓ smoke ok: $NAME@$VER → $BIN --version → $OUT  (via $INSTALL_SOURCE)"
+echo "::endgroup::"

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [5.14.1] — 2026-05-14
+
+### Fixed
+
+- **`hq install <pack>` now writes to `core/packages/<name>/`** under the
+  v12 HQ layout, not top-level `packages/<name>/`. Pre-v12 behavior left
+  an orphan tree alongside the canonical `core/packages/` shipped by the
+  template (`hq-core` / `hq-core-staging`).
+- **Post-install `scan-packages.sh` is now resolved at
+  `core/scripts/scan-packages.sh`** instead of top-level `scripts/`.
+- **Stopped writing pack entries to `modules/modules.yaml`.** Packs are
+  tracked by filesystem presence under v12 (no separate registry file).
+  `hq update <pack>` will re-resolve source from each pack's
+  `package.yaml` or prompt; this is intentional. The legacy
+  knowledge-modules feature (`strategy: 'git-clone'`) is untouched.
+
+(Surfaced during end-to-end testing of the hq-installer staging-channel
+toggle — see indigoai-us/hq-installer#61.)
+
 ## [5.14.0] — 2026-05-14
 
 ### Changed

package/dist/commands/cloud-provision.d.ts

@@ -20,7 +20,10 @@
  * Exit codes:
  *   0 — success (and `initial_sync.ok=true`)
  *   1 — vault auth/network/API error (no entity provisioned)
- *   2 — invalid slug, company missing from manifest, or company dir missing
+ *   2 — invalid slug, company dir missing, or company is status=archived.
+ *       Folder-only states (companies/<slug>/ exists on disk but no manifest
+ *       entry) self-heal via ensureManifestEntryForProvision before
+ *       validation runs, so a missing manifest entry alone is NOT an exit-2.
  *   3 — sync failure after entity provisioned (cloud_uid in JSON;
  *       `initial_sync.ok=false`). Manifest + config may have been written.
  */
@@ -99,6 +102,15 @@ interface InitialSyncArgs {
 }
 /** Vault HTTP client interface — minimal surface for entity ops. */
 export interface VaultClient {
+    /**
+     * List every person entity visible to the caller (scoped server-side by the
+     * caller's Cognito identity). Used by `provisionCompany` as a pre-flight
+     * to verify the caller has been onboarded before mutating any cloud-side
+     * resources — the initial-sync step at the end of provision needs to vend
+     * STS credentials, which the server only does for callers with a person
+     * entity.
+     */
+    listMyPersonEntities(): Promise<VaultEntity[]>;
     findCompanyBySlug(slug: string): Promise<VaultEntity | null>;
     createCompanyEntity(input: {
         slug: string;
@@ -114,8 +126,10 @@ export declare class ProvisionError extends Error {
 }
 /**
  * Validate a company slug per the contract: alphanumeric / dot / dash / underscore,
- * non-empty, and never `"personal"` (which is auto-provisioned per-user, not
- * promoted via this subcommand).
+ * non-empty, never `"."` or `".."` (path-traversal — would resolve to
+ * `companies/` itself or `<hqRoot>` and write outside the intended company
+ * directory), and never `"personal"` (auto-provisioned per-user, not promoted
+ * via this subcommand).
  *
  * Throws ProvisionError with code=2 on failure.
  */
@@ -136,11 +150,34 @@ export declare function companyConfigPath(hqRoot: string, slug: string): string;
  *   - company is `status: archived`
  *   - `companies/<slug>/` does not exist
  *
+ * Strict on purpose — callers that want the "auto-insert a missing entry when
+ * the local folder exists" affordance (cloud-provision's fault-tolerant flow)
+ * MUST call `ensureManifestEntryForProvision` first. cloud-demote and other
+ * sensitive callers depend on this strict failure for typo-catching.
+ *
  * Returns the parsed manifest (so the caller can re-use it for the patch step).
  */
 export declare function validateManifestAndDir(hqRoot: string, slug: string): {
     manifest: ManifestDoc;
 };
+/**
+ * Provision-only pre-step. If `companies/<slug>/` exists on disk but the slug
+ * is absent from `manifest.yaml`, atomically insert an empty entry
+ * (`<slug>: {}`) so the downstream `validateManifestAndDir` + `patchManifest`
+ * flow has something to operate on. Heals the common folder-only state
+ * (manual mkdir, or older tools that didn't patch manifest.yaml) that hq-sync's
+ * Connect button used to dead-end on with exit 2.
+ *
+ * No-op in every other case:
+ *   - manifest file missing / malformed (validation will surface)
+ *   - slug already present (any value, including null — preserved as-is)
+ *   - `companies/<slug>/` does not exist (validation will surface as a typo)
+ *
+ * This affordance is provision-specific. `cloud-demote` and other strict
+ * callers MUST NOT call this — their typo-catching contract depends on
+ * `validateManifestAndDir` throwing on missing-slug.
+ */
+export declare function ensureManifestEntryForProvision(hqRoot: string, slug: string): void;
 /**
  * Top-level manifest shape we touch. We preserve all unknown fields — only
  * `cloud_uid` and `bucket_name` under the target slug are mutated.

package/dist/commands/cloud-provision.js

@@ -20,12 +20,15 @@
  * Exit codes:
  *   0 — success (and `initial_sync.ok=true`)
  *   1 — vault auth/network/API error (no entity provisioned)
- *   2 — invalid slug, company missing from manifest, or company dir missing
+ *   2 — invalid slug, company dir missing, or company is status=archived.
+ *       Folder-only states (companies/<slug>/ exists on disk but no manifest
+ *       entry) self-heal via ensureManifestEntryForProvision before
+ *       validation runs, so a missing manifest entry alone is NOT an exit-2.
  *   3 — sync failure after entity provisioned (cloud_uid in JSON;
  *       `initial_sync.ok=false`). Manifest + config may have been written.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="aacb5bf2-8362-5336-b864-43296c30a1d6")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3c9e69f3-8137-5db1-8692-e38774558f61")}catch(e){}}();
 import chalk from "chalk";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -45,11 +48,13 @@ export class ProvisionError extends Error {
 }
 // ── Validation ───────────────────────────────────────────────────────────────
 const SLUG_REGEX = /^[A-Za-z0-9._-]+$/;
-const FORBIDDEN_SLUGS = new Set(["personal"]);
+const FORBIDDEN_SLUGS = new Set(["personal", ".", ".."]);
 /**
  * Validate a company slug per the contract: alphanumeric / dot / dash / underscore,
- * non-empty, and never `"personal"` (which is auto-provisioned per-user, not
- * promoted via this subcommand).
+ * non-empty, never `"."` or `".."` (path-traversal — would resolve to
+ * `companies/` itself or `<hqRoot>` and write outside the intended company
+ * directory), and never `"personal"` (auto-provisioned per-user, not promoted
+ * via this subcommand).
  *
  * Throws ProvisionError with code=2 on failure.
  */
@@ -61,7 +66,10 @@ export function validateSlug(slug) {
         throw new ProvisionError(2, `Invalid slug "${slug}" — must match ${SLUG_REGEX.source}`);
     }
     if (FORBIDDEN_SLUGS.has(slug)) {
-        throw new ProvisionError(2, `Slug "${slug}" is reserved (auto-provisioned per-user, not eligible for cloud promotion)`);
+        const reason = slug === "personal"
+            ? "auto-provisioned per-user, not eligible for cloud promotion"
+            : "path-traversal slug (would resolve to a directory outside the intended company folder)";
+        throw new ProvisionError(2, `Slug "${slug}" is reserved (${reason})`);
     }
 }
 /** Path to the top-level companies manifest file. */
@@ -86,6 +94,11 @@ export function companyConfigPath(hqRoot, slug) {
  *   - company is `status: archived`
  *   - `companies/<slug>/` does not exist
  *
+ * Strict on purpose — callers that want the "auto-insert a missing entry when
+ * the local folder exists" affordance (cloud-provision's fault-tolerant flow)
+ * MUST call `ensureManifestEntryForProvision` first. cloud-demote and other
+ * sensitive callers depend on this strict failure for typo-catching.
+ *
  * Returns the parsed manifest (so the caller can re-use it for the patch step).
  */
 export function validateManifestAndDir(hqRoot, slug) {
@@ -115,6 +128,82 @@ export function validateManifestAndDir(hqRoot, slug) {
     }
     return { manifest };
 }
+/**
+ * Provision-only pre-step. If `companies/<slug>/` exists on disk but the slug
+ * is absent from `manifest.yaml`, atomically insert an empty entry
+ * (`<slug>: {}`) so the downstream `validateManifestAndDir` + `patchManifest`
+ * flow has something to operate on. Heals the common folder-only state
+ * (manual mkdir, or older tools that didn't patch manifest.yaml) that hq-sync's
+ * Connect button used to dead-end on with exit 2.
+ *
+ * No-op in every other case:
+ *   - manifest file missing / malformed (validation will surface)
+ *   - slug already present (any value, including null — preserved as-is)
+ *   - `companies/<slug>/` does not exist (validation will surface as a typo)
+ *
+ * This affordance is provision-specific. `cloud-demote` and other strict
+ * callers MUST NOT call this — their typo-catching contract depends on
+ * `validateManifestAndDir` throwing on missing-slug.
+ */
+export function ensureManifestEntryForProvision(hqRoot, slug) {
+    const mPath = manifestPath(hqRoot);
+    if (!fs.existsSync(mPath))
+        return;
+    // Defense-in-depth against path-traversal slugs (`.`, `..`, anything that
+    // resolves outside companies/). validateSlug rejects these upstream, but
+    // this helper is exported and might be called directly by future code —
+    // never auto-insert based on a path that isn't a literal direct child of
+    // `companies/`. fs.realpathSync would also catch symlink-escapes, but the
+    // directory may legitimately not exist yet on disk; path.resolve gives us
+    // the canonical lexical form without a stat call.
+    const companiesDir = path.resolve(hqRoot, "companies");
+    const expected = path.resolve(companiesDir, slug);
+    const expectedParent = path.dirname(expected);
+    if (expectedParent !== companiesDir)
+        return;
+    if (path.basename(expected) !== slug)
+        return;
+    const dir = companyDirPath(hqRoot, slug);
+    // Must be an actual directory, not a stray file. fs.existsSync returns true
+    // for regular files too — without this guard, auto-insert would fire on a
+    // file at `companies/<slug>`, provisionCompany would then create the vault
+    // entity and patch manifest.yaml before writeCompanyConfig's `mkdir -p .hq`
+    // exploded with ENOTDIR. statSync swallows the not-found case so a missing
+    // path is treated the same as before (no auto-insert).
+    let dirStat;
+    try {
+        dirStat = fs.statSync(dir);
+    }
+    catch {
+        return;
+    }
+    if (!dirStat.isDirectory())
+        return;
+    const raw = fs.readFileSync(mPath, "utf-8");
+    let parsed;
+    try {
+        parsed = yaml.load(raw);
+    }
+    catch {
+        return;
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        !("companies" in parsed) ||
+        typeof parsed.companies !== "object") {
+        return;
+    }
+    const doc = parsed;
+    if (!doc.companies)
+        doc.companies = {};
+    if (doc.companies[slug] !== undefined)
+        return;
+    doc.companies[slug] = {};
+    const dump = yaml.dump(doc, { lineWidth: -1, noRefs: true });
+    const tmp = `${mPath}.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, dump);
+    fs.renameSync(tmp, mPath);
+}
 /**
  * Atomically patch `companies/manifest.yaml` to set `cloud_uid` + `bucket_name`
  * under the target slug. Read → mutate → temp-write → rename so concurrent
@@ -179,6 +268,18 @@ export function createDefaultVaultClient(apiUrl, accessToken) {
         Authorization: `Bearer ${accessToken}`,
     };
     return {
+        async listMyPersonEntities() {
+            const url = `${apiUrl.replace(/\/$/, "")}/entity/by-type/person`;
+            const res = await fetch(url, { method: "GET", headers });
+            if (res.status === 404)
+                return [];
+            if (!res.ok) {
+                const body = await safeBody(res);
+                throw new ProvisionError(1, `Vault GET /entity/by-type/person failed: ${res.status} ${res.statusText} — ${body}`);
+            }
+            const data = (await res.json());
+            return data.entities ?? [];
+        },
         async findCompanyBySlug(slug) {
             const url = `${apiUrl.replace(/\/$/, "")}/entity/by-slug/company/${encodeURIComponent(slug)}`;
             const res = await fetch(url, { method: "GET", headers });
@@ -258,8 +359,13 @@ async function defaultRunInitialSync(args) {
  */
 export async function provisionCompany(options) {
     const log = options.log ?? ((msg) => process.stderr.write(`[hq cloud provision] ${msg}\n`));
-    // Step 1+2+3: validate slug, manifest, dir
+    // Step 1+2+3: validate slug, auto-heal a folder-only manifest, then validate
+    // the resulting manifest + dir. The auto-heal is provision-specific: it
+    // inserts an empty entry when companies/<slug>/ exists on disk but the slug
+    // is missing from manifest.yaml. validateManifestAndDir stays strict so
+    // other callers (cloud-demote) keep their typo-catching guard.
     validateSlug(options.slug);
+    ensureManifestEntryForProvision(options.hqRoot, options.slug);
     validateManifestAndDir(options.hqRoot, options.slug);
     log(`validated slug=${options.slug}`);
     // Step 4: auth — defer to injected resolver (default: ensureCognitoToken)
@@ -270,6 +376,23 @@ export async function provisionCompany(options) {
     // Step 5: GET-then-POST for idempotency
     const vaultClient = options.vaultClient ??
         createDefaultVaultClient(options.vaultApiUrl, accessToken);
+    // Pre-flight: caller MUST have a registered person entity. Without one,
+    // the initial-sync step at the end of this flow (STS /sts/vend) returns
+    // 403 "no person entity" and leaves the operator with a half-built cloud
+    // company — vault entity created, S3 bucket provisioned, manifest patched,
+    // .hq/config.json written, but nothing actually syncing. This was the
+    // primary failure mode in the 2026-05-14 setup-session deep dive
+    // (Joey Muller / sum-digital).
+    //
+    // Failing here, BEFORE any cloud-side resource creation, leaves the operator
+    // with no cleanup work — they fix the underlying onboarding gap (run
+    // `hq onboard` / sign in with the correct federated identity) and re-run
+    // `hq cloud provision company <slug>` cleanly.
+    const persons = await vaultClient.listMyPersonEntities();
+    if (persons.length === 0) {
+        throw new ProvisionError(2, 'No person entity found for this Cognito identity. Run `hq onboard` first to create your HQ identity, then re-run `hq cloud provision company`. (Provision was halted before any cloud-side resources were created.)');
+    }
+    log(`pre-flight ok — caller has ${persons.length} person entity(ies)`);
     let entity = await vaultClient.findCompanyBySlug(options.slug);
     let createdEntity = false;
     if (entity) {
@@ -426,4 +549,4 @@ export function registerCloudProvisionCommands(program) {
     });
 }
 //# sourceMappingURL=cloud-provision.js.map
-//# debugId=aacb5bf2-8362-5336-b864-43296c30a1d6
+//# debugId=3c9e69f3-8137-5db1-8692-e38774558f61

package/dist/commands/meetings.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerMeetingsCommand(program: Command): void;
+//# sourceMappingURL=meetings.d.ts.map