[Bug]: Disabling agent device access reports success when daemon shutdown fails #35639

#!/bin/sh
set -u
checkout=${1:?pass checkout path}
scratch=$(mktemp -d)
testfile="$checkout/apps/server/src/device/StopDaemon.x04-01.test.ts"
cleanup() { rm -f "$testfile"; rm -rf "$scratch"; }
if test -e "$testfile"; then
  printf 'RESULT: inconclusive\n'
  exit 2
fi
trap cleanup EXIT HUP INT TERM
mkdir -p "$scratch/home" "$scratch/tmp" "$scratch/state"
export HOME="$scratch/home" TMPDIR="$scratch/tmp" T3CODE_HOME="$scratch/state"
printf 'node: '; node --version
printf 'vp: '; vp --version
cat > "$testfile" <<'EOF'
import { it } from "@effect/vitest";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as FileSystem from "effect/FileSystem";
import * as Sink from "effect/Sink";
import * as Stream from "effect/Stream";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
import { HttpClient, HttpClientResponse } from "effect/http";
import * as NetService from "@t3tools/shared/Net";
import * as ServerConfig from "../config.ts";
import * as ProcessRunner from "../processRunner.ts";
import * as LocalDeviceHost from "./LocalDeviceHost.ts";
import { AGENT_DEVICE_VERSION, DEVICE_HUB_VERSION, agentDeviceStateDir } from "./DeviceToolchain.ts";

const output = (code: number) => ({
  code: ChildProcessSpawner.ExitCode(code), stdout: "", stderr: "", timedOut: false,
  stdoutTruncated: false, stderrTruncated: false,
  stdoutInvalidUtf8: false, stderrInvalidUtf8: false,
});

it.effect("x04-01 reports a daemon stop command that fails", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-x04-01-" });
    const stateDir = agentDeviceStateDir(path, path.join(baseDir, "userdata"));
    const daemonFile = path.join(stateDir, "daemon.json");
    const runs: Array<ProcessRunner.ProcessRunInput> = [];
    let stopCode = 0;
    for (const [name, version, entry] of [
      ["expo-device-hub", DEVICE_HUB_VERSION, "dist/server/cli.mjs"],
      ["agent-device", AGENT_DEVICE_VERSION, "bin/agent-device.mjs"],
    ]) {
      const dir = path.join(baseDir, "tools", name!, version!);
      const file = path.join(dir, "node_modules", name!, entry!);
      yield* fs.makeDirectory(path.dirname(file), { recursive: true });
      yield* fs.writeFileString(file, "");
      yield* fs.writeFileString(path.join(dir, ".install-complete"), version!);
    }
    yield* fs.makeDirectory(stateDir, { recursive: true });
    yield* fs.writeFileString(daemonFile, JSON.stringify({
      httpPort: 12345, token: "fixture-token", pid: process.pid, version: AGENT_DEVICE_VERSION,
    }));
    const host = yield* LocalDeviceHost.make().pipe(
      Effect.provide(Layer.mergeAll(ServerConfig.layerTest(baseDir, baseDir), NetService.layer)),
      Effect.provideService(HostProcess.Environment, { HOME: baseDir, PATH: "" }),
      Effect.provideService(HostProcess.IsExecutable, false),
      Effect.provideService(HostProcess.Platform, "darwin"),
      Effect.provideService(ChildProcessSpawner.ChildProcessSpawner,
        ChildProcessSpawner.make(() => Effect.succeed(ChildProcessSpawner.makeHandle({
          pid: ChildProcessSpawner.ProcessId(123), stdout: Stream.empty, stderr: Stream.empty,
          all: Stream.empty, exitCode: Effect.never, isRunning: Effect.succeed(true),
          kill: () => Effect.void, stdin: Sink.drain, getInputFd: () => Sink.drain,
          getOutputFd: () => Stream.empty, unref: Effect.succeed(Effect.void),
        }))),
      ),
      Effect.provideService(ProcessRunner.ProcessRunner, {
        run: (input) => {
          runs.push(input);
          if (!input.args.includes("daemon")) return Effect.succeed(output(0));
          return Effect.gen(function* () {
            if (stopCode === 0) yield* fs.remove(daemonFile, { force: true });
            return output(stopCode);
          });
        },
      }),
      Effect.provideService(HttpClient.HttpClient, HttpClient.make((request) =>
        Effect.succeed(HttpClientResponse.fromWeb(request, new Response("ok", { status: 200 }))),
      )),
    );
    yield* host.ensureReady(() => Effect.void);
    const control = yield* host.stopAgent.pipe(Effect.result);
    if (control._tag !== "Success" || (yield* fs.exists(daemonFile))) {
      throw new Error("INCONCLUSIVE_SUCCESSFUL_STOP_CONTROL");
    }
    yield* fs.writeFileString(daemonFile, JSON.stringify({
      httpPort: 12345, token: "fixture-token", pid: process.pid, version: AGENT_DEVICE_VERSION,
    }));
    stopCode = 1;
    const result = yield* host.stopAgent.pipe(Effect.result);
    if (!runs.some((run) => run.args.includes("daemon") && run.args.includes("stop"))) {
      throw new Error("INCONCLUSIVE_NO_STOP_COMMAND");
    }
    if (result._tag === "Success" && (yield* fs.exists(daemonFile))) {
      throw new Error("DEFECT_REPRODUCED: failed daemon stop reported success with daemon record intact");
    }
  }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
);
EOF
cd "$checkout" || { printf 'RESULT: inconclusive\n'; exit 2; }
vp test run apps/server/src/device/StopDaemon.x04-01.test.ts > "$scratch/output" 2>&1
test_status=$?
cat "$scratch/output"
if test "$test_status" -eq 0; then
  printf 'RESULT: expected behavior\n'
  exit 0
fi
if grep -q 'DEFECT_REPRODUCED: failed daemon stop reported success with daemon record intact' "$scratch/output"; then
  printf 'RESULT: defect reproduced\n'
  exit 1
fi
printf 'RESULT: inconclusive\n'
exit 2