feat(desktop): add Runtime Host Session execution IPC (#2149)

Author: M4n5ter

apps/desktop/src/main/__tests__/runtime-host-client-operations.test.ts

@@ -200,6 +200,24 @@ test('treats empty configuration patches as read-only lookups', async () => {
   ]);
 });
 
+test('reads the bounded Host execution boundary summary', async () => {
+  const { client, requests } = clientWithResponses([
+    { kind: 'managed', access: 'read_only', revision: 4 },
+  ]);
+
+  assert.deepEqual(await client.readExecutionBoundary('session-1'), {
+    kind: 'managed',
+    access: 'read_only',
+    revision: 4,
+  });
+  assert.deepEqual(requests, [
+    {
+      operation: 'session.execution_boundary.query',
+      input: { sessionId: 'session-1' },
+    },
+  ]);
+});
+
 test('binds message controls to the current Host Epoch', async () => {
   const { client, requests } = clientWithResponses([
     { disposition: 'steering', queueRevision: 2 },
@@ -264,6 +282,118 @@ test('binds message controls to the current Host Epoch', async () => {
   ]);
 });
 
+test('uploads Attachment bytes in bounded Host chunks and commits the digest', async () => {
+  const bytes = new Uint8Array(48 * 1024 + 3).fill(7);
+  const attachment = {
+    kind: 'file' as const,
+    name: 'notes.txt',
+    mimeType: 'text/plain',
+    bytes: bytes.byteLength,
+    ref: {
+      kind: 'session_file' as const,
+      sessionId: 'session-1',
+      relativePath: 'artifact-1',
+    },
+  };
+  const { client, requests } = clientWithResponses([
+    { kind: 'upload_opened', nextOffset: 0 },
+    { kind: 'chunk_accepted', nextOffset: 48 * 1024 },
+    { kind: 'chunk_accepted', nextOffset: bytes.byteLength },
+    { kind: 'committed', attachment },
+  ]);
+
+  assert.deepEqual(
+    await client.ingestAttachment({
+      sessionId: 'session-1',
+      uploadId: 'upload-1',
+      name: 'notes.txt',
+      mimeType: 'text/plain',
+      content: bytes,
+    }),
+    attachment,
+  );
+  assert.deepEqual(
+    requests.map(({ operation, input }) => ({
+      operation,
+      kind: (input as { kind?: string }).kind,
+      offset: (input as { offset?: number }).offset,
+    })),
+    [
+      { operation: 'artifact.ingest', kind: 'begin', offset: undefined },
+      { operation: 'artifact.ingest', kind: 'chunk', offset: 0 },
+      { operation: 'artifact.ingest', kind: 'chunk', offset: 48 * 1024 },
+      { operation: 'artifact.ingest', kind: 'commit', offset: undefined },
+    ],
+  );
+  const begin = requests[0]?.input as { contentSha256: string; totalBytes: number };
+  assert.equal(begin.totalBytes, bytes.byteLength);
+  assert.match(begin.contentSha256, /^sha256:[a-f0-9]{64}$/);
+});
+
+test('aborts an opened Attachment upload when a later chunk fails', async () => {
+  const requests: RecordedRequest[] = [];
+  const connection = {
+    hostEpoch: 'host-current',
+    request: async <K extends OperationKey>(operation: K, input: OperationInput<K>) => {
+      requests.push({ operation, input });
+      if ((input as { kind?: string }).kind === 'begin') {
+        return { kind: 'upload_opened', nextOffset: 0 };
+      }
+      if ((input as { kind?: string }).kind === 'abort') {
+        return { kind: 'upload_aborted', uploadId: 'upload-1' };
+      }
+      throw new Error('chunk failed');
+    },
+    close: async () => undefined,
+  } as unknown as RuntimeHostConnection;
+  const client = new DesktopRuntimeHostClient(connection);
+
+  await assert.rejects(
+    () =>
+      client.ingestAttachment({
+        sessionId: 'session-1',
+        uploadId: 'upload-1',
+        name: 'notes.txt',
+        mimeType: 'text/plain',
+        content: new Uint8Array([1]),
+      }),
+    /chunk failed/,
+  );
+  assert.deepEqual(
+    requests.map(({ input }) => (input as { kind: string }).kind),
+    ['begin', 'chunk', 'abort'],
+  );
+});
+
+test('accepts an idempotently committed Attachment upload at begin', async () => {
+  const attachment = {
+    kind: 'file' as const,
+    name: 'notes.txt',
+    mimeType: 'text/plain',
+    bytes: 1,
+    ref: {
+      kind: 'session_file' as const,
+      sessionId: 'session-1',
+      relativePath: 'artifact-1',
+    },
+  };
+  const { client, requests } = clientWithResponses([
+    { kind: 'committed', uploadId: 'upload-1', attachment },
+  ]);
+
+  assert.deepEqual(
+    await client.ingestAttachment({
+      sessionId: 'session-1',
+      uploadId: 'upload-1',
+      name: 'notes.txt',
+      mimeType: 'text/plain',
+      content: new Uint8Array([1]),
+    }),
+    attachment,
+  );
+  assert.equal(requests.length, 1);
+});
+
 test('fails explicitly when the Host cannot represent a legacy Session', async () => {
   const { client } = clientWithResponses([
     {

apps/desktop/src/main/__tests__/runtime-host-client-uds.test.ts

@@ -20,7 +20,10 @@ import {
   tryAcquireInteractiveRootOwner,
 } from '@maka/storage/root-authority';
 import { DesktopRuntimeHostClient } from '../runtime-host-client.js';
+import { createAttachmentApprovalRegistry } from '../attachment-approval.js';
 import { registerRuntimeHostSessionCatalogIpc } from '../runtime-host-session-catalog-ipc-main.js';
+import { registerRuntimeHostSessionExecutionIpc } from '../runtime-host-session-execution-ipc-main.js';
+import { RuntimeHostSessionObserver } from '../runtime-host-session-observer.js';
 
 test('drives Desktop Session operations through a real Runtime Host connection', async () => {
   const base = await mkdtemp(join(tmpdir(), 'maka-desktop-host-client-'));
@@ -222,6 +225,106 @@ test('drives the renderer Session catalog facade through real UDS framing', asyn
   }
 });
 
+test('drives the renderer Session execution facade through real UDS framing', async () => {
+  const base = await mkdtemp(join(tmpdir(), 'maka-desktop-host-execution-ipc-'));
+  let host: RuntimeHostKernel | undefined;
+  try {
+    const capability = await resolveStorageRoot({ path: base, kind: 'interactive' });
+    const owner = await tryAcquireInteractiveRootOwner(capability);
+    assert.ok(owner);
+    const projected = session('session-1');
+    host = await RuntimeHostKernel.start({
+      owner,
+      idleGraceMs: 10_000,
+      compositionFactory: async () => ({
+        handlers: handlers({
+          'session.catalog.query': async (input) => ({
+            ok: true,
+            result: {
+              kind: 'session',
+              session: input.kind === 'get' && input.sessionId === projected.id ? projected : null,
+            },
+          }),
+          'session.execution_boundary.query': async (input) => {
+            assert.equal(input.sessionId, projected.id);
+            return {
+              ok: true,
+              result: { kind: 'managed', access: 'read_only', revision: 2 },
+            };
+          },
+          'turn.start': async (input) => {
+            assert.equal(input.sessionId, projected.id);
+            assert.equal(input.content.text, 'Run through the Host');
+            return {
+              ok: true,
+              result: {
+                sessionId: input.sessionId,
+                turnId: input.turnId,
+                runId: 'run-1',
+                status: 'running',
+              },
+            };
+          },
+        }),
+        beginDrain() {},
+        async recover() {},
+        async close() {},
+      }),
+    });
+    const connected = await connectRuntimeHost({
+      rootPath: base,
+      surface: 'desktop',
+      protocol: {
+        min: RUNTIME_HOST_PROTOCOL_VERSION,
+        max: RUNTIME_HOST_PROTOCOL_VERSION,
+      },
+    });
+    assert.equal(connected.kind, 'connected');
+    if (connected.kind !== 'connected') throw new Error('Desktop did not connect to Runtime Host');
+    const client = new DesktopRuntimeHostClient(connected.connection);
+    const observer = new RuntimeHostSessionObserver({ client, emitSessionsChanged() {} });
+    const ipc = ipcHarness();
+    registerRuntimeHostSessionExecutionIpc(
+      {
+        client,
+        observer,
+        attachmentApprovals: createAttachmentApprovalRegistry(),
+        emitSessionsChanged() {},
+        stat: async () => ({ size: 0 }),
+        resizeImage: async (bytes) => bytes,
+        newId: () => 'turn-1',
+      },
+      ipc,
+    );
+
+    assert.deepEqual(await ipc.invoke('sessions:readExecutionBoundary', projected.id), {
+      kind: 'managed',
+      access: 'read_only',
+      revision: 2,
+    });
+    assert.deepEqual(
+      await ipc.invoke('sessions:send', projected.id, {
+        type: 'send',
+        turnId: 'turn-1',
+        text: 'Run through the Host',
+      }),
+      {
+        ok: true,
+        turnId: 'turn-1',
+        attachments: [],
+        inlineReferences: [],
+        skillInvocation: { loaded: [], failed: [], receipts: [] },
+      },
+    );
+
+    await observer.close();
+    await client.close();
+  } finally {
+    await host?.close().catch(() => undefined);
+    await rm(base, { recursive: true, force: true });
+  }
+});
+
 type TestHandlers = Partial<RuntimeHostComposition['handlers']>;
 
 function handlers(overrides: TestHandlers): RuntimeHostComposition['handlers'] {