wattetheria 0.3.2 → 0.3.3

package/.env.release

@@ -1,5 +1,5 @@
 # Coordinated release image set
-RELEASE_TAG=1.0.3
+RELEASE_TAG=1.0.4
 
 WATTETHERIA_KERNEL_IMAGE=ghcr.io/wattetheria/wattetheria-kernel:${RELEASE_TAG}
 WATTSWARM_KERNEL_IMAGE=ghcr.io/wattetheria/wattswarm-kernel:${RELEASE_TAG}

package/lib/cli.js

@@ -1315,6 +1315,159 @@ function forwardedArgsForInstalledNode(commandName, rawArgv) {
   return args;
 }
 
+function isServicenetAgentCardInit(commandName, rawArgv) {
+  return commandName === "servicenet"
+    && rawArgv[1] === "agent-card"
+    && rawArgv[2] === "init";
+}
+
+function isServicenetProviderRegister(commandName, rawArgv) {
+  return commandName === "servicenet"
+    && rawArgv[1] === "provider"
+    && rawArgv[2] === "register";
+}
+
+function isServicenetPublish(commandName, rawArgv) {
+  return commandName === "servicenet"
+    && rawArgv[1] === "publish";
+}
+
+function usesWorkspaceMount(commandName, rawArgv) {
+  return isServicenetAgentCardInit(commandName, rawArgv)
+    || isServicenetProviderRegister(commandName, rawArgv)
+    || isServicenetPublish(commandName, rawArgv);
+}
+
+function findExistingAncestor(targetPath) {
+  let cursor = path.resolve(targetPath);
+  while (!fs.existsSync(cursor)) {
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      throw new Error(`No existing parent directory found for ${targetPath}`);
+    }
+    cursor = parent;
+  }
+  return cursor;
+}
+
+function toContainerPath(relativePath) {
+  if (!relativePath || relativePath === ".") {
+    return "/workspace";
+  }
+  return `/workspace/${relativePath.split(path.sep).join("/")}`;
+}
+
+function parsePathOption(rawArgv, optionName, startIndex) {
+  const equalsPrefix = `${optionName}=`;
+  for (let index = startIndex; index < rawArgv.length; index += 1) {
+    const arg = rawArgv[index];
+    if (arg === optionName) {
+      return { index, value: rawArgv[index + 1], style: "separate" };
+    }
+    if (arg.startsWith(equalsPrefix)) {
+      return { index, value: arg.slice(equalsPrefix.length), style: "equals" };
+    }
+  }
+  return null;
+}
+
+function pathMountFor(targetPath) {
+  const requestedPath = path.resolve(targetPath);
+  const existingPath = fs.existsSync(requestedPath) ? requestedPath : "";
+  const mountSource = existingPath
+    ? (
+      fs.statSync(existingPath).isDirectory()
+        ? existingPath
+        : path.dirname(existingPath)
+    )
+    : findExistingAncestor(requestedPath);
+  return {
+    mountSource,
+    containerPath: toContainerPath(path.relative(mountSource, requestedPath))
+  };
+}
+
+function rewritePathOption(rawArgv, parsedOption, containerPath) {
+  const rewrittenArgv = [...rawArgv];
+  if (parsedOption.style === "separate") {
+    rewrittenArgv[parsedOption.index + 1] = containerPath;
+  } else {
+    rewrittenArgv[parsedOption.index] = `${rewrittenArgv[parsedOption.index].split("=")[0]}=${containerPath}`;
+  }
+  return rewrittenArgv;
+}
+
+function dockerWorkspaceInvocation(commandName, rawArgv) {
+  if (isServicenetAgentCardInit(commandName, rawArgv)) {
+    const outputArg = parsePathOption(rawArgv, "--out", 3);
+    const outputPath = outputArg?.value || process.cwd();
+    if (outputArg && !outputArg.value) {
+      throw new Error("Missing value for --out");
+    }
+    const outputMount = pathMountFor(outputPath);
+    const rewrittenArgv = outputArg
+      ? rewritePathOption(rawArgv, outputArg, outputMount.containerPath)
+      : rawArgv;
+    return {
+      args: outputArg
+        ? forwardedArgsForInstalledNode(commandName, rewrittenArgv)
+        : [...forwardedArgsForInstalledNode(commandName, rawArgv), "--out", outputMount.containerPath],
+      mountSource: outputMount.mountSource
+    };
+  }
+
+  if (isServicenetProviderRegister(commandName, rawArgv)) {
+    const cardArg = parsePathOption(rawArgv, "--card", 3);
+    if (!cardArg) {
+      return {
+        args: forwardedArgsForInstalledNode(commandName, rawArgv),
+        mountSource: process.cwd()
+      };
+    }
+    if (!cardArg.value) {
+      throw new Error("Missing value for --card");
+    }
+    const cardMount = pathMountFor(cardArg.value);
+    return {
+      args: forwardedArgsForInstalledNode(
+        commandName,
+        rewritePathOption(rawArgv, cardArg, cardMount.containerPath)
+      ),
+      mountSource: cardMount.mountSource
+    };
+  }
+
+  return {
+    args: forwardedArgsForInstalledNode(commandName, rawArgv),
+    mountSource: process.cwd()
+  };
+}
+
+function hostPathFromWorkspace(containerPath, mountSource) {
+  if (containerPath === "/workspace") {
+    return mountSource;
+  }
+  if (!containerPath.startsWith("/workspace/")) {
+    return containerPath;
+  }
+  return path.join(mountSource, containerPath.slice("/workspace/".length));
+}
+
+function rewriteWorkspaceJsonStdout(stdout, mountSource) {
+  if (!stdout.trim()) {
+    return stdout;
+  }
+  try {
+    const payload = JSON.parse(stdout);
+    if (typeof payload.card === "string") {
+      payload.card = hostPathFromWorkspace(payload.card, mountSource);
+    }
+    return `${JSON.stringify(payload, null, 2)}\n`;
+  } catch (_error) {
+    return stdout;
+  }
+}
+
 function runInstalledNodeCli(commandName, rawArgv, deployment) {
   const dockerCommand = resolveDockerCommand();
   if (!dockerCommand) {
@@ -1323,6 +1476,41 @@ function runInstalledNodeCli(commandName, rawArgv, deployment) {
         `to run '${commandName}' inside the installed node. Start Docker Desktop and retry.`
     );
   }
+  if (usesWorkspaceMount(commandName, rawArgv)) {
+    const invocation = dockerWorkspaceInvocation(commandName, rawArgv);
+    const result = spawnSync(
+      dockerCommand,
+      [
+        "compose",
+        "--project-name",
+        DEFAULT_PROJECT_NAME,
+        "--env-file",
+        deployment.envPath,
+        "-f",
+        deployment.composePath,
+        "run",
+        "--rm",
+        "--no-deps",
+        "-T",
+        "--entrypoint",
+        "/app/target/release/wattetheria-client-cli",
+        "-v",
+        `${invocation.mountSource}:/workspace`,
+        "-w",
+        "/workspace",
+        "kernel",
+        ...invocation.args
+      ],
+      { stdio: ["inherit", "pipe", "inherit"], encoding: "utf8" }
+    );
+    if (result.stdout) {
+      process.stdout.write(rewriteWorkspaceJsonStdout(result.stdout, invocation.mountSource));
+    }
+    if (typeof result.status === "number") {
+      process.exit(result.status);
+    }
+    throw result.error ?? new Error(`Failed to run '${commandName}' inside the installed node`);
+  }
   const result = spawnSync(
     dockerCommand,
     [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wattetheria",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Wattetheria deployment CLI",
   "license": "Apache-2.0",
   "type": "commonjs",