Skip to content

armgit / Orkas

Public Imported from GitHub
0

Orkas is an open-source (MIT), local-first AI team for your desktop: a Commander turns your goal into to-dos and coordinates 16 built-in specialist agents plus Claude Code, Codex, OpenCode, OpenClaw and Hermes, with projects, scheduled automations and connectors. Free app for macOS & Windows; built-in models or your own keys.

Wait for chained preview SDK operations to settle

wyteb11f0572b6e
diff --git a/src/main/features/web_apps/preview.ts b/src/main/features/web_apps/preview.ts
index d0bd66ee..284860fe 100644
--- a/src/main/features/web_apps/preview.ts
+++ b/src/main/features/web_apps/preview.ts
@@ -11,7 +11,7 @@ import { serveFileRange } from '../../util/http-range';
import { isPathAllowed } from '../../util/path-sandbox';
import { mimeFor } from '../chat_artifacts';
import { bundleRevision } from './bundle-revision';
-import { MANIFEST_FILE, manifestSchema } from './catalog';
+import { MANIFEST_FILE, SDK_PATH, manifestSchema } from './catalog';
import { AppError, WebAppRuntime, type Bundle } from './runtime';
import { normalizeAppType } from './data-contract';
import { appResource } from './resources';
@@ -134,7 +134,16 @@ export async function createPreviewSdk(ses: Session, contents: WebContents, bund
const resource = await appResource(request, runtime);
if (!resource || resource.status !== 200) return new Response(null, { status: resource?.status ?? 403 });
try {
- if ('body' in resource) return new Response(resource.body, { headers: { ...resource.headers, 'Content-Type': resource.mime } });
+ if ('body' in resource) {
+ // Only isolated authoring previews expose this read-only count. It
+ // includes requests/replies in transit, without exposing their data
+ // or adding an application capability or privileged handle.
+ const body = decodeURIComponent(new URL(request.url).pathname) === '/' + SDK_PATH
+ ? resource.body.replace('/* PREVIEW_PENDING */',
+ 'Object.defineProperty(window, "__orkasPreviewPending", { configurable: true, get: () => pending.size });')
+ : resource.body;
+ return new Response(body, { headers: { ...resource.headers, 'Content-Type': resource.mime } });
+ }
const stat = await fsp.stat(resource.file);
const response = serveFileRange(request, resource.file, resource.mime, stat.size, stat.mtimeMs);
const headers = new Headers(response.headers);
@@ -151,8 +160,8 @@ export async function createPreviewSdk(ses: Session, contents: WebContents, bund
for (;;) {
const frame = contents.mainFrame.frames.find(frame => runtime.canNavigate(contents.id, open.url, frame.url));
if (!frame) throw new AppError('E_BUNDLE');
- await frame.executeJavaScript('new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)))');
- if (!pending.size) return;
+ const documentPending = await frame.executeJavaScript('new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(() => resolve(window.__orkasPreviewPending || 0))))');
+ if (!documentPending && !pending.size) return;
await Promise.allSettled([...pending]);
}
},
diff --git a/src/main/features/web_apps/sdk.js b/src/main/features/web_apps/sdk.js
index 0fdb4b95..659ed2d3 100644
--- a/src/main/features/web_apps/sdk.js
+++ b/src/main/features/web_apps/sdk.js
@@ -2,6 +2,7 @@
(function () {
'use strict';
const pending = new Map();
+ /* PREVIEW_PENDING */
let hostConnected = false;
let hostDiscovery = null;
const documentId = Array.from(crypto.getRandomValues(new Uint8Array(16)), byte => byte.toString(16).padStart(2, '0')).join('');
diff --git a/test/main/features/web-app-preview.test.ts b/test/main/features/web-app-preview.test.ts
index dcb51342..2371014d 100644
--- a/test/main/features/web-app-preview.test.ts
+++ b/test/main/features/web-app-preview.test.ts
@@ -1,6 +1,8 @@
import * as fs from 'node:fs';
import * as os from 'node:os';
import * as path from 'node:path';
+import * as vm from 'node:vm';
+import { webcrypto } from 'node:crypto';
import { afterEach, beforeEach, describe, expect, it } from 'vitest';
import { previewBundle } from '../../../src/main/features/web_apps/preview';
import { freezeFileMetadata } from '../../helpers/frozen-file-metadata';
@@ -124,6 +126,76 @@ it('settles the current bundle document after local navigation and rejects forei
await expect(preview.settle()).rejects.toThrow('E_BUNDLE');
});
+it('waits for SDK requests and chained results still in transit before finishing authoring evidence', async () => {
+ const { EventEmitter } = await import('node:events');
+ const { createPreviewSdk } = await import('../../../src/main/features/web_apps/preview');
+ manifest('{"sdkVersion":1,"capabilities":["files"]}');
+ const contents: any = new EventEmitter();
+ const outgoing: any[] = [], replies: any[] = [];
+ const events = new Map<string, (event?: any) => void>();
+ const paints: Array<() => void> = [];
+ const parent = { postMessage: (message: unknown) => outgoing.push(message) };
+ const window: any = { parent, addEventListener: (name: string, listener: (event?: any) => void) => events.set(name, listener) };
+ const context = vm.createContext({ window, parent, crypto: webcrypto, setTimeout, clearTimeout,
+ requestAnimationFrame: (callback: () => void) => paints.push(callback) });
+ const frame: any = { detached: false, frames: [], send: (_channel: string, value: any) => replies.push(value) };
+ let token = '', resource!: (request: Request) => Promise<Response>;
+ Object.assign(contents, { id: 32, mainFrame: frame, isDestroyed: () => false,
+ executeJavaScript: async (script: string) => {
+ const opened = JSON.parse(/attach\(frame, (\{.*?\})\);/s.exec(script)![1]);
+ token = opened.token;
+ frame.frames = [{ url: opened.url, executeJavaScript: (source: string) => vm.runInContext(source, context) }];
+ } });
+ const preview = await createPreviewSdk({ protocol: {
+ handle: (_scheme: string, handler: typeof resource) => { resource = handler; }, unhandle() {},
+ } } as any, contents, (await previewBundle(entry))!);
+ const paint = async () => {
+ for (const callback of paints.splice(0)) callback();
+ await new Promise(resolve => setImmediate(resolve));
+ };
+ try {
+ contents.getURL = () => preview.shellUrl;
+ await preview.attach();
+ vm.runInContext(await (await resource(new Request(preview.origin + '/__orkas/sdk.js'))).text(), context);
+ const journey = vm.runInContext(`(async () => {
+ const catalog = await window.orkasApp.call('capabilities.list');
+ try { await window.orkasApp.call('files.pick', {}); }
+ catch (error) { window.outcome = { available: catalog.methods.find(method => method.name === 'files.pick').available, code: error.code }; }
+ })()`, context);
+ let settled = false;
+ const settling = preview.settle().then(() => { settled = true; });
+ // The first request has left the document but has not reached main IPC.
+ await paint(); await paint();
+ const finishedBeforeRequestDelivery = settled;
+ let finishedBeforeReplyDelivery = false;
+ for (let sequence = 1; sequence <= 2; sequence++) {
+ await expect.poll(() => outgoing.length).toBe(1);
+ const request = outgoing.shift();
+ contents.emit('ipc-message', { senderFrame: frame }, 'orkas.web-app-preview', {
+ id: String(sequence), operation: 'webApps.call',
+ payload: { token, requestId: request.id, method: request.method, args: structuredClone(request.args) },
+ });
+ await expect.poll(() => replies.length).toBe(1);
+ // The runtime has finished, but the SDK promise and its continuation have not.
+ await paint(); await paint();
+ finishedBeforeReplyDelivery ||= settled;
+ const reply = replies.shift().event;
+ events.get('message')!({ source: parent, data: { __orkasApp: 1, id: request.id, ...reply } });
+ await new Promise(resolve => setImmediate(resolve));
+ }
+ await journey;
+ for (let i = 0; i < 4 && !settled; i++) await paint();
+ expect(settled).toBe(true);
+ await settling;
+ expect(finishedBeforeRequestDelivery).toBe(false);
+ expect(finishedBeforeReplyDelivery).toBe(false);
+ expect(window.outcome).toEqual({ available: false, code: 'E_UNAVAILABLE' });
+ expect(preview.evidence.calls).toEqual([
+ { method: 'capabilities.list', code: 'OK' }, { method: 'files.pick', code: 'E_UNAVAILABLE' },
+ ]);
+ } finally { events.get('pagehide')?.(); await preview.dispose(); }
+});
+
it('keeps preview data in disposable storage: writes are readable during the session and leave no files afterwards', async () => {
const { EventEmitter } = await import('node:events');
const { createPreviewSdk } = await import('../../../src/main/features/web_apps/preview');