Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Improve idiomatic Effect usage in config and Tailscale paths (#3073)

cursor[bot]a4446e263d77
diff --git a/apps/server/src/vcs/VcsProjectConfig.test.ts b/apps/server/src/vcs/VcsProjectConfig.test.ts
index aac4beb7e..b4977173b 100644
--- a/apps/server/src/vcs/VcsProjectConfig.test.ts
+++ b/apps/server/src/vcs/VcsProjectConfig.test.ts
@@ -67,4 +67,47 @@ describe("VcsProjectConfig", () => {
}),
);
});
+
+ it.layer(TestLayer)("falls back to auto when config JSON is malformed", (it) => {
+ it.effect("returns auto", () =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const root = yield* fileSystem.makeTempDirectoryScoped({
+ prefix: "t3-vcs-config-test-",
+ });
+ const configDir = path.join(root, ".t3code");
+ yield* fileSystem.makeDirectory(configDir, { recursive: true });
+ yield* fileSystem.writeFileString(path.join(configDir, "vcs.json"), "{not json");
+
+ const config = yield* VcsProjectConfig.VcsProjectConfig;
+ const kind = yield* config.resolveKind({ cwd: root });
+
+ assert.equal(kind, "auto");
+ }),
+ );
+ });
+
+ it.layer(TestLayer)("falls back to auto when config kind is invalid", (it) => {
+ it.effect("returns auto", () =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const root = yield* fileSystem.makeTempDirectoryScoped({
+ prefix: "t3-vcs-config-test-",
+ });
+ const configDir = path.join(root, ".t3code");
+ yield* fileSystem.makeDirectory(configDir, { recursive: true });
+ yield* fileSystem.writeFileString(
+ path.join(configDir, "vcs.json"),
+ `{"vcs":{"kind":"svn"}}`,
+ );
+
+ const config = yield* VcsProjectConfig.VcsProjectConfig;
+ const kind = yield* config.resolveKind({ cwd: root });
+
+ assert.equal(kind, "auto");
+ }),
+ );
+ });
});
diff --git a/apps/server/src/vcs/VcsProjectConfig.ts b/apps/server/src/vcs/VcsProjectConfig.ts
index 3e5ee2347..10ecfa7fd 100644
--- a/apps/server/src/vcs/VcsProjectConfig.ts
+++ b/apps/server/src/vcs/VcsProjectConfig.ts
@@ -2,10 +2,12 @@ import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import { VcsDriverKind, type VcsDriverKind as VcsDriverKindType } from "@t3tools/contracts";
+import { fromLenientJson } from "@t3tools/shared/schemaJson";
const ProjectVcsConfig = Schema.Struct({
vcs: Schema.optional(
@@ -15,16 +17,10 @@ const ProjectVcsConfig = Schema.Struct({
),
vcsKind: Schema.optional(VcsDriverKind),
});
-const isProjectVcsConfig = Schema.is(ProjectVcsConfig);
+const ProjectVcsConfigJson = fromLenientJson(ProjectVcsConfig);
+const decodeProjectVcsConfigJson = Schema.decodeUnknownOption(ProjectVcsConfigJson);
-interface ProjectVcsConfigFile {
- readonly vcs?:
- | {
- readonly kind?: VcsDriverKindType | undefined;
- }
- | undefined;
- readonly vcsKind?: VcsDriverKindType | undefined;
-}
+type ProjectVcsConfigFile = typeof ProjectVcsConfig.Type;
export interface VcsProjectConfigResolveInput {
readonly cwd: string;
@@ -45,14 +41,8 @@ function configuredKind(config: ProjectVcsConfigFile): VcsDriverKindType | "auto
return config.vcs?.kind ?? config.vcsKind ?? "auto";
}
-function parseConfig(raw: string): ProjectVcsConfigFile | null {
- try {
- const parsed = JSON.parse(raw) as unknown;
- return isProjectVcsConfig(parsed) ? parsed : null;
- } catch {
- return null;
- }
-}
+const parseConfig = (raw: string): Option.Option<ProjectVcsConfigFile> =>
+ decodeProjectVcsConfigJson(raw);
export const make = Effect.fn("makeVcsProjectConfig")(function* () {
const fileSystem = yield* FileSystem.FileSystem;
@@ -63,12 +53,12 @@ export const make = Effect.fn("makeVcsProjectConfig")(function* () {
while (true) {
const candidate = path.join(current, ".t3code", "vcs.json");
if (yield* fileSystem.exists(candidate).pipe(Effect.orElseSucceed(() => false))) {
- return candidate;
+ return Option.some(candidate);
}
const parent = path.dirname(current);
if (parent === current) {
- return null;
+ return Option.none();
}
current = parent;
}
@@ -78,26 +68,27 @@ export const make = Effect.fn("makeVcsProjectConfig")(function* () {
configPath: string,
) {
const raw = yield* fileSystem.readFileString(configPath).pipe(
+ Effect.map(Option.some),
Effect.catch((error) =>
Effect.logWarning("failed to read VCS project config", {
configPath,
error,
- }).pipe(Effect.as(null)),
+ }).pipe(Effect.as(Option.none())),
),
);
- if (raw === null) {
+ if (Option.isNone(raw)) {
return "auto" as const;
}
- const parsed = parseConfig(raw);
- if (parsed === null) {
+ const parsed = parseConfig(raw.value);
+ if (Option.isNone(parsed)) {
yield* Effect.logWarning("invalid VCS project config", {
configPath,
});
return "auto" as const;
}
- return configuredKind(parsed);
+ return configuredKind(parsed.value);
});
const resolveKind: VcsProjectConfigShape["resolveKind"] = Effect.fn(
@@ -108,11 +99,10 @@ export const make = Effect.fn("makeVcsProjectConfig")(function* () {
}
const configPath = yield* findConfigPath(input.cwd);
- if (configPath === null) {
- return "auto";
- }
-
- return yield* readConfiguredKind(configPath);
+ return yield* Option.match(configPath, {
+ onNone: () => Effect.succeed("auto" as const),
+ onSome: readConfiguredKind,
+ });
});
return VcsProjectConfig.of({
diff --git a/packages/tailscale/src/tailscale.test.ts b/packages/tailscale/src/tailscale.test.ts
index dd2b1772f..f1d47ad9d 100644
--- a/packages/tailscale/src/tailscale.test.ts
+++ b/packages/tailscale/src/tailscale.test.ts
@@ -1,8 +1,10 @@
import { assert, describe, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Sink from "effect/Sink";
import * as Stream from "effect/Stream";
+import * as TestClock from "effect/testing/TestClock";
import { ChildProcessSpawner } from "effect/unstable/process";
import {
@@ -13,6 +15,7 @@ import {
parseTailscaleMagicDnsName,
parseTailscaleStatus,
readTailscaleStatus,
+ TAILSCALE_STATUS_TIMEOUT,
} from "./tailscale.ts";
const encoder = new TextEncoder();
@@ -35,6 +38,22 @@ function mockHandle(result: { stdout?: string; stderr?: string; code?: number })
});
}
+function neverFinishingMockHandle() {
+ return ChildProcessSpawner.makeHandle({
+ pid: ChildProcessSpawner.ProcessId(1),
+ exitCode: Effect.never,
+ isRunning: Effect.succeed(true),
+ kill: () => Effect.void,
+ unref: Effect.succeed(Effect.void),
+ stdin: Sink.drain,
+ stdout: Stream.empty,
+ stderr: Stream.empty,
+ all: Stream.empty,
+ getInputFd: () => Sink.drain,
+ getOutputFd: () => Stream.empty,
+ });
+}
+
function mockSpawnerLayer(
handler: (
command: string,
@@ -112,6 +131,29 @@ describe("tailscale", () => {
});
});
+ it.effect("times out tailscale status through TestClock", () => {
+ const layer = Layer.merge(
+ TestClock.layer(),
+ Layer.succeed(
+ ChildProcessSpawner.ChildProcessSpawner,
+ ChildProcessSpawner.make(() => Effect.succeed(neverFinishingMockHandle())),
+ ),
+ );
+
+ return Effect.gen(function* () {
+ const fiber = yield* readTailscaleStatus.pipe(Effect.flip, Effect.forkScoped);
+ yield* Effect.yieldNow;
+ yield* TestClock.adjust(TAILSCALE_STATUS_TIMEOUT);
+ const error = yield* Fiber.join(fiber);
+
+ if (error._tag !== "TailscaleCommandError") {
+ assert.fail(`Expected TailscaleCommandError, received ${error._tag}.`);
+ }
+ assert.equal(error.message, "Tailscale status timed out.");
+ assert.equal(error.exitCode, null);
+ }).pipe(Effect.provide(layer));
+ });
+
it.effect("configures tailscale serve through the process spawner service", () => {
const layer = mockSpawnerLayer((command, args) => {
assert.equal(command, "tailscale");
diff --git a/packages/tailscale/src/tailscale.ts b/packages/tailscale/src/tailscale.ts
index e0cca8fde..c35b2ae03 100644
--- a/packages/tailscale/src/tailscale.ts
+++ b/packages/tailscale/src/tailscale.ts
@@ -1,5 +1,6 @@
import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
@@ -8,9 +9,9 @@ import { HttpClient, HttpClientRequest } from "effect/unstable/http";
import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
export const DEFAULT_TAILSCALE_SERVE_PORT = 443;
-export const TAILSCALE_STATUS_TIMEOUT_MS = 1_500;
-export const TAILSCALE_SERVE_TIMEOUT_MS = 10_000;
-export const TAILSCALE_PROBE_TIMEOUT_MS = 2_500;
+export const TAILSCALE_STATUS_TIMEOUT = Duration.millis(1_500);
+export const TAILSCALE_SERVE_TIMEOUT = Duration.seconds(10);
+export const TAILSCALE_PROBE_TIMEOUT = Duration.millis(2_500);
// tailscale is a real executable everywhere (`tailscale.exe` on Windows), so
// it is always spawned directly rather than through cmd.exe shell mode.
@@ -180,7 +181,7 @@ export const readTailscaleStatus: Effect.Effect<
return yield* parseTailscaleStatus(stdout);
}).pipe(
Effect.scoped,
- Effect.timeoutOption(TAILSCALE_STATUS_TIMEOUT_MS),
+ Effect.timeoutOption(TAILSCALE_STATUS_TIMEOUT),
Effect.flatMap((result) =>
Option.match(result, {
onNone: () =>
@@ -212,7 +213,7 @@ const runTailscaleCommand = (
readonly runMessage: string;
readonly exitMessage: (exitCode: number) => string;
readonly timeoutMessage: string;
- readonly timeoutMs: number;
+ readonly timeout: Duration.Input;
},
): Effect.Effect<void, TailscaleCommandError, ChildProcessSpawner.ChildProcessSpawner> =>
Effect.gen(function* () {
@@ -246,7 +247,7 @@ const runTailscaleCommand = (
}
}).pipe(
Effect.scoped,
- Effect.timeoutOption(input.timeoutMs),
+ Effect.timeoutOption(input.timeout),
Effect.flatMap((result) =>
Option.match(result, {
onNone: () => Effect.fail(tailscaleCommandError(args, input.timeoutMessage, null)),
@@ -268,7 +269,7 @@ export const ensureTailscaleServe = (input: {
runMessage: "Failed to run tailscale serve.",
exitMessage: (exitCode) => `Tailscale serve exited with code ${exitCode}.`,
timeoutMessage: "Tailscale serve timed out.",
- timeoutMs: TAILSCALE_SERVE_TIMEOUT_MS,
+ timeout: TAILSCALE_SERVE_TIMEOUT,
});
};
@@ -284,13 +285,13 @@ export const disableTailscaleServe = (
runMessage: "Failed to run tailscale serve off.",
exitMessage: (exitCode) => `Tailscale serve off exited with code ${exitCode}.`,
timeoutMessage: "Tailscale serve off timed out.",
- timeoutMs: TAILSCALE_SERVE_TIMEOUT_MS,
+ timeout: TAILSCALE_SERVE_TIMEOUT,
});
});
export const probeTailscaleHttpsEndpoint = (input: {
readonly baseUrl: string;
- readonly timeoutMs?: number;
+ readonly timeout?: Duration.Input;
}): Effect.Effect<boolean, never, HttpClient.HttpClient> =>
Effect.gen(function* () {
const client = yield* HttpClient.HttpClient;
@@ -298,7 +299,7 @@ export const probeTailscaleHttpsEndpoint = (input: {
const url = new URL("/.well-known/t3/environment", input.baseUrl);
const request = HttpClientRequest.get(url.toString());
return yield* client.execute(request);
- }).pipe(Effect.timeoutOption(input.timeoutMs ?? TAILSCALE_PROBE_TIMEOUT_MS));
+ }).pipe(Effect.timeoutOption(input.timeout ?? TAILSCALE_PROBE_TIMEOUT));
return Option.match(response, {
onNone: () => false,