@quenty/studio-bridge 0.23.0 → 0.24.0

package/src/commands/process/close/close.test.ts

@@ -14,7 +14,11 @@ vi.mock('../../../process/studio-process-closer.js', async (importOriginal) => {
 import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
-import { closeDeployTargetAsync, processCloseHandlerAsync } from './close.js';
+import {
+  closeAllStudiosAsync,
+  closeDeployTargetAsync,
+  processCloseHandlerAsync,
+} from './close.js';
 import {
   closeStudioProcessAsync,
   listStudioProcessesAsync,
@@ -124,13 +128,13 @@ describe('processCloseHandlerAsync', () => {
     expect(closeStudioProcessAsync).toHaveBeenCalledWith(10, { force: true });
   });
 
-  it('suggests --force when Studio stays open', async () => {
+  it('says Studio is asking to save when it stays open', async () => {
     vi.mocked(closeStudioProcessAsync).mockResolvedValue(false);
 
     const result = await processCloseHandlerAsync(session);
 
     expect(result.success).toBe(false);
-    expect(result.summary).toContain('--force');
+    expect(result.summary).toContain('likely asking to save');
   });
 
   it('fails without closing when no window shows the place', async () => {
@@ -248,3 +252,48 @@ describe('closeDeployTargetAsync', () => {
     expect(result).toMatchObject({ success: true, pid: 50 });
   });
 });
+
+describe('closeAllStudiosAsync', () => {
+  beforeEach(() => {
+    vi.mocked(closeStudioProcessAsync).mockReset().mockResolvedValue(true);
+  });
+
+  it('closes every running Studio without saving', async () => {
+    vi.mocked(listStudioProcessesAsync).mockResolvedValue([
+      { pid: 10, windowTitle: 'Place1 - Roblox Studio' },
+      { pid: 20, windowTitle: 'Place2 - Roblox Studio' },
+    ]);
+
+    const result = await closeAllStudiosAsync({ force: true });
+
+    expect(closeStudioProcessAsync).toHaveBeenCalledWith(10, { force: true });
+    expect(closeStudioProcessAsync).toHaveBeenCalledWith(20, { force: true });
+    expect(result).toMatchObject({ success: true, pids: [10, 20] });
+    expect(result.summary).toBe('Closed 2 Studios (pids 10, 20)');
+  });
+
+  it('succeeds when no Studio is running', async () => {
+    vi.mocked(listStudioProcessesAsync).mockResolvedValue([]);
+
+    const result = await closeAllStudiosAsync({ force: true });
+
+    expect(closeStudioProcessAsync).not.toHaveBeenCalled();
+    expect(result).toMatchObject({ success: true, pids: [] });
+  });
+
+  it('names the Studios that stayed open', async () => {
+    vi.mocked(listStudioProcessesAsync).mockResolvedValue([
+      { pid: 10, windowTitle: 'Place1 - Roblox Studio' },
+      { pid: 20, windowTitle: 'Place2 - Roblox Studio' },
+    ]);
+    vi.mocked(closeStudioProcessAsync).mockImplementation(
+      async (pid) => pid === 10
+    );
+
+    const result = await closeAllStudiosAsync({ force: false });
+
+    expect(result.success).toBe(false);
+    expect(result.pids).toEqual([10]);
+    expect(result.summary).toContain('still open (pids 20)');
+  });
+});

package/src/commands/process/close/close.ts

@@ -18,6 +18,7 @@ import {
   resolveDeployPlaceAsync,
 } from '../../../deploy/deploy-places.js';
 import { explainMissingPlaytestContextAsync } from '../../playtest/playtest-sessions.js';
+import { resolveSessionPidsAsync } from '../../../process/studio-process-identity.js';
 import { describePlaytest } from '../info/info.js';
 
 export interface ProcessCloseResult {
@@ -26,6 +27,7 @@ export interface ProcessCloseResult {
   /** The `deploy.nevermore.json` target whose Studio was closed, if one was named. */
   deployTarget?: string;
   pid?: number;
+  pids?: number[];
   summary: string;
 }
 
@@ -36,6 +38,8 @@ export interface ProcessCloseOptions {
 
 interface ProcessCloseArgs {
   deployTarget?: string;
+  all?: boolean;
+  askToSave?: boolean;
   force?: boolean;
   pid?: number;
 }
@@ -74,6 +78,15 @@ export async function processCloseHandlerAsync(
       ?.placeId;
     candidates = matchStudioProcesses(processes, placeName, placeId);
   }
+  if (candidates.length > 1 && options.pid === undefined && connection) {
+    const pid = (
+      await resolveSessionPidsAsync(connection, processes, [instanceId])
+    ).get(instanceId);
+    const own = candidates.filter((proc) => proc.pid === pid);
+    if (own.length === 1) {
+      candidates = own;
+    }
+  }
 
   return closeCandidateAsync(candidates, `'${placeName}'`, options, {
     sessionId,
@@ -129,6 +142,47 @@ export async function closeDeployTargetAsync(
   return closeCandidateAsync(candidates, showing, options, base);
 }
 
+export async function closeAllStudiosAsync(
+  options: Pick<ProcessCloseOptions, 'force'> = {}
+): Promise<ProcessCloseResult> {
+  const processes = await listStudioProcessesAsync();
+  if (processes.length === 0) {
+    return { success: true, pids: [], summary: 'No Studio is running' };
+  }
+
+  const results = await Promise.all(
+    processes.map(async ({ pid }) => ({
+      pid,
+      exited: await closeStudioProcessAsync(pid, { force: options.force }),
+    }))
+  );
+  const closed = results.filter((r) => r.exited).map((r) => r.pid);
+  const open = results.filter((r) => !r.exited).map((r) => r.pid);
+  const plural = (n: number) => (n === 1 ? 'Studio' : 'Studios');
+
+  if (open.length > 0) {
+    return {
+      success: false,
+      pids: closed,
+      summary:
+        `Closed ${closed.length} ${plural(closed.length)}; ${
+          open.length
+        } ${plural(open.length)} still open (pids ${open.join(', ')})` +
+        (options.force
+          ? ''
+          : ', likely asking to save. Run without --ask-to-save to close without saving.'),
+    };
+  }
+
+  return {
+    success: true,
+    pids: closed,
+    summary: `Closed ${closed.length} ${plural(
+      closed.length
+    )} (pids ${closed.join(', ')})`,
+  };
+}
+
 async function closeCandidateAsync(
   candidates: RunningStudioProcess[],
   showing: string,
@@ -163,7 +217,7 @@ async function closeCandidateAsync(
     return fail(
       options.force
         ? `Studio (pid ${pid}) did not exit`
-        : `Studio (pid ${pid}) is still open, likely asking to save. Use --force to close without saving.`,
+        : `Studio (pid ${pid}) is still open, likely asking to save. Run without --ask-to-save to close without saving.`,
       pid
     );
   }
@@ -183,7 +237,7 @@ export const processCloseCommand = defineCommand<
   group: 'process',
   name: 'close',
   description:
-    "Close a Studio: the one a session belongs to, or the one showing a deploy.nevermore.json target's place",
+    "Close a Studio without saving: the one a session belongs to, the one showing a deploy.nevermore.json target's place, or with --all every Studio",
   category: 'infrastructure',
   safety: 'mutate',
   scope: 'connection',
@@ -193,8 +247,16 @@ export const processCloseCommand = defineCommand<
         'deploy.nevermore.json target whose Studio to close, e.g. test or integration.places.hub',
       required: false,
     }),
+    all: arg.flag({
+      description: 'Close every running Studio, connected or not',
+    }),
+    askToSave: arg.flag({
+      description:
+        'Let Studio prompt to save first, instead of closing without saving',
+    }),
     force: arg.flag({
-      description: 'Kill Studio without letting it prompt to save',
+      description:
+        'Close without saving. The default, accepted for scripts that pass it',
       alias: 'f',
     }),
     pid: arg.option({
@@ -203,7 +265,19 @@ export const processCloseCommand = defineCommand<
     }),
   },
   handler: async (connection, args, targeting) => {
-    const options = { force: args.force, pid: args.pid };
+    const options = { force: !args.askToSave, pid: args.pid };
+    if (args.all) {
+      if (
+        args.deployTarget !== undefined ||
+        args.pid !== undefined ||
+        targeting.target !== undefined
+      ) {
+        throw new Error(
+          '--all closes every Studio; drop the target, --target and --pid.'
+        );
+      }
+      return closeAllStudiosAsync(options);
+    }
     if (args.deployTarget !== undefined) {
       return closeDeployTargetAsync(connection, args.deployTarget, options);
     }

package/src/commands/process/info/info.test.ts

@@ -228,3 +228,79 @@ describe('describePlaytest', () => {
     expect(playtest?.sessions).toHaveLength(3);
   });
 });
+
+describe('queryStateHandlerAsync with MCP', () => {
+  const ok = (studios: any[]) => async () => ({
+    status: 'ok' as const,
+    studios,
+    checkedAt: Date.now(),
+    latencyMs: 500,
+  });
+
+  it('reports the studio_id MCP reaches this Studio by', async () => {
+    const session = createMockSession({});
+
+    const result = await queryStateHandlerAsync(session, undefined, {
+      mcpSnapshotAsync: ok([
+        {
+          studioId: 'mcp-1',
+          placeName: 'TestPlace',
+          sessionId: 'test-place-3f9a-edit',
+        },
+      ]),
+    });
+
+    expect(result.mcp).toEqual({ status: 'ok', studioId: 'mcp-1' });
+    expect(formatStateText(result)).toContain(
+      'MCP:      reachable (studio_id mcp-1)'
+    );
+  });
+
+  it('says when MCP does not see this Studio', async () => {
+    const result = await queryStateHandlerAsync(
+      createMockSession({}),
+      undefined,
+      {
+        mcpSnapshotAsync: ok([]),
+      }
+    );
+
+    expect(formatStateText(result)).toContain(
+      'MCP:      not seen by its MCP server'
+    );
+  });
+
+  it('reports MCP being unavailable without failing the rest', async () => {
+    const result = await queryStateHandlerAsync(
+      createMockSession({}),
+      undefined,
+      {
+        mcpSnapshotAsync: async () => ({
+          status: 'timeout' as const,
+          studios: [],
+          message: 'tools/call timed out',
+          checkedAt: Date.now(),
+          latencyMs: 3000,
+        }),
+      }
+    );
+
+    expect(result.placeId).toBe(12345);
+    expect(formatStateText(result)).toContain(
+      'MCP:      timeout (tools/call timed out)'
+    );
+  });
+
+  it('leaves MCP out when the check gave up', async () => {
+    const result = await queryStateHandlerAsync(
+      createMockSession({}),
+      undefined,
+      {
+        mcpSnapshotAsync: async () => undefined,
+      }
+    );
+
+    expect(result.mcp).toBeUndefined();
+    expect(formatStateText(result)).not.toContain('MCP:');
+  });
+});

package/src/commands/process/info/info.ts

@@ -21,6 +21,11 @@ import {
 } from '../../../process/studio-process-closer.js';
 import { tryGetStudioWindowStateAsync } from '../../../process/studio-window-state.js';
 import { getPluginBuildVersionAsync } from '../../../plugin/plugin-build-version.js';
+import { arg } from '../../framework/arg-builder.js';
+import {
+  getStudioMcpSnapshotAsync,
+  type StudioMcpSnapshot,
+} from '../../../roblox-mcp/index.js';
 
 export interface PlaytestInfo {
   mode: 'play' | 'run';
@@ -65,13 +70,25 @@ export interface StateResult {
     focused: boolean;
     minimized: boolean;
   };
+  mcp?: {
+    status: StudioMcpSnapshot['status'];
+    studioId?: string;
+    message?: string;
+  };
   connectedAt: string;
   summary: string;
 }
 
+export interface QueryStateOptions {
+  mcpSnapshotAsync?: (
+    sessions: SessionInfo[]
+  ) => Promise<StudioMcpSnapshot | undefined>;
+}
+
 export async function queryStateHandlerAsync(
   session: BridgeSession,
-  connection?: BridgeConnection
+  connection?: BridgeConnection,
+  options: QueryStateOptions = {}
 ): Promise<StateResult> {
   // Listed sessions carry the edit session's place name for a playtest
   const listed = connection
@@ -84,9 +101,10 @@ export async function queryStateHandlerAsync(
   // playtest shows in the edit window
   const ownWindow =
     session.info.context !== 'edit' && playtest?.playerCount !== undefined;
-  const [result, expectedVersion] = await Promise.all([
+  const [result, expectedVersion, snapshot] = await Promise.all([
     session.queryStateAsync(),
     getPluginBuildVersionAsync(),
+    options.mcpSnapshotAsync?.(connection?.listSessions() ?? [session.info]),
   ]);
   const window = await tryGetWindowAsync(
     ownWindow ? [result.placeName] : [result.placeName, listed?.placeName],
@@ -111,6 +129,7 @@ export async function queryStateHandlerAsync(
     },
     playtest,
     window,
+    ...(snapshot ? { mcp: describeMcp(snapshot, session.info) } : {}),
     connectedAt: new Date(session.info.connectedAt).toISOString(),
     summary: `Mode: ${result.state}, Place: ${result.placeName} (${result.placeId})`,
   };
@@ -166,6 +185,36 @@ async function tryGetWindowAsync(
   return undefined;
 }
 
+function describeMcp(
+  snapshot: StudioMcpSnapshot,
+  info: SessionInfo
+): NonNullable<StateResult['mcp']> {
+  if (snapshot.status !== 'ok') {
+    return {
+      status: snapshot.status,
+      ...(snapshot.message ? { message: snapshot.message } : {}),
+    };
+  }
+  const editSessionId =
+    info.context === 'edit' ? info.sessionId : `${info.instanceId}-edit`;
+  const studio = snapshot.studios.find((s) => s.sessionId === editSessionId);
+  return studio
+    ? { status: 'ok', studioId: studio.studioId }
+    : { status: 'ok', message: "Studio's MCP server does not see this Studio" };
+}
+
+function formatMcp(mcp: StateResult['mcp']): string | undefined {
+  if (!mcp || mcp.status === 'unsupported') return undefined;
+  if (mcp.status === 'ok') {
+    return mcp.studioId
+      ? `reachable (studio_id ${mcp.studioId})`
+      : 'not seen by its MCP server';
+  }
+  return OutputHelper.formatWarning(
+    `${mcp.status}${mcp.message ? ` (${mcp.message})` : ''}`
+  );
+}
+
 function formatAge(isoTime: string): string {
   const seconds = Math.max(
     0,
@@ -223,10 +272,18 @@ export function formatStateText(result: StateResult): string {
           )
     }`
   );
+  const mcp = formatMcp(result.mcp);
+  if (mcp) {
+    lines.push(`MCP:      ${mcp}`);
+  }
   return lines.join('\n');
 }
 
-export const infoCommand = defineCommand({
+interface InfoArgs {
+  mcp?: boolean;
+}
+
+export const infoCommand = defineCommand<InfoArgs, StateResult>({
   group: 'process',
   name: 'info',
   description:
@@ -234,10 +291,21 @@ export const infoCommand = defineCommand({
   category: 'execution',
   safety: 'read',
   scope: 'session',
-  args: {},
+  args: {
+    mcp: arg.flag({
+      description:
+        "Also ask Studio's MCP server whether it can reach this Studio (--no-mcp to skip)",
+      default: true,
+    }),
+  },
   cli: {
     format: formatStateText,
   },
-  handler: async (session, _args, connection) =>
-    queryStateHandlerAsync(session, connection),
+  handler: async (session, args, connection) =>
+    queryStateHandlerAsync(session, connection, {
+      mcpSnapshotAsync:
+        args.mcp && !connection?.isRemote
+          ? (sessions) => getStudioMcpSnapshotAsync({ sessions })
+          : undefined,
+    }),
 });

package/src/commands/process/launch/launch.test.ts

@@ -15,8 +15,13 @@ vi.mock('../../../process/studio-process-manager.js', () => ({
   }),
 }));
 
+vi.mock('../../../process/studio-launch-registry.js', () => ({
+  recordStudioLaunchAsync: vi.fn().mockResolvedValue(undefined),
+}));
+
 import { launchHandlerAsync } from './launch.js';
 import { launchStudioAsync } from '../../../process/studio-process-manager.js';
+import { recordStudioLaunchAsync } from '../../../process/studio-launch-registry.js';
 
 let tempDir: string;
 
@@ -44,12 +49,32 @@ const place = (placeId: number, name?: string) => ({
 });
 
 describe('launchHandlerAsync', () => {
-  it('launches a bare Studio outside any deploy.nevermore.json', async () => {
+  it('opens a new Baseplate outside any deploy.nevermore.json', async () => {
     const result = await launchHandlerAsync({ cwd: tempDir });
 
-    expect(launchStudioAsync).toHaveBeenCalledWith({});
+    expect(launchStudioAsync).toHaveBeenCalledWith({
+      placeId: 95206881,
+      universeId: 28220420,
+    });
     expect(result.launched).toBe(true);
-    expect(result.summary).toBe('Studio launched');
+    expect(result.summary).toBe('Studio launched with a new Baseplate');
+  });
+
+  it('records where a Baseplate was launched from', async () => {
+    vi.mocked(launchStudioAsync).mockResolvedValueOnce({
+      process: { pid: 4242 },
+      killAsync: vi.fn(),
+    } as any);
+
+    await launchHandlerAsync({ cwd: tempDir });
+
+    expect(recordStudioLaunchAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        pid: 4242,
+        cwd: tempDir,
+        opened: 'a new Baseplate',
+      })
+    );
   });
 
   it('passes place path to launchStudioAsync', async () => {
@@ -163,8 +188,11 @@ describe('launchHandlerAsync with deploy.nevermore.json', () => {
 
     const result = await launchHandlerAsync({ cwd: tempDir });
 
-    expect(launchStudioAsync).toHaveBeenCalledWith({});
-    expect(result.summary).toBe('Studio launched');
+    expect(launchStudioAsync).toHaveBeenCalledWith({
+      placeId: 95206881,
+      universeId: 28220420,
+    });
+    expect(result.summary).toBe('Studio launched with a new Baseplate');
   });
 
   it('asks for a target when the config has no default', async () => {

package/src/commands/process/launch/launch.ts

@@ -7,11 +7,14 @@ import * as path from 'path';
 import { defineCommand } from '../../framework/define-command.js';
 import { arg } from '../../framework/arg-builder.js';
 import { launchStudioAsync } from '../../../process/studio-process-manager.js';
+import { recordStudioLaunchAsync } from '../../../process/studio-launch-registry.js';
 import {
   DEPLOY_CONFIG_FILE_NAME,
   resolveDeployPlaceAsync,
 } from '../../../deploy/deploy-places.js';
 
+const BASEPLATE_TEMPLATE = { placeId: 95206881, universeId: 28220420 };
+
 export interface LaunchOptions {
   placePath?: string;
   placeId?: number;
@@ -50,7 +53,11 @@ export async function launchHandlerAsync(
       );
   if (deployPlace) {
     const { placeId, universeId } = deployPlace.place;
-    await launchStudioAsync({ placeId, universeId });
+    await _launchAndRecordAsync(
+      { placeId, universeId },
+      `'${deployPlace.selector}' (place ${placeId})`,
+      options.cwd
+    );
     const configDir = path.relative(
       options.cwd ?? process.cwd(),
       path.dirname(deployPlace.configPath)
@@ -69,8 +76,24 @@ export async function launchHandlerAsync(
     };
   }
 
+  if (!hasExplicitPlace) {
+    await _launchAndRecordAsync(
+      BASEPLATE_TEMPLATE,
+      'a new Baseplate',
+      options.cwd
+    );
+    return {
+      launched: true,
+      summary: 'Studio launched with a new Baseplate',
+    };
+  }
+
   const { placePath, placeId, universeId } = options;
-  await launchStudioAsync({ placePath, placeId, universeId });
+  await _launchAndRecordAsync(
+    { placePath, placeId, universeId },
+    placeId != null ? `place ${placeId}` : placePath ?? 'Studio',
+    options.cwd
+  );
   const opened =
     placeId != null
       ? `place ${placeId}${
@@ -85,6 +108,21 @@ export async function launchHandlerAsync(
   };
 }
 
+async function _launchAndRecordAsync(
+  launch: Parameters<typeof launchStudioAsync>[0],
+  opened: string,
+  cwd = process.cwd()
+): Promise<void> {
+  const launchedAt = Date.now();
+  const studio = await launchStudioAsync(launch);
+  await recordStudioLaunchAsync({
+    pid: studio?.process?.pid,
+    cwd,
+    opened,
+    launchedAt,
+  }).catch(() => {});
+}
+
 interface LaunchArgs {
   deployTarget?: string;
   place?: string;
@@ -96,7 +134,7 @@ export const launchCommand = defineCommand<LaunchArgs, LaunchResult>({
   group: 'process',
   name: 'launch',
   description:
-    "Launch Roblox Studio, by default with the place of the nearest deploy.nevermore.json's default target",
+    "Launch Roblox Studio, by default with the place of the nearest deploy.nevermore.json's default target, or else a new Baseplate",
   category: 'infrastructure',
   safety: 'none',
   scope: 'standalone',