Improve SANO sample (#507)

Improve SANO sample

Author: Quinn-With-Two-Ns

nexus-standalone-operations/README.md

@@ -1,59 +1,50 @@
 This sample demonstrates how to use Standalone Nexus Operations (executing Nexus operations directly from client code without wrapping them in a Workflow).
 It shows both sync and async (workflow-backed) operations, and how to use the `ListNexusOperations` and `CountNexusOperations` APIs.
 
-## Note: Standalone Nexus operations require a server version that supports this feature. Use the dev server build at https://github.com/temporalio/cli/releases/tag/v1.7.3-standalone-nexus-operations.
+The starter and worker connect to two different namespaces (a "caller" namespace and a "handler" namespace) — this mirrors how Nexus is typically used to cross namespace boundaries. The client is configured via the SDK's [environment configuration](https://docs.temporal.io/develop/environment-configuration) support, which reads `TEMPORAL_NAMESPACE`, `TEMPORAL_ADDRESS`, etc. from the environment (and optionally profiles from `temporal.toml`).
 
-### Steps to run this sample (with expected output):
-1) Run the [Temporal dev server build that supports standalone Nexus operations](https://github.com/temporalio/cli/releases/tag/v1.7.3-standalone-nexus-operations). (If you are going to run locally, you will want to start it in another terminal; this command is blocking and runs until it receives a SIGINT (Ctrl + C) command.)
+## Note: Standalone Nexus operations require a server version that supports this feature. Use the dev server build at https://github.com/temporalio/cli/releases/tag/v1.7.4-standalone-nexus-operations.
 
-Start the dev server with the dynamic config flags required for standalone Nexus operations:
+## Run locally against a dev server
+
+1) Start the [Temporal dev server build that supports standalone Nexus operations](https://docs.temporal.io/standalone-nexus-operation#temporal-cli-support) with the required namespaces pre-created:
 
 ```bash
-temporal server start-dev \
-  --dynamic-config-value "nexusoperation.enableStandalone=true" \
-  --dynamic-config-value "history.enableChasmCallbacks=true"
+./temporal server start-dev \
+  --namespace my-caller-namespace \
+  --namespace my-handler-namespace
 ```
 
-You should see a line about the CLI, Server and UI versions, and one line each for the Server URL, UI URL and Metrics endpoint. It should look something like this:
+2) Create a Nexus endpoint that routes to the handler namespace and the worker's task queue:
 
 ```bash
-Temporal CLI 1.7.3-standalone-nexus-operations (Server 1.32.0-158.0, UI 2.52.0)
-
-Temporal Server:  localhost:7233
-Temporal UI:      http://localhost:8233
-Temporal Metrics: http://localhost:61951/metrics
+./temporal operator nexus endpoint create \
+  --name my-nexus-endpoint \
+  --target-namespace my-handler-namespace \
+  --target-task-queue nexus-handler-queue
 ```
 
-2) Create a Nexus endpoint that routes to the worker's task queue. In a second terminal, run:
-```bash
-temporal operator nexus endpoint create \
-  --name nexus-standalone-operations-endpoint \
-  --target-namespace default \
-  --target-task-queue nexus-standalone-operations
-```
+3) In a new terminal, start the worker in the handler namespace:
 
-1) Then run the following command to start the worker. The worker is a blocking process that runs until it receives a SIGINT (Ctrl + C) command.
 ```bash
-go run nexus-standalone-operations/worker/main.go
+TEMPORAL_NAMESPACE=my-handler-namespace \
+  go run nexus-standalone-operations/worker/main.go
 ```
 
-You should see the following log line:
-1. Starting the Worker with Namespace `default`, and TaskQueue `nexus-standalone-operations` and it will list the WorkerID for the created worker.
+You should see a log line similar to:
 
-For example:
 ```bash
-2026/05/21 08:59:49 INFO  Started Worker Namespace default TaskQueue nexus-standalone-operations WorkerID 71172
+2026/05/21 08:59:49 INFO  Started Worker Namespace my-handler-namespace TaskQueue nexus-handler-queue WorkerID 71172
 ```
 
-> [!NOTE]
-> Timestamps and IDs will differ on your machine.
+4) In a third terminal, run the starter in the caller namespace:
 
-4) In a third terminal, run the following command to start the example:
 ```bash
-go run nexus-standalone-operations/starter/main.go
+TEMPORAL_NAMESPACE=my-caller-namespace \
+  go run nexus-standalone-operations/starter/main.go
 ```
 
-You should see something similar to the following output:
+You should see something similar to:
 
 ```bash
 2026/05/21 09:00:30 Started Echo operation OperationID nexus-standalone-echo-op
@@ -66,5 +57,44 @@ You should see something similar to the following output:
 2026/05/21 09:00:30 Total Nexus operations: 2
 ```
 
-If you run the starter code multiple times, you should see additional `ListNexusOperations` results, as more operations are run.
-The same goes for the number from `CountNexusOperations`.
+If you run the starter multiple times, additional entries will appear in the `ListNexusOperations` output and the `CountNexusOperations` total will grow.
+
+## Run against Temporal Cloud
+
+1) Create two namespaces in Temporal Cloud (for example `my-caller-namespace.<account>` and `my-handler-namespace.<account>`) and generate an API key (or mTLS cert) that can access both.
+
+2) Create a Nexus endpoint that targets the handler namespace and the worker's task queue. See the Temporal Cloud instructions at https://docs.temporal.io/nexus/registry#create-a-nexus-endpoint. Use:
+- Endpoint name: `my-nexus-endpoint`
+- Target namespace: `my-handler-namespace.<account>`
+- Target task queue: `nexus-handler-queue`
+- Allowed caller namespaces: include `my-caller-namespace.<account>` (endpoints reject callers that are not on this list)
+
+3) Add two profiles to your [environment configuration file](https://docs.temporal.io/develop/environment-configuration), one per namespace. Using API keys:
+
+```toml
+[profile.handler]
+address = "<region>.<cloud>.api.temporal.io:7233"
+namespace = "my-handler-namespace.<account>"
+api_key = "<your-api-key>"
+
+[profile.caller]
+address = "<region>.<cloud>.api.temporal.io:7233"
+namespace = "my-caller-namespace.<account>"
+api_key = "<your-api-key>"
+```
+
+For mTLS instead of API keys, set `tls.client_cert_path` and `tls.client_key_path` on each profile (see the [docs](https://docs.temporal.io/develop/environment-configuration) for the full schema).
+
+4) Run the worker and starter in separate terminals, selecting the appropriate profile in each:
+
+```bash
+# terminal 1 (worker, handler namespace)
+export TEMPORAL_PROFILE="handler"
+go run nexus-standalone-operations/worker/main.go
+```
+
+```bash
+# terminal 2 (starter, caller namespace)
+export TEMPORAL_PROFILE="caller"
+go run nexus-standalone-operations/starter/main.go
+```

nexus-standalone-operations/handler_test.go

@@ -33,11 +33,7 @@ func Test_StandaloneNexusOperations_Using_DevServer(t *testing.T) {
 	// Start the dev server with standalone Nexus support.
 	server, err := testsuite.StartDevServer(ctx, testsuite.DevServerOptions{
 		CachedDownload: testsuite.CachedDownload{
-			Version: "v1.7.3-standalone-nexus-operations",
-		},
-		ExtraArgs: []string{
-			"--dynamic-config-value", "nexusoperation.enableStandalone=true",
-			"--dynamic-config-value", "history.enableChasmCallbacks=true",
+			Version: "v1.7.4-standalone-nexus-operations",
 		},
 	})
 	require.NoError(t, err)

nexus-standalone-operations/starter/main.go

@@ -16,7 +16,7 @@ import (
 // This sample demonstrates standalone Nexus operations — executing Nexus operations
 // directly from client code without wrapping them in a workflow.
 
-const endpointName = "nexus-standalone-operations-endpoint"
+const endpointName = "my-nexus-endpoint"
 
 func main() {
 	// The client is a heavyweight object that should be created once per process.

nexus-standalone-operations/worker/main.go

@@ -14,7 +14,7 @@ import (
 	"github.com/temporalio/samples-go/nexus/service"
 )
 
-const taskQueue = "nexus-standalone-operations"
+const taskQueue = "nexus-handler-queue"
 
 func main() {
 	// The client and worker are heavyweight objects that should be created once per process.