@aistrike-dev/ui-shell-dev 1.0.0 → 1.0.2

package/README.md

@@ -19,6 +19,20 @@ export default defineConfig({
 `vite` now serves the shell at `/` with a minted dev session, and your MFE at `/ui/latest/`, on one origin, with HMR.
 Other domains resolve by the profile's convention unless `shell.dev.json` overrides them.
 
+## Built-in MFEs
+
+The package carries prebuilt copies of the MFEs that ship with the shell (assistant, settings and home) with their mock
+APIs, and the plugin serves each on the port the shell looks for it on: assistant 5104, settings 5101, home 5102. You
+get the whole frame (Home, Settings, the assistant pane on ⌘I / Ctrl+I) with nothing else running.
+
+- A server already listening on one of those ports wins: the plugin leaves that port alone, so a real dev server for
+  that MFE (with HMR) is used instead. A port freed later is taken over on the next page load.
+- A real dev server for one of them started *after* this one fails, because the bundled copy holds its port. Start the
+  one you are editing first, or restart this server after starting it.
+- `shellDevHost({ platform: false })` serves none; `shellDevHost({ platform: ['assistant'] })` only those listed. A
+  domain that `shell.dev.json` overrides, or any profile other than `local`, is never bundled.
+- The copies are as old as the package (in this repository, the last `pnpm nx build dev-host`).
+
 Keep Vite's `server.allowedHosts` at its default: the plugin derives your MFE's origin from the request's `Host`
 header, which is only safe while Vite rejects unknown hosts. With `server.https` Vite skips host validation, so the
 self-override trusts the `Host` header as-is.
@@ -49,9 +63,9 @@ aistrike-shell token [--claims <path>] [--ttl 30d|12h|45m|90s] [--out <path>] [-
 
 `token` mints a dev token and prints it (or `{ token, session }` with `--json`), optionally writing it to `--out`.
 
-The package's own e2e (`pnpm nx e2e dev-host`) serves the settings MFE on port 5101 and fails loudly if a settings dev server already occupies it.
+The package's own e2e (`pnpm nx e2e dev-host`) serves the settings MFE on port 5101, with the bundled home and assistant on 5102 and 5104; it fails loudly if a dev server already occupies 5101, and stop any on 5102 or 5104 first. It also checks that `npm pack` would publish the bundled copies.
 
-Opening `/` in dev lands on your own MFE (the plugin injects `landing` with your domain id; `shell.dev.json` may set `landing` to another domain id; an id that is not in the shell's domain list falls back to `/home`). The other domains in the profile (for example `home` on port 5102) show as failed in the rail unless their dev servers are running too; that is expected.
+Opening `/` in dev lands on your own MFE (the plugin injects `landing` with your domain id; `shell.dev.json` may set `landing` to another domain id; an id that is not in the shell's domain list falls back to `/home`). A domain in the profile that is neither bundled nor running shows as failed in the rail.
 
 ## Checking Fast Refresh (spike 1)
 

package/dist/platform/copy.d.ts

@@ -0,0 +1,19 @@
+import type { PlatformEntry } from './host.js';
+/** A platform MFE as the package is built from it: `mock` says whether its build must carry a mock API. */
+export interface PackagedEntry extends PlatformEntry {
+    mock: boolean;
+}
+export interface CopyOptions {
+    /** The workspace's `apps/`. */
+    appsDir: string;
+    /** The package's `platform/`. */
+    targetDir: string;
+    entries: readonly PackagedEntry[];
+}
+/** Every module a built file imports that is not `node:*`; the dev host loads the mock in plain Node, without them. */
+export declare function foreignImports(code: string): string[];
+/**
+ * Platform-MFE spec 3.2: each app's `dist/` to `<id>/ui/` and its `dist-mock/mock.js` to `<id>/mock.js`, then
+ * `platform.json`. Throws, naming what to fix, for a missing build, a missing mock or a mock that imports a package.
+ */
+export declare function copyPlatform(options: CopyOptions): void;

package/dist/platform/copy.js

@@ -0,0 +1,38 @@
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const IMPORT = /\b(?:from|import)\s*\(?\s*["']([^"']+)["']/g;
+/** Every module a built file imports that is not `node:*`; the dev host loads the mock in plain Node, without them. */
+export function foreignImports(code) {
+    return [...code.matchAll(IMPORT)].map((match) => match[1]).filter((specifier) => !specifier.startsWith('node:'));
+}
+/**
+ * Platform-MFE spec 3.2: each app's `dist/` to `<id>/ui/` and its `dist-mock/mock.js` to `<id>/mock.js`, then
+ * `platform.json`. Throws, naming what to fix, for a missing build, a missing mock or a mock that imports a package.
+ */
+export function copyPlatform(options) {
+    for (const { id, mock } of options.entries) {
+        const build = join(options.appsDir, id, 'dist');
+        if (!existsSync(join(build, 'manifest.json'))) {
+            throw new Error(`platform build missing at ${build}; run: pnpm nx build ${id}`);
+        }
+        const mockFile = join(options.appsDir, id, 'dist-mock', 'mock.js');
+        if (mock) {
+            if (!existsSync(mockFile)) {
+                throw new Error(`${id}: mock build missing at ${mockFile}; run: pnpm nx build ${id}`);
+            }
+            const foreign = foreignImports(readFileSync(mockFile, 'utf8'));
+            if (foreign.length > 0) {
+                throw new Error(`${id}: ${mockFile} imports ${foreign.join(', ')}; a mock may import only node:*`);
+            }
+        }
+        cpSync(build, join(options.targetDir, id, 'ui'), { recursive: true });
+        if (mock) {
+            copyFileSync(mockFile, join(options.targetDir, id, 'mock.js'));
+        }
+    }
+    mkdirSync(options.targetDir, { recursive: true });
+    const list = options.entries.map(({ id, devPort }) => {
+        return { id, devPort };
+    });
+    writeFileSync(join(options.targetDir, 'platform.json'), `${JSON.stringify(list, null, 2)}\n`);
+}

package/dist/platform/cors.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/**
+ * Mirrors the SDK's `sameHostCors` (an MFE dev server's CORS): a page on the same host, any port, may read anything,
+ * and its preflights are answered. Returns true when it answered the request itself (a preflight's 204).
+ */
+export declare function sameHostCors(req: IncomingMessage, res: ServerResponse): boolean;

package/dist/platform/cors.js

@@ -0,0 +1,36 @@
+const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]']);
+const ANY_METHOD = 'GET, HEAD, PUT, PATCH, POST, DELETE';
+/** Mirrors `isSameHost` in the SDK's `vite/plugin.ts` (the SDK is a devDependency here; `cors.test.ts` pins both). */
+function isSameHost(origin, host) {
+    if (host === undefined) {
+        return false;
+    }
+    try {
+        const a = new URL(origin).hostname;
+        const b = new URL(`http://${host}`).hostname;
+        return a === b || (LOOPBACK.has(a) && LOOPBACK.has(b));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Mirrors the SDK's `sameHostCors` (an MFE dev server's CORS): a page on the same host, any port, may read anything,
+ * and its preflights are answered. Returns true when it answered the request itself (a preflight's 204).
+ */
+export function sameHostCors(req, res) {
+    const origin = req.headers.origin;
+    res.setHeader('Vary', 'Origin');
+    if (origin === undefined || !isSameHost(origin, req.headers.host)) {
+        return false;
+    }
+    res.setHeader('Access-Control-Allow-Origin', origin);
+    if (req.method !== 'OPTIONS' || req.headers['access-control-request-method'] === undefined) {
+        return false;
+    }
+    res.setHeader('Access-Control-Allow-Methods', ANY_METHOD);
+    res.setHeader('Access-Control-Allow-Headers', req.headers['access-control-request-headers'] ?? '');
+    res.statusCode = 204;
+    res.end();
+    return true;
+}

package/dist/platform/host.d.ts

@@ -0,0 +1,37 @@
+/** A platform MFE the package carries, and the port the shell's `local` profile looks for it on. */
+export interface PlatformEntry {
+    id: string;
+    devPort: number;
+}
+export interface PlatformLogger {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+}
+export interface SelectOptions {
+    ownId: string;
+    profile: string;
+    overrides: {
+        [id: string]: string;
+    };
+    option: boolean | string[] | undefined;
+}
+export interface PlatformHost {
+    /** Tries every entry it does not hold; resolves when every attempt has settled. Never rejects. */
+    bind: (options?: {
+        quiet?: boolean;
+    }) => Promise<void>;
+    held: () => PlatformEntry[];
+    close: () => Promise<void>;
+}
+/** `<platformDir>/platform.json`, keeping the entries whose build is present. A missing or broken list is none. */
+export declare function readPlatform(platformDir: string): PlatformEntry[];
+/**
+ * Platform-MFE spec 3.3 step 1: never the MFE being developed (it is this server), never a domain the dev file points
+ * elsewhere, nothing outside the `local` profile (the shell would not look at local ports), and what the option allows.
+ */
+export declare function selectPlatform(entries: PlatformEntry[], options: SelectOptions): PlatformEntry[];
+/**
+ * Serves each platform MFE from `<platformDir>/<id>/` on its own `devPort`. A port something else holds is left to it:
+ * a dev server already running for that domain wins.
+ */
+export declare function createPlatformHost(platformDir: string, entries: PlatformEntry[], logger: PlatformLogger): PlatformHost;

package/dist/platform/host.js

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createPlatformServer } from './server.js';
+function isEntry(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const { id, devPort } = value;
+    return typeof id === 'string' && typeof devPort === 'number' && Number.isInteger(devPort) && devPort > 0 && devPort <= 65535;
+}
+/** `<platformDir>/platform.json`, keeping the entries whose build is present. A missing or broken list is none. */
+export function readPlatform(platformDir) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(join(platformDir, 'platform.json'), 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed) || !parsed.every(isEntry)) {
+        return [];
+    }
+    return parsed.filter((entry) => existsSync(join(platformDir, entry.id, 'ui', 'manifest.json')));
+}
+/**
+ * Platform-MFE spec 3.3 step 1: never the MFE being developed (it is this server), never a domain the dev file points
+ * elsewhere, nothing outside the `local` profile (the shell would not look at local ports), and what the option allows.
+ */
+export function selectPlatform(entries, options) {
+    if (options.option === false || options.profile !== 'local') {
+        return [];
+    }
+    const allowed = Array.isArray(options.option) ? options.option : undefined;
+    return entries.filter((entry) => entry.id !== options.ownId
+        && !(entry.id in options.overrides)
+        && (allowed === undefined || allowed.includes(entry.id)));
+}
+const errorCode = (error) => error?.code;
+const reason = (error) => (error instanceof Error ? error.message : String(error));
+/** On every interface, as `mfe()`'s dev servers listen (`host: true`); IPv4 alone where the machine has no IPv6. */
+async function listen(server, port) {
+    const attempt = async (options) => new Promise((done, fail) => {
+        const onError = (error) => {
+            fail(error);
+        };
+        server.once('error', onError);
+        server.listen(options, () => {
+            server.off('error', onError);
+            done();
+        });
+    });
+    try {
+        await attempt({ port, host: '::', ipv6Only: false });
+    }
+    catch (error) {
+        if (errorCode(error) !== 'EAFNOSUPPORT') {
+            throw error;
+        }
+        await attempt({ port, host: '0.0.0.0' });
+    }
+}
+/**
+ * Serves each platform MFE from `<platformDir>/<id>/` on its own `devPort`. A port something else holds is left to it:
+ * a dev server already running for that domain wins.
+ */
+export function createPlatformHost(platformDir, entries, logger) {
+    const servers = new Map();
+    const mocks = new Map();
+    const binding = new Map();
+    /** Once per id for the life of the host, so a broken mock warns once and the mocks' state survives a rebind. */
+    const loadMock = async (id) => {
+        const file = join(platformDir, id, 'mock.js');
+        if (!existsSync(file)) {
+            return [];
+        }
+        try {
+            const module = await import(pathToFileURL(file).href);
+            if (typeof module.createMockHandlers !== 'function') {
+                logger.warn(`${id}: ${file} exports no createMockHandlers; serving it without its mock API`);
+                return [];
+            }
+            return module.createMockHandlers();
+        }
+        catch (error) {
+            logger.warn(`${id}: its mock API failed to load (${reason(error)}); serving it without`);
+            return [];
+        }
+    };
+    const bindOne = async (entry, quiet) => {
+        let handlers = mocks.get(entry.id);
+        if (handlers === undefined) {
+            handlers = loadMock(entry.id);
+            mocks.set(entry.id, handlers);
+        }
+        const server = createPlatformServer({ id: entry.id, uiDir: join(platformDir, entry.id, 'ui'), handlers: await handlers });
+        try {
+            await listen(server, entry.devPort);
+        }
+        catch (error) {
+            if (quiet) {
+                return;
+            }
+            if (errorCode(error) === 'EADDRINUSE') {
+                logger.info(`${entry.id}: using the server already on :${String(entry.devPort)}`);
+            }
+            else {
+                logger.warn(`${entry.id}: could not listen on :${String(entry.devPort)} (${reason(error)})`);
+            }
+            return;
+        }
+        servers.set(entry.id, server);
+        logger.info(`${entry.id}: bundled copy on :${String(entry.devPort)}`);
+    };
+    return {
+        async bind(options = {}) {
+            await Promise.all(entries.filter((entry) => !servers.has(entry.id)).map(async (entry) => {
+                // A page load during a bind waits for it rather than racing a second server onto the same port.
+                let pending = binding.get(entry.id);
+                if (pending === undefined) {
+                    pending = bindOne(entry, options.quiet === true).finally(() => {
+                        binding.delete(entry.id);
+                    });
+                    binding.set(entry.id, pending);
+                }
+                await pending;
+            }));
+        },
+        held() {
+            return entries.filter((entry) => servers.has(entry.id));
+        },
+        async close() {
+            await Promise.all([...binding.values()]);
+            const open = [...servers.values()];
+            servers.clear();
+            await Promise.all(open.map(async (server) => new Promise((done) => {
+                server.close(() => {
+                    done();
+                });
+                server.closeAllConnections();
+            })));
+        },
+    };
+}

package/dist/platform/list.d.ts

@@ -0,0 +1,6 @@
+import type { PackagedEntry } from './copy.js';
+/**
+ * The platform MFEs the package carries (platform-MFE spec 3.1), each on the `devPort` of the shell's domain list
+ * (`list.test.ts` pins them). The copy script writes this to `platform/platform.json`. Never the lab: it is dev-only.
+ */
+export declare const PLATFORM: readonly PackagedEntry[];

package/dist/platform/list.js

@@ -0,0 +1,9 @@
+/**
+ * The platform MFEs the package carries (platform-MFE spec 3.1), each on the `devPort` of the shell's domain list
+ * (`list.test.ts` pins them). The copy script writes this to `platform/platform.json`. Never the lab: it is dev-only.
+ */
+export const PLATFORM = [
+    { id: 'assistant', devPort: 5104, mock: true },
+    { id: 'settings', devPort: 5101, mock: true },
+    { id: 'home', devPort: 5102, mock: false },
+];

package/dist/platform/server.d.ts

@@ -0,0 +1,14 @@
+import { type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+/** A mock API handler as each platform MFE builds it (`createMockHandlers()`): true when it answered the request. */
+export type MockHandler = (req: IncomingMessage, res: ServerResponse) => boolean;
+export interface PlatformServerOptions {
+    id: string;
+    /** The MFE's production build (`platform/<id>/ui`). */
+    uiDir: string;
+    handlers: MockHandler[];
+}
+/**
+ * One bundled platform MFE, served as its own dev server would be on its own port: same-host CORS, the build at
+ * `/ui/latest/` (no redirect; the resolver accepts a manifest at `latest`, as from a dev server) and the mocks at `/api/`.
+ */
+export declare function createPlatformServer(options: PlatformServerOptions): Server;

package/dist/platform/server.js

@@ -0,0 +1,44 @@
+import { createServer } from 'node:http';
+import { normalize, resolve, sep } from 'node:path';
+import { sendFile } from '../inject.js';
+import { sameHostCors } from './cors.js';
+const UI = '/ui/latest/';
+function answer(res, status, text) {
+    res.statusCode = status;
+    res.setHeader('Content-Type', 'text/plain');
+    res.end(text);
+}
+/**
+ * One bundled platform MFE, served as its own dev server would be on its own port: same-host CORS, the build at
+ * `/ui/latest/` (no redirect; the resolver accepts a manifest at `latest`, as from a dev server) and the mocks at `/api/`.
+ */
+export function createPlatformServer(options) {
+    const uiDir = resolve(options.uiDir);
+    return createServer((req, res) => {
+        if (sameHostCors(req, res)) {
+            return;
+        }
+        let pathname;
+        try {
+            pathname = decodeURIComponent(new URL(req.url ?? '/', 'http://localhost').pathname);
+        }
+        catch {
+            answer(res, 400, 'bad request');
+            return;
+        }
+        if (pathname.startsWith('/api/')) {
+            if (!options.handlers.some((handle) => handle(req, res))) {
+                answer(res, 404, 'not found');
+            }
+            return;
+        }
+        if (pathname.startsWith(UI) && (req.method === 'GET' || req.method === 'HEAD')) {
+            const target = resolve(uiDir, `.${normalize(`/${pathname.slice(UI.length)}`)}`);
+            if (target.startsWith(uiDir + sep)) {
+                sendFile(target, res);
+                return;
+            }
+        }
+        answer(res, 404, 'not found');
+    });
+}

package/dist/vite/plugin.d.ts

@@ -10,6 +10,13 @@ export interface ShellDevHostOptions {
     ttlMs?: number;
     /** Mint no token (shell starts signed out). */
     noToken?: boolean;
+    /**
+     * Serve the bundled platform MFEs (assistant, settings, home) on their own ports, each where nothing else holds its
+     * port. Default true; false serves none; a list serves only those ids.
+     */
+    platform?: boolean | string[];
+    /** Path to the platform MFEs' builds. Default: the `platform/` directory shipped in this package. */
+    platformDir?: string;
 }
 /**
  * Vite's HTML transform prefixes root-relative URLs with its base (`/ui/latest/`); the shell's build lives at the root,

package/dist/vite/plugin.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { extname, join, normalize, resolve, sep } from 'node:path';
 import { buildDevConfig, loadDevFile } from '../devfile.js';
 import { CONTENT_TYPES, injectDevConfig, sendFile, validateDevConfig } from '../inject.js';
+import { createPlatformHost, readPlatform, selectPlatform } from '../platform/host.js';
 import { loadOrCreateKey, mintToken } from '../token.js';
 const MFE_PLUGIN = 'aistrike:mfe';
 const MISSING_MFE = 'shellDevHost() needs the mfe() plugin from @aistrike-dev/ui-shell-sdk/vite';
@@ -10,6 +11,9 @@ const PASS_THROUGH = ['/api/', '/@', '/__', '/node_modules/'];
 function defaultShellDir() {
     return resolve(import.meta.dirname, '../../shell');
 }
+function defaultPlatformDir() {
+    return resolve(import.meta.dirname, '../../platform');
+}
 function mfeId(config) {
     const plugin = config.plugins.find((p) => p.name === MFE_PLUGIN);
     const api = plugin?.api;
@@ -47,6 +51,52 @@ export function shellDevHost(options = {}) {
     const shellDir = resolve(options.shellDir ?? defaultShellDir());
     let config;
     let id = '';
+    /**
+     * Platform-MFE spec 3.3: binds once the dev server listens (at once in middleware mode, which has no server of its
+     * own), and closes before Vite's own close or restart returns, so a restart's new instance finds the ports free.
+     */
+    const startPlatform = (server, profile, file) => {
+        if (options.platform === false || !config) {
+            return null;
+        }
+        const platformDir = resolve(options.platformDir ?? defaultPlatformDir());
+        const overrides = file?.overrides ?? {};
+        const entries = selectPlatform(readPlatform(platformDir), { ownId: id, profile, overrides, option: options.platform });
+        if (entries.length === 0) {
+            return null;
+        }
+        const host = createPlatformHost(platformDir, entries, config.logger);
+        const bind = () => {
+            host.bind().catch(() => undefined); // never rejects; each failure is logged where it happens
+        };
+        if (server.httpServer === null) {
+            bind();
+        }
+        else {
+            server.httpServer.once('listening', bind);
+            server.httpServer.once('close', () => {
+                host.close().catch(() => undefined);
+            });
+        }
+        const close = server.close.bind(server);
+        server.close = async () => {
+            await host.close();
+            await close();
+        };
+        const restart = server.restart.bind(server);
+        server.restart = async (forceOptimize) => {
+            await host.close();
+            await restart(forceOptimize);
+        };
+        return {
+            host,
+            retry: async () => {
+                if (host.held().length < entries.length) {
+                    await host.bind({ quiet: true });
+                }
+            },
+        };
+    };
     return {
         name: 'aistrike:shell-dev-host',
         apply: 'serve',
@@ -75,6 +125,7 @@ export function shellDevHost(options = {}) {
                 };
             };
             validateDevConfig(configFor('http://localhost'));
+            const platform = startPlatform(server, configFor('http://localhost').profile ?? 'local', file);
             const serveShell = async (req, res, pathname) => {
                 if (pathname.startsWith('/assets/')) {
                     const target = resolve(shellDir, `.${normalize(pathname)}`);
@@ -89,6 +140,8 @@ export function shellDevHost(options = {}) {
                     notFound(res);
                     return;
                 }
+                // A server that held a platform MFE's port may have stopped since; a reload is when to take it over.
+                await platform?.retry();
                 const devConfig = configFor(`${scheme}://${req.headers.host ?? 'localhost'}`);
                 const source = join(shellDir, 'index.html');
                 const html = markShellAssets(injectDevConfig(readFileSync(source, 'utf8'), devConfig, source));
@@ -117,6 +170,9 @@ export function shellDevHost(options = {}) {
                 if (local !== undefined) {
                     config?.logger.info(`  shell  ${new URL(local).origin}/  (serving ${id} from this origin)`);
                 }
+                for (const entry of platform?.host.held() ?? []) {
+                    config?.logger.info(`  ${entry.id}  http://localhost:${String(entry.devPort)}/  (bundled)`);
+                }
             };
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aistrike-dev/ui-shell-dev",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A Vite plugin that serves the AiStrike UI shell from your micro front-end's dev server, plus a dev-token CLI.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
@@ -16,7 +16,7 @@
     "node": ">=22.12"
   },
   "bin": {
-    "aistrike-shell": "./bin/aistrike-shell.mjs"
+    "aistrike-shell": "bin/aistrike-shell.mjs"
   },
   "exports": {
     ".": {
@@ -33,15 +33,17 @@
     "dist",
     "bin",
     "shell",
+    "platform",
     "LICENSE"
   ],
   "scripts": {
-    "build": "rm -rf dist shell && tsc -p tsconfig.build.json && node scripts/copy-shell.mjs",
+    "compile": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build": "rm -rf shell platform && node scripts/copy-shell.mjs && node scripts/copy-platform.mjs",
     "prepack": "cp ../../LICENSE ./LICENSE",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "lint": "eslint .",
-    "e2e": "playwright test"
+    "e2e": "node scripts/check-pack.mjs && playwright test"
   },
   "peerDependencies": {
     "vite": "^8.0.0"
@@ -68,14 +70,48 @@
       "shell"
     ],
     "targets": {
+      "compile": {
+        "dependsOn": [
+          {
+            "projects": [
+              "sdk"
+            ],
+            "target": "build"
+          }
+        ],
+        "inputs": [
+          "production",
+          "^production"
+        ],
+        "outputs": [
+          "{projectRoot}/dist"
+        ],
+        "cache": true
+      },
       "build": {
         "dependsOn": [
+          "compile",
           "^build",
-          "shell:build"
+          "shell:build",
+          "assistant:build",
+          "settings:build",
+          "home:build"
+        ],
+        "inputs": [
+          "production",
+          "^production",
+          "{workspaceRoot}/apps/assistant/**/*",
+          "{workspaceRoot}/apps/settings/**/*",
+          "{workspaceRoot}/apps/home/**/*",
+          "!{workspaceRoot}/apps/*/**/*.test.ts",
+          "!{workspaceRoot}/apps/*/**/*.test.tsx",
+          "!{workspaceRoot}/apps/*/dist/**",
+          "!{workspaceRoot}/apps/*/dist-mock/**",
+          "!{workspaceRoot}/apps/*/node_modules/**"
         ],
         "outputs": [
-          "{projectRoot}/dist",
-          "{projectRoot}/shell"
+          "{projectRoot}/shell",
+          "{projectRoot}/platform"
         ]
       },
       "e2e": {