@quenty/studio-bridge 0.21.0 → 0.22.0

package/src/deploy/deploy-places.test.ts

@@ -0,0 +1,127 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { afterEach, beforeEach, describe, it, expect } from 'vitest';
+import {
+  findInstancesShowingPlaceAsync,
+  tryFindFolderInstanceAsync,
+} from './deploy-places.js';
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'deploy-places-test-'));
+  await fs.writeFile(
+    path.join(tempDir, 'deploy.nevermore.json'),
+    JSON.stringify({
+      targets: {
+        test: { universeId: 9, placeId: 111, project: 'test.project.json' },
+        integration: {
+          places: [
+            {
+              name: 'hub',
+              universeId: 9,
+              placeId: 222,
+              project: 'hub.project.json',
+            },
+          ],
+        },
+      },
+    })
+  );
+});
+
+afterEach(async () => {
+  await fs.rm(tempDir, { recursive: true, force: true });
+});
+
+/** Studios by instance id, with the place id each registered and the one each has open now. */
+function createConnection(
+  studios: Record<string, { registered: number; live: number }>
+) {
+  const ids = Object.keys(studios);
+  return {
+    listInstances: () =>
+      ids.map((instanceId) => ({
+        instanceId,
+        placeId: studios[instanceId].registered,
+      })),
+    listSessions: () =>
+      ids.map((instanceId) => ({
+        instanceId,
+        sessionId: `${instanceId}-edit`,
+        context: 'edit',
+      })),
+    getSession: (sessionId: string) => ({
+      queryStateAsync: async () => ({
+        placeId: studios[sessionId.replace(/-edit$/, '')].live,
+      }),
+    }),
+  } as any;
+}
+
+describe('tryFindFolderInstanceAsync', () => {
+  it("picks the one Studio that has a place of the folder's config open", async () => {
+    const connection = createConnection({
+      'local-1a2b': { registered: 0, live: 0 },
+      'place1-3c4d': { registered: 0, live: 222 },
+    });
+
+    const found = await tryFindFolderInstanceAsync(connection, tempDir);
+
+    expect(found?.instanceId).toBe('place1-3c4d');
+    expect(found?.deployPlace.selector).toBe('integration');
+  });
+
+  it('leaves the choice alone when two Studios have the config open', async () => {
+    const connection = createConnection({
+      'place1-1a2b': { registered: 111, live: 111 },
+      'place1-3c4d': { registered: 222, live: 222 },
+    });
+
+    expect(
+      await tryFindFolderInstanceAsync(connection, tempDir)
+    ).toBeUndefined();
+  });
+
+  it('leaves a single Studio to the usual resolution', async () => {
+    const connection = createConnection({
+      'local-1a2b': { registered: 0, live: 0 },
+    });
+
+    expect(
+      await tryFindFolderInstanceAsync(connection, tempDir)
+    ).toBeUndefined();
+  });
+
+  it('does nothing outside a deploy.nevermore.json', async () => {
+    const empty = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'deploy-places-empty-')
+    );
+    const connection = createConnection({
+      'place1-1a2b': { registered: 111, live: 111 },
+      'local-3c4d': { registered: 0, live: 0 },
+    });
+
+    try {
+      expect(
+        await tryFindFolderInstanceAsync(connection, empty)
+      ).toBeUndefined();
+    } finally {
+      await fs.rm(empty, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('findInstancesShowingPlaceAsync', () => {
+  it('reads a cloud place id live when it registered as 0', async () => {
+    const connection = createConnection({
+      'place1-1a2b': { registered: 0, live: 111 },
+      'place1-3c4d': { registered: 222, live: 222 },
+    });
+
+    expect(await findInstancesShowingPlaceAsync(connection, 111)).toEqual([
+      'place1-1a2b',
+    ]);
+  });
+});

package/src/deploy/deploy-places.ts

@@ -0,0 +1,229 @@
+/**
+ * Finds the places of the nearest `deploy.nevermore.json`, so commands run in
+ * a package or game folder can open or pick that project's Studio.
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import {
+  formatTargetSelector,
+  loadDeployConfigAsync,
+  parseTargetSelector,
+  resolveDefaultTargetName,
+  resolveDeployTargetPlaces,
+  type DeployConfig,
+  type DeployTarget,
+} from '@quenty/nevermore-deploy';
+import type { BridgeConnection, InstanceInfo } from '../bridge/index.js';
+
+export const DEPLOY_CONFIG_FILE_NAME = 'deploy.nevermore.json';
+
+const PLACE_ID_QUERY_TIMEOUT_MS = 3_000;
+
+export interface DeployPlace {
+  /** The target selector naming this place, e.g. `test` or `integration.places.hub`. */
+  selector: string;
+  place: DeployTarget;
+  configPath: string;
+}
+
+/**
+ * The nearest `deploy.nevermore.json` at or above `startDir` that has targets.
+ * A repo root's config can hold only a shared `universeId`, so it is skipped.
+ */
+export async function findDeployConfigPathAsync(
+  startDir: string
+): Promise<string | undefined> {
+  let current = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(current, DEPLOY_CONFIG_FILE_NAME);
+    if (await hasTargetsAsync(candidate)) {
+      return candidate;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}
+
+async function hasTargetsAsync(configPath: string): Promise<boolean> {
+  let content: string;
+  try {
+    content = await fs.readFile(configPath, 'utf-8');
+  } catch {
+    return false;
+  }
+  try {
+    return 'targets' in (JSON.parse(content) as object);
+  } catch {
+    // Loading it reports the parse error
+    return true;
+  }
+}
+
+/**
+ * The place a target names, from the config nearest `cwd`. Without `target`,
+ * uses the config's default target. Undefined when no config is found and no
+ * target was asked for.
+ */
+export async function resolveDeployPlaceAsync(
+  cwd: string,
+  target?: string
+): Promise<DeployPlace | undefined> {
+  const configPath = await findDeployConfigPathAsync(cwd);
+  if (!configPath) {
+    if (target !== undefined) {
+      throw new Error(
+        `No ${DEPLOY_CONFIG_FILE_NAME} in ${cwd} or its parents to find target '${target}' in`
+      );
+    }
+    return undefined;
+  }
+
+  const config = await loadDeployConfigAsync(configPath);
+  let selector = target;
+  if (selector === undefined) {
+    try {
+      selector = resolveDefaultTargetName(config);
+    } catch {
+      throw new Error(
+        `${configPath} has several targets and no default. Name one: ${Object.keys(
+          config.targets
+        ).join(', ')}`
+      );
+    }
+  }
+  const places = resolveDeployTargetPlaces(config, selector);
+  if (places.length > 1) {
+    const { targetName } = parseTargetSelector(selector);
+    const choices = places
+      .map((place) =>
+        place.name
+          ? `  - ${formatTargetSelector({ targetName, placeName: place.name })}`
+          : `  - place ${place.placeId}`
+      )
+      .join('\n');
+    throw new Error(
+      `Target '${targetName}' has ${places.length} places. Pick one:\n${choices}`
+    );
+  }
+
+  return { selector, place: places[0], configPath };
+}
+
+/** Every place in `config`, each under the selector that names it. */
+export function listDeployPlaces(
+  config: DeployConfig,
+  configPath: string
+): DeployPlace[] {
+  return Object.keys(config.targets).flatMap((targetName) => {
+    const places = resolveDeployTargetPlaces(config, targetName);
+    return places.map((place) => ({
+      selector:
+        places.length > 1 && place.name
+          ? formatTargetSelector({ targetName, placeName: place.name })
+          : targetName,
+      place,
+      configPath,
+    }));
+  });
+}
+
+export interface FolderInstance {
+  instanceId: string;
+  deployPlace: DeployPlace;
+}
+
+/**
+ * The one connected Studio that has a place of the nearest config open, when
+ * several Studios are connected and exactly one does. Undefined otherwise,
+ * including when the config can't be read.
+ */
+export async function tryFindFolderInstanceAsync(
+  connection: BridgeConnection,
+  cwd: string
+): Promise<FolderInstance | undefined> {
+  const instances = connection.listInstances();
+  if (instances.length < 2) {
+    return undefined;
+  }
+
+  const configPath = await findDeployConfigPathAsync(cwd);
+  if (!configPath) {
+    return undefined;
+  }
+  let places: DeployPlace[];
+  try {
+    places = listDeployPlaces(
+      await loadDeployConfigAsync(configPath),
+      configPath
+    );
+  } catch {
+    return undefined;
+  }
+
+  const placeIds = await readInstancePlaceIdsAsync(connection);
+  const matches = placeIds.flatMap(({ instanceId, placeId }) => {
+    const deployPlace = places.find((p) => p.place.placeId === placeId);
+    return deployPlace ? [{ instanceId, deployPlace }] : [];
+  });
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
+/** The connected Studios whose open place is `placeId`. */
+export async function findInstancesShowingPlaceAsync(
+  connection: BridgeConnection,
+  placeId: number
+): Promise<string[]> {
+  const placeIds = await readInstancePlaceIdsAsync(connection);
+  return placeIds
+    .filter((instance) => instance.placeId === placeId)
+    .map((instance) => instance.instanceId);
+}
+
+async function readInstancePlaceIdsAsync(
+  connection: BridgeConnection
+): Promise<Array<{ instanceId: string; placeId: number | undefined }>> {
+  return Promise.all(
+    connection.listInstances().map(async (instance) => ({
+      instanceId: instance.instanceId,
+      placeId: await tryGetPlaceIdAsync(connection, instance),
+    }))
+  );
+}
+
+/** A cloud place loads after the plugin registers, so a registered 0 is read again live. */
+async function tryGetPlaceIdAsync(
+  connection: BridgeConnection,
+  instance: InstanceInfo
+): Promise<number | undefined> {
+  if (instance.placeId) {
+    return instance.placeId;
+  }
+
+  const editSession = connection
+    .listSessions()
+    .find((s) => s.instanceId === instance.instanceId && s.context === 'edit');
+  const session = editSession && connection.getSession(editSession.sessionId);
+  if (!session) {
+    return undefined;
+  }
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const state = await Promise.race([
+      session.queryStateAsync(),
+      new Promise<undefined>((resolve) => {
+        timer = setTimeout(() => resolve(undefined), PLACE_ID_QUERY_TIMEOUT_MS);
+      }),
+    ]);
+    return state?.placeId;
+  } catch {
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/index.ts

@@ -107,11 +107,16 @@ export {
   queryLogsHandlerAsync,
   captureScreenshotHandlerAsync,
   queryDataModelHandlerAsync,
+  exportInstancesHandlerAsync,
+  importInstancesHandlerAsync,
   execHandlerAsync,
   runHandlerAsync,
   launchHandlerAsync,
   connectHandlerAsync,
   disconnectHandler,
+  playtestStartHandlerAsync,
+  playtestStopHandlerAsync,
+  playtestRunHandlerAsync,
 } from './commands/index.js';
 
 export type {
@@ -130,6 +135,12 @@ export type {
   ConnectOptions,
   ConnectResult,
   DisconnectResult,
+  PlaytestStartOptions,
+  PlaytestStartResult,
+  PlaytestStopOptions,
+  PlaytestStopResult,
+  PlaytestRunOptions,
+  PlaytestRunResult,
 } from './commands/index.js';
 
 // Command option/result types that conflict with bridge types are aliased

package/src/linux/linux-studio-launcher.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('fs', () => ({
+  openSync: vi.fn(() => 7),
+  closeSync: vi.fn(),
+}));
+
+vi.mock('os', () => ({
+  tmpdir: vi.fn(() => '/tmp'),
+}));
+
+vi.mock('child_process', () => ({
+  spawn: vi.fn(),
+}));
+
+vi.mock('@quenty/cli-output-helpers', () => ({
+  OutputHelper: { verbose: vi.fn() },
+}));
+
+vi.mock('./linux-config.js', () => ({
+  resolveLinuxConfig: vi.fn(() => ({ display: ':99' })),
+}));
+
+vi.mock('./linux-wine-env.js', () => ({
+  buildWineEnv: vi.fn(() => ({ DISPLAY: ':99' })),
+}));
+
+vi.mock('./linux-display-manager.js', () => ({
+  ensureDisplayAsync: vi.fn(async () => undefined),
+  ensureWindowManagerAsync: vi.fn(async () => undefined),
+}));
+
+import { spawn } from 'child_process';
+import { launchStudioLinuxAsync } from './linux-studio-launcher.js';
+
+const mockSpawn = vi.mocked(spawn);
+
+function makeFakeProc() {
+  return {
+    on: vi.fn(),
+    unref: vi.fn(),
+    kill: vi.fn(),
+    stdout: { on: vi.fn(), unref: vi.fn() },
+  };
+}
+
+describe('launchStudioLinuxAsync', () => {
+  let wineProc: ReturnType<typeof makeFakeProc>;
+  let tailProc: ReturnType<typeof makeFakeProc>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    wineProc = makeFakeProc();
+    tailProc = makeFakeProc();
+    mockSpawn.mockImplementation(((cmd: string) =>
+      cmd === 'tail' ? tailProc : wineProc) as never);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('unrefs the tail stdout pipe so the CLI can exit', async () => {
+    await launchStudioLinuxAsync('/studio/Studio.exe', '/place.rbxl');
+
+    expect(tailProc.unref).toHaveBeenCalled();
+    expect(tailProc.stdout.unref).toHaveBeenCalled();
+  });
+
+  it('reaps the tail process when the CLI exits', async () => {
+    const onceSpy = vi.spyOn(process, 'once');
+
+    await launchStudioLinuxAsync('/studio/Studio.exe', '/place.rbxl');
+
+    const exitHandler = onceSpy.mock.calls.find(([evt]) => evt === 'exit')?.[1];
+    expect(exitHandler).toBeTypeOf('function');
+
+    (exitHandler as () => void)();
+    expect(tailProc.kill).toHaveBeenCalledWith('SIGTERM');
+  });
+
+  it('does not unref the detached Studio process stdio', async () => {
+    await launchStudioLinuxAsync('/studio/Studio.exe', '/place.rbxl');
+
+    expect(wineProc.unref).toHaveBeenCalled();
+    const wineCall = mockSpawn.mock.calls.find(([cmd]) => cmd === 'wine');
+    expect((wineCall?.[2] as { detached?: boolean })?.detached).toBe(true);
+  });
+});

package/src/linux/linux-studio-launcher.ts

@@ -7,6 +7,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { spawn } from 'child_process';
+import type { Socket } from 'net';
 import { OutputHelper } from '@quenty/cli-output-helpers';
 import { resolveLinuxConfig } from './linux-config.js';
 import { buildWineEnv } from './linux-wine-env.js';
@@ -69,6 +70,16 @@ export async function launchStudioLinuxAsync(
     }
   });
   tailProc.unref();
+  // The stdout pipe is ref'd separately and `tail -f` never closes it
+  (tailProc.stdout as Socket | null)?.unref();
+
+  process.once('exit', () => {
+    try {
+      tailProc.kill('SIGTERM');
+    } catch {
+      // Best effort
+    }
+  });
 
   let killed = false;
   const killAsync = async () => {

package/src/plugin/persistent-plugin-installer.test.ts

@@ -43,6 +43,10 @@ vi.mock('../process/studio-process-manager.js', () => ({
   findPluginsFolder: vi.fn(() => '/mock/plugins/folder'),
 }));
 
+vi.mock('./plugin-build-version.js', () => ({
+  getPluginBuildVersionAsync: vi.fn().mockResolvedValue('abc123'),
+}));
+
 vi.mock('./plugin-discovery.js', () => ({
   getPersistentPluginPath: mockGetPersistentPluginPath,
 }));

package/src/plugin/persistent-plugin-installer.ts

@@ -12,6 +12,7 @@ import {
 } from '@quenty/nevermore-template-helpers';
 import { findPluginsFolder } from '../process/studio-process-manager.js';
 import { getPersistentPluginPath } from './plugin-discovery.js';
+import { getPluginBuildVersionAsync } from './plugin-build-version.js';
 
 const templateDir = resolveTemplatePath(
   import.meta.url,
@@ -39,7 +40,7 @@ export async function installPersistentPluginAsync(): Promise<string> {
     await TemplateHelper.createDirectoryContentsAsync(
       templateDir,
       buildContext.buildDir,
-      {},
+      { PLUGIN_VERSION: await getPluginBuildVersionAsync() },
       false
     );
 

package/src/plugin/plugin-build-version.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { hashTemplateDirAsync } from './plugin-build-version.js';
+
+describe('hashTemplateDirAsync', () => {
+  const dirs: string[] = [];
+
+  afterEach(async () => {
+    for (const dir of dirs) {
+      await fs.rm(dir, { recursive: true, force: true });
+    }
+    dirs.length = 0;
+  });
+
+  async function makeTemplateAsync(
+    files: Record<string, string>
+  ): Promise<string> {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sb-template-'));
+    dirs.push(dir);
+    for (const [name, contents] of Object.entries(files)) {
+      await fs.mkdir(path.dirname(path.join(dir, name)), { recursive: true });
+      await fs.writeFile(path.join(dir, name), contents);
+    }
+    return dir;
+  }
+
+  it('changes when plugin source changes', async () => {
+    const before = await makeTemplateAsync({ 'src/Plugin.lua': 'print(1)' });
+    const after = await makeTemplateAsync({ 'src/Plugin.lua': 'print(2)' });
+
+    expect(await hashTemplateDirAsync(before)).not.toBe(
+      await hashTemplateDirAsync(after)
+    );
+  });
+
+  it('ignores specs and line endings', async () => {
+    const plain = await makeTemplateAsync({ 'src/Plugin.lua': 'a\nb\n' });
+    const withSpec = await makeTemplateAsync({
+      'src/Plugin.lua': 'a\r\nb\r\n',
+      'src/Plugin.spec.lua': 'test',
+    });
+
+    expect(await hashTemplateDirAsync(plain)).toBe(
+      await hashTemplateDirAsync(withSpec)
+    );
+  });
+
+  it('is a short hex string', async () => {
+    const dir = await makeTemplateAsync({ 'src/Plugin.lua': 'print(1)' });
+
+    expect(await hashTemplateDirAsync(dir)).toMatch(/^[0-9a-f]{12}$/);
+  });
+});

package/src/plugin/plugin-build-version.ts

@@ -0,0 +1,53 @@
+/**
+ * The plugin reports a hash of the template it was built from as its
+ * `pluginVersion`, so the CLI can tell when the installed plugin is stale.
+ */
+
+import { createHash } from 'crypto';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { resolveTemplatePath } from '@quenty/nevermore-template-helpers';
+
+const templateDir = resolveTemplatePath(
+  import.meta.url,
+  'studio-bridge-plugin'
+);
+
+let cachedVersion: Promise<string> | undefined;
+
+export function getPluginBuildVersionAsync(): Promise<string> {
+  cachedVersion ??= hashTemplateDirAsync(templateDir);
+  return cachedVersion;
+}
+
+export async function hashTemplateDirAsync(dir: string): Promise<string> {
+  const files = await listTemplateFilesAsync(dir, dir);
+  files.sort();
+
+  const hash = createHash('sha256');
+  for (const relativePath of files) {
+    const contents = await fs.readFile(path.join(dir, relativePath), 'utf-8');
+    hash.update(relativePath.replace(/\\/g, '/'));
+    hash.update('\0');
+    hash.update(contents.replace(/\r\n/g, '\n'));
+    hash.update('\0');
+  }
+  return hash.digest('hex').slice(0, 12);
+}
+
+async function listTemplateFilesAsync(
+  baseDir: string,
+  currentDir: string
+): Promise<string[]> {
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+  const files: string[] = [];
+  for (const entry of entries) {
+    const fullPath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await listTemplateFilesAsync(baseDir, fullPath)));
+    } else if (!entry.name.endsWith('.spec.lua')) {
+      files.push(path.relative(baseDir, fullPath));
+    }
+  }
+  return files;
+}

package/src/plugin/plugin-injector.ts

@@ -9,6 +9,7 @@ import {
   resolveTemplatePath,
 } from '@quenty/nevermore-template-helpers';
 import { findPluginsFolder } from '../process/studio-process-manager.js';
+import { getPluginBuildVersionAsync } from './plugin-build-version.js';
 
 const templateDir = resolveTemplatePath(
   import.meta.url,
@@ -43,7 +44,12 @@ export async function injectPluginAsync(
     await TemplateHelper.createDirectoryContentsAsync(
       templateDir,
       buildContext.buildDir,
-      { PORT: String(port), SESSION_ID: sessionId, EPHEMERAL: 'true' },
+      {
+        PORT: String(port),
+        SESSION_ID: sessionId,
+        EPHEMERAL: 'true',
+        PLUGIN_VERSION: await getPluginBuildVersionAsync(),
+      },
       false
     );