@vellumai/cli 0.10.5 → 0.10.6-dev.202607062124.26c976d

package/node_modules/@vellumai/local-mode/src/__tests__/upgrade.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
+import { EventEmitter } from "node:events";
+
+import type { CliInvocation } from "../util";
+
+class FakeChild extends EventEmitter {
+  stdout = new EventEmitter();
+  stderr = new EventEmitter();
+  kill = mock(() => true);
+}
+
+let lastChild: FakeChild;
+const spawnArgs: Array<
+  [string, string[], { env?: NodeJS.ProcessEnv; stdio?: unknown }]
+> = [];
+const spawnMock = mock(
+  (
+    command: string,
+    args: string[],
+    options: { env?: NodeJS.ProcessEnv; stdio?: unknown },
+  ) => {
+    spawnArgs.push([command, args, options]);
+    lastChild = new FakeChild();
+    return lastChild;
+  },
+);
+
+mock.module("node:child_process", () => ({ spawn: spawnMock }));
+
+let runUpgrade: typeof import("../upgrade").runUpgrade;
+let isValidReleaseVersion: typeof import("../upgrade").isValidReleaseVersion;
+
+beforeAll(async () => {
+  ({ runUpgrade, isValidReleaseVersion } = await import("../upgrade"));
+});
+
+afterEach(() => {
+  spawnArgs.length = 0;
+  spawnMock.mockClear();
+});
+
+const invocation: CliInvocation = { command: "bun", baseArgs: ["run", "cli"] };
+
+describe("isValidReleaseVersion", () => {
+  test("accepts release tags, staying lenient about semver shape", () => {
+    for (const version of [
+      "latest",
+      "v1.2.3",
+      "V1.2.3", // uppercase prefix
+      "1.2.3",
+      "1.2", // two-part
+      "1.2.3.4", // four-part
+      "0.6.0-staging.5",
+      "1.2.3-rc.1+build.7",
+    ]) {
+      expect(isValidReleaseVersion(version)).toBe(true);
+    }
+  });
+
+  test("rejects package specs and path-traversal input", () => {
+    for (const version of [
+      "npm:@attacker/evil@1.0.0",
+      "https://evil.example/x.tgz",
+      "git+https://evil.example/x.git",
+      "github:attacker/vellum",
+      "file:/tmp/evil",
+      "../../../../tmp/evil",
+      "1.2.3-..", // no consecutive dots (would be a traversal segment)
+      "1.2.3-a..b",
+      "..",
+      "",
+      "vellum@1.2.3",
+    ]) {
+      expect(isValidReleaseVersion(version)).toBe(false);
+    }
+  });
+});
+
+describe("runUpgrade", () => {
+  test("spawns the CLI upgrade command for a release tag", async () => {
+    const pending = runUpgrade(invocation, "asst-42", { version: "v1.2.3" });
+    lastChild.emit("close", 0);
+
+    expect(await pending).toEqual({ ok: true });
+    expect(spawnArgs[0]).toEqual([
+      "bun",
+      ["run", "cli", "upgrade", "asst-42", "--version", "v1.2.3"],
+      { stdio: ["ignore", "pipe", "pipe"] },
+    ]);
+  });
+
+  test("spawns the CLI upgrade command for --latest", async () => {
+    const pending = runUpgrade(invocation, "asst-42", { latest: true });
+    lastChild.emit("close", 0);
+
+    expect(await pending).toEqual({ ok: true });
+    expect(spawnArgs[0]?.[1]).toEqual([
+      "run",
+      "cli",
+      "upgrade",
+      "asst-42",
+      "--latest",
+    ]);
+  });
+
+  test("rejects a malicious version without spawning", async () => {
+    const result = await runUpgrade(invocation, "asst-42", {
+      version: "npm:@attacker/evil@1.0.0",
+    });
+
+    expect(result).toEqual({
+      ok: false,
+      status: 400,
+      error:
+        "Invalid upgrade version 'npm:@attacker/evil@1.0.0': expected a release tag like v1.2.3 or 'latest'.",
+    });
+    expect(spawnArgs.length).toBe(0);
+  });
+
+  test("rejects a path-traversal version without spawning", async () => {
+    const result = await runUpgrade(invocation, "asst-42", {
+      version: "../../../../tmp/evil",
+    });
+
+    expect(result.ok).toBe(false);
+    expect(spawnArgs.length).toBe(0);
+  });
+});

package/node_modules/@vellumai/local-mode/src/index.ts

@@ -48,7 +48,7 @@ export { runSleep } from "./sleep";
 export type { SleepResult } from "./sleep";
 export { runWake } from "./wake";
 export type { WakeOptions, WakeResult } from "./wake";
-export { runUpgrade } from "./upgrade";
+export { runUpgrade, isValidReleaseVersion } from "./upgrade";
 export type { UpgradeOptions, UpgradeResult } from "./upgrade";
 export { getLocalAssistantStatus } from "./status";
 export type {

package/node_modules/@vellumai/local-mode/src/upgrade.ts

@@ -14,6 +14,37 @@ export interface UpgradeOptions {
   force?: boolean;
 }
 
+// A trusted release version is the literal `latest` dist-tag, or a
+// version-shaped string: an optional `v`/`V` prefix, then a leading digit,
+// then any run of `[0-9A-Za-z.+-]`. This is intentionally lenient about the
+// *shape* of the version (2-, 3-, or 4-part, arbitrary pre-release/build
+// identifiers, uppercase `V`) so we never reject a legitimate release tag.
+//
+// Security does not depend on the shape — it depends on the CHARSET. The
+// allowed set excludes `/`, `\`, `:`, `@`, `#` and whitespace, so the value can
+// never be interpreted by `bun install` as a package-manager spec (npm alias,
+// tarball/git URL, `file:`/`github:` ref) — all of which require one of those
+// characters. The mandatory leading digit means the value can never be a bare
+// `.`/`..` path segment, and `..` is rejected outright, so the version is safe
+// to use as the runtime-install directory name.
+const RELEASE_VERSION_PATTERN = /^(?:latest|[vV]?\d[0-9A-Za-z.+-]*)$/;
+
+/**
+ * Whether `version` is a trusted release identifier: the literal `latest`, or a
+ * version-shaped tag like `v1.2.3` / `1.2.3` / `0.6.0-staging.5`. Rejects
+ * package-manager specifiers (npm aliases, tarball or git URLs) and any
+ * path-traversal-like input, while staying permissive about semver shape.
+ *
+ * Defined once here and reused by both the host-bridge boundary guard
+ * (`runUpgrade`, in the shared library backing the Electron host and the web
+ * dev-server middleware) and the CLI's runtime-install sink
+ * (`ensureLocalRuntime`), so the security boundary can never drift between the
+ * two call sites.
+ */
+export function isValidReleaseVersion(version: string): boolean {
+  return RELEASE_VERSION_PATTERN.test(version) && !version.includes("..");
+}
+
 function extractVersion(output: string): string | undefined {
   const versionPattern = "(v?[0-9]+(?:\\.[0-9]+)*(?:[-+][\\w.-]+)?)";
   const upgraded = output.match(
@@ -35,6 +66,18 @@ export function runUpgrade(
   options?: UpgradeOptions,
 ): Promise<UpgradeResult> {
   return new Promise((resolve) => {
+    // Reject an untrusted `--version` at the host boundary before spawning the
+    // CLI. `latest` (or the `--latest` flag) is always allowed; an explicit
+    // version must be a release tag. Preserves the never-reject contract.
+    if (options?.version && !isValidReleaseVersion(options.version)) {
+      resolve({
+        ok: false,
+        status: 400,
+        error: `Invalid upgrade version '${options.version}': expected a release tag like v1.2.3 or 'latest'.`,
+      });
+      return;
+    }
+
     const args = [...invocation.baseArgs, "upgrade", assistantId];
     if (options?.latest) {
       args.push("--latest");

package/node_modules/@vellumai/local-mode/tsconfig.json

@@ -9,7 +9,7 @@
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
     "noEmit": true,
-    "types": ["bun-types"]
+    "types": ["bun"]
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.5",
+  "version": "0.10.6-dev.202607062124.26c976d",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {
@@ -22,7 +22,6 @@
     "format:check": "prettier --check .",
     "lint": "eslint",
     "lint:unused": "knip --include files,dependencies,unlisted",
-    "prepack": "node ../scripts/prepack-bundled-deps.mjs",
     "compile:check": "bun build --compile --external react-devtools-core src/index.ts --outfile /dev/null",
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit"
@@ -30,8 +29,6 @@
   "author": "Vellum AI",
   "license": "MIT",
   "dependencies": {
-    "@vellumai/environments": "file:../packages/environments",
-    "@vellumai/local-mode": "file:../packages/local-mode",
     "chalk": "5.6.2",
     "ink": "6.8.0",
     "nanoid": "5.1.7",

package/src/__tests__/local-runtime-version.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+
+import { isValidReleaseVersion } from "@vellumai/local-mode";
+
+import type { LocalInstanceResources } from "../lib/assistant-config.js";
+import { ensureLocalRuntime } from "../lib/local.js";
+
+// Only `instanceDir` is read, and only after the validation guard passes —
+// invalid versions throw before any filesystem access, so a minimal stub is
+// sufficient for the rejection cases.
+const resources = {
+  instanceDir: "/tmp/vellum-nonexistent-instance",
+} as unknown as LocalInstanceResources;
+
+const VALID_VERSIONS = ["latest", "v1.2.3", "1.2.3", "0.6.0-staging.5"];
+const MALICIOUS_VERSIONS = [
+  "npm:@attacker/evil@1.0.0",
+  "https://evil.example/x.tgz",
+  "git+https://evil.example/x.git",
+  "../../../../tmp/evil",
+  "1.2.3-..",
+  "1.2.3-a..b",
+];
+
+describe("ensureLocalRuntime version guard", () => {
+  test("shares the trusted-release validator with the host boundary", () => {
+    for (const version of VALID_VERSIONS) {
+      expect(isValidReleaseVersion(version)).toBe(true);
+    }
+    for (const version of MALICIOUS_VERSIONS) {
+      expect(isValidReleaseVersion(version)).toBe(false);
+    }
+  });
+
+  test("throws before any install for untrusted versions", () => {
+    for (const version of MALICIOUS_VERSIONS) {
+      expect(() => ensureLocalRuntime(resources, version)).toThrow(
+        `Invalid runtime version '${version}'`,
+      );
+    }
+  });
+});

package/src/__tests__/retire-local.test.ts

@@ -0,0 +1,157 @@
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { AssistantEntry } from "../lib/assistant-config.js";
+
+const testDir = mkdtempSync(join(tmpdir(), "retire-local-test-"));
+const originalLockfileDir = process.env.VELLUM_LOCKFILE_DIR;
+
+const stopProcessByPidFileMock = mock(
+  async (_pidFile: string, _label: string): Promise<boolean> => true,
+);
+const stopOrphanedDaemonProcessesMock = mock(async (): Promise<boolean> => false);
+const stopIngressNginxMock = mock(async (): Promise<boolean> => false);
+
+mock.module("../lib/process.js", () => ({
+  stopProcessByPidFile: stopProcessByPidFileMock,
+  stopOrphanedDaemonProcesses: stopOrphanedDaemonProcessesMock,
+}));
+
+mock.module("../lib/nginx-ingress.js", () => ({
+  stopIngressNginx: stopIngressNginxMock,
+}));
+
+// Keep archive paths on the same filesystem as the test dir so rename doesn't
+// hit EXDEV (cross-device link).
+const retiredStagingDir = join(testDir, "retired");
+mock.module("../lib/retire-archive.js", () => ({
+  getArchivePath: () => join(retiredStagingDir, "test-assistant.tar.gz"),
+  getMetadataPath: () => join(retiredStagingDir, "test-assistant.meta.json"),
+}));
+
+import { retireLocal } from "../lib/retire-local.js";
+
+const instanceDir = join(testDir, "test-instance");
+const vellumDir = join(instanceDir, ".vellum");
+
+function makeEntry(assistantId: string): AssistantEntry {
+  return {
+    assistantId,
+    runtimeUrl: "http://127.0.0.1:7801",
+    cloud: "local",
+    resources: {
+      instanceDir,
+      daemonPort: 7801,
+      gatewayPort: 7831,
+      qdrantPort: 6334,
+      cesPort: 7790,
+    },
+  };
+}
+
+function writeLockfile(entries: AssistantEntry[]): void {
+  writeFileSync(
+    join(testDir, ".vellum.lock.json"),
+    JSON.stringify({ assistants: entries }, null, 2) + "\n",
+  );
+}
+
+describe("retireLocal — CES sibling stop", () => {
+  beforeAll(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+  });
+
+  beforeEach(() => {
+    stopProcessByPidFileMock.mockReset();
+    stopProcessByPidFileMock.mockResolvedValue(true);
+    stopOrphanedDaemonProcessesMock.mockReset();
+    stopOrphanedDaemonProcessesMock.mockResolvedValue(false);
+    stopIngressNginxMock.mockReset();
+    stopIngressNginxMock.mockResolvedValue(false);
+
+    rmSync(instanceDir, { recursive: true, force: true });
+    rmSync(join(testDir, "retired"), { recursive: true, force: true });
+    mkdirSync(vellumDir, { recursive: true });
+    writeLockfile([makeEntry("test-assistant")]);
+
+    // Suppress console output from the lifecycle reporter.
+    spyOn(console, "log").mockImplementation(() => {});
+    spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterAll(() => {
+    if (originalLockfileDir === undefined) {
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    } else {
+      process.env.VELLUM_LOCKFILE_DIR = originalLockfileDir;
+    }
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("stops the CES sibling alongside daemon and gateway", async () => {
+    const entry = makeEntry("test-assistant");
+    await retireLocal("test-assistant", entry, {
+      progress: () => {},
+      log: () => {},
+      warn: () => {},
+      error: () => {},
+    });
+
+    // Verify CES PID file is among the stop calls.
+    const cesStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([pidFile, label]) =>
+        pidFile === join(vellumDir, "ces.pid") &&
+        label === "credential-executor",
+    );
+    expect(cesStopCall).toBeDefined();
+
+    // Also verify daemon and gateway are still stopped (sanity).
+    const daemonStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([, label]) => label === "daemon",
+    );
+    expect(daemonStopCall).toBeDefined();
+
+    const gatewayStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([, label]) => label === "gateway",
+    );
+    expect(gatewayStopCall).toBeDefined();
+  });
+
+  test("CES stop is a no-op when ces.pid is absent", async () => {
+    // stopProcessByPidFile returns false when the PID file doesn't exist.
+    // retireLocal should still complete successfully — the CES stop is best-effort.
+    stopProcessByPidFileMock.mockImplementation(
+      async (pidFile: string): Promise<boolean> => {
+        if (pidFile.includes("ces.pid")) return false;
+        return true;
+      },
+    );
+
+    const entry = makeEntry("test-assistant");
+    await retireLocal("test-assistant", entry, {
+      progress: () => {},
+      log: () => {},
+      warn: () => {},
+      error: () => {},
+    });
+
+    // The CES stop was attempted (PID file checked) but returned false.
+    const cesStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([pidFile, label]) =>
+        pidFile === join(vellumDir, "ces.pid") &&
+        label === "credential-executor",
+    );
+    expect(cesStopCall).toBeDefined();
+  });
+});

package/src/__tests__/sleep.test.ts

@@ -139,7 +139,8 @@ describe("sleep command", () => {
       consoleLog.mockRestore();
     }
 
-    expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(2);
+    // assistant + gateway + CES sibling
+    expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(3);
   });
 
   test("force stops the assistant even when an active call lease exists", async () => {
@@ -154,7 +155,7 @@ describe("sleep command", () => {
       consoleLog.mockRestore();
     }
 
-    expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(2);
+    expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(3);
     // The assistant stop passes a generous 120s grace so the daemon's WAL
     // checkpoint completes before any SIGKILL (default 2s would truncate it).
     expect(stopProcessByPidFileMock).toHaveBeenNthCalledWith(
@@ -171,5 +172,12 @@ describe("sleep command", () => {
       undefined,
       7000,
     );
+    // The CES sibling (CES_STANDALONE opt-in) is stopped by its PID file; a
+    // no-op when absent on the default topology.
+    expect(stopProcessByPidFileMock).toHaveBeenNthCalledWith(
+      3,
+      join(assistantRootDir, "ces.pid"),
+      "credential-executor",
+    );
   });
 });

package/src/__tests__/wake.test.ts

@@ -90,11 +90,16 @@ const resolveProcessStateMock = mock<typeof processLib.resolveProcessState>(
 const stopProcessByPidFileMock = mock<typeof processLib.stopProcessByPidFile>(
   async () => true,
 );
+const isProcessAliveMock = mock<typeof processLib.isProcessAlive>(() => ({
+  alive: false,
+  pid: null,
+}));
 
 mock.module("../lib/process", () => ({
   ...realProcessLib,
   resolveProcessState: resolveProcessStateMock,
   stopProcessByPidFile: stopProcessByPidFileMock,
+  isProcessAlive: isProcessAliveMock,
 }));
 
 const generateLocalSigningKeyMock = mock<typeof local.generateLocalSigningKey>(
@@ -110,6 +115,7 @@ const startLocalDaemonMock = mock<typeof local.startLocalDaemon>(async () => {})
 const startGatewayMock = mock<typeof local.startGateway>(
   async () => "http://127.0.0.1:7830",
 );
+const startCesMock = mock<typeof local.startCes>(async () => {});
 
 mock.module("../lib/local", () => ({
   ...realLocal,
@@ -118,6 +124,7 @@ mock.module("../lib/local", () => ({
   isGatewayWatchModeAvailable: isGatewayWatchModeAvailableMock,
   startLocalDaemon: startLocalDaemonMock,
   startGateway: startGatewayMock,
+  startCes: startCesMock,
 }));
 
 const maybeStartNgrokTunnelMock = mock<typeof ngrok.maybeStartNgrokTunnel>(
@@ -184,6 +191,10 @@ beforeEach(() => {
   startLocalDaemonMock.mockResolvedValue(undefined);
   startGatewayMock.mockReset();
   startGatewayMock.mockResolvedValue("http://127.0.0.1:7830");
+  startCesMock.mockReset();
+  startCesMock.mockResolvedValue(undefined);
+  isProcessAliveMock.mockReset();
+  isProcessAliveMock.mockReturnValue({ alive: false, pid: null });
   seedGuardianTokenFromSiblingEnvMock.mockReset();
   seedGuardianTokenFromSiblingEnvMock.mockReturnValue(false);
   loadGuardianTokenMock.mockReset();
@@ -291,4 +302,27 @@ describe("vellum wake", () => {
       "generated-bootstrap-secret",
     );
   });
+
+  test("relaunches CES sibling when daemon is healthy but CES is dead", async () => {
+    // Daemon is healthy (default mock) but CES pid says dead.
+    // isProcessAliveMock defaults to { alive: false }.
+    await wake();
+
+    // startCes should be called to relaunch the dead sibling.
+    expect(startCesMock).toHaveBeenCalledTimes(1);
+    // startLocalDaemon should NOT be called (daemon already running).
+    expect(startLocalDaemonMock).not.toHaveBeenCalled();
+  });
+
+  test("does NOT relaunch CES sibling when both daemon and CES are healthy", async () => {
+    // Daemon is healthy (default mock). CES is also alive.
+    isProcessAliveMock.mockReturnValue({ alive: true, pid: 789 });
+
+    await wake();
+
+    // startCes should NOT be called (CES is alive).
+    expect(startCesMock).not.toHaveBeenCalled();
+    // startLocalDaemon should NOT be called (daemon already running).
+    expect(startLocalDaemonMock).not.toHaveBeenCalled();
+  });
 });

package/src/commands/hatch.ts

@@ -146,7 +146,7 @@ ${userSetup}
 ${envSetLines}
 VELLUM_ASSISTANT_NAME=${instanceName}
 mkdir -p "\$HOME/.config/vellum"
-cat > "\$HOME/.config/vellum/env" << DOTENV_EOF
+cat > "\$HOME/.config/vellum/.env" << DOTENV_EOF
 ${dotenvLines}
 RUNTIME_HTTP_PORT=7821
 DOTENV_EOF

package/src/commands/recover.ts

@@ -12,6 +12,7 @@ import { saveAssistantEntry } from "../lib/assistant-config";
 import type { AssistantEntry } from "../lib/assistant-config";
 import {
   generateLocalSigningKey,
+  startCes,
   startLocalDaemon,
   startGateway,
 } from "../lib/local";
@@ -117,9 +118,14 @@ export async function recover(): Promise<void> {
   entry.guardianBootstrapSecret = bootstrapSecret;
   saveAssistantEntry(entry);
 
-  // 8. Start daemon + gateway
-  await startLocalDaemon(false, entry.resources, { signingKey });
-  await startGateway(false, entry.resources, { signingKey, bootstrapSecret });
+  // 8. Start CES sibling (opt-in) + daemon + gateway in parallel, the way the
+  // Docker topology brings its sibling processes up together. startCes is a
+  // no-op unless CES_STANDALONE is set.
+  await Promise.all([
+    startCes(false, entry.resources),
+    startLocalDaemon(false, entry.resources, { signingKey }),
+    startGateway(false, entry.resources, { signingKey, bootstrapSecret }),
+  ]);
 
   console.log(`✅ Recovered assistant '${name}'.`);
 }

package/src/commands/sleep.ts

@@ -168,6 +168,18 @@ export async function sleep(): Promise<void> {
     console.log("Gateway stopped.");
   }
 
+  // Stop the CES sibling if one was launched (CES_STANDALONE). No-op when the
+  // PID file is absent — on the default topology the assistant owns CES as an
+  // stdio child and it exits with the daemon.
+  const cesPidFile = join(vellumDir, "ces.pid");
+  const cesStopped = await stopProcessByPidFile(
+    cesPidFile,
+    "credential-executor",
+  );
+  if (cesStopped) {
+    console.log("credential-executor stopped.");
+  }
+
   // Stop the nginx ingress if one is fronting this gateway — otherwise it
   // keeps running against a dead upstream and serves 502s.
   const ingressStopped = await stopIngressNginx(join(vellumDir, "workspace"));

package/src/commands/upgrade.ts

@@ -66,6 +66,7 @@ import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 import {
   generateLocalSigningKey,
   ensureLocalRuntime,
+  startCes,
   startGateway,
   startLocalDaemon,
   stopLocalProcesses,
@@ -434,7 +435,8 @@ async function upgradeDocker(
   }
 
   // Recover the assistant host port from the entry, fall back to default.
-  const assistantPort = entry.containerInfo?.assistantPort ?? ASSISTANT_INTERNAL_PORT;
+  const assistantPort =
+    entry.containerInfo?.assistantPort ?? ASSISTANT_INTERNAL_PORT;
 
   // Create pre-upgrade backup (best-effort, daemon must be running)
   await broadcastUpgradeEvent(
@@ -984,8 +986,14 @@ async function upgradeLocal(
   const previousAppVersion = process.env.APP_VERSION;
   process.env.APP_VERSION = stripVersionPrefix(targetVersion);
   try {
-    await startLocalDaemon(false, entry.resources, { signingKey });
-    await startGateway(false, entry.resources, { signingKey, bootstrapSecret });
+    // Bring CES, daemon, and gateway up in parallel, the way the Docker
+    // topology starts its sibling processes together. startCes is a no-op
+    // unless CES_STANDALONE is set.
+    await Promise.all([
+      startCes(false, entry.resources),
+      startLocalDaemon(false, entry.resources, { signingKey }),
+      startGateway(false, entry.resources, { signingKey, bootstrapSecret }),
+    ]);
   } finally {
     if (previousAppVersion === undefined) {
       delete process.env.APP_VERSION;