nolo-cli 0.54.0-alpha.2 → 0.61.0-alpha.2

package/chunk-M3JEW6N6.js

@@ -0,0 +1,193 @@
+import {
+  API_VERSION
+} from "./chunk-LCBAMY2M.js";
+
+// packages/core/authRoutes.ts
+var authRoutes = {
+  login: {
+    path: `${API_VERSION}/users/login`,
+    method: "POST",
+    createPath: () => `${API_VERSION}/users/login`
+  },
+  signup: {
+    path: `${API_VERSION}/users/signup`,
+    method: "POST",
+    createPath: () => `${API_VERSION}/users/signup`
+  },
+  users: {
+    cliLoginStart: {
+      path: `${API_VERSION}/users/cli-login/start`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/cli-login/start`
+    },
+    cliLoginAuthorize: {
+      path: `${API_VERSION}/users/cli-login/authorize`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/cli-login/authorize`
+    },
+    cliLoginPoll: {
+      path: `${API_VERSION}/users/cli-login/poll`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/cli-login/poll`
+    },
+    list: {
+      path: `${API_VERSION}/users`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users`
+    },
+    usageReport: {
+      path: `${API_VERSION}/users/usage-report`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/usage-report`
+    },
+    failureReport: {
+      path: `${API_VERSION}/users/failure-report`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/failure-report`
+    },
+    growthReport: {
+      path: `${API_VERSION}/users/growth-report`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/growth-report`
+    },
+    providerBillingHealth: {
+      path: `${API_VERSION}/users/provider-billing-health`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/provider-billing-health`
+    },
+    providerBillingDrilldown: {
+      path: `${API_VERSION}/users/provider-billing-drilldown`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/provider-billing-drilldown`
+    },
+    providerCredentials: {
+      path: `${API_VERSION}/users/provider-credentials`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/provider-credentials`
+    },
+    providerCredentialLifecycle: {
+      path: `${API_VERSION}/users/provider-credentials/lifecycle`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/provider-credentials/lifecycle`
+    },
+    billingAnomalyLifecycle: {
+      path: `${API_VERSION}/users/billing-anomalies/lifecycle`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/billing-anomalies/lifecycle`
+    },
+    billingAnomalyDrilldown: {
+      path: `${API_VERSION}/users/billing-anomalies/drilldown`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/billing-anomalies/drilldown`
+    },
+    billingAnomalyAudit: {
+      path: `${API_VERSION}/users/billing-anomalies/audit`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/billing-anomalies/audit`
+    },
+    detail: {
+      path: `${API_VERSION}/users/:userId`,
+      method: "GET",
+      createPath: (params) => `${API_VERSION}/users/${params.userId}`
+    },
+    sessionRevoke: {
+      path: `${API_VERSION}/users/session-revoke`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/session-revoke`
+    },
+    transfer: {
+      path: `${API_VERSION}/users/:userId/transfer`,
+      method: "POST",
+      createPath: (params) => `${API_VERSION}/users/${params.userId}/transfer`
+    },
+    delete: {
+      path: `${API_VERSION}/users/:userId`,
+      method: "DELETE",
+      createPath: (params) => `${API_VERSION}/users/${params.userId}`
+    },
+    disable: {
+      path: `${API_VERSION}/users/:userId/disable`,
+      method: "POST",
+      createPath: (params) => `${API_VERSION}/users/${params.userId}/disable`
+    },
+    enable: {
+      path: `${API_VERSION}/users/:userId/enable`,
+      method: "POST",
+      createPath: (params) => `${API_VERSION}/users/${params.userId}/enable`
+    },
+    adminPermissions: {
+      path: `${API_VERSION}/users/:userId/admin-permissions`,
+      method: "POST",
+      createPath: (params) => `${API_VERSION}/users/${params.userId}/admin-permissions`
+    },
+    sendEmail: {
+      path: `${API_VERSION}/users/send-email`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/send-email`
+    },
+    spaceInvite: {
+      path: `${API_VERSION}/users/space-invite`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/space-invite`
+    },
+    spaceInviteStatus: {
+      path: `${API_VERSION}/users/space-invite/status`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/space-invite/status`
+    },
+    spaceInviteAccept: {
+      path: `${API_VERSION}/users/space-invite/accept`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/space-invite/accept`
+    },
+    emailPreferencesGet: {
+      path: `${API_VERSION}/users/email-preferences`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/email-preferences`
+    },
+    emailPreferencesUpdate: {
+      path: `${API_VERSION}/users/email-preferences`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/email-preferences`
+    },
+    emailReport: {
+      path: `${API_VERSION}/users/email-report`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/email-report`
+    },
+    emailRetryRun: {
+      path: `${API_VERSION}/users/email-retry/run`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/email-retry/run`
+    },
+    emailReplayFailures: {
+      path: `${API_VERSION}/users/email-replay-failures`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/email-replay-failures`
+    },
+    emailConfigGet: {
+      path: `${API_VERSION}/users/email-config`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/email-config`
+    },
+    emailConfigUpdate: {
+      path: `${API_VERSION}/users/email-config`,
+      method: "POST",
+      createPath: () => `${API_VERSION}/users/email-config`
+    },
+    emailUnsubscribe: {
+      path: `${API_VERSION}/users/email-unsubscribe`,
+      method: "GET",
+      createPath: () => `${API_VERSION}/users/email-unsubscribe`
+    },
+    rechargeHistory: {
+      path: `${API_VERSION}/users/:userId/recharge-history`,
+      method: "POST",
+      createPath: (params) => `${API_VERSION}/users/${params.userId}/recharge-history`
+    }
+  }
+};
+
+export {
+  authRoutes
+};

package/chunk-MBOEV4L2.js

@@ -0,0 +1,301 @@
+import {
+  require_react
+} from "./chunk-YDH3FDFQ.js";
+import {
+  createSpaceKey,
+  normalizeSpaceId
+} from "./chunk-UAD2WT54.js";
+import {
+  toTimestampMs
+} from "./chunk-DNNSCSA2.js";
+import {
+  fetchFromServer,
+  getAllServers
+} from "./chunk-QOKAKDPE.js";
+import {
+  selectIdentityToken,
+  selectIdentityUserId
+} from "./chunk-SEJ5OS6F.js";
+import {
+  isTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/create/space/spaceMembershipStore.ts
+var import_react = __toESM(require_react(), 1);
+var createInitialState = () => ({
+  memberSpaces: null,
+  loading: false,
+  membershipStatus: "idle",
+  initialized: false
+});
+var state = createInitialState();
+var listeners = /* @__PURE__ */ new Set();
+var version = 0;
+var notify = () => {
+  version += 1;
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+};
+var getMembershipUpdatedAt = (space) => {
+  if (!space) return 0;
+  return toTimestampMs(
+    space.spaceUpdatedAt ?? space.memberUpdatedAt ?? space.updatedAt ?? space.createdAt ?? space.joinedAt
+  );
+};
+function dedupeMemberSpacesById(memberSpaces) {
+  const membershipMap = /* @__PURE__ */ new Map();
+  memberSpaces.forEach((space) => {
+    const prev = membershipMap.get(space.spaceId);
+    if (!prev || getMembershipUpdatedAt(space) >= getMembershipUpdatedAt(prev)) {
+      membershipMap.set(space.spaceId, space);
+    }
+  });
+  return Array.from(membershipMap.values());
+}
+function getMemberSpaces() {
+  return state.memberSpaces;
+}
+function getAllMemberSpaces() {
+  const memberSpaces = dedupeMemberSpacesById(state.memberSpaces || []);
+  return [...memberSpaces].sort((a, b) => {
+    return getMembershipUpdatedAt(b) - getMembershipUpdatedAt(a);
+  });
+}
+function setMemberSpaces(spaces) {
+  state = {
+    ...state,
+    memberSpaces: spaces,
+    loading: false,
+    error: void 0,
+    membershipStatus: "fresh",
+    initialized: true
+  };
+  notify();
+}
+function setMembershipLoading() {
+  state = { ...state, loading: true, membershipStatus: "loading" };
+  notify();
+}
+function setMembershipRejected(errorMessage, isRemoteUnavailable) {
+  const membershipStatus = isRemoteUnavailable ? "offline" : state.membershipStatus === "loading" ? "idle" : state.membershipStatus;
+  state = {
+    ...state,
+    loading: false,
+    error: errorMessage,
+    membershipStatus
+  };
+  notify();
+}
+function hydrateMemberSpacesFromLocal(spaces) {
+  if (state.memberSpaces !== null || spaces.length === 0) return;
+  state = {
+    ...state,
+    memberSpaces: dedupeMemberSpacesById(spaces),
+    loading: false
+  };
+  notify();
+}
+function appendRecoveredMemberships(recovered) {
+  if (!recovered || recovered.length === 0) return;
+  if (state.memberSpaces === null) {
+    state = {
+      ...state,
+      memberSpaces: dedupeMemberSpacesById(recovered)
+    };
+    notify();
+    return;
+  }
+  state = {
+    ...state,
+    memberSpaces: dedupeMemberSpacesById([
+      ...state.memberSpaces,
+      ...recovered
+    ]).sort((a, b) => toTimestampMs(b.joinedAt) - toTimestampMs(a.joinedAt))
+  };
+  notify();
+}
+function setSpaceInitialized() {
+  state = { ...state, initialized: true };
+  notify();
+}
+function setMembershipLoaded() {
+  state = { ...state, loading: false, error: void 0 };
+  notify();
+}
+function addMemberSpace(space) {
+  const existing = state.memberSpaces || [];
+  state = {
+    ...state,
+    memberSpaces: dedupeMemberSpacesById([...existing, space])
+  };
+  notify();
+}
+function removeMemberSpace(spaceId) {
+  if (!state.memberSpaces) return;
+  const normalized = normalizeSpaceId(spaceId);
+  state = {
+    ...state,
+    memberSpaces: state.memberSpaces.filter(
+      (s) => normalizeSpaceId(s.spaceId) !== normalized
+    )
+  };
+  notify();
+}
+function updateMemberSpaceName(spaceId, name) {
+  if (!state.memberSpaces || !name) return;
+  state = {
+    ...state,
+    memberSpaces: state.memberSpaces.map(
+      (space) => space.spaceId === spaceId ? { ...space, spaceName: name } : space
+    )
+  };
+  notify();
+}
+
+// packages/create/space/spaceAccess.ts
+var resolveSpaceRemoteServers = (state2) => {
+  const currentServer = typeof state2?.settings?.currentServer === "string" ? state2.settings.currentServer : void 0;
+  const syncServers = Array.isArray(state2?.settings?.syncServers) ? state2.settings.syncServers : void 0;
+  return getAllServers(currentServer, syncServers);
+};
+var selectSpaceRemoteAuth = (state2) => ({
+  token: selectIdentityToken(state2) ?? null,
+  userId: selectIdentityUserId(state2) ?? null,
+  servers: resolveSpaceRemoteServers(state2)
+});
+var spaceListsUser = (spaceData, userId) => {
+  if (!spaceData || isTombstoneRecord(spaceData)) return false;
+  if (spaceData.ownerId === userId) return true;
+  return Array.isArray(spaceData.members) && spaceData.members.includes(userId);
+};
+var membershipBelongsToUser = (membership, userId) => !membership.userId || membership.userId === userId;
+var membershipFetchCache = /* @__PURE__ */ new Map();
+var MEMBERSHIP_FETCH_CACHE_TTL_MS = 3e4;
+async function fetchMembershipsFromServer(server, token, userId, timeoutMs) {
+  if (!token) return { ok: false, memberships: [] };
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${server}/rpc/getUserSpaceMemberships`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ userId }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      console.error(
+        `Failed to fetch memberships from ${server}: ${response.statusText}`
+      );
+      return { ok: false, memberships: [] };
+    }
+    const data = await response.json();
+    return {
+      ok: true,
+      server,
+      memberships: Array.isArray(data) ? data : []
+    };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    console.error(`Error fetching memberships from ${server}:`, error);
+    return { ok: false, memberships: [] };
+  }
+}
+var fetchRemoteUserSpaceMemberships = (server, token, userId, timeoutMs = 5e3) => {
+  const cacheKey = `${server}|${userId}`;
+  const cached = membershipFetchCache.get(cacheKey);
+  if (cached) return cached;
+  const promise = fetchMembershipsFromServer(server, token, userId, timeoutMs);
+  membershipFetchCache.set(cacheKey, promise);
+  promise.catch(() => {
+  }).finally(() => {
+    setTimeout(() => {
+      if (membershipFetchCache.get(cacheKey) === promise) {
+        membershipFetchCache.delete(cacheKey);
+      }
+    }, MEMBERSHIP_FETCH_CACHE_TTL_MS);
+  });
+  return promise;
+};
+var fetchRemoteSpace = async (server, token, spaceId) => {
+  try {
+    const space = await fetchFromServer(
+      server,
+      createSpaceKey.space(normalizeSpaceId(spaceId)),
+      token ?? void 0
+    );
+    return space && typeof space === "object" ? space : null;
+  } catch {
+    return null;
+  }
+};
+var hasActiveRemoteMembership = async (server, token, userId, spaceId) => {
+  const result = await fetchRemoteUserSpaceMemberships(server, token, userId);
+  if (!result.ok) return false;
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  return result.memberships.some((membership) => {
+    const membershipSpaceId = typeof membership?.spaceId === "string" ? normalizeSpaceId(membership.spaceId) : "";
+    return membershipSpaceId === normalizedSpaceId && membershipBelongsToUser(membership, userId) && !isTombstoneRecord(membership);
+  });
+};
+var fetchAuthoritativeRemoteSpace = async ({
+  servers,
+  token,
+  userId,
+  spaceId
+}) => {
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  for (const server of servers) {
+    const space = await fetchRemoteSpace(server, token, normalizedSpaceId);
+    if (!space) continue;
+    if (!spaceListsUser(space, userId)) {
+      throw new Error(`Current user is not a member of space: ${normalizedSpaceId}`);
+    }
+    if (space.ownerId !== userId) {
+      const hasMembership = await hasActiveRemoteMembership(
+        server,
+        token,
+        userId,
+        normalizedSpaceId
+      );
+      if (!hasMembership) {
+        throw new Error(
+          `Current user has no active membership for space: ${normalizedSpaceId}`
+        );
+      }
+    }
+    return space;
+  }
+  return null;
+};
+
+export {
+  selectSpaceRemoteAuth,
+  spaceListsUser,
+  membershipBelongsToUser,
+  fetchRemoteUserSpaceMemberships,
+  fetchRemoteSpace,
+  fetchAuthoritativeRemoteSpace,
+  getMemberSpaces,
+  getAllMemberSpaces,
+  setMemberSpaces,
+  setMembershipLoading,
+  setMembershipRejected,
+  hydrateMemberSpacesFromLocal,
+  appendRecoveredMemberships,
+  setSpaceInitialized,
+  setMembershipLoaded,
+  addMemberSpace,
+  removeMemberSpace,
+  updateMemberSpaceName
+};