tirtc-devtools-cli 0.0.9 → 0.0.11

package/vendor/app-server/dist/host/HostCommandCoordinator.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostCommandCoordinator = void 0;
+const HostProtocol_1 = require("./HostProtocol");
+function normalizeCommandPayload(payload) {
+    if (typeof payload === 'string') {
+        return {
+            payloadEncoding: 'utf8',
+            payload,
+        };
+    }
+    if (payload instanceof Uint8Array) {
+        return {
+            payloadEncoding: 'base64',
+            payload: Buffer.from(payload).toString('base64'),
+        };
+    }
+    if (Array.isArray(payload) && payload.every((value) => typeof value === 'number')) {
+        return {
+            payloadEncoding: 'base64',
+            payload: Buffer.from(payload).toString('base64'),
+        };
+    }
+    if (typeof payload === 'object' && payload !== null && 'type' in payload && payload.type === 'Buffer') {
+        const data = payload.data;
+        if (Array.isArray(data) && data.every((value) => typeof value === 'number')) {
+            return {
+                payloadEncoding: 'base64',
+                payload: Buffer.from(data).toString('base64'),
+            };
+        }
+    }
+    return {
+        payloadEncoding: 'utf8',
+        payload: '',
+    };
+}
+class HostCommandCoordinator {
+    state;
+    runtimeAdapter;
+    writeEvent;
+    snapshotPendingConnectionSummary;
+    noteIncomingConnection;
+    constructor(state, runtimeAdapter, writeEvent, snapshotPendingConnectionSummary, noteIncomingConnection) {
+        this.state = state;
+        this.runtimeAdapter = runtimeAdapter;
+        this.writeEvent = writeEvent;
+        this.snapshotPendingConnectionSummary = snapshotPendingConnectionSummary;
+        this.noteIncomingConnection = noteIncomingConnection;
+    }
+    handleInboundRemoteCommandRequest(payload) {
+        const remoteRequestId = Number(payload.remoteRequestId);
+        const commandId = Number(payload.commandId);
+        if (!Number.isInteger(remoteRequestId) || remoteRequestId <= 0 || !Number.isInteger(commandId)) {
+            return;
+        }
+        this.noteIncomingConnection(payload);
+        const normalizedPayload = normalizeCommandPayload(payload.payload);
+        const entry = {
+            remoteRequestId,
+            commandId,
+            payloadEncoding: normalizedPayload.payloadEncoding,
+            payload: normalizedPayload.payload,
+            receivedAt: new Date().toISOString(),
+            connection: this.snapshotPendingConnectionSummary(),
+        };
+        this.state.pendingRemoteCommands.set(remoteRequestId, entry);
+        this.writeEvent('command', 'command.remote.requested', {
+            ...entry,
+        });
+    }
+    clearPendingRemoteCommands(reason) {
+        if (this.state.pendingRemoteCommands.size === 0) {
+            return;
+        }
+        const clearedAt = new Date().toISOString();
+        for (const entry of this.state.pendingRemoteCommands.values()) {
+            this.writeEvent('command', 'command.remote.cleared', {
+                remoteRequestId: entry.remoteRequestId,
+                commandId: entry.commandId,
+                payloadEncoding: entry.payloadEncoding,
+                payload: entry.payload,
+                receivedAt: entry.receivedAt,
+                connection: entry.connection,
+                reason,
+                clearedAt,
+            });
+        }
+        this.state.pendingRemoteCommands.clear();
+    }
+    async handleCommandSend(params, nextSequenceNumber) {
+        const response = await this.runtimeAdapter.sendCommand(params.commandId, params.payloadEncoding, params.payload, params.timeoutMs);
+        return {
+            sequenceNumber: nextSequenceNumber,
+            commandId: params.commandId,
+            acceptedAt: new Date().toISOString(),
+            response,
+        };
+    }
+    async handleCommandReply(params) {
+        const requestedAt = new Date().toISOString();
+        this.writeEvent('command', 'reply.requested', {
+            remoteRequestId: params.remoteRequestId,
+            commandId: params.commandId,
+            payloadEncoding: params.payloadEncoding,
+            payloadLength: params.payload.length,
+            pendingCount: this.state.pendingRemoteCommands.size,
+            connectionState: this.state.connection.state,
+            at: requestedAt,
+        });
+        const entry = this.state.pendingRemoteCommands.get(params.remoteRequestId);
+        if (!entry) {
+            this.writeEvent('command', 'reply.rejected', {
+                remoteRequestId: params.remoteRequestId,
+                commandId: params.commandId,
+                reason: 'remote_request_not_pending',
+                pendingCount: this.state.pendingRemoteCommands.size,
+                connectionState: this.state.connection.state,
+                at: new Date().toISOString(),
+            });
+            throw new HostProtocol_1.HostProtocolError('invalid_request', `remoteRequestId ${params.remoteRequestId} is not pending`, false);
+        }
+        if (entry.commandId !== params.commandId) {
+            this.writeEvent('command', 'reply.rejected', {
+                remoteRequestId: params.remoteRequestId,
+                commandId: params.commandId,
+                expectedCommandId: entry.commandId,
+                reason: 'command_id_mismatch',
+                pendingCount: this.state.pendingRemoteCommands.size,
+                connectionState: this.state.connection.state,
+                at: new Date().toISOString(),
+            });
+            throw new HostProtocol_1.HostProtocolError('invalid_request', 'commandId does not match pending entry', false);
+        }
+        if (this.state.connection.state !== 'connected') {
+            this.writeEvent('command', 'reply.rejected', {
+                remoteRequestId: params.remoteRequestId,
+                commandId: params.commandId,
+                reason: 'connection_not_ready',
+                pendingCount: this.state.pendingRemoteCommands.size,
+                connectionState: this.state.connection.state,
+                at: new Date().toISOString(),
+            });
+            throw new HostProtocol_1.HostProtocolError('connection_not_ready', 'connection is not established', true);
+        }
+        try {
+            await this.runtimeAdapter.replyRemoteCommand(params.remoteRequestId, params.commandId, params.payloadEncoding, params.payload);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.writeEvent('command', 'reply.failed', {
+                remoteRequestId: params.remoteRequestId,
+                commandId: params.commandId,
+                reason: 'runtime_adapter_error',
+                message,
+                pendingCount: this.state.pendingRemoteCommands.size,
+                connectionState: this.state.connection.state,
+                at: new Date().toISOString(),
+            });
+            throw error;
+        }
+        this.state.pendingRemoteCommands.delete(params.remoteRequestId);
+        const repliedAt = new Date().toISOString();
+        this.writeEvent('command', 'command.remote.replied', {
+            remoteRequestId: params.remoteRequestId,
+            commandId: params.commandId,
+            payloadEncoding: entry.payloadEncoding,
+            payload: entry.payload,
+            receivedAt: entry.receivedAt,
+            connection: entry.connection,
+            repliedAt,
+        });
+        return {
+            remoteRequestId: params.remoteRequestId,
+            commandId: params.commandId,
+            repliedAt,
+        };
+    }
+    async handleCommandPendingList() {
+        const items = Array.from(this.state.pendingRemoteCommands.values())
+            .sort((left, right) => left.receivedAt.localeCompare(right.receivedAt));
+        const listedAt = new Date().toISOString();
+        this.writeEvent('command', 'pending.listed', {
+            count: items.length,
+            remoteRequestIds: items.map((item) => item.remoteRequestId),
+            commandIds: items.map((item) => item.commandId),
+            connectionState: this.state.connection.state,
+            listedAt,
+        });
+        return {
+            items,
+            listedAt,
+        };
+    }
+}
+exports.HostCommandCoordinator = HostCommandCoordinator;

package/vendor/app-server/dist/host/HostProtocol.d.ts

@@ -24,20 +24,10 @@ export type ServiceStartParams = {
     timeoutMs: number;
     bootstrapSendStreams?: StreamSendStartParams[];
 };
-export type ConnectionAutoTokenConfig = {
-    openapiEntry?: string;
-    accessId: string;
-    secretKey: string;
-    localId?: string;
-    userTtlSeconds?: number;
-    channelTtlSeconds?: number;
-};
 export type ConnectionConnectParams = {
     serviceEntry?: string;
     peerId: string;
-    token?: string;
-    tokenMode?: 'manual' | 'auto';
-    autoToken?: ConnectionAutoTokenConfig;
+    token: string;
     timeoutMs: number;
 };
 export type StreamSendStartParams = {

package/vendor/app-server/dist/host/HostProtocol.js

@@ -89,16 +89,6 @@ function getOptionalNumber(params, key) {
     }
     return value;
 }
-function getOptionalBoolean(params, key) {
-    const value = params[key];
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== 'boolean') {
-        throw new HostProtocolError('invalid_request', `Invalid ${key}`, false);
-    }
-    return value;
-}
 function getRecord(params, key) {
     const value = params[key];
     if (!isRecord(value)) {
@@ -144,38 +134,14 @@ function parseServiceStartParams(params) {
     };
 }
 function parseConnectionConnectParams(params) {
-    const token = getOptionalString(params, 'token');
-    const rawTokenMode = getOptionalString(params, 'tokenMode');
-    const tokenMode = rawTokenMode === undefined ? undefined : (() => {
-        if (rawTokenMode !== 'manual' && rawTokenMode !== 'auto') {
-            throw new HostProtocolError('invalid_request', 'Invalid tokenMode', false);
-        }
-        return rawTokenMode;
-    })();
-    const autoTokenRaw = params.autoToken;
-    let autoToken;
-    if (autoTokenRaw !== undefined) {
-        if (!isRecord(autoTokenRaw)) {
-            throw new HostProtocolError('invalid_request', 'Invalid autoToken', false);
-        }
-        autoToken = {
-            openapiEntry: getOptionalString(autoTokenRaw, 'openapiEntry'),
-            accessId: getString(autoTokenRaw, 'accessId'),
-            secretKey: getString(autoTokenRaw, 'secretKey'),
-            localId: getOptionalString(autoTokenRaw, 'localId'),
-            userTtlSeconds: getOptionalNumber(autoTokenRaw, 'userTtlSeconds'),
-            channelTtlSeconds: getOptionalNumber(autoTokenRaw, 'channelTtlSeconds'),
-        };
-    }
-    if (!token && !autoToken) {
-        throw new HostProtocolError('invalid_request', 'connection/connect requires token or autoToken', false);
+    const token = getString(params, 'token').trim();
+    if (token.length === 0) {
+        throw new HostProtocolError('invalid_request', 'connection/connect requires non-empty token', false);
     }
     return {
         serviceEntry: getOptionalString(params, 'serviceEntry'),
         peerId: getString(params, 'peerId'),
         token,
-        tokenMode,
-        autoToken,
         timeoutMs: getNumber(params, 'timeoutMs'),
     };
 }

package/vendor/app-server/dist/host/HostServer.d.ts

@@ -4,11 +4,11 @@ export declare class HostServer {
     private state;
     private artifactManager;
     private runtimeAdapter;
+    private commandCoordinator;
     private isInitialized;
     private eventCounter;
     private commandSequence;
     private tokenTool;
-    private runtimeCredentialTokenIssuer;
     private eventSinks;
     constructor(artifactManager: ArtifactManager, runtimeAdapter: RuntimeAdapter, hostEndpoint?: string);
     handleMessage(message: string): Promise<string | undefined>;
@@ -19,8 +19,6 @@ export declare class HostServer {
     appendHostLog(line: string): void;
     private handleRuntimeEvent;
     private snapshotPendingConnectionSummary;
-    private handleInboundRemoteCommandRequest;
-    private clearPendingRemoteCommands;
     private noteIncomingConnection;
     private handleIncomingConnectionDisconnected;
     private maybeAutoStartStreamFromRemoteDemand;
@@ -31,7 +29,6 @@ export declare class HostServer {
     private handleServiceStart;
     private handleServiceStop;
     private handleConnectionGet;
-    private resolveConnectionToken;
     private handleConnectionConnect;
     private startDeferredSendStreamsOnConnected;
     private activatePendingStreamsOnConnected;

package/vendor/app-server/dist/host/HostServer.js

@@ -36,8 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HostServer = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const HostCommandCoordinator_1 = require("./HostCommandCoordinator");
 const TokenTool_1 = require("./TokenTool");
-const RuntimeCredentialTokenIssuer_1 = require("./native/RuntimeCredentialTokenIssuer");
 const HostState_1 = require("./HostState");
 const HostProtocol_1 = require("./HostProtocol");
 function streamBindingKey(streamId, media) {
@@ -64,48 +64,15 @@ function resolveLocalAssetsDir(source) {
     }
     return assetsDir;
 }
-function normalizeCommandPayload(payload) {
-    if (typeof payload === 'string') {
-        return {
-            payloadEncoding: 'utf8',
-            payload,
-        };
-    }
-    if (payload instanceof Uint8Array) {
-        return {
-            payloadEncoding: 'base64',
-            payload: Buffer.from(payload).toString('base64'),
-        };
-    }
-    if (Array.isArray(payload) && payload.every((value) => typeof value === 'number')) {
-        return {
-            payloadEncoding: 'base64',
-            payload: Buffer.from(payload).toString('base64'),
-        };
-    }
-    if (typeof payload === 'object' && payload !== null && 'type' in payload && payload.type === 'Buffer') {
-        const data = payload.data;
-        if (Array.isArray(data) && data.every((value) => typeof value === 'number')) {
-            return {
-                payloadEncoding: 'base64',
-                payload: Buffer.from(data).toString('base64'),
-            };
-        }
-    }
-    return {
-        payloadEncoding: 'utf8',
-        payload: '',
-    };
-}
 class HostServer {
     state;
     artifactManager;
     runtimeAdapter;
+    commandCoordinator;
     isInitialized = false;
     eventCounter = 1;
     commandSequence = 1;
     tokenTool;
-    runtimeCredentialTokenIssuer;
     eventSinks = new Set();
     constructor(artifactManager, runtimeAdapter, hostEndpoint) {
         this.state = new HostState_1.HostState();
@@ -114,11 +81,7 @@ class HostServer {
         this.state.runtimeTarget = runtimeAdapter.runtimeTarget;
         this.state.hostEndpoint = hostEndpoint ?? runtimeAdapter.hostEndpoint;
         this.tokenTool = new TokenTool_1.TokenTool(this.artifactManager.getPaths().rootPath);
-        this.runtimeCredentialTokenIssuer = new RuntimeCredentialTokenIssuer_1.RuntimeCredentialTokenIssuer({
-            repoRoot: runtimeAdapter.repoRoot,
-            platform: runtimeAdapter.platform,
-            runtimeBundleRoot: runtimeAdapter.runtimeBundleRoot,
-        });
+        this.commandCoordinator = new HostCommandCoordinator_1.HostCommandCoordinator(this.state, this.runtimeAdapter, (family, kind, payload) => this.writeEvent(family, kind, payload), () => this.snapshotPendingConnectionSummary(), (payload) => this.noteIncomingConnection(payload));
         this.runtimeAdapter.setEventHandler((family, kind, payload) => {
             this.handleRuntimeEvent(family, kind, payload);
         });
@@ -218,7 +181,7 @@ class HostServer {
             return;
         }
         if (kind === 'command.remote.requested') {
-            this.handleInboundRemoteCommandRequest(payload);
+            this.commandCoordinator.handleInboundRemoteCommandRequest(payload);
             return;
         }
         if (kind === 'transport.remote.request_audio' ||
@@ -240,46 +203,6 @@ class HostServer {
             peerId: this.state.connection.peerId,
         };
     }
-    handleInboundRemoteCommandRequest(payload) {
-        const remoteRequestId = Number(payload.remoteRequestId);
-        const commandId = Number(payload.commandId);
-        if (!Number.isInteger(remoteRequestId) || remoteRequestId <= 0 || !Number.isInteger(commandId)) {
-            return;
-        }
-        this.noteIncomingConnection(payload);
-        const normalizedPayload = normalizeCommandPayload(payload.payload);
-        const entry = {
-            remoteRequestId,
-            commandId,
-            payloadEncoding: normalizedPayload.payloadEncoding,
-            payload: normalizedPayload.payload,
-            receivedAt: new Date().toISOString(),
-            connection: this.snapshotPendingConnectionSummary(),
-        };
-        this.state.pendingRemoteCommands.set(remoteRequestId, entry);
-        this.writeEvent('command', 'command.remote.requested', {
-            ...entry,
-        });
-    }
-    clearPendingRemoteCommands(reason) {
-        if (this.state.pendingRemoteCommands.size === 0) {
-            return;
-        }
-        const clearedAt = new Date().toISOString();
-        for (const entry of this.state.pendingRemoteCommands.values()) {
-            this.writeEvent('command', 'command.remote.cleared', {
-                remoteRequestId: entry.remoteRequestId,
-                commandId: entry.commandId,
-                payloadEncoding: entry.payloadEncoding,
-                payload: entry.payload,
-                receivedAt: entry.receivedAt,
-                connection: entry.connection,
-                reason,
-                clearedAt,
-            });
-        }
-        this.state.pendingRemoteCommands.clear();
-    }
     noteIncomingConnection(payload) {
         if (this.state.connection.state === 'connected') {
             return;
@@ -295,7 +218,7 @@ class HostServer {
         if (this.state.connection.state === 'idle' || this.state.connection.state === 'disconnected') {
             return;
         }
-        this.clearPendingRemoteCommands('connection_disconnect');
+        this.commandCoordinator.clearPendingRemoteCommands('connection_disconnect');
         const disconnectedAt = new Date().toISOString();
         this.state.connection = {
             state: 'disconnected',
@@ -442,7 +365,7 @@ class HostServer {
         };
     }
     async handleHostShutdown() {
-        this.clearPendingRemoteCommands('host_shutdown');
+        this.commandCoordinator.clearPendingRemoteCommands('host_shutdown');
         return {
             acceptedAt: new Date().toISOString(),
             service: this.state.service,
@@ -513,7 +436,7 @@ class HostServer {
             };
         }
         await this.runtimeAdapter.stopService();
-        this.clearPendingRemoteCommands('service_stop');
+        this.commandCoordinator.clearPendingRemoteCommands('service_stop');
         this.state.service.state = 'stopped';
         this.state.service.stoppedAt = new Date().toISOString();
         return {
@@ -525,29 +448,6 @@ class HostServer {
     async handleConnectionGet() {
         return this.state.connection;
     }
-    async resolveConnectionToken(params) {
-        const trimmedToken = params.token?.trim();
-        const wantsAuto = params.tokenMode === "auto" || (!trimmedToken && params.autoToken !== undefined);
-        if (!wantsAuto) {
-            if (!trimmedToken || trimmedToken.length === 0) {
-                throw new HostProtocol_1.HostProtocolError("invalid_request", "token is required when tokenMode is manual", false);
-            }
-            return { token: trimmedToken, mode: "manual" };
-        }
-        if (!params.autoToken) {
-            throw new HostProtocol_1.HostProtocolError("invalid_request", "auto token mode requires autoToken config", false);
-        }
-        const issued = await this.runtimeCredentialTokenIssuer.issueToken({
-            openapiEntry: params.autoToken.openapiEntry,
-            accessId: params.autoToken.accessId,
-            secretKey: params.autoToken.secretKey,
-            localId: params.autoToken.localId ?? params.peerId,
-            peerId: params.peerId,
-            userTtlSeconds: params.autoToken.userTtlSeconds,
-            channelTtlSeconds: params.autoToken.channelTtlSeconds,
-        });
-        return { token: issued, mode: "auto" };
-    }
     async handleConnectionConnect(params) {
         if (this.state.connection.state !== "idle" &&
             this.state.connection.state !== "disconnected" &&
@@ -557,14 +457,13 @@ class HostServer {
         if (this.state.service.state !== "stopped") {
             throw new HostProtocol_1.HostProtocolError("busy", "Service is not stopped", false);
         }
-        const tokenResolve = await this.resolveConnectionToken(params);
         this.writeEvent("connection", "token.prepared", {
-            mode: tokenResolve.mode,
+            mode: 'manual',
             peerId: params.peerId,
-            tokenLength: tokenResolve.token.length,
+            tokenLength: params.token.length,
             at: new Date().toISOString(),
         });
-        const resolvedServiceEntry = await this.runtimeAdapter.connect(params.serviceEntry, params.peerId, tokenResolve.token, params.timeoutMs);
+        const resolvedServiceEntry = await this.runtimeAdapter.connect(params.serviceEntry, params.peerId, params.token, params.timeoutMs);
         this.state.connection = {
             state: 'connecting',
             direction: 'outgoing',
@@ -640,7 +539,7 @@ class HostServer {
             };
         }
         await this.runtimeAdapter.disconnect();
-        this.clearPendingRemoteCommands('connection_disconnect');
+        this.commandCoordinator.clearPendingRemoteCommands('connection_disconnect');
         this.state.connection.state = 'disconnected';
         this.state.connection.disconnectedAt = new Date().toISOString();
         return {
@@ -765,50 +664,15 @@ class HostServer {
         };
     }
     async handleCommandSend(params) {
-        const response = await this.runtimeAdapter.sendCommand(params.commandId, params.payloadEncoding, params.payload, params.timeoutMs);
-        return {
-            sequenceNumber: this.commandSequence++,
-            commandId: params.commandId,
-            acceptedAt: new Date().toISOString(),
-            response,
-        };
+        const result = await this.commandCoordinator.handleCommandSend(params, this.commandSequence);
+        this.commandSequence += 1;
+        return result;
     }
     async handleCommandReply(params) {
-        const entry = this.state.pendingRemoteCommands.get(params.remoteRequestId);
-        if (!entry) {
-            throw new HostProtocol_1.HostProtocolError('invalid_request', `remoteRequestId ${params.remoteRequestId} is not pending`, false);
-        }
-        if (entry.commandId !== params.commandId) {
-            throw new HostProtocol_1.HostProtocolError('invalid_request', 'commandId does not match pending entry', false);
-        }
-        if (this.state.connection.state !== 'connected') {
-            throw new HostProtocol_1.HostProtocolError('connection_not_ready', 'connection is not established', true);
-        }
-        await this.runtimeAdapter.replyRemoteCommand(params.remoteRequestId, params.commandId, params.payloadEncoding, params.payload);
-        this.state.pendingRemoteCommands.delete(params.remoteRequestId);
-        const repliedAt = new Date().toISOString();
-        this.writeEvent('command', 'command.remote.replied', {
-            remoteRequestId: params.remoteRequestId,
-            commandId: params.commandId,
-            payloadEncoding: entry.payloadEncoding,
-            payload: entry.payload,
-            receivedAt: entry.receivedAt,
-            connection: entry.connection,
-            repliedAt,
-        });
-        return {
-            remoteRequestId: params.remoteRequestId,
-            commandId: params.commandId,
-            repliedAt,
-        };
+        return this.commandCoordinator.handleCommandReply(params);
     }
     async handleCommandPendingList() {
-        const items = Array.from(this.state.pendingRemoteCommands.values())
-            .sort((left, right) => left.receivedAt.localeCompare(right.receivedAt));
-        return {
-            items,
-            listedAt: new Date().toISOString(),
-        };
+        return this.commandCoordinator.handleCommandPendingList();
     }
     async handleEventsSubscribe(params) {
         const families = params.families ?? [];

package/vendor/app-server/dist/host/RuntimeAdapter.js

@@ -78,8 +78,8 @@ function resolveRepoRoot() {
         const normalized = path.resolve(candidate);
         if (pathExists(path.join(normalized, 'bin/runtime')) ||
             pathExists(path.join(normalized, 'bin/native')) ||
-            pathExists(path.join(normalized, 'app-server/bin/runtime')) ||
-            pathExists(path.join(normalized, 'app-server'))) {
+            pathExists(path.join(normalized, 'products/app-server/bin/runtime')) ||
+            pathExists(path.join(normalized, 'products/app-server'))) {
             return normalized;
         }
     }

package/vendor/app-server/dist/host/native/RuntimeCredentialTokenIssuer.js

@@ -63,9 +63,9 @@ class RuntimeCredentialTokenIssuer {
         const candidates = [
             explicit,
             path.join(this.repoRoot, `bin/native/${this.platform}/credential_napi.node`),
-            path.join(this.repoRoot, `app-server/bin/native/${this.platform}/credential_napi.node`),
+            path.join(this.repoRoot, `products/app-server/bin/native/${this.platform}/credential_napi.node`),
             path.join(this.repoRoot, `.build/app-server/native/${this.platform}/credential_napi.node`),
-            path.resolve(process.cwd(), `app-server/bin/native/${this.platform}/credential_napi.node`),
+            path.resolve(process.cwd(), `products/app-server/bin/native/${this.platform}/credential_napi.node`),
             path.resolve(process.cwd(), `.build/app-server/native/${this.platform}/credential_napi.node`),
         ].filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
         for (const candidate of candidates) {
@@ -75,7 +75,7 @@ class RuntimeCredentialTokenIssuer {
             }
         }
         throw new Error('credential addon missing for platform ' + this.platform +
-            '; run: npm --prefix app-server run build:native');
+            '; run: npm --prefix products/app-server run build:native');
     }
     ensureBinding() {
         if (this.binding) {

package/vendor/app-server/dist/host/native/RuntimeHostBridge.js

@@ -54,9 +54,9 @@ class RuntimeHostBridge {
         const candidates = [
             explicit,
             path.join(this.repoRoot, `bin/native/${this.platform}/runtime_host_napi.node`),
-            path.join(this.repoRoot, `app-server/bin/native/${this.platform}/runtime_host_napi.node`),
+            path.join(this.repoRoot, `products/app-server/bin/native/${this.platform}/runtime_host_napi.node`),
             path.join(this.repoRoot, `.build/app-server/native/${this.platform}/runtime_host_napi.node`),
-            path.resolve(process.cwd(), `app-server/bin/native/${this.platform}/runtime_host_napi.node`),
+            path.resolve(process.cwd(), `products/app-server/bin/native/${this.platform}/runtime_host_napi.node`),
             path.resolve(process.cwd(), `.build/app-server/native/${this.platform}/runtime_host_napi.node`),
         ].filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
         for (const candidate of candidates) {
@@ -66,7 +66,7 @@ class RuntimeHostBridge {
             }
         }
         throw new Error('runtime host addon missing for platform ' + this.platform +
-            '; run: npm --prefix app-server run build:native');
+            '; run: npm --prefix products/app-server run build:native');
     }
     resolveRuntimeLibDirs() {
         const dirs = [];
@@ -75,7 +75,7 @@ class RuntimeHostBridge {
             ? path.join(path.resolve(envBundleRoot.trim()), 'lib')
             : '';
         const runtimeBundleLib = path.join(this.repoRoot, `bin/runtime/${this.platform}/lib`);
-        const repoRuntimeBundleLib = path.join(this.repoRoot, `app-server/bin/runtime/${this.platform}/lib`);
+        const repoRuntimeBundleLib = path.join(this.repoRoot, `products/app-server/bin/runtime/${this.platform}/lib`);
         const nanoLib = path.join(this.repoRoot, `runtime/core/3rd/tirtc-nano/install/${this.platform}/TIRTC_NANO/lib`);
         if (runtimeBundleLibFromEnv && pathExists(runtimeBundleLibFromEnv)) {
             dirs.push(runtimeBundleLibFromEnv);

package/vendor/app-server/dist/host/runtime_backed_preflight.js

@@ -32,7 +32,7 @@ function resolveRuntimeBundleRoot(repoRoot, runtimePlatform) {
     if (pathExists(path_1.default.resolve(repoRoot, 'bin/runtime', runtimePlatform))) {
         return path_1.default.resolve(repoRoot, 'bin/runtime', runtimePlatform);
     }
-    return path_1.default.resolve(repoRoot, 'app-server/bin/runtime', runtimePlatform);
+    return path_1.default.resolve(repoRoot, 'products/app-server/bin/runtime', runtimePlatform);
 }
 function dockerAvailable() {
     try {
@@ -57,7 +57,7 @@ function probeRuntimeBackedPreflight(repoRoot) {
     if (required.some((entry) => !pathExists(entry))) {
         return {
             ready: false,
-            reason: 'runtime-backed sdk bundle is missing under app-server/bin/runtime/<platform>',
+            reason: 'runtime-backed sdk bundle is missing under products/app-server/bin/runtime/<platform>',
             runtimePlatform,
             runtimeBundleRoot,
         };

package/vendor/app-server/dist/host/tests/helpers/runtime_e2e_local_config.js

@@ -13,7 +13,7 @@ function asBoolean(value) {
     return typeof value === 'boolean' ? value : undefined;
 }
 function resolveConfigPath(repoRoot) {
-    return path_1.default.resolve(repoRoot, 'app-server/host/tests/.local/runtime-backed.e2e.local.json');
+    return path_1.default.resolve(repoRoot, 'products/app-server/host/tests/.local/runtime-backed.e2e.local.json');
 }
 function requireString(raw, key) {
     const value = asString(raw[key]);