@wendoo/bridge-app 0.2.2

package/dist/workspace-folder-project-store.js

@@ -0,0 +1,400 @@
+import { AppHostErrorCode, appHostError, applyProjectFileChangeToSnapshot, fileContentEquals, fileContentToWire, parseProjectContentManifest, serializeProjectContentManifest, WENDOO_JSON_PATH, } from "@wendoo/app-host";
+import { INSTALLED_EXTENSIONS_APP_DATA_KEY, serializeInstalledExtensionSnapshots, } from "./fetched-extension-snapshots.js";
+import { toFileSystemNotification, toProjectFileChange } from "./project-file-bridge.js";
+/** Project collection id of the single collection a workspace-folder store exposes. */
+export const WORKSPACE_FOLDER_PROJECT_COLLECTION_ID = "workspace-folder";
+/** Stable identifiers for workspace-folder store errors. */
+export const WorkspaceFolderStoreErrorCode = {
+    /** The host-provided `wendoo.json` failed content-manifest validation. */
+    INVALID_MANIFEST: "WORKSPACE_FOLDER_INVALID_MANIFEST",
+    /** A multi-project or collection-management operation was invoked; a workspace folder holds exactly one project. */
+    UNSUPPORTED_OPERATION: "WORKSPACE_FOLDER_UNSUPPORTED_OPERATION",
+};
+/** Error thrown by {@link WorkspaceFolderProjectStore}. */
+export class WorkspaceFolderStoreError extends Error {
+    /** Stable machine-readable error code. */
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "WorkspaceFolderStoreError";
+        this.code = code;
+    }
+}
+/** App-data key whose entries are stored as the manifest's `brains` chunk. */
+const BRAINS_APP_DATA_KEY = "brains";
+/** App-chunk map key inside the manifest's pass-through section. */
+const APP_CHUNKS_EXTRA_KEY = "app";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseRecord(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * A {@link ProjectStore} over a host-owned workspace folder: the folder is the
+ * single project of the store's single collection. File writes are
+ * change-granular; the project manifest and its app data are stored inside the
+ * folder's `wendoo.json` (brains and app chunks in the pass-through
+ * section, unknown fields preserved). Multi-project and collection-management
+ * operations throw {@link WorkspaceFolderStoreError}.
+ */
+export class WorkspaceFolderProjectStore {
+    keyPrefix;
+    rpc;
+    projectId;
+    appName;
+    appDataCodec;
+    collection;
+    base;
+    manifest;
+    appData = new Map();
+    chunkAppDataKeys = new Set();
+    lastManifestContent;
+    mirror = new Map();
+    constructor(options) {
+        this.keyPrefix = options.appName;
+        this.rpc = options.rpc;
+        this.projectId = options.projectId;
+        this.appName = options.appName;
+        this.appDataCodec = options.appDataCodec;
+        this.lastManifestContent = options.manifestContent;
+        const parsed = parseProjectContentManifest(options.manifestContent);
+        if (!parsed.ok) {
+            throw new WorkspaceFolderStoreError(WorkspaceFolderStoreErrorCode.INVALID_MANIFEST, `wendoo.json is not a valid project manifest: ${parsed.errors[0]?.message ?? "unknown error"}`);
+        }
+        this.base = parsed.manifest;
+        const now = Date.now();
+        this.collection = {
+            projectCollectionId: WORKSPACE_FOLDER_PROJECT_COLLECTION_ID,
+            name: parsed.manifest.name,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.manifest = {
+            id: this.projectId,
+            projectCollectionId: WORKSPACE_FOLDER_PROJECT_COLLECTION_ID,
+            name: parsed.manifest.name,
+            version: parsed.manifest.version,
+            description: parsed.manifest.description ?? "",
+            ...(parsed.manifest.thumbnailUrl !== undefined ? { thumbnailUrl: parsed.manifest.thumbnailUrl } : {}),
+            ...(Object.keys(parsed.manifest.extensions).length > 0 ? { extensions: parsed.manifest.extensions } : {}),
+            ...(parsed.manifest.targets !== undefined ? { targets: parsed.manifest.targets } : {}),
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.seedAppDataFromBase();
+        if (options.installedExtensionSnapshots && Object.keys(options.installedExtensionSnapshots).length > 0) {
+            this.appData.set(INSTALLED_EXTENSIONS_APP_DATA_KEY, serializeInstalledExtensionSnapshots(options.installedExtensionSnapshots));
+        }
+    }
+    /**
+     * Absorb a change observed on disk outside the app: a `wendoo.json`
+     * write replaces the store's manifest and app-data state; any other change
+     * updates the store's view of the folder. Returns the change in project
+     * file form for the caller to apply to the live project file system.
+     */
+    absorbExternalChange(change) {
+        if (change.action === "write" && change.path === WENDOO_JSON_PATH) {
+            this.lastManifestContent = change.content;
+            const parsed = parseProjectContentManifest(change.content);
+            if (parsed.ok) {
+                this.base = parsed.manifest;
+                this.manifest = {
+                    id: this.manifest.id,
+                    projectCollectionId: this.manifest.projectCollectionId,
+                    name: parsed.manifest.name,
+                    version: parsed.manifest.version,
+                    description: parsed.manifest.description ?? "",
+                    ...(parsed.manifest.thumbnailUrl !== undefined ? { thumbnailUrl: parsed.manifest.thumbnailUrl } : {}),
+                    ...(Object.keys(parsed.manifest.extensions).length > 0 ? { extensions: parsed.manifest.extensions } : {}),
+                    ...(parsed.manifest.targets !== undefined ? { targets: parsed.manifest.targets } : {}),
+                    createdAt: this.manifest.createdAt,
+                    updatedAt: Date.now(),
+                };
+                this.seedAppDataFromBase();
+            }
+        }
+        else {
+            applyProjectFileChangeToSnapshot(this.mirror, toProjectFileChange(change));
+        }
+        return toProjectFileChange(change);
+    }
+    // -- Project collections (single fixed collection) --
+    async listProjectCollections() {
+        return [this.collection];
+    }
+    async getProjectCollection(projectCollectionId) {
+        return projectCollectionId === this.collection.projectCollectionId ? this.collection : undefined;
+    }
+    async createProjectCollection() {
+        throw this.unsupported("createProjectCollection");
+    }
+    async updateProjectCollection() {
+        throw this.unsupported("updateProjectCollection");
+    }
+    async deleteProjectCollection() {
+        throw this.unsupported("deleteProjectCollection");
+    }
+    async ensureDefaultProjectCollection() {
+        return this.collection;
+    }
+    // -- Projects (single fixed project) --
+    async listProjects(projectCollectionId) {
+        return projectCollectionId === this.collection.projectCollectionId ? [{ ...this.manifest }] : [];
+    }
+    async countProjectsByCollection() {
+        return new Map([[this.collection.projectCollectionId, 1]]);
+    }
+    async getProject(id) {
+        return id === this.projectId ? { ...this.manifest } : undefined;
+    }
+    async createProject() {
+        throw this.unsupported("createProject");
+    }
+    async deleteProject() {
+        throw this.unsupported("deleteProject");
+    }
+    async updateProject(id, updates) {
+        this.requireProject(id);
+        this.manifest = { ...this.manifest, ...updates, updatedAt: Date.now() };
+        await this.writeManifestIfChanged();
+    }
+    async duplicateProject() {
+        throw this.unsupported("duplicateProject");
+    }
+    async copyProjectToCollection() {
+        throw this.unsupported("copyProjectToCollection");
+    }
+    // -- Project files --
+    async loadProjectFiles(id) {
+        this.requireProject(id);
+        const snapshot = await this.rpc.loadFiles();
+        snapshot.delete(WENDOO_JSON_PATH);
+        this.mirror = new Map(snapshot);
+        return new Map(snapshot);
+    }
+    async saveProjectFiles(id, snapshot) {
+        this.requireProject(id);
+        await this.writeSnapshotDiff(snapshot);
+    }
+    async applyProjectFileChanges(id, changes) {
+        this.requireProject(id);
+        for (const change of changes) {
+            if (touchesManifestFile(change)) {
+                continue;
+            }
+            if (change.action === "import") {
+                const target = new Map(change.entries);
+                await this.writeSnapshotDiff(target);
+                continue;
+            }
+            await this.rpc.sendChange(toFileSystemNotification(change));
+            applyProjectFileChangeToSnapshot(this.mirror, change);
+        }
+    }
+    // -- App data (carried in the manifest's pass-through section) --
+    async loadAppData(id, key) {
+        this.requireProject(id);
+        return this.appData.get(key);
+    }
+    async saveAppData(id, key, data) {
+        this.requireProject(id);
+        this.appData.set(key, data);
+        await this.writeManifestIfChanged();
+    }
+    async deleteAppData(id, key) {
+        this.requireProject(id);
+        this.appData.delete(key);
+        await this.writeManifestIfChanged();
+    }
+    // -- Tab session (fixed: the single folder project is always active) --
+    getProjectSession() {
+        return {
+            projectCollectionId: this.collection.projectCollectionId,
+            activeProjectId: this.projectId,
+        };
+    }
+    setProjectSession() {
+        // The folder project is the session; there is nothing to persist.
+    }
+    getLastOpenedProject() {
+        return {
+            projectCollectionId: this.collection.projectCollectionId,
+            projectId: this.projectId,
+        };
+    }
+    /** Ignores the write; this store's last opened project is always its folder project. */
+    setLastOpenedProject() { }
+    // -- Internals --
+    unsupported(operation) {
+        return new WorkspaceFolderStoreError(WorkspaceFolderStoreErrorCode.UNSUPPORTED_OPERATION, `${operation} is not available for a workspace-folder project`);
+    }
+    requireProject(id) {
+        if (id !== this.projectId) {
+            throw appHostError(AppHostErrorCode.PROJECT_NOT_FOUND, `Project not found: ${id}`);
+        }
+    }
+    seedAppDataFromBase() {
+        for (const key of this.chunkAppDataKeys) {
+            this.appData.delete(key);
+        }
+        const brains = this.base.extras?.brains;
+        if (isRecord(brains) && Object.keys(brains).length > 0) {
+            this.appData.set(BRAINS_APP_DATA_KEY, JSON.stringify(brains));
+        }
+        else {
+            this.appData.delete(BRAINS_APP_DATA_KEY);
+        }
+        if (!this.appDataCodec) {
+            this.chunkAppDataKeys = new Set();
+            return;
+        }
+        const appChunks = this.base.extras?.[APP_CHUNKS_EXTRA_KEY];
+        const ownChunk = isRecord(appChunks) ? appChunks[this.appName] : undefined;
+        const entries = ownChunk !== undefined ? this.appDataCodec.appDataFromChunk(ownChunk) : {};
+        for (const [key, value] of Object.entries(entries)) {
+            this.appData.set(key, value);
+        }
+        this.chunkAppDataKeys = new Set(Object.keys(entries));
+    }
+    composeManifestContent() {
+        const extras = { ...(this.base.extras ?? {}) };
+        const brains = parseRecord(this.appData.get(BRAINS_APP_DATA_KEY));
+        if (brains && Object.keys(brains).length > 0) {
+            extras.brains = brains;
+        }
+        else {
+            delete extras.brains;
+        }
+        const appChunks = isRecord(extras[APP_CHUNKS_EXTRA_KEY])
+            ? { ...extras[APP_CHUNKS_EXTRA_KEY] }
+            : {};
+        const ownChunk = this.appDataCodec?.chunkFromAppData(this.appData);
+        if (ownChunk !== undefined) {
+            appChunks[this.appName] = ownChunk;
+        }
+        else {
+            delete appChunks[this.appName];
+        }
+        if (Object.keys(appChunks).length > 0) {
+            extras[APP_CHUNKS_EXTRA_KEY] = appChunks;
+        }
+        else {
+            delete extras[APP_CHUNKS_EXTRA_KEY];
+        }
+        const content = {
+            name: this.manifest.name,
+            version: this.manifest.version,
+            ...(this.base.identity !== undefined ? { identity: this.base.identity } : {}),
+            description: this.manifest.description,
+            ...(this.manifest.thumbnailUrl !== undefined ? { thumbnailUrl: this.manifest.thumbnailUrl } : {}),
+            extensions: this.manifest.extensions ?? {},
+            ...(this.base.files !== undefined ? { files: this.base.files } : {}),
+            ...(this.base.ambient !== undefined ? { ambient: this.base.ambient } : {}),
+            ...(this.base.targets !== undefined ? { targets: this.base.targets } : {}),
+            ...(Object.keys(extras).length > 0 ? { extras } : {}),
+        };
+        return serializeProjectContentManifest(content);
+    }
+    async writeManifestIfChanged() {
+        const content = this.composeManifestContent();
+        if (content === this.lastManifestContent) {
+            return;
+        }
+        await this.rpc.writeManifest(content);
+        this.lastManifestContent = content;
+    }
+    async writeSnapshotDiff(target) {
+        const changes = diffSnapshotChanges(this.mirror, target);
+        for (const change of changes) {
+            await this.rpc.sendChange(change);
+        }
+        const next = new Map();
+        for (const [path, entry] of target) {
+            if (path !== WENDOO_JSON_PATH) {
+                next.set(path, entry);
+            }
+        }
+        this.mirror = next;
+    }
+}
+function touchesManifestFile(change) {
+    switch (change.action) {
+        case "write":
+        case "delete":
+        case "mkdir":
+        case "rmdir":
+            return change.path === WENDOO_JSON_PATH;
+        case "rename":
+            return change.oldPath === WENDOO_JSON_PATH || change.newPath === WENDOO_JSON_PATH;
+        case "import":
+            return false;
+    }
+}
+/**
+ * Compute the change-granular writes that bring `mirror` (the store's view of
+ * the folder) to `target`. The `wendoo.json` entry is ignored on both
+ * sides; removals under a removed directory are covered by its `rmdir`.
+ */
+function diffSnapshotChanges(mirror, target) {
+    const changes = [];
+    for (const [path, entry] of target) {
+        if (path === WENDOO_JSON_PATH) {
+            continue;
+        }
+        const current = mirror.get(path);
+        if (entry.kind === "directory") {
+            if (!current) {
+                changes.push({ action: "mkdir", path });
+            }
+            continue;
+        }
+        if (!current || current.kind !== "file" || !fileContentEquals(current.content, entry.content)) {
+            changes.push({
+                action: "write",
+                path,
+                ...fileContentToWire(entry.content),
+                newEtag: entry.etag,
+                ...(current?.kind === "file" ? { expectedEtag: current.etag } : {}),
+            });
+        }
+    }
+    const removedPaths = [...mirror.keys()].filter((path) => path !== WENDOO_JSON_PATH && !target.has(path)).sort();
+    const removedDirectories = [];
+    for (const path of removedPaths) {
+        if (removedDirectories.some((directory) => path.startsWith(`${directory}/`))) {
+            continue;
+        }
+        const entry = mirror.get(path);
+        if (entry?.kind === "directory") {
+            // A directory absent from the target as an entry may still parent
+            // target files; only an empty subtree is removed.
+            const prefix = `${path}/`;
+            let hasTargetDescendant = false;
+            for (const targetPath of target.keys()) {
+                if (targetPath.startsWith(prefix)) {
+                    hasTargetDescendant = true;
+                    break;
+                }
+            }
+            if (hasTargetDescendant) {
+                continue;
+            }
+            changes.push({ action: "rmdir", path });
+            removedDirectories.push(path);
+        }
+        else if (entry) {
+            changes.push({ action: "delete", path, expectedEtag: entry.etag });
+        }
+    }
+    return changes;
+}

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@wendoo/bridge-app",
+  "version": "0.2.2",
+  "description": "App-side client for the Wendoo bridge",
+  "license": "MIT",
+  "type": "module",
+  "author": "wendoo-lang",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wendoo-lang/wendoo-lang.git",
+    "directory": "packages/bridge-app"
+  },
+  "bugs": {
+    "url": "https://github.com/wendoo-lang/wendoo-lang/issues"
+  },
+  "homepage": "https://github.com/wendoo-lang/wendoo-lang/tree/main/packages/bridge-app#readme",
+  "keywords": [
+    "wendoo",
+    "visual-programming",
+    "tile-based",
+    "typescript",
+    "vscode",
+    "language",
+    "education",
+    "stem",
+    "coding",
+    "game-development",
+    "creative-coding",
+    "kodu",
+    "project-spark"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "browser": "./dist/index.js",
+      "import": "./dist/index.js"
+    },
+    "./compilation": {
+      "types": "./dist/compilation.d.ts",
+      "browser": "./dist/compilation.js",
+      "import": "./dist/compilation.js"
+    },
+    "./manifest-files": {
+      "types": "./dist/manifest-files.d.ts",
+      "browser": "./dist/manifest-files.js",
+      "import": "./dist/manifest-files.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    }
+  },
+  "wendooBuild": {
+    "script": "build:prod",
+    "outputs": [
+      "dist"
+    ],
+    "postProcessed": false
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "build:prod": "tsc --build tsconfig.prod.json",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo tsconfig.prod.tsbuildinfo",
+    "watch": "tsc --build --watch",
+    "lint:only": "biome lint ./src",
+    "check:only": "biome check ./src",
+    "format:only": "biome format ./src",
+    "lint": "biome lint ./src --write",
+    "check": "biome check ./src --write",
+    "pretest": "npm run build:prod",
+    "test": "tsx --tsconfig tsconfig.spec.json --test $(find src -name '*.spec.ts')",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.spec.json",
+    "format": "biome format ./src --write",
+    "release:patch": "node ../../scripts/release.js patch",
+    "release:minor": "node ../../scripts/release.js minor",
+    "release:major": "node ../../scripts/release.js major"
+  },
+  "dependencies": {
+    "@wendoo/app-host": "^0.2.8",
+    "@wendoo/bridge-client": "^0.2.7",
+    "@wendoo/bridge-protocol": "^0.2.10",
+    "@wendoo/core": "^0.2.19",
+    "@wendoo/ts-compiler": "^0.2.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.15",
+    "@types/node": "^25.3.0",
+    "tsx": "^4.21.0",
+    "typescript": "~5.9.3"
+  }
+}