@dashai/cli 0.12.1 → 0.13.0

package/dist/bin.js

@@ -428,6 +428,25 @@ async function getModuleBySlug(slug, options = {}) {
     options
   );
 }
+function isInstallGated(r) {
+  return r.install_gated === true;
+}
+async function installModule(moduleId, body, options = {}) {
+  return apiRequest(
+    "POST",
+    `/api/modules/${moduleId}/install`,
+    body,
+    options
+  );
+}
+async function listWorkspaceInstallations(workspaceId, options = {}) {
+  return apiRequest(
+    "GET",
+    `/api/modules/workspaces/${workspaceId}/installations`,
+    void 0,
+    options
+  );
+}
 async function applyDraftManifest(moduleId, manifest, options = {}) {
   return apiRequest(
     "PUT",
@@ -5200,6 +5219,386 @@ async function moduleDiffCommand(options) {
 // src/bin.ts
 init_init();
 
+// src/commands/module/install.ts
+init_api_client();
+init_config();
+init_manifest_io();
+
+// src/lib/module-lifecycle.ts
+init_api_client();
+init_output();
+init_workspaces();
+function isDevInstallKind(kind) {
+  return kind === "local" || kind === "sandbox";
+}
+function isRealRuntimeUrl(url) {
+  return !!url && /^https:\/\//i.test(url);
+}
+function isDraftVersion(v) {
+  return !v || v.includes("draft");
+}
+function compareSemver(a, b) {
+  const parse = (v) => v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d > 0 ? 1 : -1;
+  }
+  return 0;
+}
+function isUpdateAvailable(installedVersion, latestVersion) {
+  return !!installedVersion && !!latestVersion && !isDraftVersion(installedVersion) && !isDraftVersion(latestVersion) && compareSemver(latestVersion, installedVersion) > 0;
+}
+async function resolveWorkspaceWithFallback(opts) {
+  const fromCache = opts.userFlag === void 0 && opts.cachedWorkspaceId !== void 0;
+  const flag = opts.userFlag ?? (fromCache ? String(opts.cachedWorkspaceId) : opts.configDefault);
+  try {
+    return await selectWorkspace({
+      apiUrl: opts.apiUrl,
+      apiToken: opts.apiToken,
+      ...flag !== void 0 ? { flag } : {},
+      interactive: true
+    });
+  } catch (err) {
+    if (!fromCache || err instanceof ApiError) throw err;
+    info(
+      `Cached dev-install workspace ${code(String(opts.cachedWorkspaceId))} is no longer accessible \u2014 pick a workspace.`
+    );
+    return await selectWorkspace({
+      apiUrl: opts.apiUrl,
+      apiToken: opts.apiToken,
+      ...opts.configDefault !== void 0 ? { flag: opts.configDefault } : {},
+      interactive: true
+    });
+  }
+}
+
+// src/commands/module/install.ts
+init_output();
+async function moduleInstallCommand(slugArg, options) {
+  const slug = resolveSlug(slugArg, options.dir);
+  if (!slug) {
+    fail(
+      `No module slug \u2014 pass one (${code("dashwise module install <slug>")}) or run from a directory with a valid module.json.`
+    );
+    return 1;
+  }
+  if (!isLoggedIn()) {
+    fail(`Not logged in. Run ${code("dashwise login")} first.`);
+    return 1;
+  }
+  const cfg = readConfig();
+  if (!cfg) {
+    fail(`CLI config missing. Run ${code("dashwise login")}.`);
+    return 1;
+  }
+  const auth = { baseUrl: resolveApiUrl(), auth: { token: cfg.token } };
+  let mod;
+  try {
+    mod = await getModuleBySlug(slug, auth);
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 404) {
+      fail(
+        `Module ${code(slug)} not found on the backend. Run ${code("dashwise module register")} + ${code("dashwise module publish")} first.`
+      );
+      return 1;
+    }
+    fail(`Could not resolve module ${code(slug)}: ${err.message}`);
+    return 1;
+  }
+  if (!mod.current_version) {
+    fail(
+      `Module ${code(slug)} has no published version yet \u2014 nothing to install. Run ${code("dashwise module publish")} first.`
+    );
+    return 1;
+  }
+  const targetVersion = options.version ?? mod.current_version;
+  let workspace2;
+  try {
+    workspace2 = await resolveWorkspaceWithFallback({
+      userFlag: options.workspace,
+      cachedWorkspaceId: readModuleEntry(slug)?.workspaceId,
+      configDefault: cfg.workspaceSlug,
+      apiUrl: resolveApiUrl(),
+      apiToken: cfg.token
+    });
+  } catch (err) {
+    fail(`Workspace selection failed: ${err.message}`);
+    return 1;
+  }
+  let existing;
+  try {
+    const installs = await listWorkspaceInstallations(workspace2.id, auth);
+    existing = installs.find((row2) => row2.module_id === mod.id);
+  } catch (err) {
+    fail(
+      `Could not read workspace installations: ${err.message}`
+    );
+    return 1;
+  }
+  let isUpgrade = false;
+  let devInstallToReplace;
+  let confirmedViaPicker = false;
+  if (existing && isDevInstallKind(existing.kind)) {
+    const resolution = await resolveDevInstallCollision(
+      existing,
+      slug,
+      workspace2.slug,
+      options
+    );
+    if (typeof resolution === "number") return resolution;
+    devInstallToReplace = existing;
+    confirmedViaPicker = resolution === "replace-confirmed";
+    existing = void 0;
+  } else if (existing) {
+    isUpgrade = true;
+    const installedVersion2 = existing.module_version?.version;
+    if (installedVersion2 && installedVersion2 === targetVersion) {
+      info(
+        `Already deployed at ${code(`v${installedVersion2}`)} \u2014 re-running is idempotent and repairs a failed provision.`
+      );
+    } else {
+      info(
+        `Existing production install #${existing.id}${installedVersion2 ? ` at ${code(`v${installedVersion2}`)}` : ""} \u2014 this will upgrade it to ${code(`v${targetVersion}`)}.`
+      );
+    }
+  }
+  if (!options.yes && process.stdout.isTTY && !confirmedViaPicker) {
+    const message = devInstallToReplace ? `Replace the dev install (revokes local-dev credentials) and install ${code(mod.slug)} ${code(`v${targetVersion}`)} into ${code(workspace2.slug)} as production?` : `${isUpgrade ? "Upgrade" : "Install"} ${code(mod.slug)} ${code(`v${targetVersion}`)} into workspace ${code(workspace2.slug)}?`;
+    const answer = await select({
+      message,
+      options: [
+        {
+          value: "go",
+          label: devInstallToReplace ? "Yes, replace the dev install + production-install" : isUpgrade ? "Yes, upgrade now" : "Yes, install now"
+        },
+        { value: "cancel", label: "No, abort" }
+      ],
+      initialValue: devInstallToReplace ? "cancel" : "go"
+    });
+    if (isCancel(answer) || answer === "cancel") {
+      fail("Aborted. Nothing was changed.");
+      return 130;
+    }
+  }
+  let devInstallReplaced = false;
+  if (devInstallToReplace) {
+    const destroyed = await replaceDevInstall(devInstallToReplace, slug, auth);
+    if (destroyed !== 0) return destroyed;
+    devInstallReplaced = true;
+  }
+  info("Provisioning the runtime \u2014 this can take a minute\u2026");
+  let result;
+  try {
+    result = await installModule(
+      mod.id,
+      {
+        workspaceId: workspace2.id,
+        ...options.version !== void 0 ? { version: options.version } : {},
+        ...options.force !== void 0 ? { force: options.force } : {}
+      },
+      auth
+    );
+  } catch (err) {
+    return surfaceInstallError(err, mod.slug, workspace2.slug, devInstallReplaced);
+  }
+  if (isInstallGated(result)) {
+    if (options.json) {
+      out(JSON.stringify(result));
+      return 0;
+    }
+    success(
+      `Install request ${code(`#${result.install_request.id}`)} queued (status: ${result.install_request.status}).`
+    );
+    info(
+      `This module requires author approval before it installs. Once approved, check with ${code(`dashwise module status ${mod.slug} --workspace ${workspace2.slug}`)}.`
+    );
+    return 0;
+  }
+  let row;
+  let verified = false;
+  try {
+    const after = await listWorkspaceInstallations(workspace2.id, auth);
+    row = after.find((r) => r.module_id === mod.id);
+    verified = row !== void 0;
+  } catch {
+  }
+  const publicUrl = row?.public_url ?? null;
+  const installedVersion = row?.module_version?.version ?? targetVersion;
+  const runtimeProvisioned = isRealRuntimeUrl(row?.runtime_url);
+  if (options.json) {
+    out(
+      JSON.stringify({
+        installation_id: result.installation.id,
+        kind: row?.kind ?? null,
+        version: installedVersion,
+        was_upgrade: result.was_upgrade,
+        public_url: publicUrl,
+        verified
+      })
+    );
+    return 0;
+  }
+  if (!verified) {
+    success(
+      `Installed ${code(mod.slug)} ${code(`v${targetVersion}`)} (install ${code(`#${result.installation.id}`)}).`
+    );
+    info(
+      `The verification read failed \u2014 run ${code(`dashwise module status ${mod.slug} --workspace ${workspace2.slug}`)} to see the deploy state and public URL.`
+    );
+    return 0;
+  }
+  if (runtimeProvisioned && publicUrl) {
+    success(
+      `Deployed ${code(mod.slug)} ${code(`v${installedVersion}`)} \u2014 live at ${code(publicUrl)}`
+    );
+    info(
+      `Install ${code(`#${result.installation.id}`)} (kind=${row?.kind ?? "unknown"}) in workspace ${code(workspace2.slug)}${result.was_upgrade ? " \u2014 upgraded in place." : "."}`
+    );
+  } else if (runtimeProvisioned) {
+    success(
+      `Installed ${code(mod.slug)} ${code(`v${installedVersion}`)} (install ${code(`#${result.installation.id}`)}, kind=${row?.kind ?? "unknown"}).`
+    );
+    warn(
+      `The runtime is provisioned, but this platform exposes no public host \u2014 there is no public URL to print. Ask the operator to configure the public module host; re-running install won't change this.`
+    );
+  } else {
+    success(
+      `Installed ${code(mod.slug)} ${code(`v${installedVersion}`)} (install ${code(`#${result.installation.id}`)}, kind=${row?.kind ?? "unknown"}).`
+    );
+    warn(
+      `No public URL yet \u2014 runtime provisioning didn't complete. Re-running ${code("dashwise module install")} is idempotent and repairs a failed provision.`
+    );
+  }
+  return 0;
+}
+function resolveSlug(slugArg, dir) {
+  if (slugArg) return slugArg;
+  try {
+    const manifest = readManifest(dir);
+    const slug = manifest?.module?.slug;
+    return typeof slug === "string" && slug.length > 0 ? slug : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveDevInstallCollision(existing, slug, workspaceSlug, options) {
+  if (existing.kind === "sandbox") {
+    fail(
+      `Workspace ${code(workspaceSlug)} already has a ${code("kind=sandbox")} install of ${code(slug)} (id=${existing.id}), and only ONE install per (workspace, module) can exist.
+  A plain install would upgrade that row in place \u2014 but ${code("kind")} is immutable, so it would stay sandbox and hidden from the app sidebar.
+  The CLI can't destroy a sandbox install. Uninstall it from the dashboard first, or deploy with ${code("--workspace <other>")} to a separate workspace.`
+    );
+    return 1;
+  }
+  const explanation = `Workspace ${code(workspaceSlug)} already has the DEV install of ${code(slug)} (kind=local, id=${existing.id}) created by ${code("dashwise init")}.
+  Only ONE install per (workspace, module) can exist, and ${code("kind")} is immutable: a plain install would upgrade that row in place \u2014 the runtime would provision, but it would STAY a dev install, hidden from the app sidebar.
+  Options:
+    - ${code("--replace-dev-install")} \u2014 destroy the dev install, then fresh production install. Recommended when development is done. Note: this revokes the module's cached local-dev credentials, so local ${code("dashwise dev")} against this workspace needs a fresh ${code("dashwise init --force")} afterwards (which in turn cannot coexist with the production install here).
+    - ${code("--workspace <other>")} \u2014 deploy to a separate test/client workspace and keep this dev install. Recommended for ongoing development.`;
+  if (options.replaceDevInstall) return "replace";
+  if (process.stdout.isTTY && !options.yes) {
+    info(explanation);
+    const answer = await select({
+      message: `Replace the dev install of ${code(slug)} in ${code(workspaceSlug)} with a production install? (revokes local-dev credentials)`,
+      options: [
+        {
+          value: "replace",
+          label: "Replace \u2014 destroy the dev install, then production-install",
+          hint: "local `dashwise dev` here will need `dashwise init --force` afterwards"
+        },
+        { value: "cancel", label: "Cancel \u2014 I will deploy to another workspace" }
+      ],
+      initialValue: "cancel"
+    });
+    if (isCancel(answer) || answer === "cancel") {
+      fail("Aborted. Nothing was changed.");
+      return 130;
+    }
+    return "replace-confirmed";
+  }
+  fail(explanation);
+  return 1;
+}
+async function replaceDevInstall(existing, slug, auth) {
+  info(`Destroying dev install ${code(`#${existing.id}`)} (kind=local)\u2026`);
+  try {
+    await destroyDevInstallation(existing.id, auth);
+  } catch (err) {
+    if (err instanceof ApiError && err.code === "INSTALLATION_NOT_FOUND") {
+      warn("Dev install already gone server-side \u2014 continuing.");
+    } else if (err instanceof ApiError) {
+      fail(
+        `Could not destroy the dev install (${err.code} ${err.status}): ${err.message}`
+      );
+      return 1;
+    } else {
+      fail(`Could not destroy the dev install: ${err.message}`);
+      return 1;
+    }
+  }
+  const entry = readModuleEntry(slug);
+  if (entry && entry.installationId === existing.id) {
+    try {
+      removeModuleEntry(slug);
+      info(
+        `Removed ${code(slug)} from auth.json \u2014 its local-dev credentials are revoked. Local ${code("dashwise dev")} needs ${code("dashwise init --force")} (ideally against a different workspace).`
+      );
+    } catch (err) {
+      warn(
+        `Dev install destroyed but auth.json cleanup failed: ${err.message}. Remove the ${code(`modules["${slug}"]`)} entry from ${code("~/.config/dashwise/auth.json")} manually.`
+      );
+    }
+  }
+  return 0;
+}
+function surfaceInstallError(err, slug, workspaceSlug, devInstallReplaced) {
+  if (err instanceof ApiError) {
+    switch (err.code) {
+      case "INSTALL_NOT_INVITED":
+        fail(
+          `Module ${code(slug)} is invite-only and workspace ${code(workspaceSlug)} hasn't been invited.
+  Ask the module's author to invite this workspace (or open the install gate), then retry.`
+        );
+        break;
+      case "UPGRADE_BREAKS_CONSUMERS":
+        fail(
+          `Upgrading ${code(slug)} would break modules that consume its current schema.
+  Review the breaking changes, then re-run with ${code("--force")} to upgrade anyway.`
+        );
+        break;
+      case "FORBIDDEN":
+        fail(
+          `You must be an ADMIN of workspace ${code(workspaceSlug)} to install modules into it.`
+        );
+        break;
+      case "UNAUTHENTICATED":
+        fail(
+          `Auth rejected by the backend \u2014 your CLI token may be stale. Re-run ${code("dashwise login")} and try again.`
+        );
+        break;
+      default:
+        if (err.status === 400 && /publish/i.test(err.message)) {
+          fail(
+            `${err.message}
+  Run ${code("dashwise module publish")} first, then retry.`
+          );
+        } else {
+          fail(`Install failed (${err.code || err.status}): ${err.message}`);
+        }
+    }
+  } else {
+    fail(`Install failed: ${err.message}`);
+  }
+  if (devInstallReplaced) {
+    warn(
+      `Note: the dev install was already removed (that is not rolled back). Re-run ${code("dashwise module install")} to complete the production install, or ${code("dashwise init --force")} to restore local dev.`
+    );
+  }
+  return 1;
+}
+
 // src/commands/module/list.ts
 init_api_client();
 init_config();
@@ -5668,6 +6067,140 @@ function formatBytes2(n) {
   return `${(n / 1024 / 1024).toFixed(1)}MB`;
 }
 
+// src/commands/module/status.ts
+init_api_client();
+init_config();
+init_manifest_io();
+init_output();
+async function moduleStatusCommand(slugArg, options) {
+  let slug = slugArg;
+  if (!slug) {
+    try {
+      const manifest = readManifest(options.dir);
+      const fromManifest = manifest?.module?.slug;
+      if (typeof fromManifest === "string" && fromManifest.length > 0) {
+        slug = fromManifest;
+      }
+    } catch {
+    }
+  }
+  if (!slug) {
+    fail(
+      `No module slug \u2014 pass one (${code("dashwise module status <slug>")}) or run from a directory with a valid module.json.`
+    );
+    return 1;
+  }
+  if (!isLoggedIn()) {
+    fail(`Not logged in. Run ${code("dashwise login")} first.`);
+    return 1;
+  }
+  const cfg = readConfig();
+  if (!cfg) {
+    fail(`CLI config missing. Run ${code("dashwise login")}.`);
+    return 1;
+  }
+  const auth = { baseUrl: resolveApiUrl(), auth: { token: cfg.token } };
+  let mod;
+  try {
+    mod = await getModuleBySlug(slug, auth);
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 404) {
+      fail(`Module ${code(slug)} not found on the backend.`);
+      return 1;
+    }
+    fail(`Could not resolve module ${code(slug)}: ${err.message}`);
+    return 1;
+  }
+  let workspace2;
+  try {
+    workspace2 = await resolveWorkspaceWithFallback({
+      userFlag: options.workspace,
+      cachedWorkspaceId: readModuleEntry(slug)?.workspaceId,
+      configDefault: cfg.workspaceSlug,
+      apiUrl: resolveApiUrl(),
+      apiToken: cfg.token
+    });
+  } catch (err) {
+    fail(`Workspace selection failed: ${err.message}`);
+    return 1;
+  }
+  let row;
+  try {
+    const installs = await listWorkspaceInstallations(workspace2.id, auth);
+    row = installs.find((r) => r.module_id === mod.id);
+  } catch (err) {
+    fail(`Could not read workspace installations: ${err.message}`);
+    return 1;
+  }
+  const latestVersion = row?.module?.current_version ?? mod.current_version;
+  if (!row) {
+    if (options.json) {
+      out(
+        JSON.stringify({
+          installed: false,
+          module: mod.slug,
+          workspace: { id: workspace2.id, slug: workspace2.slug },
+          latest_version: latestVersion
+        })
+      );
+      return 0;
+    }
+    info(
+      `${code(mod.slug)} is not installed in workspace ${code(workspace2.slug)}.` + (latestVersion ? ` Deploy it with ${code(`dashwise module install ${mod.slug} --workspace ${workspace2.slug}`)}.` : ` It has no published version yet \u2014 run ${code("dashwise module publish")} first.`)
+    );
+    return 0;
+  }
+  const runtimeProvisioned = isRealRuntimeUrl(row.runtime_url);
+  const state = runtimeProvisioned && row.public_url ? "live" : runtimeProvisioned ? "deployed" : "not_deployed";
+  const installedVersion = row.module_version?.version ?? null;
+  const updateAvailable = isUpdateAvailable(installedVersion, latestVersion);
+  if (options.json) {
+    out(
+      JSON.stringify({
+        installed: true,
+        module: mod.slug,
+        workspace: { id: workspace2.id, slug: workspace2.slug },
+        installation_id: row.id,
+        kind: row.kind ?? null,
+        version: installedVersion,
+        latest_version: latestVersion,
+        update_available: updateAvailable,
+        runtime_provisioned: runtimeProvisioned,
+        runtime_url: row.runtime_url,
+        public_url: row.public_url,
+        state
+      })
+    );
+    return 0;
+  }
+  const stateLabel = state === "live" ? "Live" : state === "deployed" ? "Deployed" : "Not deployed \u2014 runtime not provisioned";
+  out("");
+  kv("Module:", `${mod.slug} ${dim(`(id ${mod.id})`)}`);
+  kv("Workspace:", `${workspace2.slug} ${dim(`(id ${workspace2.id})`)}`);
+  kv("Install:", `#${row.id} ${dim(`(kind=${row.kind ?? "unknown"})`)}`);
+  kv(
+    "Version:",
+    `${installedVersion ?? dim("(unknown)")}${updateAvailable ? `  ${code(`update available: v${latestVersion} \u2014 run \`dashwise module install ${mod.slug}\``)}` : latestVersion ? `  ${dim(`(latest published: v${latestVersion})`)}` : ""}`
+  );
+  kv(
+    "Runtime:",
+    runtimeProvisioned ? `provisioned ${dim(`(${row.runtime_url})`)}` : "not provisioned"
+  );
+  kv("Public URL:", row.public_url ?? dim("(none)"));
+  kv("State:", stateLabel);
+  out("");
+  if (row.kind === "local") {
+    info(
+      `This is the ${code("kind=local")} dev install \u2014 hidden from the app sidebar. A production deploy needs ${code("dashwise module install --replace-dev-install")} (or ${code("--workspace <other>")}).`
+    );
+  } else if (state === "not_deployed") {
+    info(
+      `Re-run ${code(`dashwise module install ${mod.slug} --workspace ${workspace2.slug}`)} to (re-)provision the runtime \u2014 the install POST is idempotent.`
+    );
+  }
+  return 0;
+}
+
 // src/commands/module/pull-data.ts
 init_api_client();
 init_output();
@@ -6289,7 +6822,7 @@ function rangeSatisfied(version, range) {
   const op = opMatch[1] ?? "=";
   const target = parseSemver(opMatch[2]);
   if (!target) return false;
-  const cmp = compareSemver(vParts, target);
+  const cmp = compareSemver2(vParts, target);
   switch (op) {
     case "=":
       return cmp === 0;
@@ -6318,7 +6851,7 @@ function parseSemver(s) {
   if (!m) return null;
   return [Number(m[1]), Number(m[2]), Number(m[3])];
 }
-function compareSemver(a, b) {
+function compareSemver2(a, b) {
   for (let i = 0; i < 3; i++) {
     if (a[i] !== b[i]) return a[i] - b[i];
   }
@@ -9204,6 +9737,35 @@ moduleCmd.command("publish").description("Pack the current directory + upload it
     });
   }
 );
+moduleCmd.command("install [slug]").alias("deploy").description(
+  "Install (deploy) a published module into a workspace \u2014 provisions the runtime and prints the public URL. Upgrades/repairs an existing production install idempotently. Refuses to silently land on a dev install: use --replace-dev-install or --workspace <other>."
+).option("--workspace <slug-or-id>", "Target workspace (default: cached module workspace, config default, or interactive picker).").option("--version <semver>", "Install a specific published version (default: latest).").option("--force", "Proceed even when the upgrade breaks consumer modules (UPGRADE_BREAKS_CONSUMERS).").option(
+  "--replace-dev-install",
+  "Destroy the workspace's kind=local dev install first, then fresh production install. Revokes the module's cached local-dev credentials (re-run `dashwise init --force` for local dev afterwards)."
+).option("--dir <path>", "Project root for the module.json slug lookup (default: current directory).").option("-y, --yes", "Skip the confirmation prompt (for CI / scripted use).").option("--json", "Emit the final result as machine-readable JSON.").action(
+  async (slug, cmdOpts) => {
+    process.exitCode = await moduleInstallCommand(slug, {
+      ...cmdOpts.workspace !== void 0 ? { workspace: cmdOpts.workspace } : {},
+      ...cmdOpts.version !== void 0 ? { version: cmdOpts.version } : {},
+      ...cmdOpts.force !== void 0 ? { force: cmdOpts.force } : {},
+      ...cmdOpts.replaceDevInstall !== void 0 ? { replaceDevInstall: cmdOpts.replaceDevInstall } : {},
+      ...cmdOpts.dir !== void 0 ? { dir: cmdOpts.dir } : {},
+      ...cmdOpts.yes !== void 0 ? { yes: cmdOpts.yes } : {},
+      ...cmdOpts.json !== void 0 ? { json: cmdOpts.json } : {}
+    });
+  }
+);
+moduleCmd.command("status [slug]").description(
+  "Show a module's deploy state in a workspace: install kind, installed vs latest published version, runtime provisioning, and the public URL."
+).option("--workspace <slug-or-id>", "Target workspace (default: cached module workspace, config default, or interactive picker).").option("--dir <path>", "Project root for the module.json slug lookup (default: current directory).").option("--json", "Emit machine-readable JSON.").action(
+  async (slug, cmdOpts) => {
+    process.exitCode = await moduleStatusCommand(slug, {
+      ...cmdOpts.workspace !== void 0 ? { workspace: cmdOpts.workspace } : {},
+      ...cmdOpts.dir !== void 0 ? { dir: cmdOpts.dir } : {},
+      ...cmdOpts.json !== void 0 ? { json: cmdOpts.json } : {}
+    });
+  }
+);
 moduleCmd.command("query-log").description(
   "Read the per-module SDK query log. Default: 50 most recent entries. `--slow` filters to duration_ms > 500ms; `--since 1h` narrows by time; `--tail` streams new entries every 5s."
 ).option(
@@ -9381,7 +9943,7 @@ fieldCmd.command("set-type <table-slug> <field-slug> <new-type>").description(
   }
 })();
 function getVersion() {
-  return "0.12.1";
+  return "0.13.0";
 }
 function parseIntOption(value) {
   const n = Number.parseInt(value, 10);