getobsrv 0.3.0 → 0.4.0

package/out/mcp/lib.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALLOWED_URL_SCHEMES = exports.STDERR_TAIL_CHARS = exports.MAX_INLINE_IMAGE_BYTES = exports.UsageError = void 0;
+exports.APP_NOT_REACHABLE = exports.urlSchemeError = exports.ALLOWED_URL_SCHEMES = exports.STDERR_TAIL_CHARS = exports.MAX_INLINE_IMAGE_BYTES = exports.UsageError = void 0;
 exports.buildSnapArgs = buildSnapArgs;
 exports.buildDiffArgs = buildDiffArgs;
 exports.shouldInlineImage = shouldInlineImage;
 exports.killBudgetMs = killBudgetMs;
 exports.stderrTail = stderrTail;
-exports.urlSchemeError = urlSchemeError;
+exports.planSnapPath = planSnapPath;
 exports.extractTrailingJson = extractTrailingJson;
 exports.listCatalog = listCatalog;
 const presets_1 = require("../shared/presets");
@@ -97,30 +97,51 @@ function stderrTail(stderr, max = exports.STDERR_TAIL_CHARS) {
     const trimmed = stderr.trim();
     return trimmed.length <= max ? trimmed : `…${trimmed.slice(-max)}`;
 }
-/** Schemes a tool call may hand to the CLI. */
-exports.ALLOWED_URL_SCHEMES = ['http:', 'https:', 'file:'];
+// The scheme allowlist lives in shared/url.ts so the agent-control server
+// applies the identical check; re-exported so existing importers (and their
+// unit tests) keep their path.
+var url_1 = require("../shared/url");
+Object.defineProperty(exports, "ALLOWED_URL_SCHEMES", { enumerable: true, get: function () { return url_1.ALLOWED_URL_SCHEMES; } });
+Object.defineProperty(exports, "urlSchemeError", { enumerable: true, get: function () { return url_1.urlSchemeError; } });
+exports.APP_NOT_REACHABLE = 'The Obsrv app is not reachable. Open the Obsrv desktop app and enable "Agent control" in the toolbar ' +
+    '(or pass mode: "headless" to render without it).';
 /**
- * Rejects URLs whose explicit scheme is outside the allowlist (javascript:,
- * data:, chrome:, …) with an actionable message, or returns null when the URL
- * may proceed. Scheme-relative (`//host`), bare-host (`example.com/page`) and
- * host:port (`localhost:5173`) forms pass — they normalise to http(s)
- * downstream.
+ * Decides whether an `obsrv_snap` call drives the visible app or renders
+ * headlessly (spec §14 "Live drive"), given whether a control-enabled app
+ * answered discovery. Documented calls, exercised in tests/unit/mcpLib.test.ts:
+ *
+ * - custom dims (width/height/dsf/diagonal) always render headlessly — the
+ *   live path drives the app's preset table only — with a note, even under
+ *   an explicit `mode: 'live'`.
+ * - `fullPage` always renders headlessly (the visible window cannot show a
+ *   full page), with a note.
+ * - `waitMs` is honoured headlessly; on the live path it is ignored with a
+ *   note (the live capture settles on the app's own committed navigation).
+ * - `mode: 'live'` with no reachable app is an error, never a silent
+ *   headless fallback — the caller asked to watch.
  */
-function urlSchemeError(url) {
-    const trimmed = url.trim();
-    const match = /^([a-z][a-z0-9+.-]*):/i.exec(trimmed);
-    if (!match)
-        return null; // bare host or scheme-relative
-    const scheme = `${match[1].toLowerCase()}:`;
-    if (exports.ALLOWED_URL_SCHEMES.includes(scheme))
-        return null;
-    // `localhost:5173`-style host:port, not a scheme: the "scheme" is followed
-    // by a bare port number.
-    if (/^[a-z0-9.-]+:\d+(\/|$)/i.test(trimmed))
-        return null;
-    return (`unsupported URL scheme "${scheme}" — obsrv renders ` +
-        `${exports.ALLOWED_URL_SCHEMES.map(s => `${s}//`).join(', ')} URLs only ` +
-        `(bare hosts like example.com also work; they normalise to http(s)).`);
+function planSnapPath(input, mode, liveReachable) {
+    if (mode === 'headless')
+        return { path: 'headless', notes: [] };
+    if (!liveReachable) {
+        if (mode === 'live')
+            return { error: exports.APP_NOT_REACHABLE };
+        return { path: 'headless', notes: [] };
+    }
+    const notes = [];
+    const custom = input.width !== undefined ||
+        input.height !== undefined ||
+        input.deviceScaleFactor !== undefined ||
+        input.diagonalInches !== undefined;
+    if (custom)
+        notes.push('custom dimensions are headless-only (live mode drives the preset table); rendered headlessly.');
+    if (input.fullPage)
+        notes.push('fullPage is headless-only; rendered headlessly instead of driving the app.');
+    if (notes.length > 0)
+        return { path: 'headless', notes };
+    if (input.waitMs !== undefined)
+        notes.push('waitMs is headless-only and was ignored in live mode.');
+    return { path: 'live', notes };
 }
 /**
  * Parses the CLI's machine output: the trailing JSON object on stdout.

package/out/mcp/server.js

@@ -9,7 +9,9 @@ const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const zod_1 = require("zod");
 const args_1 = require("../cli/args");
+const control_1 = require("../shared/control");
 const presets_1 = require("../shared/presets");
+const control_2 = require("./control");
 const lib_1 = require("./lib");
 /**
  * Obsrv MCP server (stdio, stateless): three read-only tools wrapping the
@@ -116,17 +118,33 @@ const snapInputShape = {
         .min(1)
         .optional()
         .describe(`Per-render budget for load + paint quiescence, in ms. Default ${args_1.DEFAULT_TIMEOUT_MS}.`),
+    mode: zod_1.z
+        .enum(['auto', 'headless', 'live'])
+        .optional()
+        .describe('auto (default): drive the visible Obsrv app when it is open with Agent control on, else render headlessly. ' +
+        'live: require the app (error if unreachable). headless: never touch the app.'),
 };
 const snapOutputShape = {
-    out: zod_1.z.string().describe('PNG path the CLI wrote (same file as pngPath).'),
-    preset: zod_1.z.string().describe('Preset id, or "custom" for width/height runs.'),
-    cssWidth: zod_1.z.number().describe('Applied CSS viewport width.'),
-    cssHeight: zod_1.z.number().describe('Applied CSS viewport height (grown under fullPage).'),
-    deviceScaleFactor: zod_1.z.number(),
-    profile: zod_1.z.string(),
-    settled: zod_1.z.boolean().describe('False: the page never went paint-quiet (e.g. animation) and the capture is best-effort.'),
+    mode: zod_1.z
+        .enum(['headless', 'live'])
+        .describe('How the snap was produced: a headless render, or a capture of the visible Obsrv app window (live drive).'),
+    out: zod_1.z.string().optional().describe('Headless only: PNG path the CLI wrote (same file as pngPath).'),
+    preset: zod_1.z.string().optional().describe('Headless only: preset id, or "custom" for width/height runs.'),
+    cssWidth: zod_1.z.number().optional().describe('Headless only: applied CSS viewport width.'),
+    cssHeight: zod_1.z.number().optional().describe('Headless only: applied CSS viewport height (grown under fullPage).'),
+    deviceScaleFactor: zod_1.z.number().optional().describe('Headless only.'),
+    profile: zod_1.z.string().optional().describe('Headless only: applied panel profile id.'),
+    settled: zod_1.z
+        .boolean()
+        .describe('Headless: the page went paint-quiet. Live: the app confirmed the navigation before the capture.'),
     warnings: zod_1.z.array(zod_1.z.string()),
     pngPath: zod_1.z.string().describe('Absolute path of the captured PNG (kept in a per-call temp dir).'),
+    url: zod_1.z.string().optional().describe('Live only: the URL the app reports showing.'),
+    presetId: zod_1.z.string().optional().describe('Live only: the screen preset selected in the app.'),
+    profileId: zod_1.z.string().optional().describe('Live only: the panel profile selected in the app.'),
+    viewMode: zod_1.z.string().optional().describe("Live only: the app's target-pane view (1:1 or fit)."),
+    width: zod_1.z.number().optional().describe('Live only: captured app-window width in px.'),
+    height: zod_1.z.number().optional().describe('Live only: captured app-window height in px.'),
 };
 const diffInputShape = {
     url: urlField,
@@ -187,6 +205,122 @@ const presetsOutputShape = {
         summary: zod_1.z.string(),
     })),
 };
+const driveInputShape = {
+    url: zod_1.z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Navigate the app (both panes) to this http://, https:// or file:// URL (bare hosts also work).'),
+    preset: zod_1.z.enum(PRESET_IDS).optional().describe('Apply this screen preset, exactly as clicking the toolbar would.'),
+    profile: zod_1.z.enum(PROFILE_IDS).optional().describe('Apply this panel profile in the app.'),
+    viewMode: zod_1.z.enum(['1:1', 'fit']).optional().describe("Switch the app's target pane between 1:1 (actual size) and fit."),
+};
+const driveOutputShape = {
+    version: zod_1.z.string().describe('The running app version.'),
+    url: zod_1.z.string().describe('The URL the target pane reports showing.'),
+    presetId: zod_1.z.string(),
+    profileId: zod_1.z.string(),
+    viewMode: zod_1.z.string(),
+    mode: zod_1.z.string().describe("The app's pane mode: 'url' (live page) or 'image' (a dropped design export)."),
+};
+// --- live drive --------------------------------------------------------------
+/** Budget for one control `status` round-trip once the app is known live. */
+const LIVE_STATUS_TIMEOUT_MS = 2_000;
+/** Budget for a preset/profile/view-mode apply (the server confirms, bounded). */
+const LIVE_APPLY_TIMEOUT_MS = 5_000;
+/** Budget for `captureVisible` (a full-window PNG over loopback). */
+const LIVE_CAPTURE_TIMEOUT_MS = 30_000;
+/** How long a live snap waits for `status.url` to reflect the navigation. */
+const LIVE_SETTLE_MS = 5_000;
+function liveFailure(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return (`${msg}. If the Obsrv app was closed or Agent control was toggled off mid-call, ` +
+        `re-open the app and re-enable the toolbar toggle — or pass mode: "headless".`);
+}
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+/**
+ * The live `obsrv_snap` path: navigate the visible app (plus preset/profile
+ * when given), wait — bounded — for the app to report the navigation, then
+ * capture the window exactly as the user sees it.
+ */
+async function liveSnap(app, input, notes) {
+    const { info } = app;
+    const warnings = [...notes];
+    const before = app.status.url;
+    let applied = '';
+    try {
+        // The navigate command answers once both panes finished loading, so it
+        // carries the same per-render budget the headless path polices.
+        const nav = await (0, control_2.controlCall)(info, 'navigate', { url: input.url.trim() }, (input.timeoutMs ?? args_1.DEFAULT_TIMEOUT_MS) + 10_000);
+        applied = typeof nav['url'] === 'string' ? nav['url'] : '';
+        if (input.preset !== undefined)
+            await (0, control_2.controlCall)(info, 'setPreset', { id: input.preset }, LIVE_APPLY_TIMEOUT_MS);
+        if (input.profile !== undefined)
+            await (0, control_2.controlCall)(info, 'setProfile', { id: input.profile }, LIVE_APPLY_TIMEOUT_MS);
+    }
+    catch (e) {
+        return toolError(liveFailure(e));
+    }
+    // The app settles when it reports the applied URL — or, after a redirect,
+    // any committed non-blank URL that is no longer the pre-navigation one.
+    let status = app.status;
+    let settled = false;
+    const deadline = Date.now() + LIVE_SETTLE_MS;
+    for (;;) {
+        try {
+            const s = (0, control_1.parseControlStatus)(await (0, control_2.controlCall)(info, 'status', {}, LIVE_STATUS_TIMEOUT_MS));
+            if (s) {
+                status = s;
+                settled = s.url === applied || (applied !== '' && s.url !== before && s.url !== 'about:blank');
+            }
+        }
+        catch (e) {
+            return toolError(liveFailure(e));
+        }
+        if (settled || Date.now() >= deadline)
+            break;
+        await sleep(250);
+    }
+    if (!settled)
+        warnings.push('the app did not confirm the navigation before capture; the PNG may show the previous page.');
+    // One short grace after the state settles: the renderer repaints the pane
+    // (and any preset resize) a frame or two after the store confirms, and a
+    // capture racing that would show a half-applied flip.
+    await sleep(300);
+    let capture;
+    try {
+        capture = await (0, control_2.controlCall)(info, 'captureVisible', {}, LIVE_CAPTURE_TIMEOUT_MS);
+    }
+    catch (e) {
+        return toolError(liveFailure(e));
+    }
+    const { data, width, height } = capture;
+    if (typeof data !== 'string' || typeof width !== 'number' || typeof height !== 'number') {
+        return toolError('the control server returned a malformed capture');
+    }
+    const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'obsrv-mcp-'));
+    const pngPath = (0, node_path_1.join)(dir, 'live.png');
+    await (0, promises_1.writeFile)(pngPath, Buffer.from(data, 'base64'));
+    const structured = {
+        mode: 'live',
+        url: status.url,
+        presetId: status.presetId,
+        profileId: status.profileId,
+        viewMode: status.viewMode,
+        width,
+        height,
+        settled,
+        warnings,
+        pngPath,
+    };
+    return {
+        content: [
+            { type: 'text', text: JSON.stringify(structured, null, 2) },
+            await imageOrNote(pngPath, 'The captured app window', 'read the file at pngPath'),
+        ],
+        structuredContent: structured,
+    };
+}
 // --- server ------------------------------------------------------------------
 const server = new mcp_js_1.McpServer({ name: 'obsrv-mcp-server', version: VERSION });
 server.registerTool('obsrv_snap', {
@@ -198,7 +332,15 @@ server.registerTool('obsrv_snap', {
         `Pass either \`preset\` (list ids with obsrv_presets) or custom \`width\` + \`height\`, never both. ` +
         `Returns structured metadata (applied viewport, profile, \`settled\`, warnings, and \`pngPath\` — the PNG ` +
         `kept in a per-call temp dir) plus the PNG as an inline image when it is within the 1.5 MiB cap; larger ` +
-        `captures (typically fullPage) stay on disk with a note.`,
+        `captures (typically fullPage) stay on disk with a note.\n\n` +
+        `Live drive: when the Obsrv desktop app is open with its "Agent control" toolbar toggle on, \`mode: "auto"\` ` +
+        `(the default) drives the *visible* app instead — the user watches the URL load and the preset flip, and the ` +
+        `returned PNG is the app window as they see it (\`mode: "live"\` in the result; \`mode: "headless"\` ` +
+        `otherwise). Custom width/height and \`fullPage\` always render headlessly (with a note); \`waitMs\` is ` +
+        `ignored in live mode. \`mode: "live"\` errors when the app is not reachable; \`mode: "headless"\` never ` +
+        `touches it. Note: although this tool is annotated read-only (it renders and captures), a live snap steers ` +
+        `the open app window — navigating it and flipping its preset in front of the user — as its means of ` +
+        `capture; that visible steering is the point of live mode.`,
     inputSchema: snapInputShape,
     outputSchema: snapOutputShape,
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
@@ -206,6 +348,20 @@ server.registerTool('obsrv_snap', {
     const badScheme = (0, lib_1.urlSchemeError)(input.url);
     if (badScheme)
         return toolError(badScheme);
+    // The live path first (spec §14 "Live drive"): a reachable control-enabled
+    // app wins under auto, is required under live, and is never probed under
+    // headless. planSnapPath documents the fallback rules.
+    const requestedMode = input.mode ?? 'auto';
+    let liveNotes = [];
+    if (requestedMode !== 'headless') {
+        const live = await (0, control_2.discoverControl)();
+        const plan = (0, lib_1.planSnapPath)(input, requestedMode, live !== null);
+        if ('error' in plan)
+            return toolError(plan.error);
+        if (plan.path === 'live' && live)
+            return liveSnap(live, input, plan.notes);
+        liveNotes = plan.notes;
+    }
     const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'obsrv-mcp-'));
     const pngPath = (0, node_path_1.join)(dir, 'snap.png');
     let args;
@@ -225,7 +381,8 @@ server.registerTool('obsrv_snap', {
     const meta = (0, lib_1.extractTrailingJson)(run.stdout);
     if (!meta)
         return toolError(`obsrv snap exited 0 but printed unparseable JSON: ${(0, lib_1.stderrTail)(run.stdout)}`);
-    const structured = { ...meta, pngPath };
+    const cliWarnings = Array.isArray(meta['warnings']) ? meta['warnings'] : [];
+    const structured = { ...meta, mode: 'headless', warnings: [...cliWarnings, ...liveNotes], pngPath };
     return {
         content: [
             { type: 'text', text: JSON.stringify(structured, null, 2) },
@@ -245,7 +402,10 @@ server.registerTool('obsrv_diff', {
         `paths of target.png / reference.png in a per-call temp dir. \`includeImages: true\` also inlines both ` +
         `PNGs (1.5 MiB cap each).\n\n` +
         `1x presets only (e.g. laptop-768, 1080p-24): dense presets (phones) and CSS viewports over 2048px are ` +
-        `refused with an explanatory error — use obsrv_snap for those.`,
+        `refused with an explanatory error — use obsrv_snap for those.\n\n` +
+        `Headless-only: a diff always performs its own two renders and never drives a running Obsrv app window ` +
+        `(the comparison needs both rasters, which the visible app cannot show) — use obsrv_snap or obsrv_drive ` +
+        `for live drive.`,
     inputSchema: diffInputShape,
     outputSchema: diffOutputShape,
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
@@ -273,6 +433,51 @@ server.registerTool('obsrv_diff', {
     }
     return { content, structuredContent: metrics };
 });
+server.registerTool('obsrv_drive', {
+    title: 'Drive the visible Obsrv app',
+    description: `Drive the Obsrv desktop app the user is looking at: navigate it to a URL, apply a screen preset, a panel ` +
+        `profile, or the target pane's 1:1/fit view — each applied exactly as clicking the toolbar would, while the ` +
+        `user watches. Applies whichever inputs are given (none = just read the current state) and returns the ` +
+        `resulting status: app version, the URL showing, and the selected preset/profile/view.\n\n` +
+        `Requires the app to be open with its "Agent control" toolbar toggle on; errors otherwise. This tool ` +
+        `mutates visible app state (it changes what the user's window shows) but renders nothing itself — use ` +
+        `obsrv_snap for a capture.`,
+    inputSchema: driveInputShape,
+    outputSchema: driveOutputShape,
+    // Honest annotation: this changes what the user's window is showing.
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+}, async (input) => {
+    if (input.url !== undefined) {
+        const badScheme = (0, lib_1.urlSchemeError)(input.url);
+        if (badScheme)
+            return toolError(badScheme);
+    }
+    const live = await (0, control_2.discoverControl)();
+    if (!live)
+        return toolError(lib_1.APP_NOT_REACHABLE);
+    try {
+        if (input.url !== undefined) {
+            await (0, control_2.controlCall)(live.info, 'navigate', { url: input.url.trim() }, args_1.DEFAULT_TIMEOUT_MS + 10_000);
+        }
+        if (input.preset !== undefined)
+            await (0, control_2.controlCall)(live.info, 'setPreset', { id: input.preset }, LIVE_APPLY_TIMEOUT_MS);
+        if (input.profile !== undefined)
+            await (0, control_2.controlCall)(live.info, 'setProfile', { id: input.profile }, LIVE_APPLY_TIMEOUT_MS);
+        if (input.viewMode !== undefined) {
+            await (0, control_2.controlCall)(live.info, 'setViewMode', { mode: input.viewMode }, LIVE_APPLY_TIMEOUT_MS);
+        }
+        const status = (0, control_1.parseControlStatus)(await (0, control_2.controlCall)(live.info, 'status', {}, LIVE_STATUS_TIMEOUT_MS));
+        if (!status)
+            return toolError('the control server returned a malformed status');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(status, null, 2) }],
+            structuredContent: { ...status },
+        };
+    }
+    catch (e) {
+        return toolError(liveFailure(e));
+    }
+});
 server.registerTool('obsrv_presets', {
     title: 'List screen presets and panel profiles',
     description: `List every screen preset (id, label, group, CSS dims, deviceScaleFactor, panel diagonal, derived physical ` +

package/out/preload/app.js

@@ -22,7 +22,10 @@ const IPC = {
   openImage: "obsrv:open-image",
   focusUrl: "obsrv:focus-url",
   openImagePath: "obsrv:open-image-path",
-  readImageFile: "obsrv:read-image-file"
+  readImageFile: "obsrv:read-image-file",
+  uiState: "obsrv:ui-state",
+  agentApply: "obsrv:agent-apply",
+  agentActivity: "obsrv:agent-activity"
 };
 function subscribe(channel, cb) {
   const listener = (_e, v) => cb(v);
@@ -82,6 +85,15 @@ const api = {
     };
   },
   onOpenImagePath: (cb) => subscribe(IPC.openImagePath, cb),
-  readImageFile: (path) => electron.ipcRenderer.invoke(IPC.readImageFile, path)
+  readImageFile: (path) => electron.ipcRenderer.invoke(IPC.readImageFile, path),
+  reportUiState: (s) => electron.ipcRenderer.send(IPC.uiState, s),
+  onAgentApply: (cb) => subscribe(IPC.agentApply, cb),
+  onAgentActivity: (cb) => {
+    const listener = () => cb();
+    electron.ipcRenderer.on(IPC.agentActivity, listener);
+    return () => {
+      electron.ipcRenderer.removeListener(IPC.agentActivity, listener);
+    };
+  }
 };
 electron.contextBridge.exposeInMainWorld("obsrv", api);

package/out/renderer/assets/{index-VleEBVgL.css → index-FtoKShe_.css}

@@ -251,11 +251,25 @@ html, body, #root { margin: 0; height: 100%; background: var(--chrome-0); color:
 .num { font-family: var(--mono); font-variant-numeric: tabular-nums; }
 
 /* An open drawer's button: weight and a 1px border, not hue. */
-.toolbar :is(.toggle-panel, .toggle-settings)[aria-pressed='true'] {
+.toolbar :is(.toggle-panel, .toggle-settings, .agent-toggle)[aria-pressed='true'] {
   border-color: var(--text-0);
   background: var(--chrome-1);
 }
 
+/* Agent control: same neutral chrome as every other toggle; the activity
+   badge is text-weight only — an agent driving the window is a status, not
+   an alert. */
+.toolbar .agent-toggle { width: auto; padding: 0 8px; white-space: nowrap; }
+.agent-activity {
+  color: var(--text-1);
+  border: 1px solid var(--line);
+  border-radius: 4px;
+  padding: 1px 6px;
+  font-size: 11px;
+  letter-spacing: 0.5px;
+  white-space: nowrap;
+}
+
 /* Drawers sit beside the panes, never over them: the native WebContentsView is
    an OS-level overlay and would cover anything painted on top of it. */
 .body { flex: 1 1 auto; display: flex; min-height: 0; }

package/out/renderer/assets/{index-BAEO9_6W.js → index-P496vEhv.js}

@@ -12688,7 +12688,7 @@ const createImpl = (createState) => {
 };
 const create = ((createState) => createImpl);
 const MAX_VIEWPORT = 4096;
-const DEFAULT_SETTINGS = { hostDiagonalInches: 27, hostNits: 500 };
+const DEFAULT_SETTINGS = { hostDiagonalInches: 27, hostNits: 500, agentControl: false };
 const SCREEN_PRESETS = [
   // Laptops — ordered largest to smallest panel, then the denser 1080p outlier.
   { id: "laptop-768", label: '1366×768 15.6"', width: 1366, height: 768, diagonalInches: 15.6, deviceScaleFactor: 1, group: "laptop" },
@@ -14172,8 +14172,29 @@ function Toolbar({ drawer, onTogglePanel, onToggleSettings }) {
   const setSurround = useStore((s) => s.setSurround);
   const viewMode = useStore((s) => s.viewMode);
   const setViewMode = useStore((s) => s.setViewMode);
+  const agentControl = useStore((s) => s.settings.agentControl);
+  const setSettings = useStore((s) => s.setSettings);
   const inputRef = reactExports.useRef(null);
   const [draft, setDraft] = reactExports.useState(barText);
+  const [agentActive, setAgentActive] = reactExports.useState(false);
+  reactExports.useEffect(() => {
+    let timer;
+    const off = window.obsrv.onAgentActivity(() => {
+      setAgentActive(true);
+      clearTimeout(timer);
+      timer = setTimeout(() => setAgentActive(false), 3e3);
+    });
+    return () => {
+      clearTimeout(timer);
+      off();
+    };
+  }, []);
+  const toggleAgent = () => {
+    const current = useStore.getState().settings;
+    const next = { ...current, agentControl: !current.agentControl };
+    setSettings(next);
+    window.obsrv.setSettings(next).catch(() => setSettings(current));
+  };
   const lastMode = reactExports.useRef(mode);
   reactExports.useEffect(() => {
     const modeChanged = lastMode.current !== mode;
@@ -14290,6 +14311,19 @@ function Toolbar({ drawer, onTogglePanel, onToggleSettings }) {
       },
       s.id
     )) }),
+    agentActive && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "agent-activity", children: "AGENT" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      "button",
+      {
+        className: "agent-toggle",
+        type: "button",
+        title: "Agent control — let a local agent drive this window",
+        "aria-label": "Agent control",
+        "aria-pressed": agentControl,
+        onClick: toggleAgent,
+        children: "Agent"
+      }
+    ),
     /* @__PURE__ */ jsxRuntimeExports.jsx(
       "button",
       {
@@ -14334,6 +14368,9 @@ function App() {
   const surround = useStore((s) => s.surround);
   const viewport = useStore(useShallow(selectViewport));
   const deviceScaleFactor = useStore(selectDeviceScaleFactor);
+  const presetId = useStore((s) => s.presetId);
+  const profileId = useStore((s) => s.profileId);
+  const viewMode = useStore((s) => s.viewMode);
   reactExports.useEffect(() => {
     window.obsrv.getHostInfo().then(setHost, (e) => console.warn("obsrv: getHostInfo failed", e));
     window.obsrv.getSettings().then(setSettings, (e) => console.warn("obsrv: getSettings failed", e));
@@ -14359,6 +14396,17 @@ function App() {
   reactExports.useEffect(() => {
     window.obsrv.setMode(mode);
   }, [mode]);
+  reactExports.useEffect(() => {
+    window.obsrv.reportUiState({ presetId, profileId, viewMode, mode });
+  }, [presetId, profileId, viewMode, mode]);
+  reactExports.useEffect(() => {
+    return window.obsrv.onAgentApply((patch) => {
+      const s = useStore.getState();
+      if (patch.presetId !== void 0) s.setPreset(patch.presetId);
+      if (patch.profileId !== void 0) s.setProfile(patch.profileId);
+      if (patch.viewMode !== void 0) s.setViewMode(patch.viewMode);
+    });
+  }, []);
   reactExports.useEffect(() => {
     document.documentElement.dataset.surround = surround;
   }, [surround]);

package/out/renderer/index.html

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' blob: data:" />
     <title>Obsrv</title>
-    <script type="module" crossorigin src="./assets/index-BAEO9_6W.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-VleEBVgL.css">
+    <script type="module" crossorigin src="./assets/index-P496vEhv.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-FtoKShe_.css">
   </head>
   <body>
     <div id="root"></div>