mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
274 lines
10 KiB
JavaScript
274 lines
10 KiB
JavaScript
#!/usr/bin/env node
|
|
// The app command of e2e.config.ts: starts the dev stack of the checkout it runs in on a fresh
|
|
// Hanzo home. e2e stops it with a signal, which ends the scope and the processes it started.
|
|
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
|
|
import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
|
|
import * as NodeServices from "@effect/platform-node/NodeServices";
|
|
import * as HostProcess from "@hanzodev/shared/HostProcess";
|
|
import * as NetService from "@hanzodev/shared/Net";
|
|
import * as Console from "effect/Console";
|
|
import * as Effect from "effect/Effect";
|
|
import * as FileSystem from "effect/FileSystem";
|
|
import * as Path from "effect/Path";
|
|
import * as SecureRandom from "effect/crypto/SecureRandom";
|
|
import * as Schedule from "effect/Schedule";
|
|
import * as Schema from "effect/Schema";
|
|
import * as Stream from "effect/Stream";
|
|
import { Argument, Command } from "effect/cli";
|
|
import { ChildProcess, ChildProcessSpawner } from "effect/process";
|
|
|
|
import { ScenarioError } from "./shell.ts";
|
|
|
|
// The dev runner's web port is 5733 plus an offset. Mirror of BASE_WEB_PORT in dev-runner.ts.
|
|
const BASE_WEB_PORT = 5733;
|
|
// The replay agent `vp run dev` registers: free, recorded turns through the real adapter.
|
|
const REPLAY = { instanceId: "devReplay", model: "showcase" };
|
|
// Generated text (titles) cannot go to the replay agent: the server swaps an ACP agent for the
|
|
// first enabled real provider, else its default, Codex. So every provider it could fall back to
|
|
// is off and Codex is a command that only fails: no run reaches a paid model.
|
|
// Mirror of TEXT_GENERATION_FALLBACK_DRIVERS in shared/serverSettings.
|
|
const REAL_PROVIDERS = [
|
|
"codex",
|
|
"claudeAgent",
|
|
"cursor",
|
|
"grok",
|
|
"muse",
|
|
"pi",
|
|
"opencode",
|
|
"antigravity",
|
|
];
|
|
|
|
// The server labels its environment with the host's name, probed through these commands.
|
|
// Captures must not depend on, or show, the machine that made them.
|
|
const HOST_LABEL_SHIM = `#!/bin/sh
|
|
case "$*" in
|
|
"--pretty" | "--get ComputerName") echo "Scenario" ;;
|
|
*) for real in /usr/bin /usr/sbin /bin; do
|
|
[ -x "$real/$(basename "$0")" ] && exec "$real/$(basename "$0")" "$@"
|
|
done
|
|
exit 127 ;;
|
|
esac
|
|
`;
|
|
|
|
const encodeSettings = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
|
|
|
|
export const prepareHome = Effect.fn("startApp.prepareHome")(function* (home: string) {
|
|
const fs = yield* FileSystem.FileSystem;
|
|
const path = yield* Path.Path;
|
|
yield* fs.remove(home, { recursive: true, force: true });
|
|
yield* fs.makeDirectory(path.join(home, "userdata"), { recursive: true });
|
|
yield* fs.makeDirectory(path.join(home, "bin"));
|
|
for (const command of ["hostnamectl", "scutil"]) {
|
|
const shim = path.join(home, "bin", command);
|
|
yield* fs.writeFileString(shim, HOST_LABEL_SHIM);
|
|
yield* fs.chmod(shim, 0o755);
|
|
}
|
|
// Editor discovery is cached, so the recording shim must exist before the server starts.
|
|
const editor = path.join(home, "bin", "cursor");
|
|
yield* fs.writeFileString(
|
|
editor,
|
|
`#!/bin/sh\nprintf '%s\\n' "$@" > "$(dirname "$0")/../editor-args.txt"\n`,
|
|
);
|
|
yield* fs.chmod(editor, 0o755);
|
|
const noModel = path.join(home, "bin/no-model");
|
|
yield* fs.writeFileString(noModel, "#!/bin/sh\necho 'scenarios run no model' >&2\nexit 1\n");
|
|
yield* fs.chmod(noModel, 0o755);
|
|
yield* fs.writeFileString(
|
|
path.join(home, "userdata/settings.json"),
|
|
yield* encodeSettings({
|
|
defaultModelSelection: REPLAY,
|
|
providerInstances: Object.fromEntries(
|
|
REAL_PROVIDERS.map((driver) => [
|
|
driver,
|
|
{
|
|
driver,
|
|
enabled: false,
|
|
...(driver === "codex" ? { config: { binaryPath: noModel } } : {}),
|
|
},
|
|
]),
|
|
),
|
|
}),
|
|
);
|
|
});
|
|
|
|
/** Starts a process in the caller's scope and hands each line it prints to `onLine`. */
|
|
export const start = Effect.fn("startApp.start")(function* (input: {
|
|
readonly cwd: string;
|
|
readonly command: string;
|
|
readonly args: ReadonlyArray<string>;
|
|
readonly env: NodeJS.ProcessEnv;
|
|
readonly onLine: (line: string) => Effect.Effect<void, never, FileSystem.FileSystem>;
|
|
}) {
|
|
const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
|
|
const child = yield* spawner.spawn(
|
|
ChildProcess.make(input.command, [...input.args], {
|
|
cwd: input.cwd,
|
|
env: input.env,
|
|
extendEnv: false,
|
|
stdin: "ignore",
|
|
stdout: "pipe",
|
|
stderr: "inherit",
|
|
forceKillAfter: "5 seconds",
|
|
}),
|
|
);
|
|
yield* child.stdout.pipe(
|
|
Stream.decodeText(),
|
|
Stream.splitLines,
|
|
Stream.runForEach(input.onLine),
|
|
Effect.ignore,
|
|
Effect.forkScoped,
|
|
);
|
|
return child;
|
|
});
|
|
|
|
const startApp = Effect.fn("startApp")(function* (input: {
|
|
readonly surface: "web" | "mobile";
|
|
readonly home: string;
|
|
readonly ports: ReadonlyArray<string>;
|
|
}) {
|
|
const fs = yield* FileSystem.FileSystem;
|
|
const path = yield* Path.Path;
|
|
const net = yield* NetService.NetService;
|
|
const node = yield* HostProcess.ExecutablePath;
|
|
const checkout = yield* HostProcess.WorkingDirectory;
|
|
const hostEnvironment = yield* HostProcess.Environment;
|
|
yield* prepareHome(input.home);
|
|
const env = {
|
|
...hostEnvironment,
|
|
PATH: `${path.join(input.home, "bin")}:${hostEnvironment.PATH ?? ""}`,
|
|
HANZO_DEV_AUTO_BOOTSTRAP_PROJECT_FROM_CWD: "0",
|
|
};
|
|
const devRunner = (mode: string, args: ReadonlyArray<string>) => [
|
|
"scripts/dev-runner.ts",
|
|
mode,
|
|
"--home-dir",
|
|
input.home,
|
|
"--no-seed",
|
|
...args,
|
|
];
|
|
|
|
if (input.surface === "web") {
|
|
// e2e opens the app at this host, so the web server is told to bind exactly it. Left to its
|
|
// default, `localhost`, it binds ::1 alone on machines that resolve the name to IPv6 first.
|
|
const [host = "", webPort = ""] = input.ports;
|
|
const origin = `http://${host}:${webPort}`;
|
|
const serverPort = String(yield* net.reserveLoopbackPort());
|
|
const token = yield* (yield* SecureRandom.SecureRandom).uuidV4();
|
|
const ports = ["--port", serverPort, "--dev-url", origin];
|
|
const webEnv = { ...env, HANZO_DEV_PORT_OFFSET: String(Number(webPort) - BASE_WEB_PORT) };
|
|
const server = yield* start({
|
|
cwd: checkout,
|
|
command: node,
|
|
args: devRunner("dev:server", ports),
|
|
env: {
|
|
...webEnv,
|
|
HANZO_DEV_DEV_ALLOWED_ORIGINS: origin,
|
|
// Makes the startup pairing link reusable, so every test can sign in with it.
|
|
HANZO_DEV_DEV_AUTH_TOKEN: `${token}${token}`.replaceAll("-", ""),
|
|
},
|
|
onLine: (line) => {
|
|
const url = /pairingUrl:\s*(\S+)/.exec(line)?.[1];
|
|
if (url === undefined) return Console.log(line);
|
|
// The link is a credential: it goes to a file the tests read, never to the log.
|
|
const { pathname, search, hash } = new URL(url);
|
|
return fs
|
|
.writeFileString(path.join(input.home, "pairing-path"), `${pathname}${search}${hash}`)
|
|
.pipe(Effect.ignore);
|
|
},
|
|
});
|
|
const web = yield* start({
|
|
cwd: checkout,
|
|
command: node,
|
|
args: devRunner("dev:web", [...ports, "--", "--host", host]),
|
|
env: webEnv,
|
|
onLine: Console.log,
|
|
});
|
|
// A web server that came up on another loopback address would leave e2e waiting out its
|
|
// whole startup timeout; say so at once instead.
|
|
const boundElsewhere = Effect.gen(function* () {
|
|
const elsewhere = host === "::1" ? "127.0.0.1" : "::1";
|
|
if (yield* net.hasListenerOnHost(Number(webPort), host)) return yield* Effect.never;
|
|
if (!(yield* net.hasListenerOnHost(Number(webPort), elsewhere))) {
|
|
return yield* new ScenarioError({ message: "The web server is not listening yet." });
|
|
}
|
|
yield* Console.error(
|
|
`The web server listens on ${elsewhere}:${webPort}, not on ${host}: it ignored --host.`,
|
|
);
|
|
return 1;
|
|
}).pipe(
|
|
Effect.retry({
|
|
schedule: Schedule.spaced("1 second"),
|
|
while: (error) => error._tag === "ScenarioError",
|
|
}),
|
|
);
|
|
return yield* Effect.raceAll([server.exitCode, web.exitCode, boundElsewhere]);
|
|
}
|
|
|
|
// The device is another machine: the server listens on every interface, and Metro serves the
|
|
// dev client its JavaScript. Tests mint their own pairing links, so the startup one is dropped.
|
|
const [serverPort = "", metroPort = "", host = ""] = input.ports;
|
|
const server = yield* start({
|
|
cwd: checkout,
|
|
command: node,
|
|
args: devRunner("dev:server", ["--host", "0.0.0.0", "--port", serverPort]),
|
|
env,
|
|
onLine: (line) => (line.includes("pairingUrl:") ? Effect.void : Console.log(line)),
|
|
});
|
|
yield* net.hasListenerOnHost(Number(serverPort), "127.0.0.1").pipe(
|
|
Effect.filterOrFail(
|
|
(listening) => listening,
|
|
() => new ScenarioError({ message: "The server is not listening yet." }),
|
|
),
|
|
Effect.retry({ schedule: Schedule.spaced("500 millis"), times: 600 }),
|
|
);
|
|
const metro = yield* start({
|
|
cwd: path.join(checkout, "apps/mobile"),
|
|
command: "npx",
|
|
args: ["expo", "start", "--dev-client", "--scheme", "hanzo-dev", "--lan", "--port", metroPort],
|
|
env: {
|
|
...env,
|
|
APP_VARIANT: "development",
|
|
CI: "1",
|
|
// Lazily fetched chunks sometimes arrive broken on pool devices.
|
|
EXPO_NO_METRO_LAZY: "1",
|
|
REACT_NATIVE_PACKAGER_HOSTNAME: host,
|
|
},
|
|
onLine: Console.log,
|
|
});
|
|
return yield* Effect.raceFirst(server.exitCode, metro.exitCode);
|
|
});
|
|
|
|
const command = Command.make(
|
|
"start-app",
|
|
{
|
|
surface: Argument.Literals("surface", ["web", "mobile"]).pipe(
|
|
Argument.withDescription(
|
|
"web: server and Vite. mobile: server on every interface and Metro.",
|
|
),
|
|
),
|
|
home: Argument.String("hanzo-home").pipe(Argument.withDescription("Hanzo home to recreate.")),
|
|
ports: Argument.String("port").pipe(
|
|
Argument.withDescription(
|
|
"web: <host> <web-port>. mobile: <server-port> <metro-port> <host>.",
|
|
),
|
|
Argument.variadic(),
|
|
),
|
|
},
|
|
(input) =>
|
|
startApp(input).pipe(
|
|
Effect.flatMap((exitCode) =>
|
|
Effect.sync(() => {
|
|
process.exitCode = Number(exitCode) || 1;
|
|
}),
|
|
),
|
|
),
|
|
);
|
|
|
|
if (import.meta.main) {
|
|
Command.run(command, { version: "0.0.0" }).pipe(
|
|
Effect.scoped,
|
|
Effect.provide([NodeServices.layer, NodeCrypto.layer, NetService.layer]),
|
|
NodeRuntime.runMain,
|
|
);
|
|
}
|