@dashai/cli 0.16.0 → 0.17.0

package/dist/bin.js

@@ -464,6 +464,19 @@ async function applyDraftManifest(moduleId, manifest, options = {}) {
     options
   );
 }
+async function getRuntimeLogs(installationId, opts = {}, options = {}) {
+  const params = new URLSearchParams();
+  if (opts.since !== void 0 && opts.since !== "") params.set("since", opts.since);
+  if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+  if (opts.tail) params.set("tail", "true");
+  const qs = params.toString();
+  return apiRequest(
+    "GET",
+    `/api/modules/installations/${installationId}/runtime-logs${qs ? `?${qs}` : ""}`,
+    void 0,
+    options
+  );
+}
 var ApiError;
 var init_api_client = __esm({
   "src/lib/api-client.ts"() {
@@ -4324,9 +4337,29 @@ function parseFieldSpec(spec) {
           `The ${quote("unique")} flag is not supported on field specs \u2014 uniqueness is a TABLE-level index. Declare it in module.json as ${quote(`owns.tables[].indexes: [{ "fields": ["${slug}"], "unique": true }]`)} and apply it with ${quote("dashwise schema push")}.`
         );
       }
+      if (DECIMALS_FLAG_REGEX.test(flag)) {
+        if (type !== "number") {
+          throw new FieldSpecError(
+            `Decimal places (${quote(flag)}) are only valid on ${quote("number")} fields, not ${quote(type)}. Field spec ${quote(spec)} sets a scale on a non-number type.`
+          );
+        }
+        if (result.decimal_places !== void 0) {
+          throw new FieldSpecError(
+            `Decimal places specified twice in field spec ${quote(spec)}.`
+          );
+        }
+        const places = Number.parseInt(flag, 10);
+        if (places < 0 || places > MAX_DECIMAL_PLACES) {
+          throw new FieldSpecError(
+            `Decimal places must be between 0 and ${MAX_DECIMAL_PLACES} (got ${quote(flag)}) in field spec ${quote(spec)}.`
+          );
+        }
+        result.decimal_places = places;
+        continue;
+      }
       if (!KNOWN_FLAGS.has(flag)) {
         throw new FieldSpecError(
-          `Unknown flag ${quote(flag)} in field spec ${quote(spec)}. Known flags: ${[...KNOWN_FLAGS].join(", ")}. For options/target/default, use ${quote("--field-json")} instead.`
+          `Unknown flag ${quote(flag)} in field spec ${quote(spec)}. Known flags: ${[...KNOWN_FLAGS].join(", ")}${type === "number" ? ` (plus a bare 0\u2013${MAX_DECIMAL_PLACES} integer for decimal places, e.g. ${quote(`${slug}:number:2`)})` : ""}. For options/target/default, use ${quote("--field-json")} instead.`
         );
       }
       if (flag === "required") result.required = true;
@@ -4377,7 +4410,7 @@ function parseFieldJson(json) {
 function quote(s) {
   return `\`${s}\``;
 }
-var FIELD_TYPES, SLUG_REGEX, KNOWN_FLAGS, FieldSpecError;
+var FIELD_TYPES, SLUG_REGEX, KNOWN_FLAGS, DECIMALS_FLAG_REGEX, MAX_DECIMAL_PLACES, FieldSpecError;
 var init_field_spec = __esm({
   "src/lib/field-spec.ts"() {
     FIELD_TYPES = [
@@ -4400,6 +4433,8 @@ var init_field_spec = __esm({
     ];
     SLUG_REGEX = /^[a-z][a-z0-9_]*[a-z0-9]$/;
     KNOWN_FLAGS = /* @__PURE__ */ new Set(["required"]);
+    DECIMALS_FLAG_REGEX = /^\d+$/;
+    MAX_DECIMAL_PLACES = 10;
     FieldSpecError = class extends Error {
       constructor(message) {
         super(message);
@@ -7241,13 +7276,13 @@ async function moduleUninstallCommand(slugArg, options) {
     }
     info(
       `Uninstalling ${code(mod.slug)} (install ${code(`#${row.id}`)}, kind=${row.kind ?? "production"}${row.module_version?.version ? `, v${row.module_version.version}` : ""}) from workspace ${code(workspace2.slug)}.
-  The app is soft-deleted, recoverable ONLY by a PLATFORM OPERATOR (contact support/HQ) within ~7 days \u2014 it does NOT appear in your dashboard trash.
-  An operator restore KEEPS the public URL${row.public_url ? ` ${code(row.public_url)}` : ""}; a REINSTALL mints a NEW one \u2014 deep links to the old URL break.`
+  The app is soft-deleted and appears in your workspace trash \u2014 a workspace admin can self-serve restore its DATA (~30 days). Reviving a running module within ~7 days is a platform-operator action.
+  A REINSTALL now KEEPS the same public URL${row.public_url ? ` ${code(row.public_url)}` : ""}, so deep links survive. (On backends older than 2026-07-15: restore is operator-only and a reinstall mints a new URL.)`
     );
     const answer = await select({
       message: `Uninstall ${code(mod.slug)} from ${code(workspace2.slug)}?`,
       options: [
-        { value: "uninstall", label: "Uninstall \u2014 soft-delete the app (operator-restorable ~7 days)" },
+        { value: "uninstall", label: "Uninstall \u2014 soft-delete the app (data restorable from workspace trash ~30 days)" },
         { value: "cancel", label: "Cancel \u2014 nothing is changed" }
       ],
       initialValue: "cancel"
@@ -7279,8 +7314,8 @@ async function moduleUninstallCommand(slugArg, options) {
     `Uninstalled ${code(mod.slug)} (install ${code(`#${row.id}`)}) from workspace ${code(workspace2.slug)}.`
   );
   info(
-    `The app was soft-deleted. If this was a mistake: only a PLATFORM OPERATOR can restore it (contact support/HQ) within ~7 days \u2014 it does NOT appear in your dashboard trash. An operator restore keeps the same public URL.
-  Reinstalling instead (${code(`dashwise module install ${mod.slug} --workspace ${workspace2.slug}`)}) mints a NEW public URL.`
+    `The app was soft-deleted. If this was a mistake: restore its DATA yourself from your workspace trash (~30 days); to bring the running module back within ~7 days, contact a platform operator (support/HQ).
+  Reinstalling (${code(`dashwise module install ${mod.slug} --workspace ${workspace2.slug}`)}) now KEEPS the same public URL. (Older backends, < 2026-07-15: restore is operator-only and reinstall mints a new URL.)`
   );
   if (options.parkConsumers) {
     info(
@@ -10489,6 +10524,319 @@ function mapAndPrintError(err, json) {
   return 1;
 }
 
+// src/commands/module/logs.ts
+init_api_client();
+init_config();
+init_manifest_io();
+init_output();
+var POLL_INTERVAL_MS3 = 2e3;
+var DURATION_UNIT_MS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function resolveSince(raw) {
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed === "") return void 0;
+  const m = /^(\d+)\s*(s|m|h|d)$/i.exec(trimmed);
+  if (m) {
+    const n = Number.parseInt(m[1], 10);
+    const unitMs = DURATION_UNIT_MS[m[2].toLowerCase()];
+    return new Date(Date.now() - n * unitMs).toISOString();
+  }
+  return trimmed;
+}
+async function moduleLogsCommand(slugArg, options) {
+  if (options.follow && options.json) {
+    fail("`--follow` and `--json` are mutually exclusive.");
+    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 }
+  };
+  const since = resolveSince(options.since);
+  let installationId;
+  let label;
+  if (options.install !== void 0) {
+    if (!Number.isInteger(options.install) || options.install <= 0) {
+      fail(
+        `--install expects a positive integer installation id (got "${options.install}").`
+      );
+      return 1;
+    }
+    installationId = options.install;
+    label = `install #${installationId}`;
+  } else {
+    const resolved = await resolveInstallationFromSlug(slugArg, options, cfg, auth);
+    if (typeof resolved === "number") return resolved;
+    installationId = resolved.installationId;
+    label = resolved.label;
+  }
+  if (options.follow) {
+    return runFollow(installationId, label, { since, limit: options.limit }, auth);
+  }
+  return runOnce3(installationId, label, options, since, auth);
+}
+async function resolveInstallationFromSlug(slugArg, options, cfg, auth) {
+  let slug = slugArg;
+  if (!slug) {
+    try {
+      const fromManifest = readManifest(options.dir)?.module?.slug;
+      if (typeof fromManifest === "string" && fromManifest.length > 0) {
+        slug = fromManifest;
+      }
+    } catch {
+    }
+  }
+  if (!slug) {
+    fail(
+      `No module slug \u2014 pass one (${code("dashwise module logs <slug>")}), run from a directory with a valid module.json, or target an install directly with ${code("--install <id>")}.`
+    );
+    return 1;
+  }
+  let modId;
+  let modSlug;
+  try {
+    const mod = await getModuleBySlug(slug, auth);
+    modId = mod.id;
+    modSlug = mod.slug;
+  } 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);
+    const matches = installs.filter((r) => r.module_id === modId);
+    row = matches.find((r) => !isDevInstallKind(r.kind) && isRealRuntimeUrl(r.runtime_url)) ?? matches.find((r) => !isDevInstallKind(r.kind)) ?? matches[0];
+  } catch (err) {
+    fail(`Could not read workspace installations: ${err.message}`);
+    return 1;
+  }
+  if (!row) {
+    info(
+      `${code(modSlug)} is not installed in workspace ${code(workspace2.slug)} \u2014 nothing to read logs from. Deploy it with ${code(`dashwise module install ${modSlug} --workspace ${workspace2.slug}`)}.`
+    );
+    return 0;
+  }
+  return {
+    installationId: row.id,
+    label: `${modSlug} in ${workspace2.slug} (install #${row.id})`
+  };
+}
+async function runOnce3(installationId, label, options, since, auth) {
+  let body;
+  try {
+    body = await getRuntimeLogs(
+      installationId,
+      {
+        ...since !== void 0 && !options.tail ? { since } : {},
+        ...options.limit !== void 0 ? { limit: options.limit } : {},
+        ...options.tail ? { tail: true } : {}
+      },
+      auth
+    );
+  } catch (err) {
+    return mapLogsError(err, options.json);
+  }
+  if (options.json) {
+    out(JSON.stringify(body));
+    return 0;
+  }
+  if (body.entries.length === 0) {
+    info(`No runtime log entries for ${label} in the requested window.`);
+    return 0;
+  }
+  for (const entry of body.entries) out(formatRow2(entry));
+  out("");
+  info(
+    `${body.entries.length} ${body.entries.length === 1 ? "line" : "lines"} (${label}).`
+  );
+  return 0;
+}
+async function runFollow(installationId, label, opts, auth) {
+  info(`Following runtime logs for ${label} (every ${POLL_INTERVAL_MS3 / 1e3}s). Ctrl-C to stop.`);
+  out("");
+  let stopped = false;
+  const onSigint = () => {
+    stopped = true;
+  };
+  process.on("SIGINT", onSigint);
+  let lastTs;
+  let seenAtLastTs = /* @__PURE__ */ new Set();
+  let firstPoll = true;
+  try {
+    while (!stopped) {
+      const query = {};
+      if (opts.limit !== void 0) query.limit = opts.limit;
+      if (firstPoll) {
+        if (opts.since !== void 0) query.since = opts.since;
+        else query.tail = true;
+      } else if (lastTs !== void 0) {
+        query.since = new Date(lastTs).toISOString();
+      }
+      let body;
+      try {
+        body = await getRuntimeLogs(installationId, query, auth);
+      } catch (err) {
+        if (isFatalFollowError(err)) {
+          return mapLogsError(err, false);
+        }
+        info(dim(`(follow: transient error \u2014 ${err.message})`));
+        await sleep4(POLL_INTERVAL_MS3, () => stopped);
+        firstPoll = false;
+        continue;
+      }
+      const fresh = [];
+      for (const entry of body.entries) {
+        if (lastTs !== void 0 && entry.ts < lastTs) continue;
+        if (lastTs !== void 0 && entry.ts === lastTs && seenAtLastTs.has(entryKey(entry))) {
+          continue;
+        }
+        fresh.push(entry);
+      }
+      fresh.sort((a, b) => a.ts - b.ts);
+      for (const entry of fresh) out(formatRow2(entry));
+      if (fresh.length > 0) {
+        const newMax = fresh[fresh.length - 1].ts;
+        if (newMax !== lastTs) seenAtLastTs = /* @__PURE__ */ new Set();
+        lastTs = newMax;
+        for (const entry of fresh) {
+          if (entry.ts === lastTs) seenAtLastTs.add(entryKey(entry));
+        }
+      }
+      firstPoll = false;
+      await sleep4(POLL_INTERVAL_MS3, () => stopped);
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  out("");
+  return 0;
+}
+function isFatalFollowError(err) {
+  if (!(err instanceof ApiError)) return false;
+  if (err.status === 401 || err.status === 403 || err.status === 404) return true;
+  return err.code === "INSTALLATION_NOT_FOUND" || err.code === "RUNTIME_NOT_PROVISIONED" || err.code === "INVALID_SINCE";
+}
+function formatTs(ts) {
+  if (!Number.isFinite(ts)) return "--:--:--";
+  return new Date(ts).toISOString().slice(11, 19);
+}
+function colorLevel(level) {
+  const padded = level.toUpperCase().padEnd(5);
+  switch (level) {
+    case "error":
+      return pc.red(padded);
+    case "warn":
+      return pc.yellow(padded);
+    case "info":
+      return pc.green(padded);
+    case "debug":
+    default:
+      return dim(padded);
+  }
+}
+function formatRow2(entry) {
+  const time = dim(formatTs(entry.ts));
+  const level = colorLevel(entry.level);
+  const reqId = entry.request_id ? `  ${dim(`[${entry.request_id}]`)}` : "";
+  return `${time}  ${level}  ${entry.message}${reqId}`;
+}
+function entryKey(entry) {
+  return `${entry.ts}\0${entry.request_id ?? ""}\0${entry.message}`;
+}
+function mapLogsError(err, json) {
+  if (err instanceof ApiError) {
+    const emit = (code_, message2) => {
+      if (json) out(JSON.stringify({ ok: false, error: { code: code_, message: message2 } }));
+      else fail(message2);
+    };
+    if (err.status === 401 || err.code === "UNAUTHENTICATED") {
+      emit("NOT_LOGGED_IN", `Not logged in. Run ${code("dashwise login")} first.`);
+      return 1;
+    }
+    if (err.status === 403) {
+      emit(
+        "FORBIDDEN",
+        `Reading runtime logs requires workspace-admin on this install's workspace.`
+      );
+      return 1;
+    }
+    if (err.status === 404 || err.code === "INSTALLATION_NOT_FOUND") {
+      emit(
+        "INSTALLATION_NOT_FOUND",
+        `Installation not found. Check the id (${code("dashwise module status <slug>")}) \u2014 it may have been uninstalled.`
+      );
+      return 1;
+    }
+    if (err.code === "RUNTIME_NOT_PROVISIONED") {
+      emit(
+        "RUNTIME_NOT_PROVISIONED",
+        `This install has no running runtime yet \u2014 deploy it first (${code("dashwise module install <slug>")}). The ${code("kind=local")} dev install never provisions a machine runtime, so it has no runtime logs.`
+      );
+      return 1;
+    }
+    if (err.code === "INVALID_SINCE") {
+      emit(
+        "INVALID_SINCE",
+        `${code("--since")} must be an ISO-8601 timestamp (e.g. ${code("2026-07-15T09:00:00Z")}) or a duration like ${code("15m")} / ${code("2h")} / ${code("2d")}.`
+      );
+      return 1;
+    }
+    if (err.code.startsWith("RUNTIME_")) {
+      emit(
+        err.code,
+        `The runtime host rejected the log read (${err.code}): ${err.message}. This is a host-side error \u2014 retry, or check the runtime with ${code("dashwise module status <slug>")}.`
+      );
+      return 1;
+    }
+    emit(err.code, `Could not read runtime logs: ${err.code} ${err.status} \u2014 ${err.message}`);
+    return 1;
+  }
+  const message = `Could not read runtime logs: ${err.message}`;
+  if (json) out(JSON.stringify({ ok: false, error: { code: "FETCH_FAILED", message } }));
+  else fail(message);
+  return 1;
+}
+async function sleep4(ms, aborted) {
+  const slice = 100;
+  let waited = 0;
+  while (waited < ms && !aborted()) {
+    await new Promise((resolve13) => setTimeout(resolve13, Math.min(slice, ms - waited)));
+    waited += slice;
+  }
+}
+
 // src/bin.ts
 init_output();
 var program = new Command();
@@ -11115,6 +11463,29 @@ moduleCmd.command("action-log").description(
     });
   }
 );
+moduleCmd.command("logs [slug]").description(
+  "Read a deployed module install's runtime logs (the host's log group). Resolves the install from the slug + workspace like `module status`, or target any install directly with `--install <id>`. `--since 15m|2h|<iso>` sets a lower bound; `--tail` shows the most-recent page; `--follow`/`-f` streams new lines every ~2s (Ctrl-C to stop). Workspace-admin."
+).option("--dir <path>", "Project root for the module.json slug lookup (default: current directory).").option("--workspace <slug-or-id>", "Target workspace (default: cached module workspace, config default, or interactive picker).").option(
+  "--install <id>",
+  "Target a specific installation id directly (deployed installs included). Find ids via `dashwise module status <slug>`. Skips slug + workspace resolution.",
+  parseIntOption
+).option(
+  "--since <iso-or-duration>",
+  'Only lines newer than this. Accepts an ISO-8601 timestamp or a duration like "15m", "2h", "2d". Ignored with --tail.'
+).option("--limit <n>", "Max lines per fetch (1-1000, backend-clamped, default 100).", parseIntOption).option("--tail", "Show the most-recent page (ignores --since).").option("-f, --follow", "Poll every ~2s for new lines. Ctrl-C to stop. Mutually exclusive with --json.").option("--json", "Emit the raw `{ entries }` JSON response. Ignored with --follow.").action(
+  async (slug, cmdOpts) => {
+    process.exitCode = await moduleLogsCommand(slug, {
+      ...cmdOpts.dir !== void 0 ? { dir: cmdOpts.dir } : {},
+      ...cmdOpts.workspace !== void 0 ? { workspace: cmdOpts.workspace } : {},
+      ...cmdOpts.install !== void 0 ? { install: cmdOpts.install } : {},
+      ...cmdOpts.since !== void 0 ? { since: cmdOpts.since } : {},
+      ...cmdOpts.limit !== void 0 ? { limit: cmdOpts.limit } : {},
+      ...cmdOpts.tail !== void 0 ? { tail: cmdOpts.tail } : {},
+      ...cmdOpts.follow !== void 0 ? { follow: cmdOpts.follow } : {},
+      ...cmdOpts.json !== void 0 ? { json: cmdOpts.json } : {}
+    });
+  }
+);
 moduleCmd.command("destroy-dev-install").description(
   "Destroy the local-dev install for the current module. Tears down the install row + dashboard tile; if the module had no other installs and was never published, drops the module too. Local module.json is preserved (only the cached runtime token + install id in auth.json get cleared)."
 ).option("--dir <path>", "Project root (default: current directory).").option(
@@ -11248,7 +11619,7 @@ fieldCmd.command("set-type <table-slug> <field-slug> <new-type>").description(
   }
 })();
 function getVersion() {
-  return "0.16.0";
+  return "0.17.0";
 }
 function parseIntOption(value) {
   const n = Number.parseInt(value, 10);