mmm-mcp-server 0.1.0

package/dist/src/auth/firebaseAuthRest.js

@@ -0,0 +1,98 @@
+import { FIREBASE_API_KEY, FIREBASE_AUTH_DOMAIN } from "../firebaseConfig.js";
+const IDENTITY_TOOLKIT_BASE = "https://identitytoolkit.googleapis.com/v1";
+const SECURE_TOKEN_URL = "https://securetoken.googleapis.com/v1/token";
+export class FirebaseAuthError extends Error {
+    raw;
+    constructor(message, raw) {
+        super(message);
+        this.raw = raw;
+        this.name = "FirebaseAuthError";
+    }
+}
+/** レスポンスがJSONでない(障害時のHTMLエラーページ等)場合でも例外にせず読む。 */
+async function parseJsonResponse(res) {
+    const text = await res.text();
+    try {
+        return text ? JSON.parse(text) : {};
+    }
+    catch {
+        return { error: { message: text || `HTTP ${res.status}` } };
+    }
+}
+async function postJson(url, body) {
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    const data = await parseJsonResponse(res);
+    if (!res.ok) {
+        const message = data?.error?.message ?? `HTTP ${res.status}`;
+        throw new FirebaseAuthError(String(message), data);
+    }
+    return data;
+}
+/** メール+パスワードでサインインする(Firebase Auth REST API)。 */
+export async function signInWithPassword(email, password) {
+    const data = await postJson(`${IDENTITY_TOOLKIT_BASE}/accounts:signInWithPassword?key=${FIREBASE_API_KEY}`, {
+        email,
+        password,
+        returnSecureToken: true,
+    });
+    return {
+        idToken: data.idToken,
+        refreshToken: data.refreshToken,
+        localId: data.localId,
+        email: data.email ?? null,
+    };
+}
+/**
+ * 第三者IdP(Google/Apple)のIDトークンをFirebaseの認証情報に交換する。
+ * `providerId`は"google.com"または"apple.com"。
+ * Appleでnonceを使った場合は元のnonce文字列(SHA-256化する前の値)を渡す。
+ */
+export async function signInWithIdp(providerId, idpIdToken, nonce) {
+    let postBody = `id_token=${encodeURIComponent(idpIdToken)}&providerId=${providerId}`;
+    if (nonce) {
+        postBody += `&nonce=${encodeURIComponent(nonce)}`;
+    }
+    const data = await postJson(`${IDENTITY_TOOLKIT_BASE}/accounts:signInWithIdp?key=${FIREBASE_API_KEY}`, {
+        postBody,
+        requestUri: `https://${FIREBASE_AUTH_DOMAIN}`,
+        returnSecureToken: true,
+        returnIdpCredential: true,
+    });
+    return {
+        idToken: data.idToken,
+        refreshToken: data.refreshToken,
+        localId: data.localId,
+        email: data.email ?? null,
+    };
+}
+/** refresh_tokenから新しいIDトークンを取得する。 */
+export async function refreshIdToken(refreshToken) {
+    const res = await fetch(`${SECURE_TOKEN_URL}?key=${FIREBASE_API_KEY}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "refresh_token",
+            refresh_token: refreshToken,
+        }),
+    });
+    const data = (await parseJsonResponse(res));
+    if (!res.ok) {
+        const message = data.error?.message ?? `HTTP ${res.status}`;
+        throw new FirebaseAuthError(String(message), data);
+    }
+    return {
+        idToken: data.id_token,
+        refreshToken: data.refresh_token,
+        userId: data.user_id,
+        expiresInSec: Number(data.expires_in),
+    };
+}
+/** 現在のアカウントのメールアドレスなどを取得する(accounts:lookup)。 */
+export async function lookupAccountEmail(idToken) {
+    const data = await postJson(`${IDENTITY_TOOLKIT_BASE}/accounts:lookup?key=${FIREBASE_API_KEY}`, { idToken });
+    return data.users[0]?.email ?? null;
+}

package/dist/src/auth/googleLoopback.js

@@ -0,0 +1,93 @@
+import { createServer } from "node:http";
+import { randomBytes, createHash } from "node:crypto";
+import open from "open";
+import { loadGoogleOAuthClientConfig } from "./googleOAuthConfig.js";
+const AUTH_ENDPOINT = "https://accounts.google.com/o/oauth2/v2/auth";
+const TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
+function base64url(buffer) {
+    return buffer
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+/**
+ * `gcloud auth login`と同種のローカルループバック方式でGoogleにサインインし、
+ * IDトークン(JWT、Firebaseへの交換に使う)を返す。
+ */
+export async function signInWithGoogleLoopback() {
+    const { client_id, client_secret } = loadGoogleOAuthClientConfig();
+    const codeVerifier = base64url(randomBytes(32));
+    const codeChallenge = base64url(createHash("sha256").update(codeVerifier).digest());
+    const state = base64url(randomBytes(16));
+    const idToken = await new Promise((resolve, reject) => {
+        const server = createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url ?? "/", "http://127.0.0.1");
+                if (url.pathname !== "/") {
+                    res.writeHead(404).end();
+                    return;
+                }
+                const returnedState = url.searchParams.get("state");
+                const code = url.searchParams.get("code");
+                const errorParam = url.searchParams.get("error");
+                if (errorParam) {
+                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                    res.end("<p>ログインがキャンセルされました。このタブは閉じて構いません。</p>");
+                    server.close();
+                    reject(new Error(`Google認証が拒否されました: ${errorParam}`));
+                    return;
+                }
+                if (returnedState !== state || !code) {
+                    res.writeHead(400).end("invalid state");
+                    return;
+                }
+                const port = server.address().port;
+                const tokenRes = await fetch(TOKEN_ENDPOINT, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                    body: new URLSearchParams({
+                        code,
+                        client_id,
+                        client_secret,
+                        redirect_uri: `http://127.0.0.1:${port}`,
+                        grant_type: "authorization_code",
+                        code_verifier: codeVerifier,
+                    }),
+                });
+                const tokenData = await tokenRes.json();
+                if (!tokenRes.ok || !tokenData.id_token) {
+                    throw new Error(tokenData.error_description ?? "Googleトークン交換に失敗しました");
+                }
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<p>Googleログインが完了しました。このタブは閉じてターミナルに戻ってください。</p>");
+                server.close();
+                resolve(tokenData.id_token);
+            }
+            catch (err) {
+                res.writeHead(500).end("internal error");
+                server.close();
+                reject(err);
+            }
+        });
+        server.listen(0, "127.0.0.1", () => {
+            const port = server.address().port;
+            const redirectUri = `http://127.0.0.1:${port}`;
+            const authUrl = new URL(AUTH_ENDPOINT);
+            authUrl.searchParams.set("client_id", client_id);
+            authUrl.searchParams.set("redirect_uri", redirectUri);
+            authUrl.searchParams.set("response_type", "code");
+            authUrl.searchParams.set("scope", "openid email profile");
+            authUrl.searchParams.set("state", state);
+            authUrl.searchParams.set("code_challenge", codeChallenge);
+            authUrl.searchParams.set("code_challenge_method", "S256");
+            authUrl.searchParams.set("prompt", "select_account");
+            console.log("ブラウザでGoogleのログイン画面を開きます…");
+            open(authUrl.toString()).catch(() => {
+                console.log(`自動で開けなかった場合は次のURLを開いてください:\n${authUrl.toString()}`);
+            });
+        });
+        server.on("error", reject);
+    });
+    return idToken;
+}

package/dist/src/auth/googleOAuthConfig.js

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { GOOGLE_OAUTH_CLIENT_ID, GOOGLE_OAUTH_CLIENT_SECRET } from "../firebaseConfig.js";
+const CONFIG_PATH = join(homedir(), ".config", "mmm-mcp", "google-oauth-client.json");
+/**
+ * GoogleログインのループバックOAuthに使うクライアント情報。
+ * 通常は全ユーザー共有のデフォルト(firebaseConfig.ts参照)をそのまま使う。
+ * 自分専用のOAuthクライアントを使いたい場合だけ、Google Cloud Consoleで
+ * 作成した「デスクトップアプリ」タイプのクライアントのJSON(`installed`の
+ * 中身)をこのパスに保存すれば、そちらが優先される。
+ */
+export function loadGoogleOAuthClientConfig() {
+    if (existsSync(CONFIG_PATH)) {
+        const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+        const installed = raw.installed ?? raw;
+        if (!installed.client_id || !installed.client_secret) {
+            throw new Error(`${CONFIG_PATH} の内容が不正です(client_id/client_secretが必要)。`);
+        }
+        return { client_id: installed.client_id, client_secret: installed.client_secret };
+    }
+    return { client_id: GOOGLE_OAUTH_CLIENT_ID, client_secret: GOOGLE_OAUTH_CLIENT_SECRET };
+}
+export function googleOAuthConfigPath() {
+    return CONFIG_PATH;
+}

package/dist/src/auth/session.js

@@ -0,0 +1,58 @@
+import { refreshIdToken } from "./firebaseAuthRest.js";
+import { loadCredentials, saveCredentials } from "./tokenStore.js";
+const EXPIRY_MARGIN_MS = 60_000;
+/**
+ * サインイン済みユーザーの有効なIDトークンを保証するセッション。
+ * refresh_tokenは使うたびに新しい値へローテーションされるため、
+ * 更新のたびにディスクへ書き戻す。
+ */
+export class AuthSession {
+    credentials;
+    idToken = null;
+    expiresAt = 0;
+    // 複数のツール呼び出しがほぼ同時にトークン切れを検知したとき、
+    // refresh_tokenを二重に消費すると(Firebaseはローテーションするため)
+    // 片方が古いトークンで上書きしてしまう。進行中の更新を使い回して防ぐ。
+    refreshing = null;
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    get uid() {
+        return this.credentials.uid;
+    }
+    get email() {
+        return this.credentials.email;
+    }
+    async getValidIdToken() {
+        if (this.idToken && Date.now() < this.expiresAt - EXPIRY_MARGIN_MS) {
+            return this.idToken;
+        }
+        if (!this.refreshing) {
+            this.refreshing = this.doRefresh().finally(() => {
+                this.refreshing = null;
+            });
+        }
+        return this.refreshing;
+    }
+    async doRefresh() {
+        const refreshed = await refreshIdToken(this.credentials.refreshToken);
+        this.idToken = refreshed.idToken;
+        this.expiresAt = Date.now() + refreshed.expiresInSec * 1000;
+        this.credentials = { ...this.credentials, refreshToken: refreshed.refreshToken };
+        saveCredentials(this.credentials);
+        return this.idToken;
+    }
+}
+export class NotSignedInError extends Error {
+    constructor() {
+        super("サインインしていません。ターミナルで `npx -y -p mmm-mcp-server mmm-login login --method google` を実行してください(email / apple も選べます。git clone して使っている場合は、そのフォルダで `npm run login -- login --method google`)。");
+        this.name = "NotSignedInError";
+    }
+}
+export function loadSession() {
+    const credentials = loadCredentials();
+    if (!credentials) {
+        throw new NotSignedInError();
+    }
+    return new AuthSession(credentials);
+}

package/dist/src/auth/tokenStore.js

@@ -0,0 +1,32 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".config", "mmm-mcp");
+const CREDENTIALS_PATH = join(CONFIG_DIR, "credentials.json");
+function ensureConfigDir() {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+}
+export function saveCredentials(credentials) {
+    ensureConfigDir();
+    writeFileSync(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2), {
+        mode: 0o600,
+    });
+}
+export function loadCredentials() {
+    if (!existsSync(CREDENTIALS_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(CREDENTIALS_PATH, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function clearCredentials() {
+    if (existsSync(CREDENTIALS_PATH)) {
+        rmSync(CREDENTIALS_PATH);
+    }
+}
+export function credentialsPath() {
+    return CREDENTIALS_PATH;
+}

package/dist/src/domain/appendForest.js

@@ -0,0 +1,82 @@
+import { newDocId } from "./idGen.js";
+import { lastChildOf } from "./body.js";
+/** ネストしたツリー入力を、ID採番済み・prev/next/parent/child関係を組んだ配列に変換する。 */
+export function buildForestFromTree(roots) {
+    const all = [];
+    function build(inputNodes, parentId) {
+        const level = [];
+        for (const input of inputNodes) {
+            const node = {
+                id: newDocId(),
+                detail: input.detail,
+                done: input.done ?? false,
+                parentId,
+                prevId: null,
+                nextId: null,
+                childId: null,
+            };
+            all.push(node);
+            level.push(node);
+            if (input.children && input.children.length > 0) {
+                const childLevel = build(input.children, node.id);
+                node.childId = childLevel[0].id;
+            }
+        }
+        for (let i = 1; i < level.length; i++) {
+            level[i].prevId = level[i - 1].id;
+            level[i - 1].nextId = level[i].id;
+        }
+        return level;
+    }
+    build(roots, null);
+    return all;
+}
+/**
+ * 組み立てたforest(森)を、既存の要素の[targetParentId]配下の末尾に連結する
+ * ためのFirestore書き込み一覧を作る。auto_structure_thought /
+ * import_markdown_context の両方から共通で使う。
+ *
+ * `isTodo`がfalseのマップでは、doneは常にfalseとして書き込む
+ * (MatryoshkaModel.importMarkdownと同じ挙動)。
+ */
+export function buildAppendWrites(bodiesPath, existingBodies, forest, targetParentId, isTodo) {
+    const roots = forest.filter((n) => n.parentId === null);
+    const last = lastChildOf(existingBodies, targetParentId);
+    if (roots.length > 0) {
+        roots[0].prevId = last;
+    }
+    const writes = forest.map((node) => ({
+        path: `${bodiesPath}/${node.id}`,
+        fields: {
+            detail: node.detail,
+            parent: node.parentId ?? targetParentId,
+            prev: node.prevId,
+            next: node.nextId,
+            child: node.childId,
+            done: isTodo ? node.done : false,
+        },
+    }));
+    if (roots.length > 0) {
+        if (last !== null) {
+            // 末尾要素のnextを書き換える。読み取り後に他の操作(並行するappendや
+            // アプリ操作)がこの要素を書き換えていた場合、requireUpdateTimeにより
+            // FAILED_PRECONDITIONで失敗する(呼び出し側はrunOptimisticで読み取り
+            // からやり直す)。
+            const lastBody = existingBodies.find((b) => b.id === last);
+            writes.push({
+                path: `${bodiesPath}/${last}`,
+                fields: { next: roots[0].id },
+                requireUpdateTime: lastBody?.updateTime,
+            });
+        }
+        else if (targetParentId !== null) {
+            const parentBody = existingBodies.find((b) => b.id === targetParentId);
+            writes.push({
+                path: `${bodiesPath}/${targetParentId}`,
+                fields: { child: roots[0].id },
+                requireUpdateTime: parentBody?.updateTime,
+            });
+        }
+    }
+    return { writes, createdIds: forest.map((n) => n.id) };
+}

package/dist/src/domain/body.js

@@ -0,0 +1,127 @@
+export function bodyFromFirestore(id, data, updateTime) {
+    return {
+        id,
+        detail: String(data.detail ?? ""),
+        prev: data.prev ?? null,
+        next: data.next ?? null,
+        parent: data.parent ?? null,
+        child: data.child ?? null,
+        done: Boolean(data.done ?? false),
+        updateTime,
+    };
+}
+/**
+ * 壊れている(prev/nextが循環・欠落している)データでも、要素を1件も
+ * 落とさずに返す。壊れ方の修復はアプリ本体(MatryoshkaModel.repair)の
+ * 役目であり、ここでは読み取り専用なので直さず、可能な範囲で順序を
+ * 復元しつつ全件を出す。
+ */
+export function buildTree(bodies) {
+    const globalVisited = new Set();
+    function orderedChildrenOf(parentId) {
+        const siblings = bodies.filter((b) => b.parent === parentId);
+        if (siblings.length === 0)
+            return [];
+        const bySelfId = new Map(siblings.map((b) => [b.id, b]));
+        const head = siblings.find((b) => b.prev === null || !bySelfId.has(b.prev));
+        const ordered = [];
+        const seen = new Set();
+        let current = head?.id ?? null;
+        while (current !== null && !seen.has(current)) {
+            const node = bySelfId.get(current);
+            if (!node)
+                break;
+            seen.add(current);
+            ordered.push(node);
+            current = node.next;
+        }
+        // next/prevの循環や分断で辿れなかった残りも、無くさず末尾に足す。
+        for (const s of siblings) {
+            if (!seen.has(s.id))
+                ordered.push(s);
+        }
+        return ordered;
+    }
+    function walk(parentId) {
+        const result = [];
+        for (const node of orderedChildrenOf(parentId)) {
+            if (globalVisited.has(node.id))
+                continue; // 循環参照からの二重取り込みを防ぐ
+            globalVisited.add(node.id);
+            result.push({
+                id: node.id,
+                detail: node.detail,
+                done: node.done,
+                parentId: node.parent,
+                children: walk(node.id),
+            });
+        }
+        return result;
+    }
+    const tree = walk(null);
+    // parentが存在しない要素を指している等で上のwalkから漏れた要素も、
+    // 最上位に足しておく(取りこぼしが無いことを優先する)。
+    for (const b of bodies) {
+        if (!globalVisited.has(b.id)) {
+            globalVisited.add(b.id);
+            tree.push({ id: b.id, detail: b.detail, done: b.done, parentId: b.parent, children: [] });
+        }
+    }
+    return tree;
+}
+/** ルートから[elementId]までの祖先(自分自身を含む)のdetailを、根から順に並べる。 */
+export function ancestorDetails(bodies, elementId) {
+    if (elementId === null)
+        return [];
+    const byId = new Map(bodies.map((b) => [b.id, b]));
+    const chain = [];
+    let current = elementId;
+    const seen = new Set();
+    while (current !== null && byId.has(current) && !seen.has(current)) {
+        seen.add(current);
+        const node = byId.get(current);
+        chain.push(node.detail);
+        current = node.parent;
+    }
+    return chain.reverse();
+}
+/** [parentId]の子の連結リストの末尾のIDを求める。子が無ければnull。 */
+export function lastChildOf(bodies, parentId) {
+    const siblings = bodies.filter((b) => b.parent === parentId);
+    if (siblings.length === 0)
+        return null;
+    const byId = new Map(siblings.map((b) => [b.id, b]));
+    let current = siblings.find((b) => b.prev === null || !byId.has(b.prev)) ?? siblings[0];
+    const seen = new Set([current.id]);
+    while (current.next !== null && byId.has(current.next) && !seen.has(current.next)) {
+        current = byId.get(current.next);
+        seen.add(current.id);
+    }
+    return current.id;
+}
+/**
+ * [rootId]自身とその配下(子孫)全ての id を集める。move/deleteのように
+ * 「要素ごと配下を丸ごと動かす・消す」操作の対象範囲を求めるために使う。
+ * 循環参照があっても無限ループしない。
+ */
+export function collectSubtreeIds(bodies, rootId) {
+    const byParent = new Map();
+    for (const b of bodies) {
+        const list = byParent.get(b.parent) ?? [];
+        list.push(b);
+        byParent.set(b.parent, list);
+    }
+    const result = [];
+    const seen = new Set();
+    function walk(id) {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        result.push(id);
+        for (const child of byParent.get(id) ?? []) {
+            walk(child.id);
+        }
+    }
+    walk(rootId);
+    return result;
+}

package/dist/src/domain/deleteElements.js

@@ -0,0 +1,85 @@
+import { collectSubtreeIds } from "./body.js";
+import { buildRemoveChildrenWrite } from "./levels.js";
+import { mergeWritesByPath } from "../firestore/restClient.js";
+/**
+ * [elementIds](配下ごと)を削除するための書き込みを組み立てる。tools/deleteElements.tsから
+ * 切り出した純粋寄りの関数(client.getDocumentだけ呼ぶ)。
+ *
+ * 1周目で消える要素を全て確定させてから2周目で繋ぎ直すのは、隣り合う要素を
+ * 同時に消すとき、1件ずつその場で繋ぎ直すと消える予定の相手を指すポインタを
+ * 書いてしまい、存在しないIDを指したまま残る不具合(実データで発生)を防ぐため。
+ */
+export async function buildDeleteElementWrites(client, bodiesPath, levelsPath, currentBodies, elementIds) {
+    const currentById = new Map(currentBodies.map((b) => [b.id, b]));
+    const writes = [];
+    const levelRemovals = new Map();
+    const allIds = new Set();
+    // 1周目: 消える要素を全て確定させる。繋ぎ直しは2周目で行う。
+    for (const elementId of elementIds) {
+        const body = currentById.get(elementId);
+        if (!body)
+            continue; // 既に削除済み(リトライ時など)
+        const subtree = collectSubtreeIds(currentBodies, elementId);
+        for (const id of subtree)
+            allIds.add(id);
+    }
+    /** [startId]から[key]方向へ、消えない要素に当たるまで辿る。 */
+    const survivingNeighbor = (startId, key) => {
+        let cursor = startId;
+        const seen = new Set();
+        while (cursor !== null && allIds.has(cursor) && !seen.has(cursor)) {
+            seen.add(cursor);
+            cursor = currentById.get(cursor)?.[key] ?? null;
+        }
+        return cursor;
+    };
+    // 2周目: 生き残る要素どうしを繋ぎ直す。
+    for (const elementId of elementIds) {
+        const body = currentById.get(elementId);
+        if (!body)
+            continue;
+        const newPrev = survivingNeighbor(body.prev, "prev");
+        const newNext = survivingNeighbor(body.next, "next");
+        if (newPrev !== null) {
+            writes.push({
+                path: `${bodiesPath}/${newPrev}`,
+                fields: { next: newNext },
+                requireUpdateTime: currentById.get(newPrev)?.updateTime,
+            });
+        }
+        else if (body.parent !== null && !allIds.has(body.parent)) {
+            writes.push({
+                path: `${bodiesPath}/${body.parent}`,
+                fields: { child: newNext },
+                requireUpdateTime: currentById.get(body.parent)?.updateTime,
+            });
+        }
+        if (newNext !== null) {
+            writes.push({
+                path: `${bodiesPath}/${newNext}`,
+                fields: { prev: newPrev },
+                requireUpdateTime: currentById.get(newNext)?.updateTime,
+            });
+        }
+        const levelId = body.parent ?? "root";
+        const list = levelRemovals.get(levelId) ?? [];
+        list.push(elementId);
+        levelRemovals.set(levelId, list);
+    }
+    for (const id of allIds) {
+        writes.push({ path: `${bodiesPath}/${id}`, delete: true });
+        // 配下の要素が子を持っていた場合、そのlevelsドキュメント自体も消す。
+        // 存在しないドキュメントへのdeleteはFirestoreでは無害。
+        writes.push({ path: `${levelsPath}/${id}`, delete: true });
+    }
+    for (const [levelId, removeIds] of levelRemovals) {
+        // 親自身も消えるなら、levels/{親} は上のdeleteで消える。
+        // ここで書き戻すと、消したドキュメントが中身入りで復活する。
+        if (allIds.has(levelId))
+            continue;
+        const write = await buildRemoveChildrenWrite(client, levelsPath, levelId, removeIds);
+        if (write)
+            writes.push(write);
+    }
+    return { writes: mergeWritesByPath(writes), deletedIds: allIds };
+}

package/dist/src/domain/header.js

@@ -0,0 +1,27 @@
+function aiReadPermissionFromFirestore(value) {
+    return value === "allow" || value === "deny" ? value : "ask";
+}
+/**
+ * Firestoreのheaderドキュメントから組み立てる。
+ * 旧`shares`フィールド(役割の区別が無い、常に編集者扱い)しか無い
+ * 既存ドキュメントとの後方互換はHeader.fromFirestore(Dart側)と同じ。
+ */
+export function headerFromFirestore(id, ownerUid, data) {
+    const editors = data.editors ?? data.shares ?? [];
+    return {
+        id,
+        ownerUid,
+        title: String(data.title ?? ""),
+        order: Number(data.order ?? 0),
+        isTodo: Boolean(data.isTodo ?? false),
+        editors,
+        viewers: data.viewers ?? [],
+        aiReadPermission: aiReadPermissionFromFirestore(data.aiReadPermission),
+    };
+}
+/** 自分がこのマップを編集できるか(所有者か、editorsに含まれる共有先か)。Header.canEdit(Dart側)と同じ。 */
+export function canEditHeader(header, uid, email) {
+    if (uid === header.ownerUid)
+        return true;
+    return email !== null && header.editors.includes(email);
+}

package/dist/src/domain/idGen.js

@@ -0,0 +1,11 @@
+import { randomBytes } from "node:crypto";
+const CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+/** Firestoreの自動ID発行(20文字のランダム文字列)相当のIDを生成する。 */
+export function newDocId() {
+    const bytes = randomBytes(20);
+    let id = "";
+    for (let i = 0; i < 20; i++) {
+        id += CHARS[bytes[i] % CHARS.length];
+    }
+    return id;
+}