nolo-cli 0.1.21 → 0.1.23

package/render/canvas/canvasRuntime.ts

@@ -0,0 +1,57 @@
+export type CanvasRuntimeAction =
+  | {
+      type: "toggle";
+      key: string;
+    }
+  | {
+      type: "setState";
+      key: string;
+      value: unknown;
+    }
+  | {
+      type: "scrollTo";
+      targetId: string;
+    };
+
+export type CanvasRuntimeState = Record<string, unknown>;
+
+export function parseCanvasRuntimeAction(action: unknown): CanvasRuntimeAction | null {
+  if (!action || typeof action !== "object") return null;
+  const candidate = action as Record<string, unknown>;
+  const type = candidate.type;
+
+  if (type === "toggle" && typeof candidate.key === "string" && candidate.key.trim()) {
+    return { type, key: candidate.key };
+  }
+
+  if (type === "setState" && typeof candidate.key === "string" && candidate.key.trim()) {
+    return { type, key: candidate.key, value: candidate.value };
+  }
+
+  if (type === "scrollTo" && typeof candidate.targetId === "string" && candidate.targetId.trim()) {
+    return { type, targetId: candidate.targetId };
+  }
+
+  return null;
+}
+
+export function reduceCanvasRuntimeAction(
+  state: CanvasRuntimeState,
+  action: CanvasRuntimeAction
+): CanvasRuntimeState {
+  if (action.type === "toggle") {
+    return {
+      ...state,
+      [action.key]: !state[action.key],
+    };
+  }
+
+  if (action.type === "setState") {
+    return {
+      ...state,
+      [action.key]: action.value,
+    };
+  }
+
+  return state;
+}

package/render/canvas/canvasSnapshotParser.ts

@@ -0,0 +1,76 @@
+import {
+  applyCanvasEvent,
+  createCanvasDocument,
+  normalizeCanvasEvent,
+} from "./canvasTree";
+import type { CanvasDocument, CanvasEvent } from "./types";
+
+export type ParsedCanvasSnapshotMessage = {
+  document: CanvasDocument;
+  events: CanvasEvent[];
+  eventCount: number;
+};
+
+export function hasCanvasSnapshotSignal(content: string): boolean {
+  return content.includes("canvas_snapshot");
+}
+
+export function extractCanvasSnapshotText(content: unknown): string | null {
+  if (typeof content === "string") {
+    return hasCanvasSnapshotSignal(content) ? content : null;
+  }
+  if (!Array.isArray(content)) return null;
+
+  const text = content
+    .map((item) =>
+      item?.type === "text" && typeof item.text === "string" ? item.text : ""
+    )
+    .filter(Boolean)
+    .join("\n");
+
+  return hasCanvasSnapshotSignal(text) ? text : null;
+}
+
+function isCanvasEvent(value: unknown): value is CanvasEvent {
+  if (!value || typeof value !== "object") return false;
+  const event = value as { type?: unknown };
+  return (
+    event.type === "appendNode" ||
+    event.type === "updateNode" ||
+    event.type === "selectNode"
+  );
+}
+
+export function parseCanvasSnapshotMessage(
+  content: string
+): ParsedCanvasSnapshotMessage | null {
+  if (!hasCanvasSnapshotSignal(content)) return null;
+
+  let document = createCanvasDocument("root");
+  const events: CanvasEvent[] = [];
+  let eventCount = 0;
+
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{") || !trimmed.includes("canvas_snapshot")) {
+      continue;
+    }
+
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed?.type !== "canvas_snapshot" || !isCanvasEvent(parsed.event)) {
+        continue;
+      }
+      const event = normalizeCanvasEvent(parsed.event);
+      if (!event) continue;
+      document = applyCanvasEvent(document, event);
+      events.push(event);
+      eventCount += 1;
+    } catch {
+      // Streaming messages often end with a partial JSON line. Ignore it until
+      // the next render provides a complete line.
+    }
+  }
+
+  return eventCount > 0 ? { document, events, eventCount } : null;
+}

package/render/canvas/canvasTree.ts

@@ -0,0 +1,308 @@
+import type { CanvasDocument, CanvasEvent, CanvasNode } from "./types";
+
+const ALLOWED_NODE_TYPES = new Set([
+  "Canvas",
+  "Stack",
+  "Grid",
+  "Section",
+  "Text",
+  "Button",
+  "Card",
+  "MetricCard",
+  "Chart",
+  "List",
+  "Table",
+  "Toolbar",
+]);
+
+const ALLOWED_STYLE_KEYS = new Set([
+  "alignItems",
+  "background",
+  "backgroundColor",
+  "border",
+  "borderColor",
+  "borderRadius",
+  "color",
+  "display",
+  "fontSize",
+  "fontWeight",
+  "gap",
+  "gridTemplateColumns",
+  "height",
+  "justifyContent",
+  "margin",
+  "maxWidth",
+  "minHeight",
+  "padding",
+  "textAlign",
+  "width",
+]);
+
+export function createCanvasDocument(rootId = "root"): CanvasDocument {
+  return {
+    version: 1,
+    root: {
+      id: rootId,
+      type: "Canvas",
+      children: [],
+    },
+    selectedNodeId: null,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isSafeId(value: unknown): value is string {
+  return typeof value === "string" && /^[a-zA-Z0-9_-]{1,80}$/.test(value);
+}
+
+function isSafePrimitive(value: unknown) {
+  return (
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  );
+}
+
+function isSafeRuntimeValue(value: unknown) {
+  return (
+    isSafePrimitive(value) ||
+    (Array.isArray(value) && value.every((item) => isSafePrimitive(item)))
+  );
+}
+
+function sanitizeRuntimeAction(value: unknown) {
+  if (!isRecord(value) || typeof value.type !== "string") return null;
+
+  if (value.type === "toggle" && isSafeId(value.key)) {
+    return { type: "toggle", key: value.key };
+  }
+
+  if (
+    value.type === "setState" &&
+    isSafeId(value.key) &&
+    isSafeRuntimeValue(value.value)
+  ) {
+    return { type: "setState", key: value.key, value: value.value };
+  }
+
+  if (value.type === "scrollTo" && isSafeId(value.targetId)) {
+    return { type: "scrollTo", targetId: value.targetId };
+  }
+
+  return null;
+}
+
+function sanitizeProps(props: unknown): Record<string, unknown> | undefined {
+  if (!isRecord(props)) return undefined;
+
+  const safeProps: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (key.startsWith("on") || key === "dangerouslySetInnerHTML") continue;
+
+    if (key === "action" || key === "runtimeAction") {
+      const action = sanitizeRuntimeAction(value);
+      if (action) safeProps[key] = action;
+      continue;
+    }
+
+    if (isSafePrimitive(value)) {
+      safeProps[key] = value;
+      continue;
+    }
+
+    if (
+      Array.isArray(value) &&
+      value.every((item) => isSafePrimitive(item))
+    ) {
+      safeProps[key] = value;
+      continue;
+    }
+
+    if (
+      key === "rows" &&
+      Array.isArray(value) &&
+      value.every((row) => Array.isArray(row) && row.every(isSafePrimitive))
+    ) {
+      safeProps[key] = value;
+    }
+  }
+
+  return Object.keys(safeProps).length ? safeProps : undefined;
+}
+
+function sanitizeStyle(style: unknown): Record<string, string | number> | undefined {
+  if (!isRecord(style)) return undefined;
+
+  const safeStyle: Record<string, string | number> = {};
+  for (const [key, value] of Object.entries(style)) {
+    if (!ALLOWED_STYLE_KEYS.has(key)) continue;
+    if (typeof value !== "string" && typeof value !== "number") continue;
+    if (typeof value === "string" && /url\s*\(|expression\s*\(/i.test(value)) continue;
+    safeStyle[key] = value;
+  }
+
+  return Object.keys(safeStyle).length ? safeStyle : undefined;
+}
+
+function sanitizeCanvasNode(node: unknown): CanvasNode | null {
+  if (!isRecord(node) || !isSafeId(node.id) || typeof node.type !== "string") {
+    return null;
+  }
+  if (!ALLOWED_NODE_TYPES.has(node.type)) return null;
+
+  const children = Array.isArray(node.children)
+    ? node.children
+        .map((child) => sanitizeCanvasNode(child))
+        .filter((child): child is CanvasNode => !!child)
+    : undefined;
+  const props = sanitizeProps(node.props);
+  const style = sanitizeStyle(node.style);
+
+  return {
+    id: node.id,
+    type: node.type as CanvasNode["type"],
+    ...(props ? { props } : {}),
+    ...(style ? { style } : {}),
+    ...(children?.length ? { children } : {}),
+  };
+}
+
+export function normalizeCanvasEvent(event: CanvasEvent): CanvasEvent | null {
+  if (event.type === "selectNode") {
+    return event.id === null || isSafeId(event.id) ? event : null;
+  }
+
+  if (event.type === "appendNode") {
+    if (!isSafeId(event.parentId)) return null;
+    const node = sanitizeCanvasNode(event.node);
+    return node ? { type: "appendNode", parentId: event.parentId, node } : null;
+  }
+
+  if (!isSafeId(event.id) || !isRecord(event.patch)) return null;
+  const props = sanitizeProps(event.patch.props);
+  const style = sanitizeStyle(event.patch.style);
+  if (!props && !style) return null;
+
+  return {
+    type: "updateNode",
+    id: event.id,
+    patch: {
+      ...(props ? { props } : {}),
+      ...(style ? { style } : {}),
+    },
+  };
+}
+
+export function getCanvasNodeSelectionPayload(document: CanvasDocument) {
+  if (!document.selectedNodeId) return null;
+  const path = findCanvasNodePath(document.root, document.selectedNodeId);
+  const selectedNode = path?.at(-1);
+  if (!path || !selectedNode) return null;
+
+  return {
+    selectedNodeId: selectedNode.id,
+    part: String(selectedNode.props?.part ?? selectedNode.id),
+    path: path.map((node) => node.id),
+    type: selectedNode.type,
+    props: selectedNode.props ?? {},
+    style: selectedNode.style ?? {},
+  };
+}
+
+export function findCanvasNodePath(
+  node: CanvasNode,
+  targetId: string,
+  path: CanvasNode[] = []
+): CanvasNode[] | null {
+  const nextPath = [...path, node];
+  if (node.id === targetId) return nextPath;
+
+  for (const child of node.children ?? []) {
+    const result = findCanvasNodePath(child, targetId, nextPath);
+    if (result) return result;
+  }
+
+  return null;
+}
+
+function updateNodeTree(
+  node: CanvasNode,
+  targetId: string,
+  updater: (node: CanvasNode) => CanvasNode
+): { node: CanvasNode; changed: boolean } {
+  if (node.id === targetId) {
+    return { node: updater(node), changed: true };
+  }
+
+  let changed = false;
+  const children = (node.children ?? []).map((child) => {
+    const result = updateNodeTree(child, targetId, updater);
+    changed ||= result.changed;
+    return result.node;
+  });
+
+  if (!changed) return { node, changed: false };
+  return {
+    node: {
+      ...node,
+      children,
+    },
+    changed: true,
+  };
+}
+
+export function applyCanvasEvent(
+  document: CanvasDocument,
+  event: CanvasEvent
+): CanvasDocument {
+  const normalizedEvent = normalizeCanvasEvent(event);
+  if (!normalizedEvent) return document;
+  event = normalizedEvent;
+
+  if (event.type === "selectNode") {
+    return {
+      ...document,
+      selectedNodeId: event.id,
+    };
+  }
+
+  if (event.type === "appendNode") {
+    if (findCanvasNodePath(document.root, event.node.id)) {
+      const updated = updateNodeTree(document.root, event.node.id, (node) => ({
+        ...node,
+        type: event.node.type,
+        props: { ...(node.props ?? {}), ...(event.node.props ?? {}) },
+        style: { ...(node.style ?? {}), ...(event.node.style ?? {}) },
+        children: event.node.children ?? node.children,
+      }));
+
+      return updated.changed ? { ...document, root: updated.node } : document;
+    }
+
+    const result = updateNodeTree(document.root, event.parentId, (node) => ({
+      ...node,
+      children: [...(node.children ?? []), event.node],
+    }));
+
+    if (!result.changed) return document;
+    return {
+      ...document,
+      root: result.node,
+    };
+  }
+
+  const result = updateNodeTree(document.root, event.id, (node) => ({
+    ...node,
+    props: event.patch.props ? { ...(node.props ?? {}), ...event.patch.props } : node.props,
+    style: event.patch.style ? { ...(node.style ?? {}), ...event.patch.style } : node.style,
+  }));
+
+  if (!result.changed) return document;
+  return {
+    ...document,
+    root: result.node,
+  };
+}

package/render/canvas/types.ts

@@ -0,0 +1,46 @@
+export type CanvasNodeType =
+  | "Canvas"
+  | "Stack"
+  | "Grid"
+  | "Section"
+  | "Text"
+  | "Button"
+  | "Card"
+  | "MetricCard"
+  | "Chart"
+  | "List"
+  | "Table"
+  | "Toolbar";
+
+export interface CanvasNode {
+  id: string;
+  type: CanvasNodeType;
+  props?: Record<string, unknown>;
+  style?: Record<string, string | number>;
+  children?: CanvasNode[];
+}
+
+export interface CanvasDocument {
+  version: 1;
+  root: CanvasNode;
+  selectedNodeId?: string | null;
+}
+
+export type CanvasEvent =
+  | {
+      type: "appendNode";
+      parentId: string;
+      node: CanvasNode;
+    }
+  | {
+      type: "updateNode";
+      id: string;
+      patch: {
+        props?: Record<string, unknown>;
+        style?: Record<string, string | number>;
+      };
+    }
+  | {
+      type: "selectNode";
+      id: string | null;
+    };

package/render/layout/deleteBehavior.ts

@@ -0,0 +1,52 @@
+type ResolveDeleteSpaceIdArgs = {
+  contentKeyType: string;
+  docSpaceId?: string | null;
+  entitySpaceId?: string | null;
+  routeSpaceId?: string | null;
+  currentSpaceId?: string | null;
+};
+
+const ROUTE_SCOPED_DELETE_TYPES = new Set([
+  "page",
+  "dialog",
+  "file",
+  "image",
+  "meta",
+]);
+
+export const resolveDeleteSpaceId = ({
+  contentKeyType,
+  docSpaceId,
+  entitySpaceId,
+  routeSpaceId,
+  currentSpaceId,
+}: ResolveDeleteSpaceIdArgs): string | undefined => {
+  const persistedSpaceId = entitySpaceId || docSpaceId || undefined;
+  if (persistedSpaceId) return persistedSpaceId;
+  if (
+    routeSpaceId &&
+    ROUTE_SCOPED_DELETE_TYPES.has(contentKeyType)
+  ) {
+    return routeSpaceId;
+  }
+  return undefined;
+};
+
+export const resolveDeleteSuccessPath = ({
+  contentKey,
+  routeSpaceId,
+}: {
+  contentKey?: string;
+  routeSpaceId?: string | null;
+}): string | undefined => {
+  if (!contentKey || routeSpaceId) return undefined;
+
+  if (
+    contentKey.startsWith("cybot-pub-") ||
+    contentKey.startsWith("agent-pub-")
+  ) {
+    return "/explore";
+  }
+
+  return undefined;
+};

package/render/layout/mainLayoutSidebar.ts

@@ -0,0 +1,17 @@
+export const shouldRenderChatSidebar = ({
+  isLoggedIn,
+  hasMounted,
+  useAllViewSidebar,
+  isLifeRoute,
+}: {
+  isLoggedIn: boolean;
+  hasMounted: boolean;
+  useAllViewSidebar: boolean;
+  isLifeRoute: boolean;
+}): boolean => {
+  if (!hasMounted) return false;
+  if (!isLoggedIn) return false;
+  if (isLifeRoute) return false;
+  if (useAllViewSidebar) return true;
+  return true;
+};

package/render/layout/mainLayoutViewMode.ts

@@ -0,0 +1,56 @@
+import { MY_ROUTE_SECTIONS } from "app/constants/mySections";
+
+const allViewRoutePaths = new Set([
+  "/",
+  ...MY_ROUTE_SECTIONS.map((section) => section.path),
+  "/share/mine",
+]);
+
+const SPACE_ROUTE_PATTERN = /^\/space\/([^/]+)(?:\/(.*))?\/?$/;
+
+export interface SpaceRouteContext {
+  isSpaceRoute: boolean;
+  isSpaceRootRoute: boolean;
+  spaceId: string | null;
+}
+
+export function isAllViewRoutePath(pathname: string): boolean {
+  return allViewRoutePaths.has(pathname);
+}
+
+export function getSpaceRouteContext(pathname: string): SpaceRouteContext {
+  const match = pathname.match(SPACE_ROUTE_PATTERN);
+  if (!match) {
+    return {
+      isSpaceRoute: false,
+      isSpaceRootRoute: false,
+      spaceId: null,
+    };
+  }
+
+  const [, encodedSpaceId, descendantPath] = match;
+
+  let spaceId = encodedSpaceId;
+  try {
+    spaceId = decodeURIComponent(encodedSpaceId);
+  } catch {
+    // Keep the encoded segment so route classification never fails on bad input.
+  }
+
+  return {
+    isSpaceRoute: true,
+    isSpaceRootRoute: !descendantPath,
+    spaceId,
+  };
+}
+
+export function isSpaceRoutePath(pathname: string): boolean {
+  return getSpaceRouteContext(pathname).isSpaceRoute;
+}
+
+export function shouldForceCategoriesViewMode(
+  pathname: string,
+  viewMode: string
+): boolean {
+  return isSpaceRoutePath(pathname) && viewMode !== "categories";
+}

package/render/layout/topbarUtils.ts

@@ -0,0 +1,87 @@
+import { useMemo } from "react";
+
+export type ContentKeyType =
+  | "app"
+  | "page"
+  | "meta"
+  | "dialog"
+  | "image"
+  | "file"
+  | "agent"
+  | "cybot"
+  | "other"
+  | "unknown";
+
+export interface TopBarProps {
+  toggleSidebar?: () => void;
+  isSidebarOpen?: boolean;
+}
+
+export const getSideChatLabels = (
+  t: (key: string, fallback?: string) => string,
+  type: ContentKeyType
+) => {
+  switch (type) {
+    case "app":
+      return {
+        open: t("showAppAssistant", "打开应用 AI"),
+        hide: t("hideAppAssistant", "隐藏应用 AI"),
+      };
+    case "page":
+      return {
+        open: t("showDocAssistant", "打开文档 AI"),
+        hide: t("hideDocAssistant", "隐藏文档 AI"),
+      };
+    case "meta":
+      return {
+        open: t("showTableAssistant", "打开表格 AI"),
+        hide: t("hideTableAssistant", "隐藏表格 AI"),
+      };
+    case "image":
+      return {
+        open: t("showImageAssistant", "打开图片 AI"),
+        hide: t("hideImageAssistant", "隐藏图片 AI"),
+      };
+    case "file":
+      return {
+        open: t("showFileAssistant", "打开文件 AI"),
+        hide: t("hideFileAssistant", "隐藏文件 AI"),
+      };
+    default:
+      return {
+        open: t("showAssistant", "打开页面 AI"),
+        hide: t("hideAssistant", "隐藏页面 AI"),
+      };
+  }
+};
+
+/** 判断是否 Mac，用于快捷键提示 */
+export const useIsMac = (): boolean =>
+  useMemo(
+    () =>
+      typeof window !== "undefined" &&
+      /Mac|iPod|iPhone|iPad/.test(window.navigator.platform),
+    []
+  );
+
+/** 根据路由中的 pageKey 推断当前内容类型 */
+export const useContentKeyType = (
+  pageKey?: string,
+  pageType?: string,
+  appKey?: string
+): ContentKeyType =>
+  useMemo(() => {
+    if (appKey) return "app";
+    if (!pageKey) return "unknown";
+    if (pageType === "image") return "image";
+    if (pageType === "file") return "file";
+    if (pageKey.startsWith("file")) return "file";
+    if (pageKey.startsWith("image")) return "image";
+    if (pageKey.startsWith("page")) return "page";
+    if (pageKey.startsWith("meta")) return "meta";
+    if (pageKey.startsWith("dialog")) return "dialog";
+    if (pageKey.startsWith("task")) return "task";
+    if (pageKey.startsWith("agent")) return "agent";
+    if (pageKey.startsWith("cybot")) return "cybot";
+    return "other";
+  }, [appKey, pageKey, pageType]);