@henols/c64-re-tools 2.0.0-rc.5 → 2.0.0-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henols/c64-re-tools",
-  "version": "2.0.0-rc.5",
+  "version": "2.0.0-rc.6",
   "description": "Agent-friendly Commodore 64 engineering toolkit for reverse engineering, debugging, development and testing.",
   "license": "MIT",
   "author": "Henrik Olsson",

package/src/host/main.ts

@@ -6,7 +6,7 @@ import { DEFAULT_HOST_PORT } from "../protocol/messages.ts";
 import { ProcessSupervisor } from "../native/processes.ts";
 import { startTrace, trace } from "../trace.ts";
 import { ListenError, parsePort, startHostServer, stopSignal } from "./server.ts";
-import { viceFlaws } from "../native/discover.ts";
+import { viceFlaws, type ViceVersion } from "../native/discover.ts";
 import { createToolDispatcher } from "./tools/index.ts";
 import { checkViceStarts, findVice } from "./vice/process.ts";
 import { viceSessionFactory } from "./vice/session.ts";
@@ -70,15 +70,16 @@ async function main(): Promise<number> {
   supervisor.startWatchdog("host");
 
   // Finding x64sc is not enough: VICE without its ROM files exits at once.
-  let flaws: string[];
+  let vice: ViceVersion;
   try {
-    flaws = viceFlaws(await checkViceStarts({ supervisor }));
+    vice = await checkViceStarts({ supervisor });
   } catch (error) {
     process.stderr.write(`${(error as Error).message}\n`);
     await supervisor.stopAll();
     return 1;
   }
-  log("VICE starts");
+  log(`VICE ${vice.major}.${vice.minor}${vice.revision === undefined ? "" : ` r${vice.revision}`} starts`);
+  const flaws = viceFlaws(vice);
   // A known VICE flaw is named, not worked around (D56).
   for (const flaw of flaws) log(`Known VICE flaw: ${flaw}`);
 
@@ -89,7 +90,7 @@ async function main(): Promise<number> {
       port,
       log,
       createViceSession: viceSessionFactory({ supervisor, log, flaws }),
-      tools: createToolDispatcher({ supervisor, log }),
+      tools: createToolDispatcher({ supervisor, log, vice }),
     });
   } catch (error) {
     if (error instanceof ListenError && error.code === "EADDRINUSE") {

package/src/host/server.ts

@@ -20,7 +20,7 @@ export interface ViceSessionHandle {
 }
 
 /** Starts a VICE session. Throws WireFailure with an actionable code when it cannot. */
-export type ViceSessionFactory = (options: { videoStandard: VideoStandard }) => Promise<ViceSessionHandle>;
+export type ViceSessionFactory = (options: { videoStandard: VideoStandard; log?: (line: string) => void }) => Promise<ViceSessionHandle>;
 
 /**
  * Runs one native-tool request. `signal` aborts when the client goes away; the
@@ -95,9 +95,12 @@ class Connection {
   constructor(socket: Socket, options: HostServerOptions, log: (line: string) => void) {
     this.#socket = socket;
     this.#options = options;
-    this.#log = log;
+    // Every line names its connection, so the console shows which client starts and stops what.
+    this.#log = (line) => log(`connection ${this.#id}: ${line}`);
     this.closed = new Promise((resolve) => (this.#resolveClosed = resolve));
-    trace().event("connection.open", { connection: this.#id, remote: `${socket.remoteAddress}:${socket.remotePort}`, local: socket.localAddress });
+    const remote = `${socket.remoteAddress}:${socket.remotePort}`;
+    this.#log(`opened from ${remote}`);
+    trace().event("connection.open", { connection: this.#id, remote, local: socket.localAddress });
     this.#handshakeTimer = setTimeout(
       () => this.#abort("no hello before the handshake timeout"),
       options.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS,
@@ -180,11 +183,13 @@ class Connection {
         this.#isTool = true;
         this.#state = "open";
         this.#send({ type: "ready" });
+        this.#log("ready for tool requests");
         trace().event("connection.ready", { connection: this.#id, role: "tool" });
         this.#restartHeartbeat();
         return;
       }
       this.#state = "starting";
+      this.#log(`starts a VICE session (${message.videoStandard ?? "pal"})`);
       this.#contain(this.#startSession(message.videoStandard ?? "pal"));
       return;
     }
@@ -206,6 +211,7 @@ class Connection {
     this.#session = session;
     this.#state = "open";
     this.#send({ type: "ready" });
+    this.#log(`VICE session ready after ${Math.round(performance.now() - started)} ms`);
     trace().event("connection.ready", { connection: this.#id, role: "vice-session", videoStandard, ms: elapsedMs(started) });
     this.#restartHeartbeat();
   }
@@ -213,7 +219,7 @@ class Connection {
   /** The new session, or undefined after the failure is sent to the client. Never rejects, also when the factory throws at once. */
   async #createSession(videoStandard: VideoStandard): Promise<ViceSessionHandle | undefined> {
     try {
-      return await this.#options.createViceSession({ videoStandard });
+      return await this.#options.createViceSession({ videoStandard, log: this.#log });
     } catch (error) {
       this.#log(`VICE session failed to start: ${error instanceof Error ? error.message : String(error)}`);
       trace().event("connection.session-failed", { connection: this.#id, error });
@@ -275,11 +281,13 @@ class Connection {
     this.#toolAbort.abort();
     const session = this.#session ?? (await this.#starting);
     this.#session = undefined;
+    if (session !== undefined) this.#log("the client is gone; stopping its VICE session");
     try {
       await session?.close();
     } catch (error) {
       this.#log(`session close failed: ${error instanceof Error ? error.message : String(error)}`);
     }
+    this.#log("closed");
     this.#resolveClosed();
   }
 }

package/src/host/tools/index.ts

@@ -3,6 +3,7 @@
 // ACME, DXA and Ghidra themselves. One entry per operation, never a
 // generic executable route.
 
+import type { ViceVersion } from "../../native/discover.ts";
 import type { ProcessSupervisor } from "../../native/processes.ts";
 import type { ToolContext } from "../../native/run.ts";
 import type { ToolOperation, ToolOperations } from "../../protocol/tools.ts";
@@ -24,8 +25,11 @@ const ADAPTERS: { [O in ToolOperation]: Adapter<O> } = {
   "petcat.decode": (_params, attachments, context) => decode(attachments[0]!, context),
 };
 
-export function createToolDispatcher(options: { supervisor: ProcessSupervisor; env?: NodeJS.ProcessEnv; log?: (line: string) => void }): ToolDispatcher {
+/** `vice`: the version that the host read from the emulator at start, for host.status. */
+export function createToolDispatcher(options: { supervisor: ProcessSupervisor; env?: NodeJS.ProcessEnv; log?: (line: string) => void; vice?: ViceVersion }): ToolDispatcher {
   return (op, params, attachments, signal) => {
-    return ADAPTERS[op](params, attachments, { supervisor: options.supervisor, signal, env: options.env, log: options.log });
+    const context = { supervisor: options.supervisor, signal, env: options.env, log: options.log };
+    if (op === "host.status") return hostStatus(context, options.vice) as ReturnType<ToolDispatcher>;
+    return ADAPTERS[op](params, attachments, context);
   };
 }

package/src/host/tools/status.ts

@@ -1,9 +1,12 @@
 // host.status: VICE and the tools that come with it, each found the way its
 // operations find it and run once with a version option. A tool from a
 // VICE older than MIN_VICE is reported as not working, as its operations refuse it.
+// VICE itself is reported with the version that the host read from the
+// running emulator at start: the Homebrew x64sc of VICE 3.10 on macOS stops
+// on -version ("argv[0] is NULL") although the emulator runs.
 
 import type { ToolStatus } from "../../protocol/tools.ts";
-import { C1541, findTool, isOlderThanMinimum, MIN_VICE, PETCAT, VICE, viceFlaws, viceVersionOf, type ToolSpec } from "../../native/discover.ts";
+import { C1541, findTool, isOlderThanMinimum, MIN_VICE, PETCAT, VICE, viceFlaws, viceVersionOf, type ToolSpec, type ViceVersion } from "../../native/discover.ts";
 import type { ToolContext } from "../../native/run.ts";
 import { probeTools } from "../../native/status.ts";
 import { findVice } from "../vice/process.ts";
@@ -16,16 +19,21 @@ function requireMinimum(status: ToolStatus, tool: ToolSpec): ToolStatus {
   return { ...status, runs: false, problem: `${found}, and c64-re-tools needs VICE ${MIN_VICE.major}.${MIN_VICE.minor} or later. ${tool.remedy}` };
 }
 
-export async function hostStatus(context: ToolContext): Promise<{ result: { tools: ToolStatus[] } }> {
+/** The version text of a VICE version, as x64sc -version prints it. */
+const versionText = (version: ViceVersion) => `x64sc (VICE ${version.major}.${version.minor}${version.revision === undefined ? "" : ` SVN r${version.revision}`})`;
+
+/** `started`: the version that the host read from the emulator at start; without it, VICE is probed with -version too. */
+export async function hostStatus(context: ToolContext, started?: ViceVersion): Promise<{ result: { tools: ToolStatus[] } }> {
   const specs = [VICE, C1541, PETCAT];
-  const tools = await probeTools(
+  const probed = await probeTools(
     [
-      { name: VICE.name, find: findVice, args: ["-version"], pattern: /^x64sc \(VICE \d/ },
+      ...(started === undefined ? [{ name: VICE.name, find: findVice, args: ["-version"], pattern: /^x64sc \(VICE \d/ }] : []),
       { name: C1541.name, find: (env) => findTool(C1541, env), args: ["-version"], pattern: /^c1541 \(VICE \d/ },
       { name: PETCAT.name, find: (env) => findTool(PETCAT, env), args: ["-version"], pattern: /^petcat \(VICE \d/ },
     ],
     context,
   );
+  const tools = started === undefined ? probed : [{ name: VICE.name, found: true, path: findVice(context.env ?? process.env), version: versionText(started), runs: true }, ...probed];
   const checked = tools.map((status, index) => requireMinimum(status, specs[index]!));
   // VICE runs with its known flaws; status names them (D56).
   const vice = checked[0]!;

package/src/host/vice/process.ts

@@ -307,6 +307,7 @@ async function launchOnce(options: LaunchOptions): Promise<ViceProcess> {
         clearInterval(slow);
       }
       if (failure !== undefined) throw failure;
+      log(`VICE stopped (pid ${child.pid}, in ${Date.now() - started} ms)`);
     })();
     return stopping;
   };
@@ -325,7 +326,7 @@ async function launchOnce(options: LaunchOptions): Promise<ViceProcess> {
     if (error instanceof WireFailure) throw error;
     throw new WireFailure("machine-unavailable", "The emulator could not be started on the host.");
   }
-  log(`VICE started (pid ${child.pid}, monitor ports ${port} and ${textPort})`);
+  log(`VICE started (${mode}, pid ${child.pid}, monitor ports ${port} and ${textPort})`);
   trace().event("vice.ready", { pid: child.pid, ms: elapsedMs(launched) });
   return { pid: child.pid, monitor, text, exited: child.exited, outputTail, stop };
 }

package/src/host/vice/session.ts

@@ -988,6 +988,7 @@ export class ViceSession implements ViceSessionHandle {
     if (this.#held !== undefined) throw new WireFailure("machine-unavailable", this.#heldWhy);
     if (this.#launch === undefined) throw new WireFailure("operation-failed", "This session cannot start another emulator.");
     const running = this.#state === "running";
+    this.#log(mode === "window" ? "moving the machine to a VICE with a window" : "moving the machine back to a headless VICE");
     await this.#stop();
     const handover: Handover = {
       file: join(this.#workDir, mode === "window" ? "window-open.vsf" : "window-close.vsf"),
@@ -1354,8 +1355,7 @@ export function viceSessionFactory(options: {
   /** The known flaws of the VICE version that the host checked at start. */
   flaws?: readonly string[];
 }): ViceSessionFactory {
-  const log = options.log ?? (() => {});
-  return async ({ videoStandard }) => {
+  return async ({ videoStandard, log = options.log ?? (() => {}) }) => {
     const launch: ViceLauncher = (mode, launchLog) =>
       launchVice({
         videoStandard,