nolo-cli 0.1.32 → 0.1.33

package/cli/spaceDeleteCommands.ts

@@ -1,312 +0,0 @@
-import { createSpaceKey, normalizeSpaceId } from "../create/space/spaceKeys";
-import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
-import { parseUserIdFromAuthToken, readOption, resolveAuthToken, resolveServerUrl } from "./cliEnvHelpers";
-import { readSpaceRecordWithFallback } from "./spaceMutationHelpers";
-
-type SpaceMembership = Record<string, any> & {
-  spaceId?: string;
-  name?: string;
-  spaceName?: string;
-  title?: string;
-};
-
-type DeleteTarget = {
-  spaceId: string;
-  name: string;
-  spaceKey: string;
-  memberKeys: string[];
-  contentCount: number;
-};
-
-type SkippedTarget = {
-  spaceId: string;
-  name: string;
-  reason: string;
-};
-
-function usage() {
-  return [
-    "Usage:",
-    "  nolo space delete --name-prefix <prefix> [--yes] [--json]",
-    "  nolo space delete --name <exact-name> [--yes] [--json]",
-    "  nolo space delete --space <spaceId|spaceKey|spaceUrl> [--yes] [--json]",
-    "",
-  ].join("\n");
-}
-
-function displayName(membership: SpaceMembership) {
-  return String(
-    membership.spaceName ??
-      membership.name ??
-      membership.title ??
-      membership.spaceTitle ??
-      ""
-  ).trim();
-}
-
-function matchesMembership(args: string[], membership: SpaceMembership) {
-  const requestedSpace = readOption(args, "--space");
-  if (requestedSpace) {
-    return normalizeSpaceId(String(membership.spaceId ?? "")) === normalizeSpaceId(requestedSpace);
-  }
-
-  const name = displayName(membership);
-  const exactName = readOption(args, "--name");
-  if (exactName) return name === exactName;
-
-  const prefix = readOption(args, "--name-prefix");
-  if (prefix) return name.startsWith(prefix);
-
-  throw new Error("space delete requires --space, --name, or --name-prefix");
-}
-
-function listMemberKeys(spaceRecord: Record<string, any>, userId: string, spaceId: string) {
-  const memberIds = new Set<string>();
-  memberIds.add(userId);
-
-  const members = spaceRecord.members;
-  if (Array.isArray(members)) {
-    for (const memberId of members) {
-      if (typeof memberId === "string" && memberId.trim()) {
-        memberIds.add(memberId.trim());
-      }
-    }
-  } else if (members && typeof members === "object") {
-    for (const memberId of Object.keys(members)) {
-      if (memberId.trim()) memberIds.add(memberId.trim());
-    }
-  }
-
-  return Array.from(memberIds).map((memberId) => createSpaceKey.member(memberId, spaceId));
-}
-
-async function fetchMemberships(args: {
-  authToken: string;
-  fetchImpl: typeof fetch;
-  serverUrl: string;
-  userId: string;
-}) {
-  const response = await args.fetchImpl(`${args.serverUrl}/rpc/getUserSpaceMemberships`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${args.authToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ userId: args.userId }),
-  });
-  const data = await response.json().catch(() => ({}));
-  if (!response.ok || !Array.isArray(data)) {
-    throw new Error(`failed to list memberships (${response.status}): ${JSON.stringify(data)}`);
-  }
-  return data as SpaceMembership[];
-}
-
-async function buildTarget(args: {
-  authToken: string;
-  db: Awaited<ReturnType<typeof getReadableCliDb>>;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  membership: SpaceMembership;
-  serverUrl: string;
-  userId: string;
-}): Promise<DeleteTarget | SkippedTarget> {
-  const spaceId = normalizeSpaceId(String(args.membership.spaceId ?? ""));
-  const name = displayName(args.membership) || spaceId;
-  if (!spaceId) {
-    return { spaceId: "", name, reason: "membership has no spaceId" };
-  }
-
-  let spaceRecord: Record<string, any>;
-  try {
-    spaceRecord = await readSpaceRecordWithFallback({
-      authToken: args.authToken,
-      db: args.db,
-      fallbackFetchImpl: args.fallbackFetchImpl,
-      fetchImpl: args.fetchImpl,
-      serverCandidates: [args.serverUrl],
-      spaceId,
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { spaceId, name, reason: `failed to read space record: ${message}` };
-  }
-
-  const ownerId = typeof spaceRecord.ownerId === "string" ? spaceRecord.ownerId : "";
-  if (ownerId && ownerId !== args.userId) {
-    return { spaceId, name, reason: `current user is not owner (${ownerId})` };
-  }
-
-  const contents = spaceRecord.contents;
-  return {
-    spaceId,
-    name: displayName(args.membership) || String(spaceRecord.name ?? spaceRecord.title ?? spaceId),
-    spaceKey: createSpaceKey.space(spaceId),
-    memberKeys: listMemberKeys(spaceRecord, args.userId, spaceId),
-    contentCount: contents && typeof contents === "object" ? Object.keys(contents).length : 0,
-  };
-}
-
-async function deleteKey(args: {
-  authToken: string;
-  fetchImpl: typeof fetch;
-  key: string;
-  serverUrl: string;
-}) {
-  const response = await args.fetchImpl(
-    `${args.serverUrl}/api/v1/db/delete/${encodeURIComponent(args.key)}`,
-    {
-      method: "DELETE",
-      headers: {
-        Authorization: `Bearer ${args.authToken}`,
-      },
-    }
-  );
-  const text = await response.text();
-  let data: any = {};
-  if (text) {
-    try {
-      data = JSON.parse(text);
-    } catch {
-      data = {};
-    }
-  }
-  if (!response.ok) {
-    throw new Error(`delete ${args.key} failed (${response.status}): ${JSON.stringify(data)}`);
-  }
-}
-
-export async function runSpaceDeleteCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-
-  if (args.includes("--help") || args.includes("-h")) {
-    output.write(`${usage()}\n`);
-    return 0;
-  }
-
-  const requestedSpace = readOption(args, "--space");
-  const exactName = readOption(args, "--name");
-  const prefix = readOption(args, "--name-prefix");
-  if (!requestedSpace && !exactName && !prefix) {
-    output.write(`${usage()}\n`);
-    return 1;
-  }
-
-  const authToken = resolveAuthToken(args, env);
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!authToken || !userId) {
-    output.write("[nolo] space delete requires an auth token with userId. Run `nolo login`.\n");
-    return 1;
-  }
-
-  const shouldDelete = args.includes("--yes");
-  const wantJson = args.includes("--json");
-  const db = deps.db ?? await getReadableCliDb(output);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const serverUrl = resolveServerUrl(args, env);
-
-  try {
-    const memberships = await fetchMemberships({
-      authToken,
-      fetchImpl,
-      serverUrl,
-      userId,
-    });
-    const matchingMemberships = memberships.filter((membership) => matchesMembership(args, membership));
-    const inspected = await Promise.all(
-      matchingMemberships.map((membership) =>
-        buildTarget({
-          authToken,
-          db,
-          fallbackFetchImpl,
-          fetchImpl,
-          membership,
-          serverUrl,
-          userId,
-        })
-      )
-    );
-
-    const targets = inspected.filter((item): item is DeleteTarget => "spaceKey" in item);
-    const skipped = inspected.filter((item): item is SkippedTarget => !("spaceKey" in item));
-    const deletedKeys: string[] = [];
-
-    if (shouldDelete) {
-      for (const target of targets) {
-        for (const memberKey of target.memberKeys) {
-          await deleteKey({
-            authToken,
-            fetchImpl,
-            key: memberKey,
-            serverUrl,
-          });
-          deletedKeys.push(memberKey);
-        }
-        await deleteKey({
-          authToken,
-          fetchImpl,
-          key: target.spaceKey,
-          serverUrl,
-        });
-        deletedKeys.push(target.spaceKey);
-        await db.batch([
-          ...target.memberKeys.map((key) => ({ type: "del" as const, key })),
-          { type: "del" as const, key: target.spaceKey },
-        ]);
-      }
-    }
-
-    const result = {
-      baseUrl: serverUrl,
-      userId,
-      dryRun: !shouldDelete,
-      totalMemberships: memberships.length,
-      matchCount: matchingMemberships.length,
-      deletableCount: targets.length,
-      skipped,
-      targets: targets.map((target) => ({
-        spaceId: target.spaceId,
-        name: target.name,
-        spaceKey: target.spaceKey,
-        memberKeys: target.memberKeys,
-        contentCount: target.contentCount,
-      })),
-      deletedKeys,
-    };
-
-    if (wantJson) {
-      output.write(`${JSON.stringify(result, null, 2)}\n`);
-      return 0;
-    }
-
-    output.write(`Base: ${result.baseUrl}\n`);
-    output.write(`User: ${result.userId}\n`);
-    output.write(`Matched spaces: ${result.matchCount}\n`);
-    for (const target of result.targets) {
-      output.write(`- ${target.name} (${target.spaceId})\n`);
-      output.write(`  space key: ${target.spaceKey}\n`);
-      output.write(`  member keys: ${target.memberKeys.join(", ") || "(none)"}\n`);
-      output.write(`  contents preserved: ${target.contentCount}\n`);
-    }
-    for (const item of skipped) {
-      output.write(`- skipped ${item.name || item.spaceId}: ${item.reason}\n`);
-    }
-    output.write(
-      shouldDelete
-        ? `Deleted keys: ${deletedKeys.length}\n`
-        : "Dry-run only. Add --yes to delete the matched spaces.\n"
-    );
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] space delete failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}

package/cli/spaceInternalCommandEntries.ts

@@ -1,21 +0,0 @@
-import { createEnvCommand } from "./cliCommandFactories";
-import type { CommandEntry } from "./cliCommandTypes";
-import { runSpaceAttachAgentCommand } from "./spaceAttachCommands";
-import {
-  runSpaceCategoryCommand,
-  runSpaceContentCategoryCommand,
-} from "./spaceCategoryCommands";
-import { runSpaceDeleteCommand } from "./spaceDeleteCommands";
-import { runSpaceListCommand } from "./spaceCommands";
-import { runSpaceReadCommand } from "./spaceReadCommands";
-
-export function getSpaceInternalCommandEntries(): CommandEntry[] {
-  return [
-    createEnvCommand(["space", "list"], "List joined spaces", runSpaceListCommand),
-    createEnvCommand(["space", "read"], "Read a space", runSpaceReadCommand),
-    createEnvCommand(["space", "attach-agent"], "Attach an existing agent to a space", runSpaceAttachAgentCommand),
-    createEnvCommand(["space", "category"], "Create or update a space category", runSpaceCategoryCommand),
-    createEnvCommand(["space", "content-category"], "Move content into a space category", runSpaceContentCategoryCommand),
-    createEnvCommand(["space", "delete"], "Delete spaces by safe filters", runSpaceDeleteCommand),
-  ];
-}

package/cli/spaceMutationHelpers.ts

@@ -1,135 +0,0 @@
-import { createSpaceKey, normalizeSpaceId } from "../create/space/spaceKeys";
-import type { CliKvDb } from "./client/hybridRecordStore";
-import { readDbRecord, writeDbRecord } from "./agentRecordHelpers";
-
-export function parseSpaceIdFromInput(raw: string): string {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    throw new Error("Space id/url is empty.");
-  }
-
-  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
-    const url = new URL(trimmed);
-    const fromQuery = url.searchParams.get("spaceId");
-    if (fromQuery) {
-      return normalizeSpaceId(fromQuery);
-    }
-
-    const parts = url.pathname.split("/").filter(Boolean);
-    const spaceIndex = parts.findIndex((part) => part === "space");
-    if (spaceIndex >= 0 && parts[spaceIndex + 1]) {
-      return normalizeSpaceId(parts[spaceIndex + 1]);
-    }
-
-    throw new Error(`Unsupported space URL: ${trimmed}`);
-  }
-
-  return normalizeSpaceId(trimmed);
-}
-
-export async function readSpaceRecordWithFallback(args: {
-  authToken: string;
-  db: CliKvDb;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  serverCandidates: string[];
-  spaceId: string;
-}) {
-  const spaceKey = createSpaceKey.space(args.spaceId);
-  try {
-    return await args.db.get(spaceKey);
-  } catch {
-    let lastError: Error | null = null;
-    for (const serverUrl of args.serverCandidates) {
-      try {
-        return await readDbRecord({
-          authToken: args.authToken,
-          dbKey: spaceKey,
-          fallbackFetchImpl: args.fallbackFetchImpl,
-          fetchImpl: args.fetchImpl,
-          serverUrl,
-        });
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-      }
-    }
-    throw lastError ?? new Error(`Failed to read ${spaceKey}`);
-  }
-}
-
-export async function writeSpaceRecord(args: {
-  authToken: string;
-  db: CliKvDb;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  record: Record<string, any>;
-  serverUrl: string;
-  spaceId: string;
-  userId: string;
-}) {
-  const spaceKey = createSpaceKey.space(args.spaceId);
-  await writeDbRecord({
-    authToken: args.authToken,
-    dbKey: spaceKey,
-    fallbackFetchImpl: args.fallbackFetchImpl,
-    fetchImpl: args.fetchImpl,
-    record: args.record,
-    serverUrl: args.serverUrl,
-    userId: args.userId,
-  });
-  await args.db.put(spaceKey, args.record);
-}
-
-export function buildTableAttachedSpaceRecord(args: {
-  categoryId?: string;
-  contentKey: string;
-  existingSpaceRecord: Record<string, any>;
-  spaceId: string;
-  title: string;
-}) {
-  const { categoryId, contentKey, existingSpaceRecord, spaceId, title } = args;
-  const now = Date.now();
-  const existingContent = existingSpaceRecord?.contents?.[contentKey];
-  const categoryIdForStorage =
-    categoryId && existingSpaceRecord?.categories?.[categoryId] ? categoryId : undefined;
-
-  return {
-    ...existingSpaceRecord,
-    dbKey: createSpaceKey.space(spaceId),
-    updatedAt: now,
-    contents: {
-      ...(existingSpaceRecord?.contents ?? {}),
-      [contentKey]: {
-        ...(existingContent ?? {}),
-        title,
-        type: "table",
-        contentKey,
-        ...(categoryIdForStorage ? { categoryId: categoryIdForStorage } : {}),
-        updatedAt: now,
-        createdAt: existingContent?.createdAt ?? now,
-      },
-    },
-  };
-}
-
-export function parseContentKeys(args: string[]) {
-  const keys = new Set<string>();
-  const singleIndex = args.indexOf("--content-key");
-  if (singleIndex >= 0 && args[singleIndex + 1]?.trim()) {
-    keys.add(args[singleIndex + 1].trim());
-  }
-  const listIndex = args.indexOf("--content-keys");
-  if (listIndex >= 0) {
-    const raw = args[listIndex + 1];
-    const parsed = JSON.parse(raw ?? "null");
-    if (!Array.isArray(parsed)) {
-      throw new Error("--content-keys must be a JSON array.");
-    }
-    for (const item of parsed) {
-      if (typeof item === "string" && item.trim()) {
-        keys.add(item.trim());
-      }
-    }
-  }
-  return Array.from(keys);
-}