@cjhyy/code-shell-server 0.9.7 → 0.9.9

package/dist/session-titles-store.d.ts

@@ -0,0 +1,17 @@
+/** Durable UI-side session titles, keyed by canonical engine session id. */
+interface TitleMap {
+    [sessionId: string]: string;
+}
+export declare class SessionTitleConflictError extends Error {
+    constructor();
+}
+/** Independent host stores share the same atomic title persistence and cross-process lock. */
+export declare function createSessionTitlesStore(file: string, options?: {
+    strictMutations?: boolean;
+}): {
+    listTitles: () => Promise<TitleMap>;
+    setTitle: (id: string, title: string, expected?: {
+        expectedTitle?: string | null;
+    }) => Promise<void>;
+};
+export {};

package/dist/session-titles-store.js

@@ -0,0 +1,174 @@
+/** Durable UI-side session titles, keyed by canonical engine session id. */
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { acquireLockOnPath } from "@cjhyy/code-shell-core/internal";
+const MAX_TITLE_ENTRIES = 20_000;
+const MAX_SESSION_ID_LENGTH = 256;
+const MAX_TITLE_LENGTH = 1_024;
+const MAX_TITLE_FILE_BYTES = 4 * 1024 * 1024;
+const FORBIDDEN_MAP_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+export class SessionTitleConflictError extends Error {
+    constructor() {
+        super("Session title changed on another device");
+        this.name = "SessionTitleConflictError";
+    }
+}
+function validSessionId(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= MAX_SESSION_ID_LENGTH &&
+        !FORBIDDEN_MAP_KEYS.has(value) &&
+        /^[A-Za-z0-9._-]+$/.test(value));
+}
+function validTitle(value) {
+    return typeof value === "string" && value.length <= MAX_TITLE_LENGTH && !value.includes("\0");
+}
+function parseTitleMap(value, strict = false) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        if (strict)
+            throw new Error("session title registry is malformed");
+        return Object.create(null);
+    }
+    if (strict && Object.keys(value).length > MAX_TITLE_ENTRIES)
+        throw new Error("session title registry contains too many entries");
+    const result = Object.create(null);
+    for (const [id, title] of Object.entries(value).slice(0, MAX_TITLE_ENTRIES)) {
+        if (!validSessionId(id) || !validTitle(title)) {
+            if (strict)
+                throw new Error("session title registry contains malformed entries");
+            continue;
+        }
+        if (strict || title)
+            result[id] = title;
+    }
+    return result;
+}
+function load(target, strict = false) {
+    let descriptor;
+    try {
+        const entry = fs.lstatSync(target);
+        if (entry.isSymbolicLink() || !entry.isFile() || entry.size > MAX_TITLE_FILE_BYTES)
+            throw new Error("session title registry must be a bounded regular file");
+        descriptor = fs.openSync(target, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+        const opened = fs.fstatSync(descriptor);
+        if (!opened.isFile() || opened.size > MAX_TITLE_FILE_BYTES)
+            throw new Error("session title registry must be a bounded regular file");
+        // A concurrent append must not turn a checked four-megabyte file into an
+        // unbounded allocation. Read at most the limit plus one sentinel byte.
+        const buffer = Buffer.alloc(Math.min(opened.size + 1, MAX_TITLE_FILE_BYTES + 1));
+        let bytes = 0;
+        while (bytes < buffer.length) {
+            const count = fs.readSync(descriptor, buffer, bytes, buffer.length - bytes, bytes);
+            if (!count)
+                break;
+            bytes += count;
+        }
+        if (bytes > opened.size || bytes > MAX_TITLE_FILE_BYTES)
+            throw new Error("session title registry changed during read");
+        return parseTitleMap(JSON.parse(buffer.subarray(0, bytes).toString("utf8")), strict);
+    }
+    catch (error) {
+        if (strict && error.code !== "ENOENT")
+            throw error;
+        return Object.create(null);
+    }
+    finally {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+    }
+}
+function save(target, map) {
+    const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        const parent = path.dirname(target);
+        fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+        const parentInfo = fs.lstatSync(parent);
+        if (parentInfo.isSymbolicLink() || !parentInfo.isDirectory())
+            throw new Error("session title directory must be a real directory");
+        try {
+            const targetInfo = fs.lstatSync(target);
+            if (targetInfo.isSymbolicLink() || !targetInfo.isFile())
+                throw new Error("session title target must be a regular file");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const serialized = `${JSON.stringify(map, null, 2)}\n`;
+        if (Buffer.byteLength(serialized, "utf8") > MAX_TITLE_FILE_BYTES)
+            throw new Error("session title registry is too large");
+        fs.writeFileSync(temporary, serialized, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        fs.renameSync(temporary, target);
+    }
+    finally {
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch {
+            /* preserve the original write error */
+        }
+    }
+}
+/** Independent host stores share the same atomic title persistence and cross-process lock. */
+export function createSessionTitlesStore(file, options = {}) {
+    let mutationQueue = Promise.resolve();
+    function serializeMutation(mutation) {
+        const target = file;
+        const result = mutationQueue.then(() => mutation(target));
+        mutationQueue = result.catch(() => undefined);
+        return result;
+    }
+    async function listTitles() {
+        await mutationQueue.catch(() => undefined);
+        return load(file);
+    }
+    function setTitle(id, title, expected = {}) {
+        if (!validSessionId(id))
+            throw new Error("invalid session id");
+        if (!validTitle(title))
+            throw new Error("invalid session title");
+        if (expected.expectedTitle !== undefined &&
+            expected.expectedTitle !== null &&
+            !validTitle(expected.expectedTitle))
+            throw new Error("invalid expected session title");
+        return serializeMutation((target) => {
+            const parent = path.dirname(target);
+            fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+            const parentInfo = fs.lstatSync(parent);
+            if (parentInfo.isSymbolicLink() || !parentInfo.isDirectory()) {
+                throw new Error("session title directory must be a real directory");
+            }
+            // A volume root such as /data is writable while its parent / is not.
+            // Keep both the lock anchor and its sibling lock inside that volume.
+            const anchor = path.join(parent, `.${path.basename(target)}.mutex`);
+            fs.mkdirSync(anchor, { recursive: true, mode: 0o700 });
+            const anchorInfo = fs.lstatSync(anchor);
+            if (!anchorInfo.isDirectory() || anchorInfo.isSymbolicLink())
+                throw new Error("session title lock anchor must be a real directory");
+            // No await inside this synchronous cross-process lock: a second store
+            // instance must never block the event loop while this holder waits for I/O.
+            const release = acquireLockOnPath(anchor);
+            try {
+                const map = load(target, options.strictMutations);
+                if (expected.expectedTitle !== undefined &&
+                    (map[id] ?? "") !== (expected.expectedTitle ?? ""))
+                    throw new SessionTitleConflictError();
+                if (title) {
+                    if (!(id in map) && Object.keys(map).length >= MAX_TITLE_ENTRIES) {
+                        throw new Error("session title registry is full");
+                    }
+                    map[id] = title;
+                }
+                else
+                    delete map[id];
+                save(target, map);
+            }
+            finally {
+                release();
+            }
+        });
+    }
+    return { listTitles, setTitle };
+}

package/dist/static-files.js

@@ -9,6 +9,7 @@ const CONTENT_TYPES = {
     ".mjs": "text/javascript; charset=utf-8",
     ".css": "text/css; charset=utf-8",
     ".json": "application/json; charset=utf-8",
+    ".webmanifest": "application/manifest+json; charset=utf-8",
     ".svg": "image/svg+xml",
     ".png": "image/png",
     ".jpg": "image/jpeg",

package/dist/worker-bridge-core.js

@@ -195,6 +195,8 @@ export class WorkerBridgeCore {
         catch {
             return false;
         }
+        if (!msg || typeof msg !== "object" || Array.isArray(msg))
+            return false;
         if (msg.id === undefined || msg.id === null)
             return false;
         const pending = this.pendingRequests.get(msg.id);
@@ -288,12 +290,21 @@ export class WorkerBridgeCore {
                 settleOnExit: options.settleOnExit === true,
                 settle,
             });
-            const rawFrame = JSON.stringify({
-                jsonrpc: "2.0",
-                id,
-                method,
-                ...(params === undefined ? {} : { params }),
-            });
+            let rawFrame;
+            try {
+                rawFrame = JSON.stringify({
+                    jsonrpc: "2.0",
+                    id,
+                    method,
+                    ...(params === undefined ? {} : { params }),
+                });
+            }
+            catch (error) {
+                // Invalid params can never reach the wire. Honor the never-rejecting
+                // outcome contract and clear their correlation/timer immediately.
+                settle({ status: "sendFailed", error });
+                return;
+            }
             let sent = false;
             let sendError;
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-server",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "description": "CodeShell server transport layer — mobile remote HTTP/WS host, pairing, passcode gate, tunnel, rooms, uploads, and session/attachment services. Electron-free; precursor of the auth gateway.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,6 +25,18 @@
     "./serve": {
       "types": "./dist/index.serve.d.ts",
       "import": "./dist/index.serve.js"
+    },
+    "./desktop-web": {
+      "types": "./dist/index.desktop-web.d.ts",
+      "import": "./dist/index.desktop-web.js"
+    },
+    "./links": {
+      "types": "./dist/index.links.d.ts",
+      "import": "./dist/index.links.js"
+    },
+    "./panels": {
+      "types": "./dist/index.panels.d.ts",
+      "import": "./dist/index.panels.js"
     }
   },
   "bin": {
@@ -39,11 +51,13 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-capability-coding": "0.9.7",
-    "@cjhyy/code-shell-core": "0.9.7",
-    "@cjhyy/code-shell-web": "0.9.7",
+    "@cjhyy/code-shell-capability-coding": "0.9.9",
+    "@cjhyy/code-shell-core": "0.9.9",
+    "@cjhyy/code-shell-web": "0.9.9",
+    "@modelcontextprotocol/sdk": "^1.12.1",
     "@types/ws": "^8.18.1",
-    "ws": "^8.21.0"
+    "ws": "^8.21.0",
+    "@cjhyy/code-shell-link": "0.9.9"
   },
   "engines": {
     "node": ">=20.10"