Merge branch 'main' into grypez/add-logger-package

Author: grypez

packages/cli/src/app.ts

@@ -116,8 +116,6 @@ await yargs(hideBin(process.argv))
       const closeHandlers: (() => Promise<void>)[] = [];
       const resolvedDir = path.resolve(args.dir);
 
-      await bundleSource(resolvedDir, logger);
-
       const handleClose = async (): Promise<void> => {
         await Promise.all(
           closeHandlers.map(async (close) => withTimeout(close(), 400)),

packages/cli/src/commands/watch.test.ts

@@ -8,7 +8,7 @@ import { unlink } from 'fs/promises';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 import { bundleFile } from './bundle.ts';
-import { watchDir, makeWatchEvents, filterOnlyJsFiles } from './watch.ts';
+import { watchDir, makeWatchEvents, shouldIgnore } from './watch.ts';
 
 vi.mock('fs/promises', () => ({
   unlink: vi.fn(async () => new Promise<void>(() => undefined)),
@@ -46,21 +46,22 @@ describe('watchDir', () => {
   });
 });
 
-describe('filterOnlyJsFiles', () => {
+describe('shouldIgnore', () => {
   const missingStats = undefined as unknown as Stats;
   const fileStats = { isFile: () => true } as unknown as Stats;
   const nonFileStats = { isFile: () => false } as unknown as Stats;
 
   it.each`
-    description                    | file             | stats           | expectation
-    ${'a file with missing stats'} | ${'test.js'}     | ${missingStats} | ${false}
-    ${'a non-file'}                | ${'test.js'}     | ${nonFileStats} | ${false}
-    ${'a .ts file'}                | ${'test.ts'}     | ${fileStats}    | ${false}
-    ${'a .bundle file'}            | ${'test.bundle'} | ${fileStats}    | ${false}
-    ${'a .txt file'}               | ${'test.txt'}    | ${nonFileStats} | ${false}
-    ${'a .js file'}                | ${'test.js'}     | ${fileStats}    | ${true}
+    description                     | file                      | stats           | expectation
+    ${'a file with missing stats'}  | ${'test.js'}              | ${missingStats} | ${false}
+    ${'a non-file'}                 | ${'test.js'}              | ${nonFileStats} | ${false}
+    ${'a .js file'}                 | ${'test.js'}              | ${fileStats}    | ${false}
+    ${'a .ts file'}                 | ${'test.ts'}              | ${fileStats}    | ${true}
+    ${'a .bundle file'}             | ${'test.bundle'}          | ${fileStats}    | ${true}
+    ${'a .txt file'}                | ${'test.txt'}             | ${fileStats}    | ${true}
+    ${'a .js file in node_modules'} | ${'node_modules/test.js'} | ${fileStats}    | ${true}
   `('returns $expectation for $description', ({ file, expectation, stats }) => {
-    expect(filterOnlyJsFiles(file, stats)).toBe(expectation);
+    expect(shouldIgnore(file, stats)).toBe(expectation);
   });
 });
 

packages/cli/src/commands/watch.ts

@@ -56,8 +56,11 @@ export const makeWatchEvents = (
   error: (error: Error) => throwError(error),
 });
 
-export const filterOnlyJsFiles: MatchFunction = (file, stats) =>
-  (stats?.isFile() ?? false) && file.endsWith('.js');
+export const shouldIgnore: MatchFunction = (file, stats): boolean =>
+  // Ignore files and directories in `node_modules`.
+  file.includes('node_modules') ||
+  // Watch non-files, but ignore files that are not JavaScript.
+  ((stats?.isFile() ?? false) && !file.endsWith('.js'));
 
 /**
  * Start a watcher that bundles `.js` files in the target dir.
@@ -77,14 +80,8 @@ export function watchDir(dir: string, logger: Logger): WatchDirReturn {
   const { reject: throwError, promise: errorPromise } = makePromiseKit<never>();
 
   let watcher = watch(resolvedDir, {
-    ignoreInitial: true,
-    ignored: [
-      '**/node_modules/**',
-      '**/*.test.js',
-      '**/*.test.ts',
-      '**/*.bundle',
-      filterOnlyJsFiles,
-    ],
+    ignoreInitial: false,
+    ignored: shouldIgnore,
   });
 
   const events = makeWatchEvents(watcher, readyResolve, throwError, logger);

packages/extension/src/kernel-integration/VatWorkerClient.ts

@@ -1,9 +1,5 @@
 import { isJsonRpcResponse } from '@metamask/utils';
-import type {
-  JsonRpcId,
-  JsonRpcRequest,
-  JsonRpcResponse,
-} from '@metamask/utils';
+import type { JsonRpcId, JsonRpcResponse } from '@metamask/utils';
 import type { VatWorkerManager, VatId, VatConfig } from '@ocap/kernel';
 import { vatWorkerServiceMethodSpecs } from '@ocap/kernel/rpc';
 import { Logger } from '@ocap/logger';
@@ -17,7 +13,7 @@ import type {
   PostMessageEnvelope,
   PostMessageTarget,
 } from '@ocap/streams/browser';
-import type { JsonRpcMessage } from '@ocap/utils';
+import type { JsonRpcCall, JsonRpcMessage } from '@ocap/utils';
 import { isJsonRpcMessage, stringify } from '@ocap/utils';
 
 // Appears in the docs.
@@ -26,7 +22,7 @@ import type { ExtensionVatWorkerService } from './VatWorkerServer.ts';
 
 export type VatWorkerClientStream = PostMessageDuplexStream<
   MessageEvent<JsonRpcResponse>,
-  PostMessageEnvelope<JsonRpcRequest>
+  PostMessageEnvelope<JsonRpcCall>
 >;
 
 export class ExtensionVatWorkerClient implements VatWorkerManager {
@@ -62,8 +58,10 @@ export class ExtensionVatWorkerClient implements VatWorkerManager {
     this.#rpcClient = new RpcClient(
       vatWorkerServiceMethodSpecs,
       async (request) => {
-        if (request.method === 'launch') {
-          this.#portMap.set(request.id, undefined);
+        if ('id' in request) {
+          if (request.method === 'launch') {
+            this.#portMap.set(request.id, undefined);
+          }
         }
         await this.#stream.write({ payload: request, transfer: [] });
       },

packages/extension/src/kernel-integration/kernel-worker.ts

@@ -1,6 +1,5 @@
 import { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import type { JsonRpcRequest, JsonRpcResponse } from '@metamask/utils';
-import { isJsonRpcRequest } from '@metamask/utils';
 import type { ClusterConfig } from '@ocap/kernel';
 import { ClusterConfigStruct, Kernel } from '@ocap/kernel';
 import { Logger } from '@ocap/logger';
@@ -10,7 +9,8 @@ import {
   MessagePortDuplexStream,
   receiveMessagePort,
 } from '@ocap/streams/browser';
-import { fetchValidatedJson } from '@ocap/utils';
+import { fetchValidatedJson, isJsonRpcCall } from '@ocap/utils';
+import type { JsonRpcCall } from '@ocap/utils';
 
 import { makeLoggingMiddleware } from './middleware/logging.ts';
 import { createPanelMessageMiddleware } from './middleware/panel-message.ts';
@@ -40,9 +40,9 @@ async function main(): Promise<void> {
   );
 
   const kernelStream = await MessagePortDuplexStream.make<
-    JsonRpcRequest,
+    JsonRpcCall,
     JsonRpcResponse
-  >(port, isJsonRpcRequest);
+  >(port, isJsonRpcCall);
 
   // Initialize kernel dependencies
   const vatWorkerClient = ExtensionVatWorkerClient.make(
@@ -64,7 +64,11 @@ async function main(): Promise<void> {
   const kernelEngine = new JsonRpcEngine();
   kernelEngine.push(makeLoggingMiddleware(logger.subLogger('kernel-command')));
   kernelEngine.push(createPanelMessageMiddleware(kernel, kernelDatabase));
-  receiveUiConnections(async (request) => kernelEngine.handle(request), logger);
+  // JsonRpcEngine type error: does not handle JSON-RPC notifications
+  receiveUiConnections(
+    async (request) => kernelEngine.handle(request as JsonRpcRequest),
+    logger,
+  );
   const launchDefaultSubcluster = firstTime || ALWAYS_RESET_STORAGE;
 
   const defaultSubcluster = await fetchValidatedJson<ClusterConfig>(

packages/extension/src/kernel-integration/ui-connections.test.ts

@@ -1,8 +1,9 @@
-import type { JsonRpcRequest, JsonRpcResponse } from '@metamask/utils';
+import type { JsonRpcResponse } from '@metamask/utils';
 import { Logger } from '@ocap/logger';
 import type { PostMessageTarget } from '@ocap/streams/browser';
 import { delay } from '@ocap/test-utils';
 import { TestDuplexStream } from '@ocap/test-utils/streams';
+import type { JsonRpcCall } from '@ocap/utils';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 import {
@@ -161,7 +162,7 @@ describe('ui-connections', () => {
     const logger = makeMockLogger();
 
     const mockHandleMessage = vi.fn(
-      async (_request: JsonRpcRequest): Promise<JsonRpcResponse> => ({
+      async (_request: JsonRpcCall): Promise<JsonRpcResponse> => ({
         id: 'foo',
         jsonrpc: '2.0' as const,
         result: { vats: [], clusterConfig },

packages/extension/src/kernel-integration/ui-connections.ts

@@ -1,8 +1,9 @@
 import { isJsonRpcRequest, isJsonRpcResponse } from '@metamask/utils';
-import type { JsonRpcRequest, JsonRpcResponse } from '@metamask/utils';
+import type { JsonRpcResponse } from '@metamask/utils';
 import type { Logger } from '@ocap/logger';
 import { PostMessageDuplexStream } from '@ocap/streams/browser';
 import { stringify } from '@ocap/utils';
+import type { JsonRpcCall } from '@ocap/utils';
 import { nanoid } from 'nanoid';
 
 import { isUiControlCommand } from './ui-control-command.ts';
@@ -11,18 +12,16 @@ import type { UiControlCommand } from './ui-control-command.ts';
 export const UI_CONTROL_CHANNEL_NAME = 'ui-control';
 
 export type KernelControlStream = PostMessageDuplexStream<
-  JsonRpcRequest,
+  JsonRpcCall,
   JsonRpcResponse
 >;
 
 export type KernelControlReplyStream = PostMessageDuplexStream<
   JsonRpcResponse,
-  JsonRpcRequest
+  JsonRpcCall
 >;
 
-type HandleInstanceMessage = (
-  request: JsonRpcRequest,
-) => Promise<JsonRpcResponse>;
+type HandleInstanceMessage = (request: JsonRpcCall) => Promise<JsonRpcResponse>;
 
 /**
  * Establishes a connection between a UI instance and the kernel. Should be called
@@ -45,7 +44,7 @@ export const establishKernelConnection = async (
 
   const kernelStream = await PostMessageDuplexStream.make<
     JsonRpcResponse,
-    JsonRpcRequest
+    JsonRpcCall
   >({
     validateInput: isJsonRpcResponse,
     messageTarget: instanceChannel,

packages/extension/src/offscreen.ts

@@ -1,5 +1,6 @@
-import { isJsonRpcRequest, isJsonRpcResponse } from '@metamask/utils';
-import type { JsonRpcRequest, JsonRpcResponse } from '@metamask/utils';
+
+import { isJsonRpcResponse } from '@metamask/utils';
+import type { JsonRpcResponse } from '@metamask/utils';
 import { Logger } from '@ocap/logger';
 import type { DuplexStream } from '@ocap/streams';
 import {
@@ -8,7 +9,8 @@ import {
   MessagePortDuplexStream,
 } from '@ocap/streams/browser';
 import type { PostMessageTarget } from '@ocap/streams/browser';
-import { delay } from '@ocap/utils';
+import { delay, isJsonRpcCall } from '@ocap/utils';
+import type { JsonRpcCall } from '@ocap/utils';
 
 import { makeIframeVatWorker } from './kernel-integration/iframe-vat-worker.ts';
 import { ExtensionVatWorkerService } from './kernel-integration/VatWorkerServer.ts';
@@ -26,9 +28,9 @@ async function main(): Promise<void> {
 
   // Create stream for messages from the background script
   const backgroundStream = await ChromeRuntimeDuplexStream.make<
-    JsonRpcRequest,
+    JsonRpcCall,
     JsonRpcResponse
-  >(chrome.runtime, 'offscreen', 'background', isJsonRpcRequest);
+  >(chrome.runtime, 'offscreen', 'background', isJsonRpcCall);
 
   const { kernelStream, vatWorkerService } = await makeKernelWorker();
 
@@ -46,7 +48,7 @@ async function main(): Promise<void> {
  * @returns The message port stream for worker communication
  */
 async function makeKernelWorker(): Promise<{
-  kernelStream: DuplexStream<JsonRpcResponse, JsonRpcRequest>;
+  kernelStream: DuplexStream<JsonRpcResponse, JsonRpcCall>;
   vatWorkerService: ExtensionVatWorkerService;
 }> {
   const worker = new Worker('kernel-worker.js', { type: 'module' });
@@ -57,7 +59,7 @@ async function makeKernelWorker(): Promise<{
 
   const kernelStream = await MessagePortDuplexStream.make<
     JsonRpcResponse,
-    JsonRpcRequest
+    JsonRpcCall
   >(port, isJsonRpcResponse);
 
   const vatWorkerService = ExtensionVatWorkerService.make(

packages/kernel/src/Kernel.ts

@@ -1,6 +1,7 @@
 import type { CapData } from '@endo/marshal';
 import { serializeError } from '@metamask/rpc-errors';
-import type { JsonRpcRequest, JsonRpcResponse } from '@metamask/utils';
+import { hasProperty } from '@metamask/utils';
+import type { JsonRpcResponse } from '@metamask/utils';
 import {
   StreamReadError,
   VatAlreadyExistsError,
@@ -11,6 +12,7 @@ import { RpcService } from '@ocap/rpc-methods';
 import type { ExtractParams, ExtractResult } from '@ocap/rpc-methods';
 import type { KernelDatabase } from '@ocap/store';
 import type { DuplexStream } from '@ocap/streams';
+import type { JsonRpcCall } from '@ocap/utils';
 
 import { KernelQueue } from './KernelQueue.ts';
 import { KernelRouter } from './KernelRouter.ts';
@@ -33,7 +35,7 @@ import { VatHandle } from './VatHandle.ts';
 
 export class Kernel {
   /** Command channel from the controlling console/browser extension/test driver */
-  readonly #commandStream: DuplexStream<JsonRpcRequest, JsonRpcResponse>;
+  readonly #commandStream: DuplexStream<JsonRpcCall, JsonRpcResponse>;
 
   readonly #rpcService: RpcService<typeof kernelHandlers>;
 
@@ -70,7 +72,7 @@ export class Kernel {
    */
   // eslint-disable-next-line no-restricted-syntax
   private constructor(
-    commandStream: DuplexStream<JsonRpcRequest, JsonRpcResponse>,
+    commandStream: DuplexStream<JsonRpcCall, JsonRpcResponse>,
     vatWorkerService: VatWorkerManager,
     kernelDatabase: KernelDatabase,
     options: {
@@ -108,7 +110,7 @@ export class Kernel {
    * @returns A promise for the new kernel instance.
    */
   static async make(
-    commandStream: DuplexStream<JsonRpcRequest, JsonRpcResponse>,
+    commandStream: DuplexStream<JsonRpcCall, JsonRpcResponse>,
     vatWorkerService: VatWorkerManager,
     kernelDatabase: KernelDatabase,
     options: {
@@ -155,25 +157,29 @@ export class Kernel {
    *
    * @param message - The message to handle.
    */
-  async #handleCommandMessage(message: JsonRpcRequest): Promise<void> {
+  async #handleCommandMessage(message: JsonRpcCall): Promise<void> {
     try {
       this.#rpcService.assertHasMethod(message.method);
       const result = await this.#rpcService.execute(
         message.method,
         message.params,
       );
-      await this.#commandStream.write({
-        id: message.id,
-        jsonrpc: '2.0',
-        result,
-      });
+      if (hasProperty(message, 'id') && typeof message.id === 'string') {
+        await this.#commandStream.write({
+          id: message.id,
+          jsonrpc: '2.0',
+          result,
+        });
+      }
     } catch (error) {
       this.#logger.error('Error executing command', error);
-      await this.#commandStream.write({
-        id: message.id,
-        jsonrpc: '2.0',
-        error: serializeError(error),
-      });
+      if (hasProperty(message, 'id') && typeof message.id === 'string') {
+        await this.#commandStream.write({
+          id: message.id,
+          jsonrpc: '2.0',
+          error: serializeError(error),
+        });
+      }
     }
   }
 

packages/kernel/src/rpc/kernel/index.ts

@@ -1,14 +1,18 @@
-import type { MethodRequest } from '@ocap/rpc-methods';
+import type {
+  HandlerRecord,
+  MethodRequest,
+  MethodSpecRecord,
+} from '@ocap/rpc-methods';
 
 import { pingHandler, pingSpec } from '../vat/ping.ts';
 
 export const kernelHandlers = {
   ping: pingHandler,
-} as const;
+} as HandlerRecord<typeof pingHandler>;
 
 export const kernelMethodSpecs = {
   ping: pingSpec,
-} as const;
+} as MethodSpecRecord<typeof pingSpec>;
 
 type Handlers = (typeof kernelHandlers)[keyof typeof kernelHandlers];