@1agh/maude 1.3.0 → 1.4.0

package/apps/studio/comments-overlay.tsx

@@ -338,6 +338,11 @@ export function CommentsOverlay(): React.ReactNode {
   // safe because they carry identical content; the Y.Array path just
   // reaches us first (no 800 ms debounce delay).
   const collab = useCollab();
+  // Who is looking — the same identity a new comment is signed with (the
+  // project's git user on a desktop, the vouched member in a cloud cell).
+  // Asked directly: this overlay also runs in the comment-mount bundle, where
+  // the collab context is another module's and reads as null.
+  const me = useViewerName();
   useEffect(() => {
     if (!collab) return;
     const arr = collab.doc.getArray<OverlayComment>('comments');
@@ -566,6 +571,11 @@ export function CommentsOverlay(): React.ReactNode {
             onPatch={(patch) => handlePatch(focused.id, patch)}
             onDelete={() => handleDelete(focused.id)}
             onReply={(body) => handleReply(focused.id, body)}
+            mine={
+              !isReadOnlyCanvas() &&
+              !!(me ?? collab?.myName) &&
+              (focused.author ?? '').trim() === (me ?? collab?.myName ?? '').trim()
+            }
           />
         );
       })()}
@@ -1048,13 +1058,33 @@ function CommentComposer({
 // directly to `/_api/comments/<id>/reply` because that endpoint exists only on
 // Bun runtime and lives in `http.ts`.
 
-function CommentThread({
+let viewerName: Promise<string | null> | null = null;
+/** The viewer's display identity, asked once per document. */
+function useViewerName(): string | null {
+  const [name, setName] = useState<string | null>(null);
+  useEffect(() => {
+    if (typeof fetch === 'undefined') return;
+    viewerName ??= fetch('/_api/git-user')
+      .then((r) => (r.ok ? r.json() : null))
+      .then((j) => (typeof j?.name === 'string' && j.name.trim() ? j.name.trim() : null))
+      .catch(() => null);
+    let alive = true;
+    void viewerName.then((n) => alive && setName(n));
+    return () => {
+      alive = false;
+    };
+  }, []);
+  return name;
+}
+
+export function CommentThread({
   comment,
   sequence,
   onClose,
   onPatch,
   onDelete,
   onReply,
+  mine = false,
 }: {
   comment: OverlayComment;
   sequence: number;
@@ -1062,12 +1092,23 @@ function CommentThread({
   onPatch: (patch: Record<string, unknown>) => void;
   onDelete: () => void;
   onReply: (body: string) => Promise<boolean>;
+  /** The person looking wrote this comment — they may edit its text. */
+  mine?: boolean;
 }) {
   const dialogRef = useRef<HTMLDivElement | null>(null);
   const replyRef = useRef<HTMLTextAreaElement | null>(null);
   const rafRef = useRef<number | null>(null);
   const [reply, setReply] = useState('');
   const [sending, setSending] = useState(false);
+  // Editing your own comment: the text in place, saved as a patch (the same
+  // channel resolve/reopen use). null = not editing.
+  const [draft, setDraft] = useState<string | null>(null);
+  const saveDraft = useCallback(() => {
+    const v = (draft ?? '').trim();
+    if (!v) return;
+    if (v !== comment.text) onPatch({ text: v });
+    setDraft(null);
+  }, [draft, comment.text, onPatch]);
 
   // Live anchor — popover tracks the pin via rAF so it stays glued to its
   // target through pan / zoom (FigJam parity). Writing to the dialog style
@@ -1176,7 +1217,40 @@ function CommentThread({
         {selectorChip ? <code className="cm-thread__selector">{selectorChip}</code> : null}
       </div>
 
-      <div className="cm-thread__body">{renderBodyWithMentions(comment.text)}</div>
+      {draft === null ? (
+        <div className="cm-thread__body">{renderBodyWithMentions(comment.text)}</div>
+      ) : (
+        <div className="cm-thread__reply-form">
+          <MentionAwareTextarea
+            className="cm-thread__reply-textarea"
+            value={draft}
+            placeholder="Edit your comment… ⌘↵ to save"
+            onChange={setDraft}
+            onKeyDown={(e: React.KeyboardEvent<HTMLTextAreaElement>) => {
+              if ((e.metaKey || e.ctrlKey) && e.key === 'Enter') {
+                e.preventDefault();
+                saveDraft();
+              }
+            }}
+            rows={3}
+            ariaLabel="Edit comment"
+          />
+          <div className="cm-thread__reply-actions">
+            <button type="button" className="cm-btn" onClick={() => setDraft(null)}>
+              Cancel
+            </button>
+            <button
+              type="button"
+              className="cm-btn cm-btn--primary"
+              data-testid="comment-edit-save"
+              disabled={!draft.trim()}
+              onClick={saveDraft}
+            >
+              Save
+            </button>
+          </div>
+        </div>
+      )}
 
       {(comment.thread ?? []).map((r) => (
         <div className="cm-thread__reply" key={r.id}>
@@ -1218,6 +1292,16 @@ function CommentThread({
           </div>
 
           <div className="cm-thread__actions">
+            {mine && draft === null ? (
+              <button
+                type="button"
+                className="cm-btn"
+                data-testid="comment-edit"
+                onClick={() => setDraft(comment.text)}
+              >
+                Edit
+              </button>
+            ) : null}
             {comment.status === 'resolved' ? (
               <button type="button" className="cm-btn" onClick={() => onPatch({ status: 'open' })}>
                 ↺ Reopen

package/apps/studio/context.ts

@@ -329,6 +329,96 @@ function resolveRepoRoot(): string {
   return process.cwd();
 }
 
+/** Where the sync runtime keeps what the linked project says about itself. */
+export const PROJECT_CONFIG_CACHE_REL = '_state/project-config.json';
+
+export interface ProjectConfig {
+  canvasGroups: { label: string; path: string }[];
+  designSystems: { name: string; path: string; tokensCssRel?: string }[];
+}
+
+/**
+ * The project's own labels and design systems, as the hub reported them —
+ * UNTRUSTED (DDR-054): only short names and contained relative paths survive.
+ */
+export function sanitizeProjectConfig(raw: unknown): ProjectConfig | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const r = raw as { canvasGroups?: unknown; designSystems?: unknown };
+  const groups = Array.isArray(r.canvasGroups) ? r.canvasGroups : [];
+  const systems = Array.isArray(r.designSystems) ? r.designSystems : [];
+  const canvasGroups = groups
+    .filter(
+      (g): g is { label: string; path: string } =>
+        !!g &&
+        typeof g === 'object' &&
+        typeof (g as { label?: unknown }).label === 'string' &&
+        (g as { label: string }).label.length > 0 &&
+        (g as { label: string }).label.length <= 64 &&
+        isContainedRel((g as { path?: unknown }).path)
+    )
+    .slice(0, 32)
+    .map((g) => ({ label: g.label, path: g.path.replace(/^\/+|\/+$/g, '') }));
+  const designSystems = systems
+    .filter(
+      (d): d is { name: string; path: string; tokensCssRel?: string } =>
+        !!d &&
+        typeof d === 'object' &&
+        typeof (d as { name?: unknown }).name === 'string' &&
+        /^[\w .-]{1,64}$/.test((d as { name: string }).name) &&
+        isContainedRel((d as { path?: unknown }).path) &&
+        ((d as { tokensCssRel?: unknown }).tokensCssRel == null ||
+          isContainedRel((d as { tokensCssRel?: unknown }).tokensCssRel))
+    )
+    .slice(0, 16)
+    .map((d) => ({
+      name: d.name,
+      path: d.path.replace(/^\/+|\/+$/g, ''),
+      ...(typeof d.tokensCssRel === 'string' ? { tokensCssRel: d.tokensCssRel } : {}),
+    }));
+  return { canvasGroups, designSystems };
+}
+
+/**
+ * What the linked project says about itself that this copy's own config does
+ * not. A managed desktop copy is declared from group PATHS alone, so its
+ * groups had no labels ("system", never "Design system") and it knew no
+ * design systems: the project's design system never appeared on a teammate's
+ * desktop (plan T31/L16). This only FILLS IN — a label the local config chose
+ * and a local design system of the same name always win — and only for a
+ * group this copy already declares.
+ */
+function withProjectConfig(cfg: DevServerConfig, repoRoot: string): DevServerConfig {
+  if (!cfg.linkedHub) return cfg;
+  let project: ProjectConfig | null = null;
+  try {
+    const designRel = String(cfg.designRoot ?? '.design').replace(/^\/+|\/+$/g, '');
+    project = sanitizeProjectConfig(
+      JSON.parse(readFileSync(path.join(repoRoot, designRel, PROJECT_CONFIG_CACHE_REL), 'utf8'))
+    );
+  } catch {
+    return cfg;
+  }
+  if (!project) return cfg;
+  const labels = new Map(project.canvasGroups.map((g) => [g.path, g.label]));
+  const canvasGroups = (cfg.canvasGroups ?? []).map((g) => {
+    const p = String(g.path ?? '').replace(/^\/+|\/+$/g, '');
+    const label = labels.get(p);
+    return label && (!g.label || g.label === p) ? { ...g, label } : g;
+  });
+  const declared = new Set((cfg.designSystems ?? []).map((d) => d.name));
+  const groupPaths = canvasGroups.map((g) => String(g.path).replace(/^\/+|\/+$/g, ''));
+  const adopted = project.designSystems.filter(
+    (d) =>
+      !declared.has(d.name) && groupPaths.some((g) => d.path === g || d.path.startsWith(`${g}/`))
+  );
+  if (adopted.length === 0 && canvasGroups.every((g, i) => g === cfg.canvasGroups[i])) return cfg;
+  return {
+    ...cfg,
+    canvasGroups,
+    ...(adopted.length ? { designSystems: [...(cfg.designSystems ?? []), ...adopted] } : {}),
+  };
+}
+
 function loadConfig(repoRoot: string): DevServerConfig {
   const configPath = path.join(repoRoot, '.design', 'config.json');
   let raw: string;
@@ -339,7 +429,9 @@ function loadConfig(repoRoot: string): DevServerConfig {
   }
   try {
     const parsed = JSON.parse(raw);
-    return normalizeConfig({ ...DEFAULT_CONFIG, ...parsed, _source: '.design/config.json' });
+    return normalizeConfig(
+      withProjectConfig({ ...DEFAULT_CONFIG, ...parsed, _source: '.design/config.json' }, repoRoot)
+    );
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     console.error(`  warn: ${configPath} is not valid JSON: ${msg}. Using defaults.`);