nextclaw 0.30.0 → 0.32.0

package/resources/apps/nextclaw-personal-organizer/service-components/nextclaw-personal-organizer-data/calendar-subscription.service.mjs

@@ -0,0 +1,152 @@
+import { randomUUID } from "node:crypto";
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+
+const MAX_ICS_BYTES = 5 * 1024 * 1024;
+
+export class CalendarSubscriptionService {
+  constructor({ normalizeHttpUrl, now, toIso }) {
+    this.normalizeHttpUrl = normalizeHttpUrl;
+    this.now = now;
+    this.toIso = toIso;
+  }
+
+  sync = async (state, subscription) => {
+    try {
+      const content = await this.fetchCalendarText(subscription.url);
+      const events = this.parseIcs(content, subscription);
+      state.items = state.items.filter((item) => item.subscriptionId !== subscription.id);
+      state.items.push(...events);
+      subscription.lastSyncedAt = this.now();
+      subscription.lastError = "";
+    } catch (error) {
+      subscription.lastError = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  };
+
+  fetchCalendarText = async (url) => {
+    let currentUrl = await this.requirePublicHttpUrl(url);
+    for (let redirectCount = 0; redirectCount <= 3; redirectCount += 1) {
+      const response = await fetch(currentUrl, {
+        redirect: "manual",
+        signal: globalThis.AbortSignal.timeout(12_000),
+      });
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get("location");
+        if (!location || redirectCount === 3) {
+          throw new Error("calendar redirected too many times");
+        }
+        currentUrl = await this.requirePublicHttpUrl(
+          new URL(location, currentUrl).toString(),
+        );
+        continue;
+      }
+      if (!response.ok) {
+        throw new Error(`calendar returned HTTP ${response.status}`);
+      }
+      const contentLength = Number(response.headers.get("content-length"));
+      if (Number.isFinite(contentLength) && contentLength > MAX_ICS_BYTES) {
+        throw new Error(`calendar exceeds ${MAX_ICS_BYTES} bytes`);
+      }
+      const content = await response.text();
+      if (Buffer.byteLength(content, "utf8") > MAX_ICS_BYTES) {
+        throw new Error(`calendar exceeds ${MAX_ICS_BYTES} bytes`);
+      }
+      return content;
+    }
+    throw new Error("calendar redirect resolution failed");
+  };
+
+  requirePublicHttpUrl = async (value) => {
+    const url = new URL(this.normalizeHttpUrl(value));
+    if (url.username || url.password) {
+      throw new Error("calendar url cannot include credentials");
+    }
+    const hostname = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    if (hostname === "localhost" || hostname.endsWith(".localhost")) {
+      throw new Error("calendar url must use a public host");
+    }
+    const addresses = isIP(hostname)
+      ? [{ address: hostname }]
+      : await lookup(hostname, { all: true, verbatim: true });
+    if (addresses.length === 0 || addresses.some(({ address }) => !isPublicIpAddress(address))) {
+      throw new Error("calendar url must resolve to a public host");
+    }
+    return url.toString();
+  };
+
+  parseIcs = (raw, subscription) => {
+    const lines = raw.replace(/\r\n[ \t]/g, "").split(/\r?\n/);
+    const events = [];
+    let current = null;
+    for (const line of lines) {
+      if (line === "BEGIN:VEVENT") {
+        current = {};
+      } else if (line === "END:VEVENT" && current) {
+        if (current.DTSTART && current.SUMMARY) {
+          const start = this.parseIcsDate(current.DTSTART);
+          events.push({
+            id: `ics:${subscription.id}:${current.UID || randomUUID()}`,
+            title: current.SUMMARY,
+            start,
+            end: this.parseIcsDate(current.DTEND || current.DTSTART),
+            allDay: /^\d{8}$/.test(current.DTSTART),
+            location: current.LOCATION || "",
+            notes: current.DESCRIPTION || "",
+            source: "ics",
+            subscriptionId: subscription.id,
+            subscriptionName: subscription.name,
+            createdAt: this.now(),
+            updatedAt: this.now(),
+          });
+        }
+        current = null;
+      } else if (current) {
+        const separator = line.indexOf(":");
+        if (separator > 0) {
+          current[line.slice(0, separator).split(";")[0]] = line
+            .slice(separator + 1)
+            .replace(/\\n/g, "\n")
+            .replace(/\\,/g, ",");
+        }
+      }
+    }
+    return events;
+  };
+
+  parseIcsDate = (value) => {
+    if (/^\d{8}$/.test(value)) {
+      return new Date(
+        `${value.slice(0, 4)}-${value.slice(4, 6)}-${value.slice(6, 8)}T00:00:00Z`,
+      ).toISOString();
+    }
+    const match = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z?$/.exec(value);
+    if (!match) {
+      return this.toIso(value, "ICS date");
+    }
+    const timezone = value.endsWith("Z") ? "Z" : "";
+    return new Date(
+      `${match[1]}-${match[2]}-${match[3]}T${match[4]}:${match[5]}:${match[6]}${timezone}`,
+    ).toISOString();
+  };
+}
+
+function isPublicIpAddress(address) {
+  if (isIP(address) === 4) {
+    const [first, second] = address.split(".").map(Number);
+    return !(first === 0 || first === 10 || first === 127 || first >= 224 ||
+      (first === 100 && second >= 64 && second <= 127) ||
+      (first === 169 && second === 254) ||
+      (first === 172 && second >= 16 && second <= 31) ||
+      (first === 192 && second === 168) ||
+      (first === 198 && (second === 18 || second === 19)));
+  }
+  const normalized = address.toLowerCase();
+  return isIP(address) === 6 &&
+    normalized !== "::" && normalized !== "::1" &&
+    !normalized.startsWith("fc") && !normalized.startsWith("fd") &&
+    !normalized.startsWith("fe8") && !normalized.startsWith("fe9") &&
+    !normalized.startsWith("fea") && !normalized.startsWith("feb") &&
+    !normalized.startsWith("::ffff:");
+}

package/resources/apps/nextclaw-personal-organizer/service-components/nextclaw-personal-organizer-data/index.mjs

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { CalendarSubscriptionService } from "./calendar-subscription.service.mjs";
+
+const dataDirectory = process.env.NEXTCLAW_APP_DATA_DIR?.trim();
+const MAX_NOTE_BYTES = 2 * 1024 * 1024;
+if (!dataDirectory) {
+  throw new Error("NEXTCLAW_APP_DATA_DIR is required.");
+}
+await mkdir(dataDirectory, { recursive: true });
+
+const files = {
+  todos: path.join(dataDirectory, "todos.json"),
+  favorites: path.join(dataDirectory, "favorites.json"),
+  calendar: path.join(dataDirectory, "calendar.json"),
+  notesIndex: path.join(dataDirectory, "notes-index.json"),
+  notesDirectory: path.join(dataDirectory, "notes"),
+};
+await mkdir(files.notesDirectory, { recursive: true });
+
+const objectSchema = (properties, required = []) => ({
+  type: "object",
+  properties,
+  required,
+  additionalProperties: false,
+});
+const string = { type: "string" };
+const boolean = { type: "boolean" };
+
+const tools = [
+  ["todo_list", "List todos", objectSchema({ status: { type: "string", enum: ["all", "open", "completed"] } })],
+  ["todo_create", "Create a todo", objectSchema({ title: string, notes: string, dueDate: string, priority: { type: "string", enum: ["low", "normal", "high"] } }, ["title"])],
+  ["todo_update", "Update a todo", objectSchema({ id: string, title: string, notes: string, dueDate: string, priority: { type: "string", enum: ["low", "normal", "high"] }, completed: boolean }, ["id"])],
+  ["todo_delete", "Delete a todo", objectSchema({ id: string }, ["id"])],
+  ["note_list", "List Markdown notes", objectSchema({ query: string })],
+  ["note_read", "Read a Markdown note", objectSchema({ id: string }, ["id"])],
+  ["note_save", "Create or update a Markdown note", objectSchema({ id: string, title: string, content: string }, ["title", "content"])],
+  ["note_delete", "Delete a Markdown note", objectSchema({ id: string }, ["id"])],
+  ["favorite_list", "List favorites", objectSchema({ query: string, tag: string })],
+  ["favorite_save", "Save a favorite", objectSchema({ url: string, title: string, note: string, tags: { type: "array", items: string } }, ["url", "title"])],
+  ["favorite_update", "Update a favorite", objectSchema({ id: string, url: string, title: string, note: string, tags: { type: "array", items: string } }, ["id"])],
+  ["favorite_delete", "Delete a favorite", objectSchema({ id: string }, ["id"])],
+  ["event_list", "List calendar events", objectSchema({ start: string, end: string })],
+  ["event_create", "Create an event", objectSchema({ title: string, start: string, end: string, allDay: boolean, location: string, notes: string }, ["title", "start"])],
+  ["event_update", "Update an event", objectSchema({ id: string, title: string, start: string, end: string, allDay: boolean, location: string, notes: string }, ["id"])],
+  ["event_delete", "Delete an event", objectSchema({ id: string }, ["id"])],
+  ["calendar_subscribe", "Connect an ICS calendar URL", objectSchema({ name: string, url: string }, ["name", "url"])],
+  ["calendar_sync", "Sync connected ICS calendars", objectSchema({ id: string })],
+  ["calendar_unsubscribe", "Disconnect an ICS calendar", objectSchema({ id: string }, ["id"])],
+].map(([name, description, inputSchema]) => ({ name, description, inputSchema }));
+
+async function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return structuredClone(fallback);
+    throw error;
+  }
+}
+
+async function writeJson(filePath, value) {
+  await writeTextAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+async function writeTextAtomic(filePath, value) {
+  const tempPath = `${filePath}.${randomUUID()}.tmp`;
+  await mkdir(path.dirname(filePath), { recursive: true });
+  try {
+    await writeFile(tempPath, value, { encoding: "utf8", mode: 0o600 });
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => undefined);
+    throw error;
+  }
+}
+
+const now = () => new Date().toISOString();
+const requireText = (value, field) => {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${field} is required`);
+  return value.trim();
+};
+const optionalText = (value) => typeof value === "string" ? value.trim() : "";
+const requireId = (value) => requireText(value, "id");
+const requireNoteId = (value) => {
+  const noteId = requireId(value);
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(noteId) || noteId === "." || noteId === "..") {
+    throw new Error("note id is invalid");
+  }
+  return noteId;
+};
+const normalizeTags = (value) => Array.isArray(value)
+  ? [...new Set(value.map((entry) => optionalText(entry)).filter(Boolean))].slice(0, 20)
+  : [];
+const assertHttpUrl = (value) => {
+  const url = new URL(requireText(value, "url"));
+  if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("url must use http or https");
+  return url.toString();
+};
+const calendarSubscriptionService = new CalendarSubscriptionService({
+  normalizeHttpUrl: assertHttpUrl,
+  now,
+  toIso,
+});
+
+async function mutateCollection(filePath, callback) {
+  const state = await readJson(filePath, { schemaVersion: 1, items: [] });
+  const result = await callback(state.items);
+  await writeJson(filePath, { schemaVersion: 1, items: state.items });
+  return result;
+}
+
+const actions = {
+  todo_list: async ({ status = "all" }) => {
+    const state = await readJson(files.todos, { schemaVersion: 1, items: [] });
+    const items = state.items
+      .filter((item) => status === "all" || (status === "completed") === item.completed)
+      .sort((left, right) => Number(left.completed) - Number(right.completed) || optionalText(left.dueDate).localeCompare(optionalText(right.dueDate)) || right.createdAt.localeCompare(left.createdAt));
+    return { items };
+  },
+  todo_create: async (input) => await mutateCollection(files.todos, (items) => {
+    const timestamp = now();
+    const item = { id: randomUUID(), title: requireText(input.title, "title"), notes: optionalText(input.notes), dueDate: optionalText(input.dueDate), priority: ["low", "high"].includes(input.priority) ? input.priority : "normal", completed: false, createdAt: timestamp, updatedAt: timestamp };
+    items.push(item);
+    return { item };
+  }),
+  todo_update: async (input) => await mutateCollection(files.todos, (items) => {
+    const item = items.find((entry) => entry.id === requireId(input.id));
+    if (!item) throw new Error("todo not found");
+    for (const field of ["title", "notes", "dueDate"]) if (typeof input[field] === "string") item[field] = field === "title" ? requireText(input[field], field) : input[field].trim();
+    if (typeof input.completed === "boolean") item.completed = input.completed;
+    if (["low", "normal", "high"].includes(input.priority)) item.priority = input.priority;
+    item.updatedAt = now();
+    return { item };
+  }),
+  todo_delete: async ({ id }) => await mutateCollection(files.todos, (items) => {
+    const index = items.findIndex((item) => item.id === requireId(id));
+    if (index < 0) throw new Error("todo not found");
+    items.splice(index, 1);
+    return { deleted: true, id };
+  }),
+  note_list: async ({ query = "" }) => {
+    const state = await readJson(files.notesIndex, { schemaVersion: 1, items: [] });
+    const normalizedQuery = optionalText(query).toLowerCase();
+    return { items: state.items.filter((item) => !normalizedQuery || item.title.toLowerCase().includes(normalizedQuery)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)) };
+  },
+  note_read: async ({ id }) => {
+    const noteId = requireNoteId(id);
+    const state = await readJson(files.notesIndex, { schemaVersion: 1, items: [] });
+    const item = state.items.find((entry) => entry.id === noteId);
+    if (!item) throw new Error("note not found");
+    return { item: { ...item, content: await readFile(path.join(files.notesDirectory, `${noteId}.md`), "utf8") } };
+  },
+  note_save: async (input) => {
+    const state = await readJson(files.notesIndex, { schemaVersion: 1, items: [] });
+    const timestamp = now();
+    const noteId = requireNoteId(optionalText(input.id) || randomUUID());
+    const content = String(input.content ?? "");
+    if (Buffer.byteLength(content, "utf8") > MAX_NOTE_BYTES) {
+      throw new Error(`note content exceeds ${MAX_NOTE_BYTES} bytes`);
+    }
+    let item = state.items.find((entry) => entry.id === noteId);
+    if (!item) {
+      item = { id: noteId, title: requireText(input.title, "title"), createdAt: timestamp, updatedAt: timestamp };
+      state.items.push(item);
+    } else {
+      item.title = requireText(input.title, "title");
+      item.updatedAt = timestamp;
+    }
+    const notePath = path.join(files.notesDirectory, `${noteId}.md`);
+    let previousContent;
+    try {
+      previousContent = await readFile(notePath, "utf8");
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+    await writeTextAtomic(notePath, content);
+    try {
+      await writeJson(files.notesIndex, state);
+    } catch (error) {
+      try {
+        if (previousContent === undefined) await rm(notePath, { force: true });
+        else await writeTextAtomic(notePath, previousContent);
+      } catch (restoreError) {
+        throw new AggregateError([error, restoreError], "note save failed and content could not be restored");
+      }
+      throw error;
+    }
+    return { item: { ...item, content } };
+  },
+  note_delete: async ({ id }) => {
+    const noteId = requireNoteId(id);
+    const state = await readJson(files.notesIndex, { schemaVersion: 1, items: [] });
+    const nextItems = state.items.filter((item) => item.id !== noteId);
+    if (nextItems.length === state.items.length) throw new Error("note not found");
+    await writeJson(files.notesIndex, { ...state, items: nextItems });
+    try {
+      await rm(path.join(files.notesDirectory, `${noteId}.md`), { force: true });
+    } catch (error) {
+      try {
+        await writeJson(files.notesIndex, state);
+      } catch (restoreError) {
+        throw new AggregateError([error, restoreError], "note delete failed and index could not be restored");
+      }
+      throw error;
+    }
+    return { deleted: true, id: noteId };
+  },
+  favorite_list: async ({ query = "", tag = "" }) => {
+    const state = await readJson(files.favorites, { schemaVersion: 1, items: [] });
+    const normalizedQuery = optionalText(query).toLowerCase();
+    const normalizedTag = optionalText(tag).toLowerCase();
+    return { items: state.items.filter((item) => (!normalizedQuery || `${item.title} ${item.url} ${item.note}`.toLowerCase().includes(normalizedQuery)) && (!normalizedTag || item.tags.some((entry) => entry.toLowerCase() === normalizedTag))).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)) };
+  },
+  favorite_save: async (input) => await mutateCollection(files.favorites, (items) => {
+    const timestamp = now();
+    const item = { id: randomUUID(), url: assertHttpUrl(input.url), title: requireText(input.title, "title"), note: optionalText(input.note), tags: normalizeTags(input.tags), createdAt: timestamp, updatedAt: timestamp };
+    items.push(item);
+    return { item };
+  }),
+  favorite_update: async (input) => await mutateCollection(files.favorites, (items) => {
+    const item = items.find((entry) => entry.id === requireId(input.id));
+    if (!item) throw new Error("favorite not found");
+    if (typeof input.url === "string") item.url = assertHttpUrl(input.url);
+    if (typeof input.title === "string") item.title = requireText(input.title, "title");
+    if (typeof input.note === "string") item.note = input.note.trim();
+    if (Array.isArray(input.tags)) item.tags = normalizeTags(input.tags);
+    item.updatedAt = now();
+    return { item };
+  }),
+  favorite_delete: async ({ id }) => await mutateCollection(files.favorites, (items) => {
+    const index = items.findIndex((item) => item.id === requireId(id));
+    if (index < 0) throw new Error("favorite not found");
+    items.splice(index, 1);
+    return { deleted: true, id };
+  }),
+  event_list: async ({ start = "", end = "" }) => {
+    const state = await readJson(files.calendar, { schemaVersion: 1, items: [], subscriptions: [] });
+    const from = start ? new Date(start).getTime() : Number.NEGATIVE_INFINITY;
+    const to = end ? new Date(end).getTime() : Number.POSITIVE_INFINITY;
+    return { items: state.items.filter((item) => new Date(item.start).getTime() >= from && new Date(item.start).getTime() <= to).sort((left, right) => left.start.localeCompare(right.start)), subscriptions: state.subscriptions };
+  },
+  event_create: async (input) => await mutateCalendar((state) => {
+    const timestamp = now();
+    const start = toIso(input.start, "start");
+    const item = { id: randomUUID(), title: requireText(input.title, "title"), start, end: input.end ? toIso(input.end, "end") : start, allDay: input.allDay === true, location: optionalText(input.location), notes: optionalText(input.notes), source: "local", createdAt: timestamp, updatedAt: timestamp };
+    state.items.push(item);
+    return { item };
+  }),
+  event_update: async (input) => await mutateCalendar((state) => {
+    const item = state.items.find((entry) => entry.id === requireId(input.id) && entry.source === "local");
+    if (!item) throw new Error("editable event not found");
+    if (typeof input.title === "string") item.title = requireText(input.title, "title");
+    if (typeof input.start === "string") item.start = toIso(input.start, "start");
+    if (typeof input.end === "string") item.end = toIso(input.end, "end");
+    if (typeof input.allDay === "boolean") item.allDay = input.allDay;
+    if (typeof input.location === "string") item.location = input.location.trim();
+    if (typeof input.notes === "string") item.notes = input.notes.trim();
+    item.updatedAt = now();
+    return { item };
+  }),
+  event_delete: async ({ id }) => await mutateCalendar((state) => {
+    const index = state.items.findIndex((item) => item.id === requireId(id) && item.source === "local");
+    if (index < 0) throw new Error("editable event not found");
+    state.items.splice(index, 1);
+    return { deleted: true, id };
+  }),
+  calendar_subscribe: async ({ name, url }) => await mutateCalendar(async (state) => {
+    const subscription = { id: randomUUID(), name: requireText(name, "name"), url: assertHttpUrl(url), lastSyncedAt: "", lastError: "" };
+    state.subscriptions.push(subscription);
+    await calendarSubscriptionService.sync(state, subscription);
+    return { subscription, imported: state.items.filter((item) => item.subscriptionId === subscription.id).length };
+  }),
+  calendar_sync: async ({ id = "" }) => await mutateCalendar(async (state) => {
+    const subscriptions = id ? state.subscriptions.filter((entry) => entry.id === id) : state.subscriptions;
+    for (const subscription of subscriptions) {
+      await calendarSubscriptionService.sync(state, subscription);
+    }
+    return { subscriptions, imported: state.items.filter((item) => item.source === "ics").length };
+  }),
+  calendar_unsubscribe: async ({ id }) => await mutateCalendar((state) => {
+    const subscriptionId = requireId(id);
+    state.subscriptions = state.subscriptions.filter((entry) => entry.id !== subscriptionId);
+    state.items = state.items.filter((item) => item.subscriptionId !== subscriptionId);
+    return { deleted: true, id: subscriptionId };
+  }),
+};
+
+async function mutateCalendar(callback) {
+  const state = await readJson(files.calendar, { schemaVersion: 1, items: [], subscriptions: [] });
+  try {
+    const result = await callback(state);
+    await writeJson(files.calendar, state);
+    return result;
+  } catch (error) {
+    try {
+      await writeJson(files.calendar, state);
+    } catch (persistError) {
+      throw new AggregateError([error, persistError], "calendar operation failed and state could not be persisted");
+    }
+    throw error;
+  }
+}
+
+function toIso(value, field) {
+  const date = new Date(requireText(value, field));
+  if (!Number.isFinite(date.getTime())) throw new Error(`${field} must be a valid date`);
+  return date.toISOString();
+}
+
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+async function handle(request) {
+  if (request.method === "initialize") return { protocolVersion: request.params?.protocolVersion ?? "2025-03-26", capabilities: { tools: {} }, serverInfo: { name: "nextclaw-personal-organizer-data", version: "0.1.1" } };
+  if (request.method === "ping") return {};
+  if (request.method === "tools/list") return { tools };
+  if (request.method === "tools/call") {
+    const action = actions[request.params?.name];
+    if (!action) throw new Error(`unknown tool: ${request.params?.name}`);
+    const payload = await action(request.params?.arguments ?? {});
+    return { content: [{ type: "text", text: JSON.stringify(payload) }], structuredContent: payload };
+  }
+  throw new Error(`method not found: ${request.method}`);
+}
+
+const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
+for await (const line of input) {
+  if (!line.trim()) continue;
+  let request;
+  try {
+    request = JSON.parse(line);
+    if (request.id === undefined) continue;
+    send({ jsonrpc: "2.0", id: request.id, result: await handle(request) });
+  } catch (error) {
+    if (request?.id !== undefined) send({ jsonrpc: "2.0", id: request.id, error: { code: -32603, message: error instanceof Error ? error.message : String(error) } });
+  }
+}

package/resources/apps/nextclaw-personal-organizer/service-components/nextclaw-personal-organizer-data/service-app.json

@@ -0,0 +1,35 @@
+{
+  "id": "nextclaw-personal-organizer-data",
+  "title": "个人空间数据服务",
+  "titleI18n": { "zh-CN": "个人空间数据服务", "en-US": "Personal Space Data" },
+  "description": "在本机稳定目录中管理待办、Markdown 笔记、收藏和日历。",
+  "descriptionI18n": {
+    "zh-CN": "在本机稳定目录中管理待办、Markdown 笔记、收藏和日历。",
+    "en-US": "Store todos, Markdown notes, favorites, and calendar data in a stable local directory."
+  },
+  "enabled": true,
+  "protocol": "mcp",
+  "command": "node",
+  "args": ["index.mjs"],
+  "actions": {
+    "todo_list": { "risk": "read", "title": "读取待办" },
+    "todo_create": { "risk": "write", "title": "创建待办" },
+    "todo_update": { "risk": "write", "title": "修改待办" },
+    "todo_delete": { "risk": "write", "title": "删除待办" },
+    "note_list": { "risk": "read", "title": "读取笔记列表" },
+    "note_read": { "risk": "read", "title": "读取笔记" },
+    "note_save": { "risk": "write", "title": "保存 Markdown 笔记" },
+    "note_delete": { "risk": "write", "title": "删除笔记" },
+    "favorite_list": { "risk": "read", "title": "读取收藏" },
+    "favorite_save": { "risk": "write", "title": "保存收藏" },
+    "favorite_update": { "risk": "write", "title": "修改收藏" },
+    "favorite_delete": { "risk": "write", "title": "删除收藏" },
+    "event_list": { "risk": "read", "title": "读取日程" },
+    "event_create": { "risk": "write", "title": "创建日程" },
+    "event_update": { "risk": "write", "title": "修改日程" },
+    "event_delete": { "risk": "write", "title": "删除日程" },
+    "calendar_subscribe": { "risk": "external", "title": "连接 ICS 日历" },
+    "calendar_sync": { "risk": "external", "title": "同步已连接日历" },
+    "calendar_unsubscribe": { "risk": "write", "title": "断开日历连接" }
+  }
+}

package/ui-dist/assets/{abnfDiagram-VRR7QNED-DvTjgVMf.js → abnfDiagram-VRR7QNED-BcFJp_1X.js}

@@ -1 +1 @@
-import{n as e}from"./chunk-5HE753X5-ko0o7_q0.js";import{n as t}from"./chunk-Y2CYZVJY-D_B2ZRNt.js";import{m as n}from"./src-vgz8E_-O.js";import"./chunk-WYO6CB5R-mOJNzbWl.js";import"./chunk-VAUOI2AC-HLGIHQ6k.js";import{n as r,r as i,t as a}from"./chunk-MOJQB5TN-XP6FJHY_.js";import{t as o}from"./chunk-JWPE2WC7-B8M4G76F.js";import{t as s}from"./mermaid-parser.core-DPmMOjXD.js";var c=e().RailroadAbnf.parser.LangiumParser,l=t(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=t(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=t(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=t(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=t(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=t(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=t(e=>{o(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:t(e=>{a.clear(),n.debug(`[ABNF Parser] Starting Langium parse`);let t=c.parse(e);if(t.lexerErrors.length>0||t.parserErrors.length>0)throw new s(t);let r=t.value;n.debug(`[ABNF Parser] Parsed rules:`,r.rules.length),h(r),n.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:i,styles:r};export{g as diagram};
+import{n as e}from"./chunk-5HE753X5-C-w6CQZK.js";import{n as t}from"./chunk-Y2CYZVJY-D1mAU_Po.js";import{m as n}from"./src-Bw-mzbQb.js";import"./chunk-WYO6CB5R-Dn9To_OI.js";import"./chunk-VAUOI2AC-BGvh3yIx.js";import{n as r,r as i,t as a}from"./chunk-MOJQB5TN-Di52TorW.js";import{t as o}from"./chunk-JWPE2WC7-DawOjNE3.js";import{t as s}from"./mermaid-parser.core-XUNZhr2W.js";var c=e().RailroadAbnf.parser.LangiumParser,l=t(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=t(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=t(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=t(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=t(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=t(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=t(e=>{o(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:t(e=>{a.clear(),n.debug(`[ABNF Parser] Starting Langium parse`);let t=c.parse(e);if(t.lexerErrors.length>0||t.parserErrors.length>0)throw new s(t);let r=t.value;n.debug(`[ABNF Parser] Parsed rules:`,r.rules.length),h(r),n.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:i,styles:r};export{g as diagram};