summer-engine 4.6.0 → 4.8.0

package/dist/cli/commands/token.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+/**
+ * `summer token`: print the Summer sign-in's current access token (Supabase
+ * OAuth, about one hour; refreshed first when it is about to expire), for
+ * curl against the Summer API:
+ *
+ *   curl -H "Authorization: Bearer $(summer token)" https://www.summerengine.com/v1/models
+ *
+ * Only the token goes to stdout; a missing sign-in says so on stderr and exits 1.
+ */
+export interface TokenCommandDependencies {
+    token: () => Promise<string>;
+    print: (line: string) => void;
+    printError: (line: string) => void;
+}
+export declare function runTokenCommand(overrides?: Partial<TokenCommandDependencies>): Promise<number>;
+export declare const tokenCommand: Command;

package/dist/cli/commands/token.js

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import { getStoreAccessToken, OAuthError } from "../../core/oauth.js";
+const defaults = () => ({
+    token: () => getStoreAccessToken(),
+    print: (line) => process.stdout.write(`${line}\n`),
+    printError: (line) => console.error(line),
+});
+export async function runTokenCommand(overrides = {}) {
+    const deps = { ...defaults(), ...overrides };
+    try {
+        deps.print(await deps.token());
+        return 0;
+    }
+    catch (error) {
+        deps.printError(error instanceof OAuthError ? 'This computer is not signed in to Summer. Run "summer login", then retry.' : error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+export const tokenCommand = new Command("token")
+    .description("Print a one-hour Summer API access token from this computer's Summer sign-in (summer login), for curl: Authorization: Bearer $(summer token)")
+    .action(async () => {
+    const code = await runTokenCommand();
+    if (code)
+        process.exitCode = code;
+});

package/dist/cli/index.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { loginCommand } from "./commands/login.js";
 import { logoutCommand } from "./commands/logout.js";
+import { tokenCommand } from "./commands/token.js";
 import { statusCommand } from "./commands/status.js";
 import { runCommand } from "./commands/run.js";
 import { openCommand } from "./commands/open.js";
@@ -18,6 +19,7 @@ import { configCommand } from "./commands/config.js";
 import { eventsCommand } from "./commands/events.js";
 import { previewCommand } from "./commands/preview.js";
 import { toolCommand } from "./commands/tool.js";
+import { apiCommand } from "./commands/api.js";
 import { opsCliCommands } from "./commands/ops.js";
 import { getBanner } from "./banner.js";
 import { runRootAction } from "./root-action.js";
@@ -42,6 +44,7 @@ export function runCli(mcpCommand) {
     program.addCommand(installCommand);
     program.addCommand(loginCommand);
     program.addCommand(logoutCommand);
+    program.addCommand(tokenCommand);
     program.addCommand(statusCommand);
     program.addCommand(runCommand);
     program.addCommand(openCommand);
@@ -58,6 +61,7 @@ export function runCli(mcpCommand) {
     program.addCommand(eventsCommand);
     program.addCommand(previewCommand);
     program.addCommand(toolCommand);
+    program.addCommand(apiCommand);
     // The 4.0 operation catalog (`summer <area> <action>`); SUMMER_SURFACE=v3 leaves it out.
     if (resolveSurface(undefined) === "v4") {
         for (const command of opsCliCommands())

package/dist/core/api-client.d.ts

@@ -74,7 +74,6 @@ export type EventsPollParams = {
      *  truncated:true when the page was full. */
     limit?: number;
 };
-/** rebind() could not re-read engine health; the session identity is unchanged. */
 export declare class EngineRebindError extends Error {
     constructor(message: string);
 }
@@ -152,6 +151,11 @@ export declare class EngineApiClient {
      * feed its ONE response in here instead of issuing a second request.
      */
     private _resolveQueuedResponse;
+    /**
+     * One Studio page op in the app's own Studio tab (capabilities.studioPage):
+     * POST /api/studio {op, input} -> 202, then its one terminal envelope.
+     */
+    studioPage(op: string, input: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;
     health(): Promise<unknown>;
     /**
      * One long-poll of GET /api/events/poll (the engine's events channel). The

package/dist/core/api-client.js

@@ -3,6 +3,7 @@ import { tmpdir } from "os";
 import { join } from "path";
 import { randomUUID } from "node:crypto";
 import { checkEngineHealth, discoverRegistryConnection, engineNotRunningError, engineSelectionFromEnv, getApiPort, getApiToken, resolveEngineConnection, } from "./engine.js";
+import { AGENT_HOST_HEADER, resolveAgentHost } from "./agent-host.js";
 import { asRecord, boolFrom, numberFrom, stringFrom } from "./util/json.js";
 import { classifyOpsResponse, pollOpToTerminal, } from "./async-op-lifecycle.js";
 import { pickPlayDeterminism } from "./capabilities/play-determinism.js";
@@ -56,6 +57,16 @@ function withoutImageData(payload) {
     return metadata;
 }
 /** rebind() could not re-read engine health; the session identity is unchanged. */
+/**
+ * The agent app driving the engine (Claude Code, Codex, ...), so the person's
+ * editor can say who is working ("Claude Code · Placing 12 trees"). Local
+ * only: the engine on this computer reads it for its activity line; it never
+ * leaves the machine from here, so the telemetry opt-out does not apply.
+ */
+function engineAgentHeader() {
+    const host = resolveAgentHost().id;
+    return host && host !== "unknown" ? { [AGENT_HOST_HEADER]: host } : {};
+}
 export class EngineRebindError extends Error {
     constructor(message) {
         super(message);
@@ -254,6 +265,7 @@ export class EngineApiClient {
         const headers = {
             Authorization: `Bearer ${this.token}`,
             "Content-Type": "application/json",
+            ...engineAgentHeader(),
         };
         const res = await fetch(url, {
             method,
@@ -282,6 +294,7 @@ export class EngineApiClient {
             headers: {
                 Authorization: `Bearer ${this.token}`,
                 "Content-Type": "application/json",
+                ...engineAgentHeader(),
             },
             body: body !== undefined ? JSON.stringify(body) : undefined,
             signal: AbortSignal.timeout(timeoutMs),
@@ -404,6 +417,14 @@ export class EngineApiClient {
             };
         }
     }
+    /**
+     * One Studio page op in the app's own Studio tab (capabilities.studioPage):
+     * POST /api/studio {op, input} -> 202, then its one terminal envelope.
+     */
+    async studioPage(op, input, timeoutMs = 90_000) {
+        const path = this.getEngineCapabilities()?.studioPage?.path ?? "/api/studio";
+        return this._requestQueued("POST", path, { op, input }, timeoutMs);
+    }
     async health() {
         return this.request("GET", "/api/health");
     }

package/dist/core/capabilities/doctor.d.ts

@@ -23,7 +23,7 @@ interface DoctorOptions {
 }
 export declare function runDoctor(options?: DoctorOptions): Promise<DoctorResult>;
 /** The oldest Node major the package supports: `engines.node` in package.json. */
-export declare const MIN_NODE_MAJOR = 20;
+export declare const MIN_NODE_MAJOR = 22;
 export declare function checkNodeVersion(nodeVersion?: string): DoctorCheck;
 export declare function checkLogin(): Promise<DoctorCheck>;
 /**

package/dist/core/capabilities/doctor.js

@@ -49,7 +49,7 @@ export async function runDoctor(options = {}) {
     return result;
 }
 /** The oldest Node major the package supports: `engines.node` in package.json. */
-export const MIN_NODE_MAJOR = 20;
+export const MIN_NODE_MAJOR = 22;
 export function checkNodeVersion(nodeVersion = process.versions.node) {
     const major = Number(nodeVersion.split(".")[0]);
     const shown = `v${nodeVersion.replace(/^v/, "")}`;

package/dist/core/capabilities/game-task-plan.d.ts

@@ -16,14 +16,14 @@ export declare const gameTaskPlanInputSchema: z.ZodObject<{
     verification: z.ZodDefault<z.ZodEnum<["none", "fast", "full"]>>;
 }, "strip", z.ZodTypeAny, {
     mode: "auto" | "ship" | "debug" | "asset" | "new-game" | "feature" | "playtest" | "polish";
-    target: "auto" | "audio" | "level" | "npc" | "ui" | "2d" | "3d" | "animation" | "multiplayer";
+    target: "auto" | "audio" | "level" | "npc" | "ui" | "3d" | "2d" | "animation" | "multiplayer";
     goal: string;
     assetPolicy: "reuse-first" | "ask-before-paid-generation" | "no-paid-generation" | "generate-when-clearly-needed";
     verification: "none" | "full" | "fast";
 }, {
     goal: string;
     mode?: "auto" | "ship" | "debug" | "asset" | "new-game" | "feature" | "playtest" | "polish" | undefined;
-    target?: "auto" | "audio" | "level" | "npc" | "ui" | "2d" | "3d" | "animation" | "multiplayer" | undefined;
+    target?: "auto" | "audio" | "level" | "npc" | "ui" | "3d" | "2d" | "animation" | "multiplayer" | undefined;
     assetPolicy?: "reuse-first" | "ask-before-paid-generation" | "no-paid-generation" | "generate-when-clearly-needed" | undefined;
     verification?: "none" | "full" | "fast" | undefined;
 }>;

package/dist/core/capabilities/navigation/open.d.ts

@@ -126,6 +126,9 @@ export declare function isAllowedNavigationOrigin(origin: string): boolean;
  *  escapes, nothing that could name a file outside the project. Returns the
  *  problem, or null when the path is acceptable. */
 export declare function resPathProblem(value: string): string | null;
+/** A summerengine.com Studio path (`/studio`, `/studio/games`, `/studio?tab=assets`), the
+ *  only paths the engine's `studio` Navigate row opens. */
+export declare function isStudioPath(path: string): boolean;
 export declare function tokenize(text: string): string[];
 /** Rank every target for a free-text query. Exported for tests. */
 export declare function rankTargets(query: string, surface?: OpenSurface): OpenMatch[];

package/dist/core/capabilities/navigation/open.js

@@ -87,6 +87,50 @@ export function resPathProblem(value) {
         return "must not contain control characters";
     return null;
 }
+/** A summerengine.com Studio path (`/studio`, `/studio/games`, `/studio?tab=assets`), the
+ *  only paths the engine's `studio` Navigate row opens. */
+export function isStudioPath(path) {
+    return /^\/studio(?:[/?#]|$)/.test(path);
+}
+/**
+ * A Studio path opens in the Summer app's own Studio tab when the running
+ * engine advertises the `studio` Navigate destination (it loads the tab when
+ * the person has not opened it yet). Otherwise, the engine off, an older
+ * engine or a refused Navigate, null: the caller opens the browser as before.
+ */
+async function openInAppStudio(deps, path, url, extra) {
+    if (!isStudioPath(path))
+        return null;
+    let client;
+    try {
+        client = await deps.engine();
+    }
+    catch {
+        return null;
+    }
+    if (!advertisedNavigation(client)?.has("studio"))
+        return null;
+    const op = { op: "Navigate", target: "studio", path };
+    let receipt;
+    try {
+        receipt = await client.executeOps([op]);
+    }
+    catch {
+        return null;
+    }
+    if (extractOpError(receipt))
+        return null;
+    return {
+        ok: true,
+        action: "opened",
+        url,
+        ...extra,
+        op,
+        engine: { running: true, version: client.getEngineVersion?.(), navigation: true },
+        receipt,
+        hint: "Opened in the Studio tab of the Summer app, not a browser.",
+    };
+}
 /** Launch the browser; a failed launch is a result, not a crash. */
 async function launch(deps, url) {
     try {
@@ -444,6 +488,9 @@ export async function runOpen(args, deps) {
         };
         if (print)
             return base;
+        const inApp = await openInAppStudio(deps, resolution.url, url, { unmapped: true });
+        if (inApp)
+            return inApp;
         const failure = await launch(deps, url);
         if (failure)
             return openFailed(url, failure, { unmapped: true });
@@ -479,6 +526,12 @@ export async function runOpen(args, deps) {
         };
         if (print)
             return result;
+        if (target.web.origin !== "docs") {
+            // The app's Studio tab is signed in with the app: no login detour.
+            const inApp = await openInAppStudio(deps, path, url, { target: summary });
+            if (inApp)
+                return inApp;
+        }
         const toOpen = needsLogin && loggedIn === false ? loginUrl : url;
         const failure = await launch(deps, toOpen);
         if (failure)

package/dist/core/capabilities/projects-local.js

@@ -143,7 +143,8 @@ sessionFolder = process.cwd()) {
     }
     let client;
     try {
-        client = await openProjectInEditor(root, { cwd: root }, { install: input.install === true }, deps);
+        // The agent asked for this game: an editor with another one switches (J16.1).
+        client = await openProjectInEditor(root, { cwd: root }, { install: input.install === true, switchOpen: true }, deps);
     }
     catch (error) {
         if (error instanceof EngineInstallError)

package/dist/core/capabilities/runtime-control.d.ts

@@ -141,18 +141,18 @@ export declare const runtimeSpawnArgsSchema: z.ZodObject<{
     action: "free" | "spawn";
     mode?: "free" | "queue_free" | undefined;
     name?: string | undefined;
+    path?: string | undefined;
     instance?: string | undefined;
     scene?: string | undefined;
-    path?: string | undefined;
     parent?: string | undefined;
     props?: Record<string, string | number | boolean> | undefined;
 }, {
     action: "free" | "spawn";
     mode?: "free" | "queue_free" | undefined;
     name?: string | undefined;
+    path?: string | undefined;
     instance?: string | undefined;
     scene?: string | undefined;
-    path?: string | undefined;
     parent?: string | undefined;
     props?: Record<string, string | number | boolean> | undefined;
 }>;

package/dist/core/capabilities/seeing/args.d.ts

@@ -177,10 +177,10 @@ export declare const shotSheetArgsSchema: z.ZodObject<{
         bookmark_name?: string | undefined;
     }[];
     scenePath?: string | undefined;
+    view?: "lighting" | "beauty" | "unshaded" | "normals" | "overdraw" | "wireframe" | undefined;
     compare_previous?: boolean | undefined;
     max_size?: number | undefined;
     save_to?: string | undefined;
-    view?: "lighting" | "beauty" | "unshaded" | "normals" | "overdraw" | "wireframe" | undefined;
     update_previous?: boolean | undefined;
     aspect?: number | undefined;
 }, {
@@ -192,10 +192,10 @@ export declare const shotSheetArgsSchema: z.ZodObject<{
         bookmark_name?: string | undefined;
     }[];
     scenePath?: string | undefined;
+    view?: "lighting" | "beauty" | "unshaded" | "normals" | "overdraw" | "wireframe" | undefined;
     compare_previous?: boolean | undefined;
     max_size?: number | undefined;
     save_to?: string | undefined;
-    view?: "lighting" | "beauty" | "unshaded" | "normals" | "overdraw" | "wireframe" | undefined;
     update_previous?: boolean | undefined;
     aspect?: number | undefined;
 }>;
@@ -251,11 +251,11 @@ export declare const zoomArgsSchema: z.ZodObject<{
     camera_position?: string | undefined;
     camera_look_at?: string | undefined;
     fov?: number | undefined;
+    view?: "lighting" | "beauty" | "unshaded" | "normals" | "overdraw" | "wireframe" | undefined;
     bookmark_name?: string | undefined;
     region?: number[] | undefined;
     max_size?: number | undefined;
     save_to?: string | undefined;
-    view?: "lighting" | "beauty" | "unshaded" | "normals" | "overdraw" | "wireframe" | undefined;
     mark?: number | undefined;
     reference_size?: number[] | undefined;
     pad?: number | undefined;
@@ -264,11 +264,11 @@ export declare const zoomArgsSchema: z.ZodObject<{
     camera_position?: string | undefined;
     camera_look_at?: string | undefined;
     fov?: number | undefined;
+    view?: "lighting" | "beauty" | "unshaded" | "normals" | "overdraw" | "wireframe" | undefined;
     bookmark_name?: string | undefined;
     region?: number[] | undefined;
     max_size?: number | undefined;
     save_to?: string | undefined;
-    view?: "lighting" | "beauty" | "unshaded" | "normals" | "overdraw" | "wireframe" | undefined;
     mark?: number | undefined;
     reference_size?: number[] | undefined;
     pad?: number | undefined;

package/dist/core/capabilities/tool-dispatch.js

@@ -16,6 +16,7 @@
  * as the single per-tool dispatch table so the handler bodies stop being two
  * mirrors as well.
  */
+import { viewSetOp } from "./view-set.js";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
@@ -79,6 +80,7 @@ import { captureGame, captureScene, captureViewport } from "./capture.js";
 // the scripting ones come with their op builders from ./scene-script.js.
 import { ALIGN_DISTRIBUTE_FALLBACK, GREP_FALLBACK, NAVIGATION_PROBE_FALLBACK, RUNTIME_NODE_FALLBACK, RUNTIME_TREE_FALLBACK, SNAP_TO_SURFACE_FALLBACK, SNAPSHOT_DIFF_FALLBACK, STARCAST_FALLBACK, TEST_PLACEMENT_FALLBACK, WORLD_SNAPSHOT_FALLBACK, } from "./engine-fallbacks.js";
 import { sendLibraryFeedback, } from "../feedback/client.js";
+import { batchToolResult, cancelJob, checkBatch, createBatch, estimateJob, getBatch, getJob, jobToolResult, listModels, runJob, summerApiToolAnswer } from "../summer-api.js";
 // One copy of the batch op classification and the instantiate/batch engine
 // path, shared with the MCP face.
 import { PLACEMENT_FIELDS, SCENE_MUTATION_OPS, SCENE_QUERY_OPS, instantiateScene, runBatch, } from "./placement-batch.js";
@@ -1296,6 +1298,11 @@ export const TOOL_DISPATCH = [
             op.scenePath = args.scenePath;
         return requireEngineSuccess(await (await ctx.engine()).executeOps([op]));
     }),
+    entry("summer_view_set", "Show the person a view, rail and focus in the editor", true, async (args, ctx) => {
+        const frame = Array.isArray(args.frame) ? args.frame.filter((entry) => typeof entry === "string") : undefined;
+        const op = viewSetOp({ view: str(args, "view"), rail: optStr(args, "rail"), focus: optStr(args, "focus"), frame });
+        return requireEngineSuccess(await (await ctx.engine()).executeOps([op]));
+    }),
     entry("summer_replace_node", "Replace a node with a different scene or type and verify the saved scene", true, async (args, ctx) => {
         // ONE implementation for both faces (core/capabilities/replace-node.ts):
         // persisted ops + read-back of the saved .tscn.
@@ -1767,6 +1774,36 @@ export const TOOL_DISPATCH = [
             throw new ToolResultError(result, result.hint);
         return result;
     }),
+    // --- account ---
+    entry("summer_api_models", "The Summer API's models with input and price", false, async (args) => summerApiToolAnswer(() => listModels({ ...(optStr(args, "model") ? { model: optStr(args, "model") } : {}), ...(optStr(args, "capability") ? { capability: optStr(args, "capability") } : {}) }))),
+    entry("summer_api_estimate", "The exact price of one Summer API job; charges nothing", false, async (args) => summerApiToolAnswer(() => estimateJob(str(args, "model"), args.input ?? {}))),
+    entry("summer_api_run", "Run one Summer API job with the Summer sign-in on this computer", false, async (args) => summerApiToolAnswer(async () => {
+        const out = optStr(args, "out");
+        const follow = args.wait === true || Boolean(out);
+        const job = await runJob(str(args, "model"), args.input ?? {}, {
+            ...(optStr(args, "quoteId") ? { quoteId: optStr(args, "quoteId") } : {}),
+            ...(optStr(args, "idempotencyKey") ? { idempotencyKey: optStr(args, "idempotencyKey") } : {}),
+            ...(follow ? { waitSeconds: 30 } : {}),
+        });
+        return jobToolResult(job, { wait: args.wait === true, ...(out ? { out } : {}) });
+    })),
+    entry("summer_api_batch", "Run up to 500 Summer API jobs at once (all or none), or read a batch", false, async (args) => summerApiToolAnswer(async () => {
+        const out = optStr(args, "out");
+        const follow = { wait: args.wait === true, ...(out ? { out } : {}) };
+        const batchId = optStr(args, "batchId");
+        if (batchId)
+            return batchToolResult(await getBatch(batchId), follow);
+        const key = optStr(args, "idempotencyKey");
+        const batch = await createBatch(checkBatch(Array.isArray(args.jobs) ? args.jobs : []), key ? { idempotencyKey: key } : {});
+        return batchToolResult(batch, follow);
+    })),
+    entry("summer_api_job", "Read, follow, download or cancel a Summer API job", false, async (args) => summerApiToolAnswer(async () => {
+        const jobId = str(args, "jobId");
+        if (args.cancel === true)
+            return { job: await cancelJob(jobId) };
+        const out = optStr(args, "out");
+        return jobToolResult(await getJob(jobId), { wait: args.wait === true, ...(out ? { out } : {}) });
+    })),
     // --- feedback ---
     entry("summer_library_feedback", "Report library entry outcomes so Summer can fix and re-rank them", false, async (args) => {
         if (!Array.isArray(args.reports) || args.reports.length === 0) {

package/dist/core/capabilities/ui-control.d.ts

@@ -88,16 +88,16 @@ export declare const uiActivateArgsSchema: z.ZodObject<{
     button: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     value?: string | number | undefined;
-    title?: string | undefined;
     path?: string | undefined;
+    title?: string | undefined;
     action?: "focus" | "press" | "select_tab" | "toggle" | "set_text" | "set_value" | "dismiss_dialog" | undefined;
     button?: string | undefined;
     index?: number | undefined;
     submit?: boolean | undefined;
 }, {
     value?: string | number | undefined;
-    title?: string | undefined;
     path?: string | undefined;
+    title?: string | undefined;
     action?: "focus" | "press" | "select_tab" | "toggle" | "set_text" | "set_value" | "dismiss_dialog" | undefined;
     button?: string | undefined;
     index?: number | undefined;

package/dist/core/capabilities/view-set.d.ts

@@ -0,0 +1,11 @@
+/**
+ * summer_view_set / engine.view_set (PRODUCT-SPEC J17): an outside agent shows
+ * the person what it works on, through the engine's SetView op: the view, the
+ * right rail, what to focus, and the nodes to frame the camera on.
+ */
+export declare function viewSetOp(args: {
+    view: string;
+    rail?: string;
+    focus?: string;
+    frame?: string[];
+}): Record<string, unknown>;

package/dist/core/capabilities/view-set.js

@@ -0,0 +1,15 @@
+/**
+ * summer_view_set / engine.view_set (PRODUCT-SPEC J17): an outside agent shows
+ * the person what it works on, through the engine's SetView op: the view, the
+ * right rail, what to focus, and the nodes to frame the camera on.
+ */
+export function viewSetOp(args) {
+    const op = { op: "SetView", view: args.view };
+    if (args.rail)
+        op.rail = args.rail;
+    if (args.focus)
+        op.focus = args.focus;
+    if (args.frame?.length)
+        op.frame = args.frame;
+    return op;
+}

package/dist/core/capability-skew.d.ts

@@ -81,6 +81,9 @@ export interface EngineCapabilities {
      *  destination ids this build can open. Absent = engine predates the op;
      *  summer_open then falls back to the legacy per-surface ops it can map. */
     navigation?: EngineNavigationCapabilities;
+    /** The Studio page ops this app answers itself through its own Studio tab
+     *  (POST /api/studio). Absent = send them to Summer's server. */
+    studioPage?: EngineStudioPageCapabilities;
     /** Launch postures this build ENFORCES: "focus" (always), "background"
      *  (`--summer-background`), "offscreen" (`--summer-offscreen` /
      *  `--summer-verify`). Non-macOS builds advertise ["focus"] only. Absent =
@@ -89,6 +92,11 @@ export interface EngineCapabilities {
      *  snake_case spelling too. */
     launchPostures?: string[];
 }
+export interface EngineStudioPageCapabilities {
+    version?: number;
+    path: string;
+    ops: string[];
+}
 export interface EngineNavigationCapabilities {
     version?: number;
     targets: EngineNavigationTarget[];

package/dist/core/capability-skew.js

@@ -49,6 +49,8 @@ export const CLI_KNOWN_OP_NEEDS = [
     // engine's one-table op; the other three are the legacy
     // fallbacks on engines that predate it.
     "Navigate", "OpenResource", "FocusDock", "RevealInFileSystem",
+    // engine.view_set: the frame's view, rail, focus and frame (core/capabilities/view-set.ts)
+    "SetView",
     // Summer Apps editor docks (summer_app_dock: core/capabilities/apps.ts)
     "OpenAppDock", "CloseAppDock", "ListAppDocks",
     // summer_enable_plugin (core/capabilities/enable-plugin.ts)
@@ -188,11 +190,27 @@ export function parseEngineCapabilities(raw) {
     const navigation = parseNavigation(record.navigation);
     if (navigation)
         out.navigation = navigation;
+    const studioPage = parseStudioPage(record.studioPage);
+    if (studioPage)
+        out.studioPage = studioPage;
     const launchPostures = stringList(record.launchPostures) ?? stringList(record.launch_postures);
     if (launchPostures)
         out.launchPostures = launchPostures;
     return Object.keys(out).length > 0 ? out : undefined;
 }
+function parseStudioPage(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const record = raw;
+    const ops = stringList(record.ops);
+    if (!ops?.length)
+        return undefined;
+    return {
+        ...(typeof record.version === "number" ? { version: record.version } : {}),
+        path: typeof record.path === "string" && record.path.startsWith("/api/") ? record.path : "/api/studio",
+        ops,
+    };
+}
 function parseNavigation(raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
         return undefined;

package/dist/core/cli-session.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The browser sign-in for the Summer account (the `cli_session` flow): the
+ * person opens `{gateway}/login?cli_session=<id>`, signs in, and approves;
+ * this polls `{gateway}/api/auth/cli-login?session=<id>` until the gateway
+ * hands over the CLI token, then saves it to ~/.summer (the files the desktop
+ * engine and every tool read). `summer login` and the MCP's sign-in link
+ * (core/sign-in-link.ts) share it.
+ */
+import { type LoginSession } from "./auth.js";
+export declare const POLL_TIMEOUT_MS = 900000;
+export interface CliSessionPollDependencies {
+    fetch: typeof fetch;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    log: (message: string) => void;
+    /** Stop waiting (another sign-in already saved a token, the server is closing). */
+    cancelled?: () => boolean | Promise<boolean>;
+}
+/** The page the person opens to sign in. */
+export declare function cliSessionLoginUrl(gatewayUrl: string, sessionId: string): string;
+/**
+ * Wait for the browser sign-in of `sessionId`, save it, and return it.
+ * Throws on a rejected request, an invalid token, a timeout, or `cancelled`.
+ */
+export declare function pollCliSession(gatewayUrl: string, sessionId: string, deps: CliSessionPollDependencies): Promise<LoginSession>;