@dooc-dev/dooc 0.0.1 → 0.0.2

package/dist/plugins/blocks.d.ts

@@ -75,18 +75,19 @@ export type PluginBlock = {
 } | {
     type: "divider";
 };
+export interface PluginIcon {
+    light: string;
+    dark?: string;
+}
 export interface PluginBlockContent {
-    format: "blocks";
     header?: {
         title: string;
         context?: string;
         reference?: string;
-        icon?: {
-            light: string;
-            dark?: string;
-        };
+        icon?: PluginIcon;
     };
     blocks: PluginBlock[];
 }
 export declare const pluginLink: (value: unknown) => value is string;
+export declare const validPluginIcon: (value: unknown) => value is PluginIcon;
 export declare const validPluginBlocks: (value: unknown) => value is PluginBlockContent;

package/dist/plugins/blocks.js

@@ -17,6 +17,7 @@ export const pluginLink = (value) => {
 const icon = (value) => typeof value === "string" &&
     value.length <= 100_000 &&
     /^data:image\/(?:svg\+xml|png|webp);base64,[A-Za-z0-9+/]+={0,2}$/.test(value);
+export const validPluginIcon = (value) => record(value) && icon(value.light) && optional(value.dark, icon);
 const edit = (value) => record(value) && text(value.action) && optional(value.field, text);
 const inlines = (value) => array(value, (item) => text(item) ||
     (record(item) &&
@@ -89,11 +90,11 @@ export const validPluginBlocks = (value) => {
             }
         });
     return (record(value) &&
-        value.format === "blocks" &&
+        !("format" in value) &&
         blocks(value.blocks, 0) &&
         optional(value.header, (h) => record(h) &&
             text(h.title) &&
             optional(h.context, text) &&
             optional(h.reference, text) &&
-            optional(h.icon, (v) => record(v) && icon(v.light) && optional(v.dark, icon))));
+            optional(h.icon, validPluginIcon)));
 };

package/dist/plugins/index.d.ts

@@ -1,4 +1,4 @@
 export type { PluginAction, PluginActionContext, PluginActionField, PluginActionRequest, PluginActionResult, } from "./actions.js";
-export type { PluginBlock, PluginBlockContent, PluginCell, PluginEdit, PluginInline, PluginTone, } from "./blocks.js";
+export type { PluginBlock, PluginBlockContent, PluginCell, PluginEdit, PluginIcon, PluginInline, PluginTone, } from "./blocks.js";
 export { PluginError, parseOAuthToken } from "./oauth.js";
 export type { DataPlugin, OAuthToken, PluginContent, PluginContext, PluginOAuth, PluginUser, PluginView, } from "./types.js";

package/dist/plugins/local-storage.d.ts

@@ -0,0 +1,18 @@
+import type { DataPlugin, OAuthToken, PluginUser } from "./types.js";
+export interface SavedConnection {
+    token: OAuthToken;
+    expires: number;
+    user: PluginUser;
+}
+export interface PluginCredentialStore {
+    get(plugin: DataPlugin): SavedConnection | undefined;
+    set(plugin: DataPlugin, value?: SavedConnection): void;
+    withLock?<T>(plugin: DataPlugin, run: () => Promise<T>): Promise<T>;
+}
+/** Personal state is outside document roots and never included in exported bundles. */
+export declare const createLocalPluginStorage: (userDir?: string) => {
+    read: (name: string) => unknown;
+    write: (name: string, value: unknown) => void;
+    credentials: PluginCredentialStore;
+};
+export type LocalPluginStorage = ReturnType<typeof createLocalPluginStorage>;

package/dist/plugins/local-storage.js

@@ -0,0 +1,115 @@
+import { createHash, randomBytes } from "node:crypto";
+import { lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { parseOAuthToken } from "./oauth.js";
+/** Personal state is outside document roots and never included in exported bundles. */
+export const createLocalPluginStorage = (userDir = process.env.DOOC_USER_DIR ?? join(homedir(), ".dooc")) => {
+    const folder = join(userDir, "plugins");
+    const path = (name) => {
+        if (!/^[a-z]+-[a-f0-9]{64}\.json$/.test(name))
+            throw new Error("Invalid plugin storage key");
+        for (const directory of [userDir, folder]) {
+            const entry = lstatSync(directory, { throwIfNoEntry: false });
+            if (entry &&
+                (!entry.isDirectory() ||
+                    entry.isSymbolicLink() ||
+                    (process.platform !== "win32" &&
+                        ((entry.mode & 0o022) !== 0 || entry.uid !== process.getuid?.()))))
+                throw new Error("Personal plugin storage must be a local directory");
+        }
+        return join(folder, name);
+    };
+    const read = (name) => {
+        const file = path(name);
+        const entry = lstatSync(file, { throwIfNoEntry: false });
+        if (!entry)
+            return undefined;
+        if (!entry.isFile() ||
+            entry.isSymbolicLink() ||
+            entry.size > 1_048_576 ||
+            (process.platform !== "win32" &&
+                ((entry.mode & 0o077) !== 0 || entry.uid !== process.getuid?.())))
+            throw new Error("Personal plugin files must be private to the current user");
+        return JSON.parse(readFileSync(file, "utf8"));
+    };
+    const write = (name, value) => {
+        const file = path(name);
+        mkdirSync(folder, { recursive: true, mode: 0o700 });
+        const temporary = `${file}.${randomBytes(8).toString("hex")}.tmp`;
+        try {
+            writeFileSync(temporary, JSON.stringify(value), { flag: "wx", mode: 0o600 });
+            renameSync(temporary, file);
+        }
+        finally {
+            rmSync(temporary, { force: true });
+        }
+    };
+    const key = (plugin) => `credentials-${createHash("sha256")
+        .update(JSON.stringify([
+        plugin.id,
+        plugin.oauth.authorizationUrl,
+        plugin.oauth.tokenUrl,
+        plugin.oauth.clientId,
+        plugin.oauth.clientSecret ?? "",
+        [...plugin.oauth.scopes].sort(),
+        [...plugin.apiOrigins].sort(),
+        plugin.oauth.authorizationParams ?? {},
+    ]))
+        .digest("hex")}.json`;
+    const credentials = {
+        get(plugin) {
+            const value = read(key(plugin));
+            if (!value)
+                return undefined;
+            const token = parseOAuthToken(value.token);
+            if (!value.user ||
+                typeof value.user.id !== "string" ||
+                !value.user.id ||
+                value.user.id.length > 512 ||
+                typeof value.user.name !== "string" ||
+                !value.user.name ||
+                value.user.name.length > 512 ||
+                (value.expires !== null &&
+                    (typeof value.expires !== "number" || !Number.isFinite(value.expires))))
+                throw new Error("Invalid saved plugin login");
+            return { token, user: value.user, expires: value.expires ?? Infinity };
+        },
+        set(plugin, value) {
+            write(key(plugin), value ?? null);
+        },
+        async withLock(plugin, run) {
+            const lock = `${path(key(plugin))}.lock`;
+            mkdirSync(folder, { recursive: true, mode: 0o700 });
+            const owner = randomBytes(16).toString("hex");
+            const deadline = Date.now() + 20000;
+            while (true) {
+                try {
+                    writeFileSync(lock, owner, { flag: "wx", mode: 0o600 });
+                    break;
+                }
+                catch (error) {
+                    if (error.code !== "EEXIST")
+                        throw error;
+                    const entry = lstatSync(lock, { throwIfNoEntry: false });
+                    if (entry?.isSymbolicLink())
+                        throw new Error("Invalid login lock");
+                    if (entry && Date.now() - entry.mtimeMs > 30000)
+                        rmSync(lock, { force: true });
+                    if (Date.now() >= deadline)
+                        throw new Error("Another dooc process is refreshing this login. Try again.");
+                    await delay(50);
+                }
+            }
+            try {
+                return await run();
+            }
+            finally {
+                if (readFileSync(lock, "utf8") === owner)
+                    rmSync(lock, { force: true });
+            }
+        },
+    };
+    return { read, write, credentials };
+};

package/dist/plugins/oauth.js

@@ -1,3 +1,4 @@
+import { validPluginIcon } from "./blocks.js";
 export class PluginError extends Error {
     status;
     name = "DoocPluginError";
@@ -112,6 +113,11 @@ export const validatePlugins = (input) => {
         ids.add(plugin.id);
         const oauth = plugin.oauth;
         if (!oauth ||
+            (plugin.name !== undefined &&
+                (typeof plugin.name !== "string" ||
+                    !plugin.name.trim() ||
+                    plugin.name.length > 100)) ||
+            (plugin.icon !== undefined && !validPluginIcon(plugin.icon)) ||
             typeof oauth.clientId !== "string" ||
             !oauth.clientId.trim() ||
             (oauth.clientSecret !== undefined && typeof oauth.clientSecret !== "string") ||

package/dist/plugins/runtime.d.ts

@@ -1,6 +1,7 @@
 import { type PluginActionResult } from "./actions.js";
+import type { PluginCredentialStore } from "./local-storage.js";
 import type { DataPlugin, PluginUser } from "./types.js";
-export declare const createPluginRuntime: (definitions: readonly DataPlugin[], transport?: typeof fetch) => {
+export declare const createPluginRuntime: (definitions: readonly DataPlugin[], transport?: typeof fetch, credentials?: PluginCredentialStore) => {
     resolve(source: unknown): string | undefined;
     register(plugin: DataPlugin): void;
     unregister: (pluginId: string) => void;
@@ -9,6 +10,7 @@ export declare const createPluginRuntime: (definitions: readonly DataPlugin[], t
     connect(id: string, pluginId: string, redirectUri: string): string;
     callback(id: string, pluginId: string, redirectUri: string, params: URLSearchParams): Promise<void>;
     disconnect(id: string, pluginId: string): void;
+    status(id: string, pluginId: string): PluginUser | undefined;
     read(id: string, pluginId: string, source: unknown): Promise<{
         user: PluginUser;
         view: import("./view.js").PluginView;

package/dist/plugins/runtime.js

@@ -5,9 +5,9 @@ import { parsePluginUrl, validatePluginView } from "./view.js";
 const nonce = () => randomBytes(32).toString("base64url");
 const expired = () => new PluginError(401, "Connect this plugin again");
 const expiry = (token) => token.expires_in === undefined ? Infinity : Date.now() + token.expires_in * 1000;
-export const createPluginRuntime = (definitions, transport) => {
+export const createPluginRuntime = (definitions, transport, credentials) => {
     const plugins = new Map(validatePlugins(definitions).map((plugin) => [plugin.id, plugin]));
-    // shortcut: sessions and tokens live in memory for eight hours; add an OS credential store for persistent login.
+    // Browser sessions expire independently of optional personal credential persistence.
     const sessions = new Map();
     const sessionFor = (id) => {
         const session = sessions.get(id);
@@ -96,27 +96,62 @@ export const createPluginRuntime = (definitions, transport) => {
         const plugin = pluginFor(pluginId);
         if (!plugin.matches(url))
             throw new PluginError(400, "URL is not supported by this plugin");
-        const connection = session.connections.get(pluginId);
-        if (!connection)
+        let restored = session.connections.get(pluginId);
+        if (credentials) {
+            const saved = credentials.get(plugin);
+            if (!saved) {
+                session.connections.delete(pluginId);
+                throw expired();
+            }
+            if (!restored || restored.user.id !== saved.user.id) {
+                restored = saved;
+                session.connections.set(pluginId, restored);
+            }
+            else if (restored.token.access_token !== saved.token.access_token) {
+                restored.token = saved.token;
+                restored.expires = saved.expires;
+            }
+        }
+        if (!restored)
             throw expired();
+        const connection = restored;
         try {
             if (connection.expires <= Date.now() + 30_000) {
                 const refreshToken = connection.token.refresh_token;
                 if (!refreshToken)
                     throw expired();
                 connection.refreshing ??= (async () => {
-                    try {
+                    const refresh = async () => {
+                        const saved = credentials?.get(plugin);
+                        if (credentials && (!saved || saved.user.id !== connection.user.id))
+                            throw expired();
+                        if (saved && saved.token.access_token !== connection.token.access_token) {
+                            connection.token = saved.token;
+                            connection.expires = saved.expires;
+                            if (connection.expires > Date.now() + 30_000)
+                                return;
+                        }
+                        const previous = connection.token.access_token;
+                        const usedRefresh = connection.token.refresh_token ?? refreshToken;
                         const token = await exchange(plugin, {
                             grant_type: "refresh_token",
-                            refresh_token: refreshToken,
+                            refresh_token: usedRefresh,
                         });
                         assertCurrent(id, pluginId, connection);
+                        if (credentials && credentials.get(plugin)?.token.access_token !== previous)
+                            throw expired();
                         connection.token = {
                             ...token,
-                            refresh_token: token.refresh_token ?? refreshToken,
+                            refresh_token: token.refresh_token ?? usedRefresh,
                             scope: token.scope ?? connection.token.scope,
                         };
                         connection.expires = expiry(token);
+                        credentials?.set(plugin, connection);
+                    };
+                    try {
+                        await (credentials?.withLock
+                            ? credentials.withLock(plugin, refresh)
+                            : refresh());
                     }
                     finally {
                         connection.refreshing = undefined;
@@ -132,8 +167,12 @@ export const createPluginRuntime = (definitions, transport) => {
         catch (error) {
             if (isPluginError(error) &&
                 error.status === 401 &&
-                session.connections.get(pluginId) === connection)
+                session.connections.get(pluginId) === connection) {
                 session.connections.delete(pluginId);
+                const saved = credentials?.get(plugin);
+                if (saved?.token.access_token === connection.token.access_token)
+                    credentials?.set(plugin);
+            }
             throw error;
         }
     };
@@ -196,6 +235,10 @@ export const createPluginRuntime = (definitions, transport) => {
                 expires: Date.now() + 10 * 60 * 1000,
             };
             session.connections.delete(pluginId);
+            credentials?.set(plugin);
+            if (credentials)
+                for (const other of sessions.values())
+                    other.connections.delete(pluginId);
             session.attempts.set(pluginId, attempt);
             const url = new URL(plugin.oauth.authorizationUrl);
             for (const [key, value] of Object.entries(plugin.oauth.authorizationParams ?? {}))
@@ -246,16 +289,29 @@ export const createPluginRuntime = (definitions, transport) => {
             if (sessionFor(id).attempts.get(pluginId) !== attempt)
                 throw expired();
             session.attempts.delete(pluginId);
-            session.connections.set(pluginId, {
-                token,
-                expires,
-                user: { id: user.id, name: user.name },
-            });
+            const connection = { token, expires, user: { id: user.id, name: user.name } };
+            credentials?.set(plugin, connection);
+            session.connections.set(pluginId, connection);
         },
         disconnect(id, pluginId) {
             const session = sessionFor(id);
             session.connections.delete(pluginId);
             session.attempts.delete(pluginId);
+            credentials?.set(pluginFor(pluginId));
+            if (credentials)
+                for (const other of sessions.values())
+                    other.connections.delete(pluginId);
+        },
+        status(id, pluginId) {
+            const plugin = pluginFor(pluginId);
+            const session = sessionFor(id);
+            const connection = credentials
+                ? credentials.get(plugin)
+                : session.connections.get(pluginId);
+            if (!connection ||
+                (connection.expires <= Date.now() && !connection.token.refresh_token))
+                return undefined;
+            return { ...connection.user };
         },
         read(id, pluginId, source) {
             return access(id, pluginId, source, async (plugin, url, connection) => ({

package/dist/plugins/types.d.ts

@@ -32,10 +32,13 @@ export interface PluginContext {
 }
 export type { PluginContent, PluginView } from "./view.js";
 import type { PluginAction, PluginActionContext, PluginActionRequest, PluginActionResult } from "./actions.js";
+import type { PluginIcon } from "./blocks.js";
 import type { PluginView } from "./view.js";
 /** Trusted server code injected into the viewer, independently of document configuration. */
 export interface DataPlugin {
     id: string;
+    name?: string;
+    icon?: PluginIcon;
     /** Match a service URL without fetching it; unmatched embeds remain ordinary links. */
     matches: (url: URL) => boolean;
     oauth: PluginOAuth;

package/dist/plugins/view.d.ts

@@ -1,27 +1,5 @@
 import { type PluginBlockContent } from "./blocks.js";
-export type PluginContent = PluginBlockContent | {
-    format: "html";
-    html: string;
-    height?: number | "auto";
-} | {
-    format: "json";
-    preset: "card";
-    title: string;
-    text: string;
-} | {
-    format: "json";
-    preset: "list";
-    items: string[];
-} | {
-    format: "json";
-    preset: "table";
-    headers: string[];
-    rows: (string | number | boolean | null)[][];
-} | {
-    format: "json";
-    preset: "code";
-    value: unknown;
-};
+export type PluginContent = PluginBlockContent;
 export type PluginView = PluginContent & {
     collapsed?: PluginContent;
 };

package/dist/plugins/view.js

@@ -1,44 +1,4 @@
 import { validPluginBlocks } from "./blocks.js";
-const validContent = (view) => {
-    let valid = false;
-    if (view && typeof view === "object") {
-        if (view.format === "blocks")
-            return validPluginBlocks(view);
-        if (view.format === "html")
-            valid =
-                typeof view.html === "string" &&
-                    (view.height === undefined ||
-                        view.height === "auto" ||
-                        (Number.isInteger(view.height) && view.height >= 32 && view.height <= 1200));
-        if (view.format === "json") {
-            switch (view.preset) {
-                case "card":
-                    valid = typeof view.title === "string" && typeof view.text === "string";
-                    break;
-                case "list":
-                    valid =
-                        Array.isArray(view.items) &&
-                            view.items.every((item) => typeof item === "string");
-                    break;
-                case "table":
-                    valid =
-                        Array.isArray(view.headers) &&
-                            view.headers.every((h) => typeof h === "string") &&
-                            Array.isArray(view.rows) &&
-                            view.rows.every((row) => Array.isArray(row) &&
-                                row.length === view.headers.length &&
-                                row.every((cell) => cell === null ||
-                                    ["string", "boolean"].includes(typeof cell) ||
-                                    (typeof cell === "number" && Number.isFinite(cell))));
-                    break;
-                case "code":
-                    valid = view.value !== undefined;
-                    break;
-            }
-        }
-    }
-    return valid;
-};
 export const validatePluginView = (input) => {
     const encoded = JSON.stringify(input);
     if (typeof encoded !== "string")
@@ -46,7 +6,8 @@ export const validatePluginView = (input) => {
     if (new TextEncoder().encode(encoded).length > 2 * 1024 * 1024)
         throw new Error("Plugin view is too large");
     const view = JSON.parse(encoded);
-    if (!validContent(view) || (view.collapsed !== undefined && !validContent(view.collapsed)))
+    if (!validPluginBlocks(view) ||
+        (view.collapsed !== undefined && !validPluginBlocks(view.collapsed)))
         throw new Error("Invalid plugin view");
     return view;
 };