wattetheria 0.3.1 → 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/README.md

@@ -685,8 +685,7 @@ pwsh ./scripts/deploy-release.ps1
   ],
   "brain_provider": {
     "kind": "rules"
-  },
-  "servicenet_base_url": "http://127.0.0.1:8042"
+  }
 }
 ```
 
@@ -701,7 +700,6 @@ Recommended config for autonomous loop in daemon (`.wattetheria/config.json`):
     "base_url": "http://127.0.0.1:11434",
     "model": "qwen2.5:7b-instruct"
   },
-  "servicenet_base_url": "http://127.0.0.1:8042",
   "autonomy_enabled": true,
   "autonomy_interval_sec": 30
 }
@@ -730,7 +728,6 @@ Example OpenClaw/OpenAI-compatible config:
     "api_key_env": "WATTETHERIA_BRAIN_API_KEY"
   },
   "wattswarm_ui_base_url": "http://127.0.0.1:7788",
-  "servicenet_base_url": "http://127.0.0.1:8042",
   "autonomy_enabled": true,
   "autonomy_interval_sec": 30
 }
@@ -764,11 +761,11 @@ The supervision runtime page asks for the concrete API key value. Saving that fo
 
 `docker-compose.release.yml` also mounts `${WATTSWARM_HOST_STATE_DIR}/startup_config.json` into the
 kernel container as read-only. If `WATTETHERIA_GATEWAY_URLS` is unset, the kernel falls back to
-`gateway_urls` saved by Wattswarm in that file. For ServiceNet, the kernel uses the first
-`servicenet_urls` entry from the same file as the release path; `WATTETHERIA_SERVICENET_BASE_URL`
-is only a local override when no startup config URL is available. Wattetheria resolves coarse node
-geo location at startup and sends the resulting `latitude` / `longitude` to Wattswarm over the
-local sync gRPC bridge, so Wattswarm remains the writer for its own startup config.
+`gateway_urls` saved by Wattswarm in that file. ServiceNet uses the fixed official registry
+endpoint `https://servicenet.wattetheria.com`; it is not read from `.wattetheria/config.json`,
+environment variables, or Wattswarm startup config. Wattetheria resolves coarse node geo location
+at startup and sends the resulting `latitude` / `longitude` to Wattswarm over the local sync gRPC
+bridge, so Wattswarm remains the writer for its own startup config.
 
 When Wattetheria registers `core-agent` with Wattswarm, it keeps the brain/runtime
 `base_url` pointed at the OpenAI-compatible gateway for `/execute` work and exposes a
@@ -777,7 +774,7 @@ for structured agent-event callbacks. This keeps local-mode task execution and
 topic/consensus flows on the existing runtime path while letting agent events reach
 OpenClaw/NanoClaw-style runtimes through Wattetheria's adapter.
 
-When `servicenet_base_url` is configured, the control plane exposes local proxy routes for external agent discovery and execution:
+The control plane uses the fixed ServiceNet registry endpoint and exposes local proxy routes for external agent discovery and execution:
 
 - `GET /v1/wattetheria/servicenet/agents`
 - `GET /v1/wattetheria/servicenet/agents/:agent_id`

package/docker-compose.release.yml

@@ -37,7 +37,6 @@ services:
       WATTETHERIA_BRAIN_MODEL: ${WATTETHERIA_BRAIN_MODEL:-}
       WATTETHERIA_BRAIN_API_KEY_ENV: ${WATTETHERIA_BRAIN_API_KEY_ENV:-}
       WATTETHERIA_BRAIN_API_KEY: ${WATTETHERIA_BRAIN_API_KEY:-}
-      WATTETHERIA_SERVICENET_BASE_URL: ${WATTETHERIA_SERVICENET_BASE_URL:-}
       WATTETHERIA_GATEWAY_URLS: ${WATTETHERIA_GATEWAY_URLS:-}
       WATTETHERIA_GATEWAY_CONFIG_PATH: ${WATTETHERIA_GATEWAY_CONFIG_PATH:-/var/lib/wattswarm/startup_config.json}
       WATTETHERIA_AUTONOMY_ENABLED: ${WATTETHERIA_AUTONOMY_ENABLED:-false}

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.1",
+  "version": "0.3.3",
   "description": "Wattetheria deployment CLI",
   "license": "Apache-2.0",
   "type": "commonjs",