nolo-cli 0.6.1 → 0.8.0-alpha.10

package/spaceCommands-LC4FDAKE.js

@@ -0,0 +1,450 @@
+import {
+  readLiveDbRecordAfterTombstoneMerge
+} from "./chunk-QUWDTOUP.js";
+import {
+  readDbRecord,
+  writeAgentRecord
+} from "./chunk-FQZWM5YX.js";
+import "./chunk-HD63YREL.js";
+import "./chunk-VHBWHNVT.js";
+import "./chunk-KQHGZWSV.js";
+import {
+  authRoutes
+} from "./chunk-MRC4Q34M.js";
+import {
+  createSpaceKey,
+  normalizeSpaceId
+} from "./chunk-UAD2WT54.js";
+import "./chunk-IDZTNRP2.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import "./chunk-OLZBQWZU.js";
+import "./chunk-6P2WX5IA.js";
+import "./chunk-ZNFJWEN4.js";
+import "./chunk-TILFE6LV.js";
+import "./chunk-NEMRK4EK.js";
+import "./chunk-XDVAYP26.js";
+import "./chunk-LM25IZBJ.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-572EKYLF.js";
+import "./chunk-TDIQFT2F.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-BR2WP3DF.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-HNMXYYJR.js";
+import {
+  resolveFileCategory
+} from "./chunk-AZPCASRE.js";
+import "./chunk-KX6YBIHG.js";
+import {
+  require_index_umd
+} from "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/cli/spaceCommands.ts
+var import_ulid = __toESM(require_index_umd(), 1);
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+var VALID_INVITE_ROLES = /* @__PURE__ */ new Set([
+  "admin" /* ADMIN */,
+  "member" /* MEMBER */,
+  "guest" /* GUEST */
+]);
+function hasHelpArg(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function writeOutput(deps, text) {
+  (deps.output ?? process.stdout).write(text);
+}
+function requireTokenUser(args, env) {
+  const authToken = resolveAuthToken(args, env);
+  const userId = parseUserIdFromAuthToken(authToken) || env.USER_ID || "";
+  if (!authToken) {
+    throw new Error("space command requires an auth token. Pass --token or set AUTH_TOKEN.");
+  }
+  if (!userId) {
+    throw new Error("auth token does not contain userId. Pass a user-scoped token.");
+  }
+  return { authToken, userId };
+}
+function printCreateUsage(output) {
+  output.write(`Usage:
+  nolo space create --name <name> [--description <text>] [--id <spaceId>]
+
+Options:
+  --visibility private|public  Defaults to private.
+  --public                     Shortcut for --visibility public.
+  --server <url>               Default write target.
+  --token <jwt>                Auth token. Required for writes.
+  --json                       Print machine-readable JSON.
+`);
+}
+function printInviteUsage(output) {
+  output.write(`Usage:
+  nolo space invite --space <spaceId> --member <userId> [--role member|admin|guest]
+
+Options:
+  --server <url>               Default write target.
+  --token <jwt>                Auth token. Required for writes.
+  --json                       Print machine-readable JSON.
+
+Note:
+  Use --member for an existing Nolo user id, or --email to send a pending
+  space invitation email.
+`);
+}
+function printAcceptInviteUsage(output) {
+  output.write(`Usage:
+  nolo space accept-invite --invite <inviteToken>
+
+Options:
+  --server <url>               Default API target.
+  --token <jwt>                Auth token. Required for accepting.
+  --invite <inviteToken>       Space invite token from the email link.
+  --space-invite <inviteToken> Alias for --invite.
+  --json                       Print machine-readable JSON.
+`);
+}
+function printUploadUsage(output) {
+  output.write(`Usage:
+  nolo space upload --space <spaceId> --file <path>
+
+Options:
+  --server <url>               Default API target.
+  --token <jwt>                Auth token. Required for writes.
+  --json                       Print machine-readable JSON.
+
+Note:
+  Currently only YAML files (.yaml, .yml) are supported.
+`);
+}
+async function writeDbRecord(args) {
+  await writeAgentRecord({
+    agentKey: args.dbKey,
+    authToken: args.authToken,
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.serverUrl,
+    userId: args.userId,
+    record: args.record
+  });
+}
+async function runSpaceCreateCommand(args, deps) {
+  if (hasHelpArg(args)) {
+    printCreateUsage(deps.output ?? process.stdout);
+    return 0;
+  }
+  const name = readOption(args, "--name") ?? args.find((value) => !value.startsWith("-"));
+  if (!name?.trim()) {
+    throw new Error("space create requires --name <name>.");
+  }
+  const { authToken, userId } = requireTokenUser(args, deps.env);
+  const serverUrl = resolveServerUrl(args, deps.env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const spaceId = normalizeSpaceId(readOption(args, "--id") ?? (0, import_ulid.ulid)());
+  const now = Date.now();
+  const nowISO = new Date(now).toISOString();
+  const visibilityRaw = readOption(args, "--visibility");
+  const visibility = hasFlag(args, "--public") || visibilityRaw === "public" /* PUBLIC */ ? "public" /* PUBLIC */ : "private" /* PRIVATE */;
+  const description = readOption(args, "--description") ?? "";
+  const spaceKey = createSpaceKey.space(spaceId);
+  const memberKey = createSpaceKey.member(userId, spaceId);
+  const spaceRecord = {
+    id: spaceId,
+    dbKey: spaceKey,
+    type: "space" /* SPACE */,
+    name: name.trim(),
+    description,
+    ownerId: userId,
+    visibility,
+    members: [userId],
+    categories: {},
+    contents: {},
+    createdAt: now,
+    updatedAt: now
+  };
+  const memberRecord = {
+    dbKey: memberKey,
+    type: "space" /* SPACE */,
+    userId,
+    role: "owner" /* OWNER */,
+    joinedAt: now,
+    spaceId,
+    spaceName: name.trim(),
+    ownerId: userId,
+    visibility,
+    createdAt: nowISO,
+    updatedAt: nowISO,
+    spaceCreatedAt: now,
+    spaceUpdatedAt: now
+  };
+  await writeDbRecord({ authToken, dbKey: spaceKey, fetchImpl, record: spaceRecord, serverUrl, userId });
+  await writeDbRecord({ authToken, dbKey: memberKey, fetchImpl, record: memberRecord, serverUrl, userId });
+  const result = { spaceId, spaceKey, memberKey, name: name.trim(), visibility, serverUrl };
+  if (hasFlag(args, "--json")) {
+    writeOutput(deps, `${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    writeOutput(deps, `Created space ${spaceId} (${name.trim()})
+`);
+  }
+  return 0;
+}
+async function runSpaceInviteCommand(args, deps) {
+  if (hasHelpArg(args)) {
+    printInviteUsage(deps.output ?? process.stdout);
+    return 0;
+  }
+  const spaceIdRaw = readOption(args, "--space") ?? readOption(args, "--space-id");
+  const email = readOption(args, "--email");
+  const memberId = readOption(args, "--member") ?? readOption(args, "--member-id");
+  if (!spaceIdRaw?.trim()) throw new Error("space invite requires --space <spaceId>.");
+  if (!memberId?.trim() && !email?.trim()) {
+    throw new Error("space invite requires --member <userId> or --email <address>.");
+  }
+  const role = readOption(args, "--role") ?? "member" /* MEMBER */;
+  if (!VALID_INVITE_ROLES.has(role)) {
+    throw new Error("--role must be one of member, admin, or guest.");
+  }
+  const { authToken, userId } = requireTokenUser(args, deps.env);
+  const serverUrl = resolveServerUrl(args, deps.env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const spaceId = normalizeSpaceId(spaceIdRaw);
+  if (email?.trim()) {
+    const response = await fetchImpl(`${serverUrl}${authRoutes.users.spaceInvite.path}`, {
+      method: authRoutes.users.spaceInvite.method,
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        spaceId,
+        email: email.trim(),
+        role
+      })
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new Error(
+        data?.error?.message || data?.error || `space invite failed: HTTP ${response.status}`
+      );
+    }
+    if (hasFlag(args, "--json")) {
+      writeOutput(deps, `${JSON.stringify(data, null, 2)}
+`);
+    } else {
+      writeOutput(deps, `Invited ${email.trim()} to space ${spaceId} as ${role}
+`);
+    }
+    return 0;
+  }
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceRecord = await readDbRecord({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl,
+    serverUrl
+  });
+  const members = Array.isArray(spaceRecord?.members) ? spaceRecord.members : [];
+  if (!members.includes(userId)) {
+    throw new Error("current user is not a member of this space.");
+  }
+  if (members.includes(memberId)) {
+    throw new Error("member already exists in this space.");
+  }
+  const now = Date.now();
+  const updatedSpaceRecord = {
+    ...spaceRecord,
+    members: [...members, memberId],
+    updatedAt: now
+  };
+  if (!memberId?.trim()) {
+    throw new Error("space invite requires --member <userId>.");
+  }
+  const memberKey = createSpaceKey.member(memberId.trim(), spaceId);
+  const memberRecord = {
+    dbKey: memberKey,
+    type: "space" /* SPACE */,
+    userId: memberId,
+    role,
+    joinedAt: now,
+    updatedAt: now,
+    spaceId,
+    spaceName: spaceRecord.name ?? spaceId,
+    ownerId: spaceRecord.ownerId,
+    visibility: spaceRecord.visibility ?? "private" /* PRIVATE */,
+    spaceCreatedAt: spaceRecord.createdAt,
+    spaceUpdatedAt: now
+  };
+  await writeDbRecord({ authToken, dbKey: spaceKey, fetchImpl, record: updatedSpaceRecord, serverUrl, userId });
+  await writeDbRecord({ authToken, dbKey: memberKey, fetchImpl, record: memberRecord, serverUrl, userId });
+  const result = { spaceId, spaceKey, memberKey, memberId, role, serverUrl };
+  if (hasFlag(args, "--json")) {
+    writeOutput(deps, `${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    writeOutput(deps, `Invited ${memberId} to space ${spaceId} as ${role}
+`);
+  }
+  return 0;
+}
+async function runSpaceAcceptInviteCommand(args, deps) {
+  if (hasHelpArg(args)) {
+    printAcceptInviteUsage(deps.output ?? process.stdout);
+    return 0;
+  }
+  const inviteToken = readOption(args, "--invite") ?? readOption(args, "--space-invite") ?? readOption(args, "--invite-token");
+  if (!inviteToken?.trim()) {
+    throw new Error("space accept-invite requires --invite <inviteToken>.");
+  }
+  const { authToken } = requireTokenUser(args, deps.env);
+  const serverUrl = resolveServerUrl(args, deps.env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const response = await fetchImpl(`${serverUrl}${authRoutes.users.spaceInviteAccept.path}`, {
+    method: authRoutes.users.spaceInviteAccept.method,
+    headers: {
+      Authorization: `Bearer ${authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      token: inviteToken.trim()
+    })
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(
+      data?.error?.message || data?.error || `space invite accept failed: HTTP ${response.status}`
+    );
+  }
+  if (hasFlag(args, "--json")) {
+    writeOutput(deps, `${JSON.stringify(data, null, 2)}
+`);
+  } else {
+    writeOutput(deps, `Accepted invite for space ${data?.spaceId ?? ""}
+`);
+  }
+  return 0;
+}
+async function runSpaceUploadCommand(args, deps) {
+  if (hasHelpArg(args)) {
+    printUploadUsage(deps.output ?? process.stdout);
+    return 0;
+  }
+  const spaceIdRaw = readOption(args, "--space") ?? readOption(args, "--space-id");
+  const filePath = readOption(args, "--file");
+  if (!spaceIdRaw?.trim()) throw new Error("space upload requires --space <spaceId>.");
+  if (!filePath?.trim()) throw new Error("space upload requires --file <path>.");
+  const ext = extname(filePath).toLowerCase();
+  if (ext !== ".yaml" && ext !== ".yml") {
+    throw new Error("Only YAML files (.yaml, .yml) are supported for space upload.");
+  }
+  const { authToken, userId } = requireTokenUser(args, deps.env);
+  const serverUrl = resolveServerUrl(args, deps.env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const spaceId = normalizeSpaceId(spaceIdRaw);
+  const fileContent = readFileSync(filePath);
+  const spaceKey = createSpaceKey.space(spaceId);
+  const uploadName = basename(filePath);
+  const mimeType = "application/yaml";
+  const now = Date.now();
+  const nowIso = new Date(now).toISOString();
+  const { record: spaceRecord } = await readLiveDbRecordAfterTombstoneMerge({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl,
+    serverUrls: resolveServerCandidates(args, deps.env, serverUrl)
+  });
+  const formData = new FormData();
+  formData.append("file", new Blob([fileContent], { type: mimeType }), uploadName);
+  const fileId = (0, import_ulid.ulid)();
+  const fileDbKey = `file-${userId}-${fileId}`;
+  formData.append("metadata", JSON.stringify({
+    id: fileId,
+    title: uploadName,
+    originalName: uploadName,
+    fileName: `${fileId}${ext}`,
+    filePath: "",
+    size: fileContent.length,
+    mimeType,
+    type: "file" /* FILE */,
+    fileCategory: resolveFileCategory({
+      mimeType,
+      fileName: uploadName
+    }),
+    dbKey: fileDbKey,
+    userId,
+    ownerType: "space",
+    ownerId: spaceId,
+    ownerDbKey: spaceKey,
+    source: "cli-space-upload",
+    createdAt: nowIso,
+    updatedAt: nowIso
+  }));
+  formData.append("customKey", fileDbKey);
+  formData.append("userId", userId);
+  formData.append("ownerType", "space");
+  formData.append("ownerId", spaceId);
+  const uploadRes = await fetchImpl(`${serverUrl}/api/v1/db/upload`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${authToken}`
+    },
+    body: formData
+  });
+  const uploadData = await uploadRes.json().catch(() => ({}));
+  if (!uploadRes.ok) {
+    throw new Error(
+      uploadData?.error?.message || uploadData?.error || `space upload failed: HTTP ${uploadRes.status}`
+    );
+  }
+  const contents = spaceRecord.contents || {};
+  contents[fileDbKey] = {
+    ...contents[fileDbKey] ?? {},
+    title: uploadName,
+    type: "file" /* FILE */,
+    contentKey: fileDbKey,
+    createdAt: contents[fileDbKey]?.createdAt ?? now,
+    updatedAt: now
+  };
+  await writeDbRecord({
+    authToken,
+    dbKey: spaceKey,
+    fetchImpl,
+    record: { ...spaceRecord, contents, updatedAt: now },
+    serverUrl,
+    userId
+  });
+  if (hasFlag(args, "--json")) {
+    writeOutput(deps, `${JSON.stringify({ ...uploadData, spaceId, spaceKey }, null, 2)}
+`);
+  } else {
+    writeOutput(deps, `Uploaded ${uploadName} to space ${spaceId} (fileId: ${fileId})
+`);
+  }
+  return 0;
+}
+export {
+  runSpaceAcceptInviteCommand,
+  runSpaceCreateCommand,
+  runSpaceInviteCommand,
+  runSpaceUploadCommand
+};

package/spaceSlice-32XOGBEF.js

@@ -0,0 +1,145 @@
+import {
+  DEFAULT_COLLAPSED_CATEGORIES,
+  addCategory,
+  addContentToSpace,
+  addMember,
+  addSpace,
+  applySpaceEvent,
+  changeSpace,
+  dedupeMemberSpacesById,
+  deleteCategory,
+  deleteContentFromSpace,
+  deleteMultipleContent,
+  deleteSpace,
+  fetchSpace,
+  fetchSpaceSidebarState,
+  fetchUserSpaceMemberships,
+  fixSpace,
+  hydrateMemberSpacesFromLocal,
+  markDialogRead,
+  moveContentToSpace,
+  removeMember,
+  reorderCategories,
+  resetSpace,
+  selectAllMemberSpaces,
+  selectCollapsedCategories,
+  selectCurrentSpace,
+  selectCurrentSpaceId,
+  selectDialogEventTimestamps,
+  selectDialogStatus,
+  selectDialogStatusFromEntity,
+  selectDialogStatuses,
+  selectDialogTitles,
+  selectIsCategoryCollapsed,
+  selectIsDialogUnread,
+  selectIsDialogUnreadFromEntity,
+  selectMembershipStatus,
+  selectOwnedMemberSpaces,
+  selectSpaceInitialized,
+  selectSpaceLoading,
+  selectUnreadDialogIds,
+  selectViewMode,
+  setAllCategoriesCollapsed,
+  setViewMode,
+  spaceSlice_default,
+  toggleCategoryCollapse,
+  updateCategoryName,
+  updateContentCategory,
+  updateContentPinned,
+  updateContentTitle,
+  updateSpace,
+  uploadAndAddFileToSpace
+} from "./chunk-TKOUBWBO.js";
+import "./chunk-MRC4Q34M.js";
+import "./chunk-J4576WMJ.js";
+import "./chunk-CWMSB67P.js";
+import "./chunk-POCFIDGQ.js";
+import "./chunk-IYQV26RA.js";
+import "./chunk-Z4NR32XR.js";
+import "./chunk-M76ECQRD.js";
+import "./chunk-AUGHVUFE.js";
+import "./chunk-H2RMRZJE.js";
+import "./chunk-UAD2WT54.js";
+import "./chunk-USZMK5UT.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-572EKYLF.js";
+import "./chunk-TDIQFT2F.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-BR2WP3DF.js";
+import "./chunk-DFFIZ25G.js";
+import "./chunk-3ASDTTEI.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-HNMXYYJR.js";
+import "./chunk-VEJLAVTC.js";
+import "./chunk-Y5GCAMGP.js";
+import "./chunk-G5H7RNFL.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  DEFAULT_COLLAPSED_CATEGORIES,
+  addCategory,
+  addContentToSpace,
+  addMember,
+  addSpace,
+  applySpaceEvent,
+  changeSpace,
+  dedupeMemberSpacesById,
+  spaceSlice_default as default,
+  deleteCategory,
+  deleteContentFromSpace,
+  deleteMultipleContent,
+  deleteSpace,
+  fetchSpace,
+  fetchSpaceSidebarState,
+  fetchUserSpaceMemberships,
+  fixSpace,
+  hydrateMemberSpacesFromLocal,
+  markDialogRead,
+  moveContentToSpace,
+  removeMember,
+  reorderCategories,
+  resetSpace,
+  selectAllMemberSpaces,
+  selectCollapsedCategories,
+  selectCurrentSpace,
+  selectCurrentSpaceId,
+  selectDialogEventTimestamps,
+  selectDialogStatus,
+  selectDialogStatusFromEntity,
+  selectDialogStatuses,
+  selectDialogTitles,
+  selectIsCategoryCollapsed,
+  selectIsDialogUnread,
+  selectIsDialogUnreadFromEntity,
+  selectMembershipStatus,
+  selectOwnedMemberSpaces,
+  selectSpaceInitialized,
+  selectSpaceLoading,
+  selectUnreadDialogIds,
+  selectViewMode,
+  setAllCategoriesCollapsed,
+  setViewMode,
+  toggleCategoryCollapse,
+  updateCategoryName,
+  updateContentCategory,
+  updateContentPinned,
+  updateContentTitle,
+  updateSpace,
+  uploadAndAddFileToSpace
+};