chore: narrow windows branch scope to desktop delivery

Author: PerishCode

.github/workflows/cancel-closed-pr-desktop-e2e.yml

@@ -0,0 +1,55 @@
+name: Cancel closed PR Desktop E2E runs
+
+on:
+  pull_request:
+    types: [closed]
+
+permissions:
+  actions: write
+  contents: read
+  pull-requests: read
+
+jobs:
+  cancel-desktop-e2e-runs:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Cancel stale Desktop E2E pull_request runs for this PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const prNumber = context.payload.pull_request.number;
+            const workflowId = "desktop-e2e.yml";
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+
+            const workflowRuns = await github.paginate(github.rest.actions.listWorkflowRuns, {
+              owner,
+              repo,
+              workflow_id: workflowId,
+              event: "pull_request",
+              per_page: 100,
+            });
+
+            const cancellableRuns = workflowRuns.filter((run) => {
+              const matchesPr = run.pull_requests?.some((pr) => pr.number === prNumber);
+              const isCancellable = run.status !== "completed";
+
+              return matchesPr && isCancellable;
+            });
+
+            if (cancellableRuns.length === 0) {
+              core.info(`No queued or in-progress Desktop E2E pull_request runs found for PR #${prNumber}.`);
+              return;
+            }
+
+            for (const run of cancellableRuns) {
+              core.info(`Canceling Desktop E2E run ${run.id} for PR #${prNumber} (status: ${run.status}).`);
+
+              await github.rest.actions.cancelWorkflowRun({
+                owner,
+                repo,
+                run_id: run.id,
+              });
+            }
+
+            core.info(`Requested cancellation for ${cancellableRuns.length} Desktop E2E run(s) for PR #${prNumber}.`);

apps/controller/src/app/container.ts

@@ -77,12 +77,10 @@ const NEXU_OFFICIAL_MODEL_REFRESH_INTERVAL_MS = 60 * 1000;
 export async function createContainer(): Promise<ControllerContainer> {
   const configStore = new NexuConfigStore(env);
   await configStore.reconcileConfiguredDesktopCloudState();
-  if (env.manageOpenclawProcess) {
-    await configStore.syncManagedRuntimeGateway({
-      port: env.openclawGatewayPort,
-      authMode: env.openclawGatewayToken ? "token" : "none",
-    });
-  }
+  await configStore.syncManagedRuntimeGateway({
+    port: env.openclawGatewayPort,
+    authMode: env.openclawGatewayToken ? "token" : "none",
+  });
   const artifactsStore = new ArtifactsStore(env);
   const compiledStore = new CompiledOpenClawStore(env);
   const configWriter = new OpenClawConfigWriter(env);

apps/controller/src/app/env.ts

@@ -37,6 +37,10 @@ const booleanSchema = z
   .enum(["true", "false", "1", "0"])
   .transform((value) => value === "true" || value === "1");
 
+function booleanWithDefault(defaultValue: boolean) {
+  return booleanSchema.optional().transform((value) => value ?? defaultValue);
+}
+
 const openclawOwnershipModeSchema = z.enum(["external", "internal"]);
 
 function parseUrlPort(value: string): number | null {
@@ -93,8 +97,8 @@ const envSchema = z.object({
   OPENCLAW_LAUNCHD_LABEL: z.string().optional(),
   LITELLM_BASE_URL: z.string().optional(),
   LITELLM_API_KEY: z.string().optional(),
-  RUNTIME_MANAGE_OPENCLAW_PROCESS: booleanSchema.default("false"),
-  RUNTIME_GATEWAY_PROBE_ENABLED: booleanSchema.default("true"),
+  RUNTIME_MANAGE_OPENCLAW_PROCESS: booleanWithDefault(false),
+  RUNTIME_GATEWAY_PROBE_ENABLED: booleanWithDefault(true),
   RUNTIME_SYNC_INTERVAL_MS: z.coerce.number().int().positive().default(2000),
   RUNTIME_HEALTH_INTERVAL_MS: z.coerce.number().int().positive().default(5000),
   DEFAULT_MODEL_ID: z.string().default("link/gemini-3-flash-preview"),
@@ -103,8 +107,6 @@ const envSchema = z.object({
   VITE_POSTHOG_API_KEY: z.string().optional(),
   POSTHOG_HOST: z.string().optional(),
   VITE_POSTHOG_HOST: z.string().optional(),
-  AMPLITUDE_API_KEY: z.string().optional(),
-  VITE_AMPLITUDE_API_KEY: z.string().optional(),
 });
 
 const parsed = envSchema.parse(process.env);
@@ -202,8 +204,6 @@ export const env = {
   posthogApiKey:
     parsed.POSTHOG_API_KEY?.trim() || parsed.VITE_POSTHOG_API_KEY?.trim(),
   posthogHost: parsed.POSTHOG_HOST?.trim() || parsed.VITE_POSTHOG_HOST?.trim(),
-  amplitudeApiKey:
-    parsed.AMPLITUDE_API_KEY?.trim() || parsed.VITE_AMPLITUDE_API_KEY?.trim(),
 };
 
 export type ControllerEnv = typeof env;

apps/controller/src/index.ts

@@ -9,7 +9,6 @@ async function main(): Promise<void> {
   const container = await createContainer();
   const stopBackgroundLoops = await bootstrapController(container);
   const app = createApp(container);
-
   const server = serve(
     {
       fetch: app.fetch,

apps/controller/src/lib/channel-binding-compiler.ts

@@ -278,6 +278,9 @@ export function compileChannelsConfig(params: {
       ? {
           feishu: {
             enabled: true,
+            // Card Kit streaming: replies stream in real-time via feishu
+            // interactive cards. Without these, replies arrive as plain text
+            // after the full LLM response completes (no streaming UX).
             streaming: true,
             renderMode: "card",
             dmPolicy: "open",

apps/controller/src/lib/openclaw-runtime-bridge.ts

@@ -7,7 +7,6 @@ import path from "node:path";
 import { createInterface } from "node:readline";
 import type { ControllerEnv } from "../app/env.js";
 import { logger } from "../lib/logger.js";
-import { resolveOpenClawEntryPath } from "../lib/openclaw-runtime-bridge.js";
 
 const MAX_CONSECUTIVE_RESTARTS = 10;
 const BASE_RESTART_DELAY_MS = 3000;
@@ -38,6 +37,20 @@ function findWorkspaceRoot(startDir: string): string | null {
   return null;
 }
 
+function resolveOpenclawEntryFromBin(binPath: string): string | null {
+  const resolvedBinPath = path.resolve(binPath.trim());
+  if (resolvedBinPath.endsWith(".mjs") && existsSync(resolvedBinPath)) {
+    return resolvedBinPath;
+  }
+
+  const entry = path.resolve(
+    path.dirname(resolvedBinPath),
+    "..",
+    "node_modules/openclaw/openclaw.mjs",
+  );
+  return existsSync(entry) ? entry : null;
+}
+
 export interface OpenClawRuntimeEvent {
   event: string;
   payload?: unknown;
@@ -123,55 +136,49 @@ export class OpenClawProcessManager {
     let extraEnv: Record<string, string> = {};
 
     if (electronExec) {
-      const entry = resolveOpenClawEntryPath({
-        openclawBin: this.env.openclawBin,
-        workspaceRoot:
+      const openclawEntryFromBin = resolveOpenclawEntryFromBin(
+        this.env.openclawBin,
+      );
+      if (openclawEntryFromBin) {
+        cmd = electronExec;
+        args = [openclawEntryFromBin, "gateway", "run"];
+        extraEnv = { ELECTRON_RUN_AS_NODE: "1" };
+      } else {
+        const workspaceRoot =
           process.env.NEXU_WORKSPACE_ROOT?.trim() ||
-          findWorkspaceRoot(process.cwd()),
-      });
-      if (!entry) {
-        throw new Error(
-          "Unable to resolve OpenClaw entry point from OPENCLAW_BIN",
-        );
+          findWorkspaceRoot(process.cwd());
+        const runtimeEntryPath = workspaceRoot
+          ? path.join(
+              workspaceRoot,
+              "openclaw-runtime",
+              "node_modules",
+              "openclaw",
+              "openclaw.mjs",
+            )
+          : null;
+
+        if (runtimeEntryPath && existsSync(runtimeEntryPath)) {
+          cmd = electronExec;
+          args = [runtimeEntryPath, "gateway", "run"];
+          extraEnv = { ELECTRON_RUN_AS_NODE: "1" };
+        } else {
+          // Resolve the openclaw entry point relative to the bin script
+          const entry = resolveOpenclawEntryFromBin(this.env.openclawBin);
+          if (!entry) {
+            throw new Error(
+              "Unable to resolve OpenClaw entry point from OPENCLAW_BIN",
+            );
+          }
+          cmd = electronExec;
+          args = [entry, "gateway", "run"];
+          extraEnv = { ELECTRON_RUN_AS_NODE: "1" };
+        }
       }
-      logger.info(
-        {
-          openclawBin: this.env.openclawBin,
-          entry,
-          electronExec,
-        },
-        "controller resolved openclaw entry via repo-root openclaw runtime bridge",
-      );
-      cmd = electronExec;
-      args = [entry, "gateway", "run"];
-      extraEnv = { ELECTRON_RUN_AS_NODE: "1" };
     } else {
-      logger.info(
-        {
-          openclawBin: this.env.openclawBin,
-          electronExec: null,
-        },
-        "controller using direct openclaw binary path",
-      );
       cmd = this.env.openclawBin;
       args = ["gateway", "run"];
     }
 
-    logger.info(
-      {
-        mode: electronExec ? "electron-entry" : "direct-bin",
-        cmd,
-        args,
-        cwd: path.resolve(this.env.openclawStateDir),
-        openclawBin: this.env.openclawBin,
-        openclawBinExists: existsSync(this.env.openclawBin),
-        electronExec,
-        electronExecExists: electronExec ? existsSync(electronExec) : null,
-        platform: process.platform,
-      },
-      "openclaw spawn contract",
-    );
-
     const child = spawn(cmd, args, {
       cwd: path.resolve(this.env.openclawStateDir),
       env: {
@@ -232,13 +239,7 @@ export class OpenClawProcessManager {
 
     child.once("error", (error) => {
       logger.error(
-        {
-          error: error.message,
-          code: "code" in error ? error.code : undefined,
-          path: "path" in error ? error.path : undefined,
-          syscall: "syscall" in error ? error.syscall : undefined,
-          spawnargs: "spawnargs" in error ? error.spawnargs : undefined,
-        },
+        { error: error.message },
         "failed to spawn openclaw process",
       );
       this.child = null;

apps/controller/src/runtime/openclaw-process.ts

@@ -1224,16 +1224,9 @@ export class SessionsRuntime {
       return true;
     }
 
-    if (normalized === sessionKey || UUID_LIKE_TITLE_PATTERN.test(normalized)) {
-      return true;
-    }
-
-    if (normalized.endsWith(" · qqbot")) {
-      const qqbotLabel = normalized.slice(0, -" · qqbot".length).trim();
-      return this.isOpaqueQqbotValue(qqbotLabel, "user");
-    }
-
-    return false;
+    return (
+      normalized === sessionKey || UUID_LIKE_TITLE_PATTERN.test(normalized)
+    );
   }
 
   private extractExactChatTargetMetadata(