@amalgm/shell 0.1.161 → 0.1.163

package/dist/machine-host.js

@@ -2,40 +2,23 @@ import { randomBytes, randomUUID } from "node:crypto";
 import { existsSync, readdirSync, rmSync } from "node:fs";
 import { homedir as osHomedir, hostname, platform, release } from "node:os";
 import { join, resolve } from "node:path";
-import { Agents } from "@amalgm/agents";
-import { createRestServer as createAgentsRest } from "@amalgm/agents/http";
-import { createMcpServer as createAgentsMcp, createMcpTools as createAgentsMcpTools } from "@amalgm/agents/mcp";
-import { createMcpServer as createAppsMcp, createMcpTools as createAppsMcpTools } from "@amalgm/apps";
-import { createBrowser } from "@amalgm/browser";
-import { createBrowserMcpServer, createBrowserMcpTools } from "@amalgm/browser/mcp";
-import { createNodeAutomationProcessHost } from "@amalgm/automations";
-import { createAutomationMcpServer } from "@amalgm/automations/mcp";
-import { createShellChannelsCommands } from "@amalgm/channels/cli";
-import { createChannelsMcpServer } from "@amalgm/channels/mcp";
-import { createChatMcpServer } from "@amalgm/chat/mcp";
-import { buildRootManifest, joinMachine, mergeRecordAuth, resumeMachine, scopedAmalgmDir, userMachineDir, } from "@amalgm/core/identity";
-import { addFilesWorkspace, registerFilesWorkspace, } from "@amalgm/live/files";
-import { createMcpServer as createToolsMcp, } from "@amalgm/tools";
-import { createToolboxHttpServer } from "@amalgm/tools/http";
+import { buildRootManifest, approveMachineSetup, adoptMachineSetup, joinApprovedMachine, mergeRecordAuth, resumeMachine, resolveRuntimeBinding, runtimeBindingsMatch, runtimeBindingFromRecord, RUNTIME_IDENTITY_PATH, createRuntimeIdentity, runtimeRootSegments, resolveRuntimeEndpoint, scopedAmalgmDir, userMachineDir, } from "@amalgm/core/identity";
 import { atomicJson, atomicJsonSet, ensurePrivateDir, readJson, } from "./filesystem.js";
 import { emitFilesStage, } from "./files-observability.js";
 import { FilesStageRecorder, serializeStages } from "./files-trace.js";
-import { createShellChatComposition } from "./chat-composition.js";
 import { createShellAuthorization, loadInstallationDeviceKey, } from "./authorization/index.js";
 import { recoverMachineAuthorization, } from "./authorization/recovery-host.js";
 import { postRegistration } from "./authorization/registration-http.js";
 import { postSetupJson, setupOrigin } from "./authorization/setup-http.js";
 import { installBuiltinAgents } from "./builtin-agents.js";
+import { InstallationOwnership } from "./installation/ownership.js";
+import { runtimeAppOrigin, runtimeProxyOrigin, runtimeWireUrl } from "./installation/environment.js";
 import { forwardMount } from "./forward.js";
 import { createGateway } from "./gateway.js";
 import { localMount } from "./local-host.js";
-import { connectOfficialMcpServer } from "./official-mcp-host.js";
-import { createPlatformProductHost, } from "./platform-product-host.js";
 import { createPtyHost } from "./pty-host.js";
-import { callRuntimeCommand, inspectRuntimeCommands, publishRuntimeCommands, runtimeCommandConnection, unpublishRuntimeCommands, } from "./runtime-command-host.js";
+import { callRuntimeCommand, assertRuntimeCanStart, inspectRuntimeCommands, publishRuntimeCommands, runtimeCommandConnection, unpublishRuntimeCommands, } from "./runtime-command-host.js";
 import { shellReleaseCatalog, shellReleaseVerifier } from "./release-catalog.js";
-import { platformToolDefinitions } from "./platform-tools.js";
-import { UserGroundHost, } from "./user-ground-host.js";
 /** The production effects around Core's machine-setup operation. It does not
  * decide ordering, readiness, or installation selection; those remain Core. */
 export class MachineHost {
@@ -44,19 +27,41 @@ export class MachineHost {
     amalgmRoot;
     deviceFile;
     ports;
+    binding;
+    ownership;
     selectedUserEmail;
     groundHost = null;
     running = new Set();
     stages;
     constructor(options) {
         setupOrigin(options.appUrl);
-        this.options = options;
+        this.binding = resolveRuntimeBinding(options);
+        if (options.services && this.binding.runtimeLabel !== 'local')
+            throw new Error('Only a local profile may override runtime service selection.');
+        runtimeAppOrigin(this.binding, options.appUrl);
+        for (const [role, endpoint] of [['proxy', options.proxyUrl], ['wire', options.wireUrl],
+            ['automations', options.platformProducts?.automationsBaseUrl], ['channels', options.platformProducts?.channelsBaseUrl]]) {
+            if (endpoint)
+                resolveRuntimeEndpoint(this.binding, role, endpoint, options.appUrl);
+        }
+        this.options = { ...options, ...this.binding };
         this.stages = new FilesStageRecorder(options.onFilesStage);
         this.homedir = options.homedir ?? osHomedir();
-        this.amalgmRoot = options.amalgmRoot ?? join(this.homedir, "amalgm");
+        this.amalgmRoot = resolve(options.amalgmRoot ?? join(this.homedir, ...runtimeRootSegments(this.binding)));
+        this.ownership = new InstallationOwnership({
+            home: this.homedir,
+            installationRoot: this.amalgmRoot,
+            binding: this.binding,
+        });
         this.deviceFile = join(this.amalgmRoot, ".amalgm", "device.json");
         this.selectedUserEmail = normalizeEmail(options.userEmail);
-        this.ensureInstallationRoot();
+        try {
+            this.ownership.initialize(() => this.ensureInstallationRoot());
+        }
+        catch (error) {
+            this.ownership.close();
+            throw error;
+        }
         const deviceStore = {
             load: async () => readJson(this.deviceFile),
             save: async (device) => atomicJson(this.deviceFile, device),
@@ -96,17 +101,17 @@ export class MachineHost {
                         : {}),
                     ...(this.options.authorizationPlatform
                         ? { platform: this.options.authorizationPlatform }
-                        : this.options.homedir ? { platform: "linux" } : {}),
+                        : {}),
                 });
                 const response = await postRegistration(globalThis.fetch, this.options.appUrl, {
                     ...body, authorization_key_thumbprint: signer.keyThumbprint,
                 }, token, signer);
+                runtimeWireUrl(this.binding, this.options.appUrl, text(response.tunnel_url), this.options.wireUrl);
                 const email = normalizeEmail(response.user_email);
                 if (!email)
                     throw Object.assign(new Error("registration did not return a user email"), {
                         code: "missing_user_email",
                     });
-                this.selectedUserEmail = email;
                 return response;
             },
         };
@@ -138,12 +143,14 @@ export class MachineHost {
                     throw Object.assign(new Error("machine tunnel credentials are missing"), { code: "tunnel_credentials_missing" });
                 }
                 await this.groundHost?.close();
+                const { UserGroundHost } = await import("./user-ground-host.js");
                 this.groundHost = new UserGroundHost({
                     amalgmRoot: this.amalgmRoot,
                     deviceId: identity.deviceId,
                     tunnelUrl,
                     tunnelToken,
                     runtimeVersion: this.options.runtimeVersion,
+                    reserveWritableRoot: (path) => { this.ownership.reserve(path, identity.userEmail); },
                     openWatch: this.options.openWatch,
                     onWatchHealth: this.options.onWatchHealth,
                     onDetectScan: this.options.onDetectScan,
@@ -179,19 +186,79 @@ export class MachineHost {
             sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
         };
     }
-    join(input) {
-        return joinMachine({
+    async approveSetup(input) {
+        const approved = await approveMachineSetup({
             ...input,
             appUrl: this.options.appUrl,
             platform: `${platform()}-${release()}`,
             appVersion: this.options.runtimeVersion,
-            runtimeLabel: this.options.runtimeLabel ?? "main",
+            ...this.binding,
             branch: this.options.branch ?? "main",
+            ...(this.binding.localSession ? { localSession: this.binding.localSession } : {}),
         }, this.ports);
+        const email = approved.grant.approved_by.email;
+        if (this.options.userEmail && normalizeEmail(this.options.userEmail) !== email) {
+            throw Object.assign(new Error('Setup was approved by a different account than the selected user.'), { code: 'approved_user_mismatch' });
+        }
+        this.selectedUserEmail = email;
+        return approved;
+    }
+    async join(input) {
+        await this.ownership.waitForRuntime('setup');
+        try {
+            const approved = await this.approveSetup(input);
+            this.ownership.acquireRuntime(this.requireSelectedUser());
+            this.assertRuntimeCanStart();
+            return await joinApprovedMachine(approved, this.ports);
+        }
+        finally {
+            this.ownership.releaseRuntime('setup');
+        }
+    }
+    /** Shared, finite UI setup. An existing owner is never disturbed by adoption. */
+    async setup(input) {
+        await this.ownership.waitForRuntime('setup');
+        let enrolling = false;
+        try {
+            const approved = await this.approveSetup(input);
+            const machine = await this.loadMachine();
+            if (machine?.ready) {
+                await adoptMachineSetup(approved, machine, this.ports);
+                return { disposition: 'adopted', userEmail: this.requireSelectedUser(),
+                    userId: approved.grant.approved_by.user_id, computerId: text(machine.publicRecord.computer_id),
+                    deviceId: approved.device.device_id };
+            }
+            this.ownership.acquireRuntime(this.requireSelectedUser());
+            this.assertRuntimeCanStart();
+            enrolling = true;
+            const ready = await joinApprovedMachine(approved, this.ports);
+            return { disposition: 'enrolled', userEmail: this.requireSelectedUser(),
+                userId: ready.userId, computerId: ready.computerId, deviceId: ready.deviceId };
+        }
+        finally {
+            try {
+                if (enrolling) {
+                    await this.drainRuntime();
+                    this.ownership.releaseRuntime(this.requireSelectedUser());
+                }
+            }
+            finally {
+                this.ownership.releaseRuntime('setup');
+            }
+        }
     }
     resume() {
         this.resolveUserForResume();
-        return resumeMachine(this.ports);
+        this.ownership.acquireRuntime(this.requireSelectedUser());
+        this.assertRuntimeCanStart();
+        return resumeMachine(this.ports, { services: this.options.services });
+    }
+    assertRuntimeCanStart() {
+        const deviceId = text(readJson(this.deviceFile)?.device_id);
+        if (!deviceId)
+            return;
+        assertRuntimeCanStart({ userRoot: this.paths().userRoot, deviceId,
+            ...this.binding, userScope: this.requireSelectedUser() });
     }
     async recoverAuthorizationKey(input = {}) {
         this.resolveUserForResume();
@@ -204,7 +271,7 @@ export class MachineHost {
             machine,
             appUrl: this.options.appUrl,
             runtimeVersion: this.options.runtimeVersion,
-            runtimeLabel: this.options.runtimeLabel ?? "main",
+            ...this.binding,
             branch: this.options.branch ?? "main",
             fallbackName: defaultMachineName(),
             fallbackPlatform: `${platform()}-${release()}`,
@@ -226,6 +293,7 @@ export class MachineHost {
         const deviceId = text(device?.device_id) || null;
         if (!deviceId) {
             return {
+                binding: this.binding,
                 user,
                 deviceId: null,
                 registration: "absent",
@@ -240,6 +308,8 @@ export class MachineHost {
         }
         const paths = this.paths(user);
         const publicRecord = readJson(paths.publicRecord);
+        if (publicRecord)
+            this.assertRecordBinding(publicRecord);
         const secretAuth = readJson(paths.secretAuth);
         const installation = readJson(paths.installation);
         const storedStatus = readJson(paths.status);
@@ -251,11 +321,12 @@ export class MachineHost {
             ? await inspectRuntimeCommands({
                 userRoot: paths.userRoot,
                 deviceId,
-                runtimeLabel: this.options.runtimeLabel ?? "main",
+                ...this.binding,
                 userScope: user,
             })
             : { published: false, running: false, pid: null, port: null };
         return {
+            binding: this.binding,
             user,
             deviceId,
             registration,
@@ -282,6 +353,7 @@ export class MachineHost {
             primitive: "download", stage: "files-add", status: "started", workspaceId,
         });
         try {
+            const { addFilesWorkspace } = await import("@amalgm/live/files");
             const added = await addFilesWorkspace(workspaceId, destinationParent, this.groundHost.filesCommandPorts().add);
             const result = { ...added, watch: this.groundHost.addedWorkspaceEvidence(added.workspaceId) };
             emitFilesStage(this.stages.observe, {
@@ -318,7 +390,7 @@ export class MachineHost {
             primitive: "register", stage: "durable-declaration", status: "started", path: requestedPath,
         });
         try {
-            const declared = await registerFilesWorkspace(requestedPath, this.groundHost.filesCommandPorts().register);
+            const declared = await (await import("@amalgm/live/files")).registerFilesWorkspace(requestedPath, this.groundHost.filesCommandPorts().register);
             emitFilesStage(this.stages.observe, {
                 primitive: "register",
                 stage: "durable-declaration",
@@ -383,6 +455,10 @@ export class MachineHost {
         return Object.freeze(adapter);
     }
     async close(options = {}) {
+        await this.drainRuntime(options);
+        this.ownership.close();
+    }
+    async drainRuntime(options = {}) {
         const runtimes = [...this.running];
         this.running.clear();
         await this.groundHost?.close(options);
@@ -398,11 +474,20 @@ export class MachineHost {
             nowIso: () => new Date().toISOString(),
             randomHex: (bytes) => randomBytes(bytes).toString("hex"),
         });
-        if (!existing?.installationId)
-            atomicJson(manifestFile, manifest);
+        const previousBinding = existing?.runtimeBinding;
+        if (previousBinding && !runtimeBindingsMatch(previousBinding, this.binding)) {
+            throw new Error('This installation root belongs to another runtime binding.');
+        }
+        if (existing?.installationId && !previousBinding && this.binding.runtimeLabel !== 'main') {
+            throw new Error('An unbound existing installation must be adopted explicitly; use a fresh root for preview/local.');
+        }
+        if (!existing?.installationId || !previousBinding) {
+            atomicJson(manifestFile, { ...manifest, runtimeBinding: this.binding });
+        }
     }
     async openChannelsCommands() {
         const access = runtimeCommandConnection(await this.runtimeCommandAddress());
+        const { createShellChannelsCommands } = await import("@amalgm/channels/cli");
         return createShellChannelsCommands(access);
     }
     async runtimeCommandAddress() {
@@ -419,7 +504,7 @@ export class MachineHost {
         return {
             userRoot: this.paths().userRoot,
             deviceId,
-            runtimeLabel: this.options.runtimeLabel ?? "main",
+            ...this.binding,
             userScope: userEmail,
         };
     }
@@ -440,7 +525,7 @@ export class MachineHost {
                 : {}),
             ...(this.options.authorizationPlatform
                 ? { platform: this.options.authorizationPlatform }
-                : this.options.homedir ? { platform: "linux" } : {}),
+                : {}),
         };
     }
     paths(email = this.requireSelectedUser()) {
@@ -494,6 +579,17 @@ export class MachineHost {
             });
         }
     }
+    assertRecordBinding(record) {
+        const stored = runtimeBindingFromRecord(record);
+        if (!runtimeBindingsMatch(stored, this.binding)
+            || (typeof record.app_url === 'string' && setupOrigin(record.app_url) !== setupOrigin(this.options.appUrl))) {
+            throw Object.assign(new Error('Stored machine belongs to another runtime binding or control plane.'), {
+                code: 'machine_binding_mismatch',
+            });
+        }
+        if (record.tunnel_url !== undefined)
+            runtimeWireUrl(this.binding, this.options.appUrl, text(record.tunnel_url), this.options.wireUrl);
+    }
     async loadMachine() {
         if (!this.selectedUserEmail)
             this.resolveUserForResume();
@@ -506,12 +602,15 @@ export class MachineHost {
         const status = readJson(paths.status);
         if (!publicRecord || !secretAuth || !installation || !status)
             return null;
+        this.assertRecordBinding(publicRecord);
         return { publicRecord, secretAuth, installation, ready: status.ready === true };
     }
     async saveMachine(machine) {
+        this.assertRecordBinding(machine.publicRecord);
         const recordEmail = normalizeEmail(machine.publicRecord.user_email);
         if (recordEmail)
             this.selectedUserEmail = recordEmail;
+        this.ownership.acquireRuntime(this.requireSelectedUser());
         const paths = this.paths();
         atomicJsonSet([
             [paths.publicRecord, machine.publicRecord],
@@ -535,6 +634,9 @@ export class MachineHost {
         const userRoot = this.paths(userEmail).userRoot;
         const workspaceRoot = join(userRoot, "workspaces");
         const runtimeToken = randomBytes(32).toString("base64url");
+        const runtimeIdentity = createRuntimeIdentity({
+            binding: this.binding, userScope: userEmail, deviceId, instanceId: randomUUID(),
+        });
         const env = {
             ...process.env,
             AMALGM_ROOT: this.amalgmRoot,
@@ -545,7 +647,8 @@ export class MachineHost {
             AMALGM_RUNTIME_LABEL: this.options.runtimeLabel ?? "main",
             AMALGM_BRANCH: this.options.branch ?? "main",
             AMALGM_RUNTIME_TOKEN: runtimeToken,
-            AMALGM_PROXY_URL: this.options.proxyUrl ?? "https://amalgm-api-proxy-v2.fly.dev",
+            AMALGM_LOCAL_SESSION: this.binding.localSession,
+            AMALGM_PROXY_URL: runtimeProxyOrigin(this.binding, this.options.appUrl, this.options.proxyUrl),
             AMALGM_WORKSPACES_DIR: workspaceRoot,
         };
         const pty = createPtyHost({
@@ -554,37 +657,48 @@ export class MachineHost {
         });
         const services = new Set(machine.installation.services);
         const serviceStateRoot = join(this.paths(userEmail).machineDir, "services");
-        const agentsService = services.has("agents")
-            ? new Agents({ stateDir: join(serviceStateRoot, "agents") })
+        const agentsSdk = services.has("agents") ? await import("@amalgm/agents") : null;
+        const agentsMcpSdk = agentsSdk ? await import("@amalgm/agents/mcp") : null;
+        const agentsHttpSdk = agentsSdk ? await import("@amalgm/agents/http") : null;
+        const toolsSdk = services.has("tools") ? await import("@amalgm/tools") : null;
+        const toolsHttpSdk = toolsSdk ? await import("@amalgm/tools/http") : null;
+        const includeApps = services.has("apps") || machine.installation.selection === "all";
+        const includeBrowser = services.has("browser") || machine.installation.selection === "all";
+        const appsSdk = toolsSdk && includeApps ? await import("@amalgm/apps") : null;
+        const browserSdk = toolsSdk && includeBrowser ? await import("@amalgm/browser") : null;
+        const browserMcpSdk = browserSdk ? await import("@amalgm/browser/mcp") : null;
+        const agentsService = agentsSdk
+            ? new agentsSdk.Agents({ stateDir: join(serviceStateRoot, "agents") })
             : null;
         if (agentsService)
             installBuiltinAgents(agentsService);
-        const agentsMcp = agentsService ? createAgentsMcp({ agents: agentsService }) : null;
-        const agentsRest = agentsService ? createAgentsRest({ agents: agentsService }) : null;
+        const agentsMcp = agentsService ? agentsMcpSdk.createMcpServer({ agents: agentsService }) : null;
+        const agentsRest = agentsService ? agentsHttpSdk.createRestServer({ agents: agentsService }) : null;
         const agentsAddress = agentsRest ? await agentsRest.listen(0, "127.0.0.1") : null;
         const platformTools = services.has("tools")
-            ? await platformToolDefinitions({
-                agents: agentsMcp ?? { tools: createAgentsMcpTools({}) },
-                apps: { tools: createAppsMcpTools({}) },
-                browser: { tools: createBrowserMcpTools({}) },
+            ? await (await import("./platform-tools.js")).platformToolDefinitions({
+                ...(agentsMcp ? { agents: agentsMcp } : {}),
+                ...(appsSdk ? { apps: { tools: appsSdk.createMcpTools({}) } } : {}),
+                ...(browserMcpSdk ? { browser: { tools: browserMcpSdk.createBrowserMcpTools({}) } } : {}),
+                chat: services.has("chat"),
                 products: {
-                    automations: Boolean(this.options.platformProducts),
-                    channels: Boolean(this.options.platformProducts),
+                    automations: Boolean(this.options.platformProducts?.automationsBaseUrl),
+                    channels: Boolean(this.options.platformProducts?.channelsBaseUrl),
                 },
             })
             : [];
         const toolsMcp = services.has("tools")
-            ? createToolsMcp({
+            ? toolsSdk.createMcpServer({
                 databaseFile: join(serviceStateRoot, "tools", "tools.db"),
                 deploymentDir: join(userRoot, "toolbox"),
                 systemTools: [...platformTools],
             })
             : null;
-        const toolsManagement = toolsMcp ? createToolsMcp({
+        const toolsManagement = toolsMcp ? toolsSdk.createMcpServer({
             toolbox: toolsMcp.toolbox,
             mcp: { loadout: [], includeManagement: true },
         }) : null;
-        const toolsHttp = toolsMcp ? createToolboxHttpServer({ toolbox: toolsMcp.toolbox }) : null;
+        const toolsHttp = toolsMcp ? toolsHttpSdk.createToolboxHttpServer({ toolbox: toolsMcp.toolbox }) : null;
         const toolsAddress = toolsHttp ? await toolsHttp.listen(0, "127.0.0.1") : null;
         if (services.has("chat") && (!agentsService || !toolsMcp)) {
             throw new Error("The Chat release requires Agents and Tools");
@@ -600,7 +714,7 @@ export class MachineHost {
                 : {}),
             ...(this.options.authorizationPlatform
                 ? { platform: this.options.authorizationPlatform }
-                : this.options.homedir ? { platform: "linux" } : {}),
+                : {}),
         });
         let gateway = null;
         const gatewayPort = () => {
@@ -610,7 +724,7 @@ export class MachineHost {
             return address.port;
         };
         const chat = services.has("chat") && agentsService && toolsMcp
-            ? await createShellChatComposition({
+            ? await (await import("./chat-composition.js")).createShellChatComposition({
                 ownerUserId: userId,
                 computerId,
                 stateDir: join(serviceStateRoot, "chat"),
@@ -625,13 +739,15 @@ export class MachineHost {
             })
             : null;
         const products = this.options.platformProducts
-            ? createPlatformProductHost({
+            ? await (await import("./platform-product-host.js")).createPlatformProductHost({
                 ...this.options.platformProducts,
                 authorization,
-                processes: createNodeAutomationProcessHost({
-                    defaultCwd: this.homedir,
-                    environment: { ...process.env, HOME: this.homedir },
-                }),
+                ...(this.options.platformProducts.automationsBaseUrl ? {
+                    processes: (await import("@amalgm/automations")).createNodeAutomationProcessHost({
+                        defaultCwd: this.homedir,
+                        environment: { ...process.env, HOME: this.homedir },
+                    }),
+                } : {}),
                 ...(toolsMcp ? { toolbox: toolsMcp.toolbox } : {}),
                 ...(chat ? { actions: { 'chat.chat_agent_run': chatAgentAction(chat.agentRunner) } } : {}),
                 ...(chat ? { inboundExecutor: {
@@ -647,23 +763,27 @@ export class MachineHost {
                     } } : {}),
             })
             : null;
-        const automationsMcp = products
-            ? await connectOfficialMcpServer(createAutomationMcpServer(products.automations), { name: 'amalgm-automations', version: '0.2.5' })
+        const automationsMcp = products?.automations
+            ? await (await import("./official-mcp-host.js")).connectOfficialMcpServer((await import("@amalgm/automations/mcp")).createAutomationMcpServer(products.automations), { name: 'amalgm-automations', version: '0.2.5' })
             : null;
-        const channelsMcp = products
-            ? await connectOfficialMcpServer(createChannelsMcpServer(products.channels), { name: 'amalgm-channels', version: '0.1.0' })
+        const channelsMcp = products?.channels
+            ? await (await import("./official-mcp-host.js")).connectOfficialMcpServer((await import("@amalgm/channels/mcp")).createChannelsMcpServer(products.channels), { name: 'amalgm-channels', version: '0.1.0' })
             : null;
-        const chatMcp = chat ? createChatMcpServer(chat.chat, { agentRunner: chat.agentRunner }) : null;
+        const chatMcp = chat ? (await import("@amalgm/chat/mcp")).createChatMcpServer(chat.chat, { agentRunner: chat.agentRunner }) : null;
         let appsMcp = null;
         const selectedAppsMcp = () => {
-            appsMcp ??= createAppsMcp({ stateDir: join(serviceStateRoot, "apps") });
+            if (!appsSdk)
+                throw new Error("Apps is not selected in this installation.");
+            appsMcp ??= appsSdk.createMcpServer({ stateDir: join(serviceStateRoot, "apps") });
             return appsMcp;
         };
         let browserMcp = null;
         let browserService = null;
         const selectedBrowserMcp = () => {
-            browserService ??= createBrowser({ root: join(serviceStateRoot, "browser") });
-            browserMcp ??= createBrowserMcpServer(browserService);
+            if (!browserSdk || !browserMcpSdk)
+                throw new Error("Browser is not selected in this installation.");
+            browserService ??= browserSdk.createBrowser({ root: join(serviceStateRoot, "browser") });
+            browserMcp ??= browserMcpSdk.createBrowserMcpServer(browserService);
             return browserMcp;
         };
         const closeSelectedProducts = async () => {
@@ -678,6 +798,7 @@ export class MachineHost {
             env,
             exemptPrefixes: ["/chat/egress/"],
             mounts: [
+                { prefix: RUNTIME_IDENTITY_PATH, handle: async () => runtimeIdentity },
                 {
                     prefix: "/entities/register",
                     handle: (body) => this.journey(body, () => this.registerWorkspace(bodyText(body, "path"))),
@@ -696,11 +817,12 @@ export class MachineHost {
                         protocol: "mcp-json-rpc",
                         handle: (body) => toolsMcp.handle(body),
                     }] : []),
-                ...(toolsMcp ? [{
+                ...(appsSdk ? [{
                         prefix: "/mcp/apps",
                         protocol: "mcp-json-rpc",
                         handle: (body) => selectedAppsMcp().handle(body),
-                    }, {
+                    }] : []),
+                ...(browserSdk ? [{
                         prefix: "/mcp/browser",
                         protocol: "mcp-json-rpc",
                         handle: (body) => selectedBrowserMcp().handle(body),
@@ -757,9 +879,10 @@ export class MachineHost {
             await this.groundHost.activateRuntimeTunnel(address.port, runtimeToken);
             products?.runner.start();
             commandPublication = {
+                instanceId: runtimeIdentity.instanceId,
                 userRoot: this.paths(userEmail).userRoot,
                 deviceId,
-                runtimeLabel: this.options.runtimeLabel ?? "main",
+                ...this.binding,
                 userScope: userEmail,
                 port: address.port,
                 token: runtimeToken,