@tsplc/build 0.2.8 → 0.2.10

package/dist/index.js

@@ -53,7 +53,7 @@ var readBuild = async (directory) => {
 // packages/build/src/docker-build.ts
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { cp as cp3, mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile3, rm as rm3 } from "node:fs/promises";
+import { cp as cp4, mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile3, rm as rm3 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
 import { resolve as resolve5 } from "node:path";
 import { promisify } from "node:util";
@@ -134,7 +134,7 @@ var buildFailureSchema = z2.strictObject({
 // packages/build/src/docker-run.ts
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
+import { copyFile as copyFile2, cp as cp3, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
 import { basename, posix, relative, resolve as resolve4, sep } from "node:path";
 var runDocker = (args, failure) => new Promise((accept, reject) => {
   const child = spawn("docker", args, {
@@ -164,7 +164,7 @@ var runDocker = (args, failure) => new Promise((accept, reject) => {
   });
 });
 var bindMount = (source, target, readonly = false) => `type=bind,"source=${source.replaceAll('"', '""')}",target=${target}${readonly ? ",readonly" : ""}`;
-async function mountLibraries(libraries, directory) {
+async function mountLibraries(libraries, directory, root = "/input") {
   if (!libraries?.length)
     return;
   await mkdir2(resolve4(directory, "libraries"), { recursive: true });
@@ -174,22 +174,30 @@ async function mountLibraries(libraries, directory) {
       throw new Error(`Library changed after installation: ${library.title}`);
     const filename = `${library.sha256}-${basename(library.path)}`;
     await writeFile3(resolve4(directory, "libraries", filename), data);
-    return { ...library, path: `/input/libraries/${filename}` };
+    return { ...library, path: `${root}/libraries/${filename}` };
   }));
 }
+var containerConfig = (config, paths, libraries) => ({
+  ...config,
+  libraries,
+  configFile: undefined,
+  docker: undefined,
+  codesys: undefined,
+  sourceDir: paths.sourceDir,
+  entry: posix.resolve(paths.sourceDir, relative(config.sourceDir, config.entry).split(sep).join("/")),
+  template: paths.template,
+  outDir: "/output",
+  runtime: undefined
+});
+var writeOperationRequest = async (config, directory, root) => {
+  await mkdir2(directory, { recursive: true });
+  await cp3(config.sourceDir, resolve4(directory, "sources"), { recursive: true });
+  await copyFile2(config.template, resolve4(directory, "template.project"));
+  await writeFile3(resolve4(directory, "config.json"), JSON.stringify(containerConfig(config, { sourceDir: `${root}/sources`, template: `${root}/template.project` }, await mountLibraries(config.libraries, directory, root))));
+  return `${root}/config.json`;
+};
 var prepareContainerRun = async (config, requestDirectory, options) => {
-  await writeFile3(resolve4(requestDirectory, "config.json"), JSON.stringify({
-    ...config,
-    libraries: options.sources ? await mountLibraries(config.libraries, requestDirectory) : [],
-    configFile: undefined,
-    docker: undefined,
-    codesys: undefined,
-    sourceDir: "/sources",
-    entry: posix.resolve("/sources", relative(config.sourceDir, config.entry).split(sep).join("/")),
-    template: "/template.project",
-    outDir: "/output",
-    runtime: undefined
-  }));
+  await writeFile3(resolve4(requestDirectory, "config.json"), JSON.stringify(containerConfig(config, { sourceDir: "/sources", template: "/template.project" }, options.sources ? await mountLibraries(config.libraries, requestDirectory) : [])));
   return [
     "--init",
     ...config.docker?.cpuSet ? ["--cpuset-cpus", config.docker.cpuSet] : [],
@@ -246,7 +254,7 @@ var configureDocker = async () => {
     const cache = resolve5(context, "winetricks");
     await mkdir3(cache);
     if (process.env["CODESYS_WINETRICKS_CACHE"]) {
-      await cp3(process.env["CODESYS_WINETRICKS_CACHE"], cache, {
+      await cp4(process.env["CODESYS_WINETRICKS_CACHE"], cache, {
         recursive: true
       });
     }
@@ -345,7 +353,7 @@ ${failure.message}`;
 // packages/build/src/host/codesys-worker.ts
 import {
   access,
-  copyFile as copyFile2,
+  copyFile as copyFile3,
   mkdir as mkdir4,
   open,
   readFile as readFile4,
@@ -1254,7 +1262,7 @@ import { existsSync } from "node:fs";
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir as mkdir5, mkdtemp as mkdtemp3, readFile as readFile6, rm as rm5 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { resolve as resolve8 } from "node:path";
+import { posix as posix2, resolve as resolve8 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 import { promisify as promisify4 } from "node:util";
 import { z as z5 } from "zod";
@@ -1287,6 +1295,22 @@ var controllerResultSchema = z5.strictObject({
   state: z5.string().nonempty(),
   values: z5.record(z5.string(), z5.string())
 });
+var controllerCredentialsSchema = z5.strictObject({
+  username: z5.string().nonempty(),
+  password: z5.string().nonempty()
+});
+var warmOperationSchema = z5.strictObject({
+  operation: z5.enum(["download", "online-change"]),
+  operationId: z5.uuid(),
+  request: z5.string().nonempty(),
+  initializeUser: z5.boolean(),
+  credentials: controllerCredentialsSchema.optional()
+});
+var failureReason = (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  return (message.trim().split(`
+`).at(-1) ?? message).replace(/^\w+: /, "");
+};
 var controllerTarget = (config, online) => ({
   network: online.network,
   gateway: online.gateway,
@@ -1296,28 +1320,37 @@ var controllerTarget = (config, online) => ({
     deviceTree: createHash2("sha256").update(JSON.stringify(config.deviceTree)).digest("hex")
   }
 });
-var controllerConnection = async (config) => {
-  if (!config.docker || !config.online) {
-    throw new Error("Docker image and online gateway/device configuration are required for controller operations");
-  }
-  const environmentNames = config.online.credentials ? [config.online.credentials.usernameEnv, config.online.credentials.passwordEnv] : [];
-  for (const name of environmentNames) {
+var credentialEnvironment = (config) => {
+  const names = config.online?.credentials ? [config.online.credentials.usernameEnv, config.online.credentials.passwordEnv] : [];
+  for (const name of names) {
     if (process.env[name] === undefined) {
       throw new Error(`Controller credential environment variable ${name} is not set`);
     }
   }
+  return names;
+};
+var controllerConnection = async (config) => {
+  if (!config.docker || !config.online) {
+    throw new Error("Docker image and online gateway/device configuration are required for controller operations");
+  }
   const { stdout } = await execute4("docker", ["image", "inspect", "--format", "{{.Id}}", dockerImage], { timeout: config.timeouts.hostCommand }).catch((cause) => {
     throw new Error(`Cannot inspect Docker builder image ${dockerImage}. Install and start Docker, then run tsplc-build configure if the image is missing`, { cause });
   });
   return {
-    environmentNames,
     imageId: imageIdSchema.parse(stdout.trim()),
     templateHash: createHash2("sha256").update(await readFile6(config.template)).digest("hex"),
     target: controllerTarget(config, config.online)
   };
 };
+var checkReceipt = (result, expected, diagnostics) => {
+  if (result.operationId !== expected.operationId || result.operation !== expected.operation || result.imageId !== expected.imageId || result.templateHash !== expected.templateHash || JSON.stringify(result.target) !== JSON.stringify(expected.target)) {
+    throw new Error(`Controller receipt does not match this operation's image, template or target. Inspect ${diagnostics} for diagnostics`);
+  }
+  return result;
+};
 var controllerOperation = async (config, operation, options) => {
-  const { environmentNames, imageId, templateHash, target } = await controllerConnection(config);
+  const environmentNames = credentialEnvironment(config);
+  const { imageId, templateHash, target } = await controllerConnection(config);
   const operationId = randomUUID2();
   const requestDirectory = await mkdtemp3(resolve8(tmpdir3(), "codesys-controller-"));
   const diagnostics = resolve8(config.outDir, ".codesys/controller");
@@ -1353,10 +1386,7 @@ var controllerOperation = async (config, operation, options) => {
     const result = await readFile6(resolve8(diagnostics, "result.json"), "utf8").then((content) => controllerResultSchema.parse(JSON.parse(content))).catch((cause) => {
       throw new Error(`Docker did not produce a valid controller receipt. Inspect ${diagnostics} for diagnostics`, { cause });
     });
-    if (result.operationId !== operationId || result.operation !== operation || result.imageId !== imageId || result.templateHash !== templateHash || JSON.stringify(result.target) !== JSON.stringify(target)) {
-      throw new Error(`Controller receipt does not match this operation's image, template or target. Inspect ${diagnostics} for diagnostics`);
-    }
-    return result;
+    return checkReceipt(result, { operationId, operation, imageId, templateHash, target }, diagnostics);
   } finally {
     await rm5(requestDirectory, { recursive: true, force: true });
   }
@@ -1391,36 +1421,54 @@ var loginReplySchema = z5.discriminatedUnion("ok", [
   z5.strictObject({ ok: z5.literal(false), error: z5.string() })
 ]);
 var loginPort = 4851;
+var warmPort = 4852;
 var docker = (args, timeout) => execute4("docker", args, { timeout }).then(({ stdout }) => stdout.trim());
 var isRunning = async (name, timeout) => await docker(["container", "ls", "--quiet", "--filter", `name=^${name}$`], timeout) !== "";
-var attachLogin = async (name, timeout) => {
-  const published = await docker(["port", name, String(loginPort)], timeout);
-  const url = `http://${published.split(`
-`)[0]}`;
-  const call = async (init) => {
-    const reply = loginReplySchema.parse(await (await fetch(url, init)).json());
-    if (!reply.ok)
-      throw new Error(reply.error);
-    return reply.result;
-  };
-  return {
+var callContainer = async (name, port, method, body) => {
+  const child = Bun.spawn([
+    "docker",
+    "exec",
+    ...body === undefined ? [] : ["--interactive"],
     name,
-    ready: () => fetch(url).then((response) => response.ok).catch(() => false),
-    send: async (command) => loginResultSchema.parse(await call({
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(command)
-    })),
-    close: async () => {
-      await call({ method: "DELETE" });
-      await docker(["wait", name], timeout);
-      await docker(["rm", name], timeout);
-    }
-  };
+    "curl",
+    "--silent",
+    "--show-error",
+    "--request",
+    method,
+    ...body === undefined ? [] : ["--header", "Content-Type: application/json", "--data-binary", "@-"],
+    `http://127.0.0.1:${port}/`
+  ], {
+    stdin: body === undefined ? "ignore" : new Blob([JSON.stringify(body)]),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [output, errors, code] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited
+  ]);
+  if (code !== 0)
+    throw new Error(errors.trim() || `docker exec failed (${code})`);
+  const reply = loginReplySchema.parse(JSON.parse(output));
+  if (!reply.ok)
+    throw new Error(reply.error);
+  return reply.result;
 };
+var answers = (name, port) => callContainer(name, port, "GET").then(() => true, () => false);
+var attachLogin = (name, timeout) => ({
+  name,
+  ready: () => answers(name, loginPort),
+  send: async (command) => loginResultSchema.parse(await callContainer(name, loginPort, "POST", command)),
+  close: async () => {
+    await callContainer(name, loginPort, "DELETE");
+    await docker(["wait", name], timeout);
+    await docker(["rm", name], timeout);
+  }
+});
 var findControllerLogin = async (name) => await isRunning(name, 15000) ? attachLogin(name, 15000) : undefined;
 var openControllerLogin = async (config, name) => {
-  const { environmentNames, imageId, target } = await controllerConnection(config);
+  const environmentNames = credentialEnvironment(config);
+  const { imageId, target } = await controllerConnection(config);
   const timeout = config.timeouts.hostCommand;
   await docker(["rm", "--force", name], timeout);
   const requestDirectory = resolve8(config.outDir, ".codesys/login-request");
@@ -1430,8 +1478,6 @@ var openControllerLogin = async (config, name) => {
     "--detach",
     "--name",
     name,
-    "--publish",
-    `127.0.0.1::${loginPort}`,
     ...await prepareContainerRun(config, requestDirectory, {
       network: target.network,
       environment: environmentNames,
@@ -1446,23 +1492,99 @@ var openControllerLogin = async (config, name) => {
     "--port",
     String(loginPort)
   ], timeout);
+  const login = attachLogin(name, timeout);
   const deadline = Date.now() + config.timeouts.startup + config.timeouts.build;
   while (Date.now() < deadline) {
-    const login = await isRunning(name, timeout) ? await attachLogin(name, timeout).catch(() => {
-      return;
-    }) : undefined;
-    if (!login && !await isRunning(name, timeout)) {
+    if (!await isRunning(name, timeout)) {
       const logs = await execute4("docker", ["logs", "--tail", "40", name], { timeout });
       throw new Error(`The controller login failed:
 ${logs.stdout}${logs.stderr}`);
     }
-    if (login && await login.ready())
+    if (await login.ready())
       return login;
     await delay2(2000);
   }
   await docker(["rm", "--force", name], timeout);
   throw new Error("The controller login did not open in time");
 };
+var warmController = async (config, name, connection) => {
+  const timeout = config.timeouts.hostCommand;
+  const { imageId, target } = connection;
+  const settings = createHash2("sha256").update(JSON.stringify({ imageId, target, timeouts: config.timeouts, docker: config.docker })).digest("hex");
+  const label = `tsplc.warm=${settings}`;
+  const running = async () => await docker(["container", "ls", "--quiet", "--filter", `name=^${name}$`, "--filter", `label=${label}`], timeout) !== "";
+  if (!await running()) {
+    await docker(["rm", "--force", name], timeout);
+    const requestDirectory = resolve8(config.outDir, ".codesys/warm-request");
+    await mkdir5(requestDirectory, { recursive: true });
+    await docker([
+      "run",
+      "--detach",
+      "--name",
+      name,
+      "--label",
+      label,
+      ...await prepareContainerRun(config, requestDirectory, {
+        network: target.network,
+        sources: false
+      }),
+      imageId,
+      "warm",
+      "--request",
+      "/input/config.json",
+      "--image-id",
+      imageId,
+      "--port",
+      String(warmPort)
+    ], timeout);
+  }
+  const deadline = Date.now() + config.timeouts.startup;
+  while (Date.now() < deadline) {
+    if (!await running()) {
+      const logs = await execute4("docker", ["logs", "--tail", "40", name], { timeout });
+      throw new Error(`CODESYS failed to start:
+${logs.stdout}${logs.stderr}`);
+    }
+    if (await answers(name, warmPort))
+      return;
+    await delay2(2000);
+  }
+  await docker(["rm", "--force", name], timeout);
+  throw new Error("CODESYS did not start in time");
+};
+var startWarmController = async (config, name) => {
+  await warmController(config, name, await controllerConnection(config));
+};
+var updateWarmController = async (config, name, operation, options = {}) => {
+  const connection = await controllerConnection(config);
+  await warmController(config, name, connection);
+  const operationId = randomUUID2();
+  const diagnostics = resolve8(config.outDir, ".codesys/controller");
+  const directory = resolve8(config.outDir, ".codesys/requests", operationId);
+  try {
+    const request = await writeOperationRequest(config, directory, posix2.join("/output/.codesys/requests", operationId));
+    const result = await callContainer(name, warmPort, "POST", {
+      operation,
+      operationId,
+      request,
+      initializeUser: options.initializeUser ?? false,
+      credentials: options.credentials
+    }).catch((error) => {
+      throw new Error(`${failureReason(error)}. Inspect ${diagnostics} for diagnostics`, {
+        cause: error
+      });
+    });
+    return checkReceipt(controllerResultSchema.parse(result), {
+      operationId,
+      operation,
+      imageId: connection.imageId,
+      templateHash: connection.templateHash,
+      target: connection.target
+    }, diagnostics);
+  } finally {
+    await rm5(directory, { recursive: true, force: true });
+  }
+};
 // packages/build/src/run.ts
 import { execFile as execFile5 } from "node:child_process";
 import { mkdtemp as mkdtemp4, readFile as readFile7, rm as rm6, writeFile as writeFile5 } from "node:fs/promises";
@@ -1702,9 +1824,11 @@ export {
   readBuild,
   resolveConfig,
   runProject,
+  startWarmController,
   updateController,
+  updateWarmController,
   validateLibrary
 };
 
-//# debugId=2FE06AE03D021AE864756E2164756E21
+//# debugId=E1299EFC223A3AA564756E2164756E21
 //# sourceMappingURL=index.js.map