@fieldwangai/agentflow 0.1.162 → 0.1.164

package/bin/lib/marketplace.mjs

@@ -19,10 +19,17 @@ import {
   inspectNodePackageDirectory,
   writeNodePackageFiles,
 } from "./node-package-archive.mjs";
+import {
+  marketplaceStatsFor,
+  marketplaceUsageStats,
+  normalizeMarketplaceVisibility,
+} from "./marketplace-usage.mjs";
 
 const NODE_MANIFEST = "node.yaml";
 const COLLECTION_MANIFEST = "collection.yaml";
 const FLOW_SNIPPET_MANIFEST = "flow-snippet.yaml";
+const FLOW_PACKAGE_MANIFEST = "flow-package.yaml";
+const FLOW_PACKAGE_GRAPH = "workspace.graph.json";
 const LOCK_FILENAME = "agentflow.lock.json";
 
 function workspacePackageRoot(workspaceRoot) {
@@ -131,6 +138,7 @@ function normalizeManifest(raw, packageDir, source = "workspace") {
     baseDefinitionId,
     displayName: raw.displayName != null ? String(raw.displayName) : raw.name != null ? String(raw.name) : id,
     description: raw.description != null ? String(raw.description) : "",
+    visibility: normalizeMarketplaceVisibility(raw.visibility),
     input,
     output,
     runtime,
@@ -168,7 +176,12 @@ function canManageMarketplaceOwner(ownerUserId, opts = {}) {
 
 function canAccessMarketplaceNode(manifest, opts = {}) {
   if ((manifest?.source || "marketplace") !== "marketplace") return true;
-  return canAccessMarketplaceOwner(manifestOwnerUserId(manifest), opts);
+  const ownerUserId = manifestOwnerUserId(manifest);
+  if (!canAccessMarketplaceOwner(ownerUserId, opts)) return false;
+  if (normalizeMarketplaceVisibility(manifest?.visibility) === "public") return true;
+  const requestedUserId = String(opts.userId || "").trim();
+  if (!requestedUserId) return true;
+  return isAdminRequest(opts) || Boolean(ownerUserId) && ownerUserId === requestedUserId;
 }
 
 function sortVersionsDesc(versions) {
@@ -204,6 +217,14 @@ function resolveWorkspaceFlowSnippetPackageDir(workspaceRoot, id, version) {
   return target;
 }
 
+function resolveWorkspaceFlowPackageDir(workspaceRoot, id, version) {
+  if (!isSafePathSegment(id) || !isSafePathSegment(version)) return null;
+  const base = path.resolve(workspacePackageRoot(workspaceRoot), "flows");
+  const target = path.resolve(base, id, version);
+  if (target !== base && !target.startsWith(base + path.sep)) return null;
+  return target;
+}
+
 function collectFlowDirs(rootDir, source, archived = false) {
   const out = [];
   if (!fs.existsSync(rootDir)) return out;
@@ -470,6 +491,7 @@ export function listMarketplaceNodes(workspaceRoot, flowData = null, opts = {})
 
 export function listMarketplacePackages(workspaceRoot, opts = {}) {
   const root = workspacePackageRoot(workspaceRoot);
+  const stats = marketplaceUsageStats(workspaceRoot);
   const nodes = listMarketplaceNodes(workspaceRoot, null, opts).map((n) => ({
     id: n.id,
     version: n.version,
@@ -490,9 +512,16 @@ export function listMarketplacePackages(workspaceRoot, opts = {}) {
     installedAt: String(n.installedAt || ""),
     ownerUserId: n.ownerUserId || n.createdBy || "",
     createdBy: n.createdBy || n.ownerUserId || "",
+    visibility: normalizeMarketplaceVisibility(n.visibility),
     packageDir: n.packageDir,
     usage: listMarketplaceNodeUsages(workspaceRoot, n.id, n.version, opts),
-  }));
+    ...marketplaceStatsFor(stats, "node", n.id, n.version, n.ownerUserId || n.createdBy || ""),
+  })).sort((a, b) => (
+    Number(b.useCount || 0) - Number(a.useCount || 0)
+    || Number(b.installCount || 0) - Number(a.installCount || 0)
+    || String(a.id).localeCompare(String(b.id))
+    || String(b.version).localeCompare(String(a.version), undefined, { numeric: true, sensitivity: "base" })
+  ));
   const collections = [];
   const collectionsRoot = path.join(root, "collections");
   if (fs.existsSync(collectionsRoot)) {
@@ -519,6 +548,7 @@ export function listMarketplaceFlowSnippets(workspaceRoot, opts = {}) {
   const root = workspacePackageRoot(workspaceRoot);
   const snippetsRoot = path.join(root, "flow-snippets");
   const snippets = [];
+  const stats = marketplaceUsageStats(workspaceRoot);
   const requestedUserId = String(opts.userId || "").trim();
   if (!fs.existsSync(snippetsRoot)) return { snippets };
   for (const entry of fs.readdirSync(snippetsRoot, { withFileTypes: true })) {
@@ -531,6 +561,8 @@ export function listMarketplaceFlowSnippets(workspaceRoot, opts = {}) {
       const snippet = manifest.snippet && typeof manifest.snippet === "object" ? manifest.snippet : {};
       const ownerUserId = String(manifest.ownerUserId || manifest.createdBy || "").trim();
       if (requestedUserId && !canAccessMarketplaceOwner(ownerUserId, opts)) continue;
+      const visibility = normalizeMarketplaceVisibility(manifest.visibility);
+      if (visibility === "private" && requestedUserId && !isAdminRequest(opts) && ownerUserId !== requestedUserId) continue;
       snippets.push({
         id: manifest.id || entry.name,
         version: manifest.version || version,
@@ -542,18 +574,162 @@ export function listMarketplaceFlowSnippets(workspaceRoot, opts = {}) {
         createdAt: manifest.createdAt || "",
         updatedAt: manifest.updatedAt || "",
         ownerUserId,
+        visibility,
         packageDir: dir,
         snippet,
+        ...marketplaceStatsFor(stats, "flow-snippet", manifest.id || entry.name, manifest.version || version, ownerUserId),
       });
     }
   }
   snippets.sort((a, b) => {
+    const byUsage = Number(b.useCount || 0) - Number(a.useCount || 0);
+    const byInstall = Number(b.installCount || 0) - Number(a.installCount || 0);
     const byTime = String(b.updatedAt || b.createdAt || "").localeCompare(String(a.updatedAt || a.createdAt || ""));
-    return byTime || a.id.localeCompare(b.id) || a.version.localeCompare(b.version);
+    return byUsage || byInstall || byTime || a.id.localeCompare(b.id) || a.version.localeCompare(b.version);
   });
   return { snippets };
 }
 
+function marketplaceRecordAccessible(manifest, opts = {}) {
+  const ownerUserId = String(manifest?.ownerUserId || manifest?.createdBy || "").trim();
+  if (!canAccessMarketplaceOwner(ownerUserId, opts)) return false;
+  if (normalizeMarketplaceVisibility(manifest?.visibility) === "public") return true;
+  const requestedUserId = String(opts.userId || "").trim();
+  if (!requestedUserId) return true;
+  return isAdminRequest(opts) || ownerUserId === requestedUserId;
+}
+
+export function listMarketplaceFlows(workspaceRoot, opts = {}) {
+  const base = path.join(workspacePackageRoot(workspaceRoot), "flows");
+  const stats = marketplaceUsageStats(workspaceRoot);
+  const flows = [];
+  if (!fs.existsSync(base)) return { flows };
+  for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    for (const version of listVersionDirs(path.join(base, entry.name))) {
+      const packageDir = resolveWorkspaceFlowPackageDir(workspaceRoot, entry.name, version);
+      const manifest = packageDir ? readYamlObject(path.join(packageDir, FLOW_PACKAGE_MANIFEST)) : null;
+      if (!manifest || !marketplaceRecordAccessible(manifest, opts)) continue;
+      const id = String(manifest.id || entry.name);
+      const resourceVersion = String(manifest.version || version);
+      flows.push({
+        id,
+        version: resourceVersion,
+        displayName: String(manifest.displayName || manifest.name || id),
+        description: String(manifest.description || ""),
+        tags: Array.isArray(manifest.tags) ? manifest.tags.map((tag) => String(tag)) : [],
+        ownerUserId: String(manifest.ownerUserId || manifest.createdBy || ""),
+        visibility: normalizeMarketplaceVisibility(manifest.visibility),
+        nodeCount: Number(manifest.nodeCount || 0),
+        edgeCount: Number(manifest.edgeCount || 0),
+        createdAt: String(manifest.createdAt || ""),
+        updatedAt: String(manifest.updatedAt || manifest.createdAt || ""),
+        packageDir,
+        ...marketplaceStatsFor(stats, "flow", id, resourceVersion, String(manifest.ownerUserId || manifest.createdBy || "")),
+      });
+    }
+  }
+  flows.sort((a, b) => (
+    Number(b.useCount || 0) - Number(a.useCount || 0)
+    || Number(b.installCount || 0) - Number(a.installCount || 0)
+    || String(b.updatedAt || "").localeCompare(String(a.updatedAt || ""))
+    || a.id.localeCompare(b.id)
+    || b.version.localeCompare(a.version, undefined, { numeric: true, sensitivity: "base" })
+  ));
+  return { flows };
+}
+
+export function publishMarketplaceFlow(workspaceRoot, payload = {}, opts = {}) {
+  const ownerUserId = String(opts.userId || "").trim();
+  if (!ownerUserId) return { ok: false, error: "Authentication required" };
+  const label = String(payload.displayName || payload.name || payload.id || "flow").trim();
+  const id = safePackageId(payload.id || payload.packageId || label);
+  const version = normalizeVersion(payload.version || "1.0.0");
+  const graph = payload.graph && typeof payload.graph === "object" && !Array.isArray(payload.graph) ? payload.graph : null;
+  if (!id || !graph) return { ok: false, error: "Invalid marketplace flow" };
+  const packageDir = resolveWorkspaceFlowPackageDir(workspaceRoot, id, version);
+  if (!packageDir) return { ok: false, error: "Invalid marketplace flow id or version" };
+  const existing = readYamlObject(path.join(packageDir, FLOW_PACKAGE_MANIFEST));
+  if (existing && !canManageMarketplaceOwner(String(existing.ownerUserId || existing.createdBy || ""), opts)) {
+    return { ok: false, error: "Marketplace flow permission denied" };
+  }
+  if (existing) {
+    const existingGraph = readJsonObject(path.join(packageDir, FLOW_PACKAGE_GRAPH));
+    if (JSON.stringify(existingGraph) !== JSON.stringify(graph)) {
+      return { ok: false, conflict: true, error: `${id}@${version} 已存在且内容不同，请提升版本号` };
+    }
+    return {
+      ok: true,
+      alreadyExists: true,
+      ...existing,
+      visibility: normalizeMarketplaceVisibility(existing.visibility),
+      packageDir,
+    };
+  }
+  const now = new Date().toISOString();
+  const manifest = {
+    id,
+    version,
+    displayName: label,
+    description: String(payload.description || "").trim(),
+    tags: Array.isArray(payload.tags) ? payload.tags.map((tag) => String(tag).trim()).filter(Boolean) : [],
+    visibility: normalizeMarketplaceVisibility(payload.visibility),
+    ownerUserId,
+    createdBy: ownerUserId,
+    nodeCount: Object.keys(graph.instances || {}).length,
+    edgeCount: Array.isArray(graph.edges) ? graph.edges.length : 0,
+    createdAt: String(existing?.createdAt || now),
+    updatedAt: now,
+  };
+  fs.mkdirSync(path.dirname(packageDir), { recursive: true });
+  fs.rmSync(packageDir, { recursive: true, force: true });
+  fs.mkdirSync(packageDir, { recursive: true });
+  fs.writeFileSync(path.join(packageDir, FLOW_PACKAGE_MANIFEST), yaml.dump(manifest, { lineWidth: -1 }), "utf-8");
+  fs.writeFileSync(path.join(packageDir, FLOW_PACKAGE_GRAPH), `${JSON.stringify(graph, null, 2)}\n`, "utf-8");
+  fs.writeFileSync(path.join(packageDir, "README.md"), `# ${label}\n\n${manifest.description || "Published AgentFlow template."}\n`, "utf-8");
+  return { ok: true, ...manifest, packageDir };
+}
+
+export function readMarketplaceFlow(workspaceRoot, id, version, opts = {}) {
+  const packageDir = resolveWorkspaceFlowPackageDir(workspaceRoot, id, version);
+  const manifest = packageDir ? readYamlObject(path.join(packageDir, FLOW_PACKAGE_MANIFEST)) : null;
+  if (!manifest || !marketplaceRecordAccessible(manifest, opts)) return { ok: false, error: "Marketplace flow not found" };
+  const graph = readJsonObject(path.join(packageDir, FLOW_PACKAGE_GRAPH));
+  if (!graph) return { ok: false, error: "Marketplace flow graph is missing" };
+  return { ok: true, manifest, graph, packageDir };
+}
+
+export function setMarketplaceVisibility(workspaceRoot, kind, id, version, visibility, opts = {}) {
+  const normalized = normalizeMarketplaceVisibility(visibility);
+  let manifestPath = "";
+  if (kind === "flow") {
+    const dir = resolveWorkspaceFlowPackageDir(workspaceRoot, id, version);
+    manifestPath = dir ? path.join(dir, FLOW_PACKAGE_MANIFEST) : "";
+  } else if (kind === "flow-snippet") {
+    const dir = resolveWorkspaceFlowSnippetPackageDir(workspaceRoot, id, version);
+    manifestPath = dir ? path.join(dir, FLOW_SNIPPET_MANIFEST) : "";
+  } else if (kind === "node") {
+    const dir = resolveWorkspaceNodePackageDir(workspaceRoot, id, version);
+    if (!dir) return { ok: false, error: "Invalid marketplace node" };
+    const manifest = normalizeManifest(readNodeManifestRaw(dir), dir, "marketplace");
+    if (!manifest || !canManageMarketplaceOwner(manifestOwnerUserId(manifest), opts)) {
+      return { ok: false, error: "Marketplace node permission denied" };
+    }
+    const metadataPath = path.join(dir, NODE_PACKAGE_METADATA_FILENAME);
+    const metadata = readJsonObject(metadataPath) || {};
+    fs.writeFileSync(metadataPath, `${JSON.stringify({ ...metadata, visibility: normalized }, null, 2)}\n`, "utf-8");
+    return { ok: true, kind, id, version, visibility: normalized };
+  } else {
+    return { ok: false, error: "Unsupported marketplace resource kind" };
+  }
+  const manifest = manifestPath ? readYamlObject(manifestPath) : null;
+  if (!manifest || !canManageMarketplaceOwner(String(manifest.ownerUserId || manifest.createdBy || ""), opts)) {
+    return { ok: false, error: "Marketplace resource permission denied" };
+  }
+  fs.writeFileSync(manifestPath, yaml.dump({ ...manifest, visibility: normalized, updatedAt: new Date().toISOString() }, { lineWidth: -1 }), "utf-8");
+  return { ok: true, kind, id, version, visibility: normalized };
+}
+
 export function deleteMarketplaceNodePackage(workspaceRoot, id, version, opts = {}) {
   const packageDir = resolveWorkspaceNodePackageDir(workspaceRoot, id, version);
   if (!packageDir) return { ok: false, error: "Invalid marketplace node id or version" };
@@ -638,6 +814,7 @@ export function publishNodePackage(workspaceRoot, sourceDir, opts = {}) {
   const ownerUserId = String(opts.ownerUserId || opts.userId || manifest.ownerUserId || manifest.createdBy || "").trim();
   fs.writeFileSync(path.join(dest, NODE_PACKAGE_METADATA_FILENAME), `${JSON.stringify({
     ...(ownerUserId ? { ownerUserId, createdBy: ownerUserId } : {}),
+    visibility: normalizeMarketplaceVisibility(opts.visibility),
     contentSha256: inspected.contentSha256,
     fileList: inspected.fileList,
     fileCount: inspected.fileCount,
@@ -692,6 +869,7 @@ export function publishNodePackageArchive(workspaceRoot, archiveInput, opts = {}
     if (!written.ok) return written;
     fs.writeFileSync(path.join(staging, NODE_PACKAGE_METADATA_FILENAME), `${JSON.stringify({
       ...(ownerUserId ? { ownerUserId, createdBy: ownerUserId } : {}),
+      visibility: normalizeMarketplaceVisibility(opts.visibility),
       contentSha256: inspected.contentSha256,
       archiveSha256: inspected.archiveSha256,
       fileList: inspected.fileList,
@@ -994,6 +1172,7 @@ export function publishNodeFromInstance(workspaceRoot, payload = {}, options = {
     ...(ui ? { ui } : {}),
     ownerUserId,
     createdBy: ownerUserId,
+    visibility: normalizeMarketplaceVisibility(payload.visibility),
     createdAt: existingManifest?.createdAt || now,
     updatedAt: now,
   };
@@ -1056,6 +1235,7 @@ export function publishFlowSnippet(workspaceRoot, payload = {}, opts = {}) {
     tags: Array.isArray(payload.tags) ? payload.tags.map((x) => String(x).trim()).filter(Boolean) : [],
     ownerUserId,
     createdBy: ownerUserId,
+    visibility: normalizeMarketplaceVisibility(payload.visibility),
     nodeCount,
     edgeCount: edges.length,
     createdAt: now,

package/bin/lib/node-package-manifest.mjs

@@ -29,7 +29,7 @@ import { normalizeNodeUiForSlots } from "./node-ui-kit.mjs";
 export const NODE_PACKAGE_ENTRY = "index.mjs";
 
 /** 槽位类型；与 builtin/nodes/*.md 的 `type:` 取值一致。 */
-const SLOT_TYPES = new Set(["text", "file", "bool", "node", "image", "json"]);
+const SLOT_TYPES = new Set(["text", "file", "bool", "node", "image", "json", "context"]);
 
 function staticEval(node, where) {
   if (!node) throw new Error(`${where}: 空表达式`);

package/bin/lib/spaces.mjs

@@ -0,0 +1,200 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+import { getAgentflowDataRoot } from "./paths.mjs";
+
+export const SPACES_FILENAME = "spaces.json";
+
+function spacesPath() {
+  return path.join(getAgentflowDataRoot(), SPACES_FILENAME);
+}
+
+function cleanText(value, max = 200) {
+  return String(value || "").trim().slice(0, max);
+}
+
+export function normalizeSpaceSlug(value = "") {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 64);
+}
+
+export function normalizeSpaceVisibility(value = "public") {
+  return String(value || "").trim().toLowerCase() === "private" ? "private" : "public";
+}
+
+export function normalizeSpacePagePath(value = "/") {
+  const raw = String(value || "").trim();
+  if (!raw || raw === "/") return "/";
+  const parts = raw.split("/").map((part) => normalizeSpaceSlug(part)).filter(Boolean);
+  return parts.length ? `/${parts.join("/")}` : "/";
+}
+
+function normalizePage(page = {}, index = 0) {
+  const shareId = cleanText(page.shareId, 160);
+  if (!shareId) return null;
+  const pagePath = normalizeSpacePagePath(page.path || page.route || "/");
+  return {
+    id: cleanText(page.id, 100) || `page_${crypto.randomBytes(8).toString("hex")}`,
+    title: cleanText(page.title, 160) || (pagePath === "/" ? "首页" : pagePath.split("/").filter(Boolean).pop()),
+    path: pagePath,
+    shareId,
+    hidden: page.hidden === true,
+    order: Number.isFinite(Number(page.order)) ? Number(page.order) : index,
+    createdAt: cleanText(page.createdAt, 80) || new Date().toISOString(),
+    updatedAt: cleanText(page.updatedAt, 80) || new Date().toISOString(),
+  };
+}
+
+function normalizeSpace(space = {}) {
+  const ownerId = cleanText(space.ownerId, 100);
+  const slug = normalizeSpaceSlug(space.slug);
+  if (!ownerId || !slug) return null;
+  const pages = (Array.isArray(space.pages) ? space.pages : [])
+    .map(normalizePage)
+    .filter(Boolean)
+    .sort((a, b) => a.order - b.order || a.createdAt.localeCompare(b.createdAt));
+  return {
+    id: cleanText(space.id, 100) || `space_${crypto.randomBytes(8).toString("hex")}`,
+    ownerId,
+    slug,
+    title: cleanText(space.title, 160) || slug,
+    description: cleanText(space.description, 1000),
+    visibility: normalizeSpaceVisibility(space.visibility),
+    status: String(space.status || "active").trim().toLowerCase() === "paused" ? "paused" : "active",
+    pages,
+    createdAt: cleanText(space.createdAt, 80) || new Date().toISOString(),
+    updatedAt: cleanText(space.updatedAt, 80) || new Date().toISOString(),
+  };
+}
+
+export function readSpaces() {
+  const file = spacesPath();
+  if (!fs.existsSync(file)) return [];
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+    const input = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.spaces) ? parsed.spaces : [];
+    return input.map(normalizeSpace).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export function writeSpaces(spaces = []) {
+  const file = spacesPath();
+  const normalized = (Array.isArray(spaces) ? spaces : []).map(normalizeSpace).filter(Boolean);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify({ version: 1, spaces: normalized }, null, 2)}\n`, "utf-8");
+  fs.renameSync(temp, file);
+  return normalized;
+}
+
+export function listSpacesForUser(userId = "", isAdmin = false) {
+  const actor = cleanText(userId, 100);
+  return readSpaces().filter((space) => isAdmin || space.ownerId === actor);
+}
+
+export function getSpaceById(id = "") {
+  const wanted = cleanText(id, 100);
+  return readSpaces().find((space) => space.id === wanted) || null;
+}
+
+export function getSpaceByRoute(ownerId = "", slug = "") {
+  const owner = cleanText(ownerId, 100);
+  const safeSlug = normalizeSpaceSlug(slug);
+  return readSpaces().find((space) => space.ownerId === owner && space.slug === safeSlug) || null;
+}
+
+export function createSpace({ ownerId, slug, title, description = "", visibility = "public" } = {}) {
+  const owner = cleanText(ownerId, 100);
+  const safeSlug = normalizeSpaceSlug(slug || title);
+  if (!owner) return { error: "Missing space owner" };
+  if (!safeSlug) return { error: "Space slug must contain letters or numbers" };
+  const spaces = readSpaces();
+  if (spaces.some((space) => space.ownerId === owner && space.slug === safeSlug)) {
+    return { error: "Space slug already exists" };
+  }
+  const now = new Date().toISOString();
+  const space = normalizeSpace({
+    id: `space_${crypto.randomBytes(8).toString("hex")}`,
+    ownerId: owner,
+    slug: safeSlug,
+    title: title || safeSlug,
+    description,
+    visibility,
+    pages: [],
+    createdAt: now,
+    updatedAt: now,
+  });
+  spaces.push(space);
+  writeSpaces(spaces);
+  return { space };
+}
+
+export function updateSpace(id = "", patch = {}) {
+  const spaces = readSpaces();
+  const index = spaces.findIndex((space) => space.id === cleanText(id, 100));
+  if (index < 0) return { error: "Space not found" };
+  const current = spaces[index];
+  const nextSlug = patch.slug == null ? current.slug : normalizeSpaceSlug(patch.slug);
+  if (!nextSlug) return { error: "Space slug must contain letters or numbers" };
+  if (spaces.some((space, itemIndex) => itemIndex !== index && space.ownerId === current.ownerId && space.slug === nextSlug)) {
+    return { error: "Space slug already exists" };
+  }
+  const next = normalizeSpace({
+    ...current,
+    ...(patch.title == null ? {} : { title: patch.title }),
+    ...(patch.description == null ? {} : { description: patch.description }),
+    ...(patch.visibility == null ? {} : { visibility: patch.visibility }),
+    ...(patch.status == null ? {} : { status: patch.status }),
+    slug: nextSlug,
+    updatedAt: new Date().toISOString(),
+  });
+  spaces[index] = next;
+  writeSpaces(spaces);
+  return { space: next };
+}
+
+export function upsertSpacePage(spaceId = "", input = {}) {
+  const spaces = readSpaces();
+  const spaceIndex = spaces.findIndex((space) => space.id === cleanText(spaceId, 100));
+  if (spaceIndex < 0) return { error: "Space not found" };
+  const space = spaces[spaceIndex];
+  const pagePath = normalizeSpacePagePath(input.path || "/");
+  const existingIndex = space.pages.findIndex((page) => page.path === pagePath);
+  const previous = existingIndex >= 0 ? space.pages[existingIndex] : {};
+  const page = normalizePage({
+    ...previous,
+    ...input,
+    id: previous.id || input.id,
+    path: pagePath,
+    order: existingIndex >= 0 ? previous.order : space.pages.length,
+    createdAt: previous.createdAt || input.createdAt,
+    updatedAt: new Date().toISOString(),
+  }, existingIndex >= 0 ? existingIndex : space.pages.length);
+  if (!page) return { error: "Missing display share" };
+  if (existingIndex >= 0) space.pages[existingIndex] = page;
+  else space.pages.push(page);
+  space.updatedAt = new Date().toISOString();
+  spaces[spaceIndex] = normalizeSpace(space);
+  writeSpaces(spaces);
+  return { space: spaces[spaceIndex], page };
+}
+
+export function deleteSpacePage(spaceId = "", pageId = "") {
+  const spaces = readSpaces();
+  const spaceIndex = spaces.findIndex((space) => space.id === cleanText(spaceId, 100));
+  if (spaceIndex < 0) return { error: "Space not found" };
+  const before = spaces[spaceIndex].pages.length;
+  spaces[spaceIndex].pages = spaces[spaceIndex].pages.filter((page) => page.id !== cleanText(pageId, 100));
+  if (spaces[spaceIndex].pages.length === before) return { error: "Space page not found" };
+  spaces[spaceIndex].pages = spaces[spaceIndex].pages.map((page, index) => ({ ...page, order: index }));
+  spaces[spaceIndex].updatedAt = new Date().toISOString();
+  writeSpaces(spaces);
+  return { space: spaces[spaceIndex] };
+}