@opencraw/driver 0.5.0 → 0.7.0

package/README.md

@@ -60,6 +60,19 @@ stdin at once. Answers may arrive out of order; match them by `id`.
   `-32602` (bad params, the problems listed), `-32000` (a failure to act on: its message says what to do).
 - stdout carries protocol messages only. The driver's own logs go to stderr.
 
+## The runtime: no Node needed
+
+Each driver release carries, as assets of its GitHub release `driver@<version>`, an archive per platform
+(`win32-x64`, `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`): a Node binary, the driver and its
+dependencies, and `runtime.json`, whose `command` starts it (both paths relative to the unpacked folder).
+`driver-runtime.json` lists them with their SHA-256 and size; its schema is `schemas/driver-runtime.schema.json`
+and `schemas/driver-runtime.fixture.json` is an example. A client downloads its platform's archive once, refuses
+one whose hash does not match, unpacks it into a per-user cache and starts the driver from there.
+
+`node packages/driver/packaging/stage-runtime.mjs` builds this platform's archive into `dist/drop/driver-runtime`
+(after `smith build -p driver`), and starts the staged driver once with `PATH` emptied, to prove it needs nothing
+else. Browsers are not in it: they are installed through the driver, the Playwright way.
+
 ## Development
 
 `smith run lint typecheck test build -p driver`. After changing a contract in `src/protocol/`, run

package/dist/index.esm.js

@@ -512,8 +512,10 @@ function openLineChannel(input, output, handle) {
     if (typeof message.method === "string") track(answer(message));
     else settle(message);
   });
+  let ended = false;
   const closed = new Promise((resolve) => {
     lines.on("close", () => {
+      ended = true;
       for (const waiting of pending.values()) waiting.reject(new Error("the client closed the channel"));
       pending.clear();
       resolve();
@@ -521,6 +523,10 @@ function openLineChannel(input, output, handle) {
   });
   return {
     request: async (method, params) => await new Promise((resolve, reject) => {
+      if (ended) {
+        reject(new Error("the channel is closed"));
+        return;
+      }
       const id = nextId++;
       pending.set(id, { resolve, reject });
       write({ jsonrpc: "2.0", id, method, params });
@@ -575,10 +581,35 @@ async function serveDriver(input, output, identity) {
   await channel.drained();
   await sessions.closeAll();
 }
+
+// src/runtime-manifest/runtime-manifest.contract.ts
+import { z as z3 } from "zod";
+var RUNTIME_PLATFORMS = ["win32-x64", "darwin-arm64", "darwin-x64", "linux-x64", "linux-arm64"];
+var archiveSchema = z3.strictObject({
+  /** The archive's file name, an asset of the same GitHub release as the manifest. */
+  file: z3.string().regex(/^opencraw-driver-[\w.-]+\.tar\.gz$/),
+  /** Its SHA-256, lowercase hex: a client refuses an archive that does not match. */
+  sha256: z3.string().regex(/^[0-9a-f]{64}$/),
+  size: z3.number().int().positive()
+});
+var runtimeManifestSchema = z3.strictObject({
+  driverVersion: z3.string().min(1),
+  protocolVersion: z3.string().regex(/^\d+\.\d+\.\d+$/),
+  /** The Node version every archive carries. */
+  node: z3.string().regex(/^v\d+\.\d+\.\d+$/),
+  archives: z3.partialRecord(z3.enum(RUNTIME_PLATFORMS), archiveSchema)
+});
+
+// src/runtime-manifest/runtime-manifest-json-schema.mapper.ts
+import { z as z4 } from "zod";
+function runtimeManifestJsonSchema() {
+  return { $id: "https://opencraw.dev/schemas/driver-runtime.schema.json", ...z4.toJSONSchema(runtimeManifestSchema, { target: "draft-2020-12" }) };
+}
 export {
   MESSAGES,
   PROTOCOL_VERSION,
   RPC_ERRORS,
+  RUNTIME_PLATFORMS,
   RpcFailure,
   calloutParamsSchema,
   calloutResultSchema,
@@ -607,6 +638,8 @@ export {
   runParamsSchema,
   runResultSchema,
   runSessions,
+  runtimeManifestJsonSchema,
+  runtimeManifestSchema,
   serveDriver,
   streamingSink,
   validateParamsSchema,

package/dist/main.esm.js

@@ -473,8 +473,10 @@ function openLineChannel(input, output, handle) {
     if (typeof message.method === "string") track(answer(message));
     else settle(message);
   });
+  let ended = false;
   const closed = new Promise((resolve) => {
     lines.on("close", () => {
+      ended = true;
       for (const waiting of pending.values()) waiting.reject(new Error("the client closed the channel"));
       pending.clear();
       resolve();
@@ -482,6 +484,10 @@ function openLineChannel(input, output, handle) {
   });
   return {
     request: async (method, params) => await new Promise((resolve, reject) => {
+      if (ended) {
+        reject(new Error("the channel is closed"));
+        return;
+      }
       const id = nextId++;
       pending.set(id, { resolve, reject });
       write({ jsonrpc: "2.0", id, method, params });

package/dist/src/index.d.ts

@@ -2,6 +2,8 @@ export { serveDriver } from './server/index.js';
 export type { DriverIdentity } from './server/index.js';
 export { PROTOCOL_VERSION, MESSAGES, driverProtocolJsonSchema, initializeParamsSchema, initializeResultSchema, validateParamsSchema, validateResultSchema, runParamsSchema, runResultSchema, cancelParamsSchema, cancelResultSchema, eventParamsSchema, recordParamsSchema, finishedParamsSchema, calloutParamsSchema, calloutResultSchema, probeParamsSchema, probeResultSchema, diffParamsSchema, diffResultSchema, exportParamsSchema, exportResultSchema, workParamsSchema, workItemSchema, workNextParamsSchema, workNextResultSchema, workDoneParamsSchema, workFailedParamsSchema, } from './protocol/index.js';
 export type { InitializeParams, InitializeResult, ValidateParams, ValidateResult, RunParams, RunResult, CancelParams, CancelResult, EventParams, RecordParams, FinishedParams, CalloutParams, ProbeParams, DiffParams, DiffResult, ExportParams, ExportResult, WorkParams, WorkItemMessage, WorkNextResult, WorkDoneParams, WorkFailedParams, } from './protocol/index.js';
+export { RUNTIME_PLATFORMS, runtimeManifestSchema, runtimeManifestJsonSchema } from './runtime-manifest/index.js';
+export type { RuntimeManifest, RuntimePlatform } from './runtime-manifest/index.js';
 export { openLineChannel, RPC_ERRORS, RpcFailure } from './transport/index.js';
 export type { LineChannel, RequestHandler, RpcError, RpcMessage } from './transport/index.js';
 export { runSessions, validateRecipes, streamingSink } from './session/index.js';

package/dist/src/runtime-manifest/index.d.ts

@@ -0,0 +1,4 @@
+export { RUNTIME_PLATFORMS, runtimeManifestSchema } from './runtime-manifest.contract.js';
+export type { RuntimeManifest, RuntimePlatform } from './runtime-manifest.contract.js';
+export { runtimeManifestJsonSchema } from './runtime-manifest-json-schema.mapper.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/runtime-manifest/runtime-manifest-json-schema.mapper.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `driver-runtime.json`'s JSON Schema, written to `schemas/driver-runtime.schema.json`: what clients in
+ * other languages generate their manifest model from.
+ *
+ * @returns The schema.
+ */
+export declare function runtimeManifestJsonSchema(): Record<string, unknown>;
+//# sourceMappingURL=runtime-manifest-json-schema.mapper.d.ts.map

package/dist/src/runtime-manifest/runtime-manifest.contract.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/** The platforms the driver's runtime is built for: `<process.platform>-<process.arch>`. */
+export declare const RUNTIME_PLATFORMS: readonly ['win32-x64', 'darwin-arm64', 'darwin-x64', 'linux-x64', 'linux-arm64'];
+export type RuntimePlatform = typeof RUNTIME_PLATFORMS[number];
+/**
+ * `driver-runtime.json`, an asset of each driver release beside the archives: what a client in any
+ * language reads to download the runtime for its platform, check it and start it. The archive holds a
+ * Node binary, the driver and its dependencies, and `runtime.json` (`command`: the Node binary and the
+ * driver's entry, both relative to the folder the archive is unpacked into).
+ */
+export declare const runtimeManifestSchema: z.ZodObject<{
+    driverVersion: z.ZodString;
+    protocolVersion: z.ZodString;
+    node: z.ZodString;
+    archives: z.ZodRecord<z.ZodEnum<{
+        "darwin-arm64": "darwin-arm64";
+        "darwin-x64": "darwin-x64";
+        "linux-arm64": "linux-arm64";
+        "linux-x64": "linux-x64";
+        "win32-x64": "win32-x64";
+    }> & z.core.$partial, z.ZodObject<{
+        file: z.ZodString;
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RuntimeManifest = z.infer<typeof runtimeManifestSchema>;
+//# sourceMappingURL=runtime-manifest.contract.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencraw/driver",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "OpenCraw's driver: the engine over JSON-RPC on stdio, for clients in other languages",
   "license": "MIT",
   "type": "module",

package/schemas/driver-runtime.fixture.json

@@ -0,0 +1,9 @@
+{
+  "driverVersion": "0.6.0",
+  "protocolVersion": "1.2.0",
+  "node": "v24.12.0",
+  "archives": {
+    "linux-x64": { "file": "opencraw-driver-0.6.0-linux-x64.tar.gz", "sha256": "697d28005ed87b2887cf79edca25f06da89ab19bcb48f49c0a67dbdbcb004ad7", "size": 65410362 },
+    "win32-x64": { "file": "opencraw-driver-0.6.0-win32-x64.tar.gz", "sha256": "0f1e2d3c4b5a69788796a5b4c3d2e1f00f1e2d3c4b5a69788796a5b4c3d2e1f0", "size": 66120448 }
+  }
+}

package/schemas/driver-runtime.schema.json

@@ -0,0 +1,63 @@
+{
+  "$id": "https://opencraw.dev/schemas/driver-runtime.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "driverVersion": {
+      "type": "string",
+      "minLength": 1
+    },
+    "protocolVersion": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$"
+    },
+    "node": {
+      "type": "string",
+      "pattern": "^v\\d+\\.\\d+\\.\\d+$"
+    },
+    "archives": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string",
+        "enum": [
+          "win32-x64",
+          "darwin-arm64",
+          "darwin-x64",
+          "linux-x64",
+          "linux-arm64"
+        ]
+      },
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "file": {
+            "type": "string",
+            "pattern": "^opencraw-driver-[\\w.-]+\\.tar\\.gz$"
+          },
+          "sha256": {
+            "type": "string",
+            "pattern": "^[0-9a-f]{64}$"
+          },
+          "size": {
+            "type": "integer",
+            "exclusiveMinimum": 0,
+            "maximum": 9007199254740991
+          }
+        },
+        "required": [
+          "file",
+          "sha256",
+          "size"
+        ],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required": [
+    "driverVersion",
+    "protocolVersion",
+    "node",
+    "archives"
+  ],
+  "additionalProperties": false
+}