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.
import * as Predicate from "effect/Predicate";
import * as NodeAssert from "node:assert/strict";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as Stream from "effect/Stream";
import { beforeEach } from "vite-plus/test";
import { McpServerId, ProviderDriverKind, ProviderInstanceId } from "@akeru/contracts";
import { createModelSelection } from "@akeru/shared/model";
import { ServerConfig } from "../../config.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
import { withMcpRuntimeHeaders } from "../McpServerConfig.ts";
import { OpenCodeRuntime } from "../opencodeRuntime.ts";
import {
isOpenCodeNotFound,
isSameOpenCodeDirectory,
makeOpenCodeAdapter,
} from "./OpenCodeAdapter.ts";
import {
OpenCodeAdapter,
asThreadId,
providerSessionDirectoryTestLayer,
openCodeAdapterTestSettings,
makeOpenCodeAdapterHarness,
} from "./test-support/openCodeAdapterHarness.ts";
import { OPENCODE_PROVIDER_DEFAULT_VARIANT } from "./opencode/OpenCodeProtocol.ts";
const { runtimeMock, OpenCodeRuntimeTestDouble, OpenCodeAdapterTestLayer } =
makeOpenCodeAdapterHarness();
beforeEach(() => {
runtimeMock.reset();
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("reuses a configured OpenCode server URL instead of spawning a local server", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const session = yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId: asThreadId("thread-opencode"),
runtimeMode: "full-access",
});
NodeAssert.equal(session.provider, "opencode");
NodeAssert.equal(session.threadId, "thread-opencode");
NodeAssert.deepEqual(runtimeMock.state.startCalls, []);
NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
NodeAssert.deepEqual(runtimeMock.state.authHeaders, [
`Basic ${btoa("opencode:secret-password")}`,
]);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("returns a durable resume cursor for a freshly created session", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-opencode-cursor");
const session = yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
});
// Without a persisted cursor, a session is created and its id is
// surfaced as a resume cursor so the upper layer can persist it.
NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, []);
NodeAssert.deepEqual(session.resumeCursor, {
schemaVersion: 1,
sessionId: "http://127.0.0.1:9999/session",
});
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("forwards transient headers to remote MCP servers", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const mcpServer = withMcpRuntimeHeaders(
{
id: McpServerId.make("composio-session"),
name: "Composio",
transport: "url" as const,
url: "https://app.composio.dev/tool_router/v3/session/mcp",
enabled: true,
createdAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
},
{ "x-api-key": "project-key" },
);
const threadId = asThreadId("thread-opencode-composio");
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
mcpServers: [mcpServer],
});
NodeAssert.deepEqual(runtimeMock.state.mcpAddCalls, [
{
name: "composio-session",
config: {
type: "remote",
url: "https://app.composio.dev/tool_router/v3/session/mcp",
headers: { "x-api-key": "project-key" },
oauth: false,
},
},
]);
NodeAssert.equal("headers" in mcpServer, false);
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("resumes the persisted OpenCode session instead of creating a new one", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-opencode-resume");
const session = yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
resumeCursor: { schemaVersion: 1, sessionId: "ses_persisted" },
});
// The adapter validates the persisted id with session.get and re-adopts
// it — no new session is minted (issue #3604).
NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_persisted"]);
NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
NodeAssert.deepEqual(session.resumeCursor, {
schemaVersion: 1,
sessionId: "ses_persisted",
});
// Resume re-asserts the permission ruleset for the current runtimeMode.
NodeAssert.equal(runtimeMock.state.sessionUpdateCalls.length, 1);
NodeAssert.equal(runtimeMock.state.sessionUpdateCalls[0]?.sessionID, "ses_persisted");
NodeAssert.equal(runtimeMock.state.sessionUpdateCalls[0]?.permission != null, true);
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("sends follow-up turns to the resumed session id", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-opencode-resume-turn");
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
resumeCursor: { schemaVersion: 1, sessionId: "ses_persisted" },
});
const result = yield* adapter.sendTurn({
threadId,
input: "continue where we left off",
modelSelection: createModelSelection(
ProviderInstanceId.make("opencode"),
"anthropic/sonnet",
),
});
// The prompt targets the resumed id, and the turn re-surfaces the cursor.
NodeAssert.deepEqual(
(runtimeMock.state.promptCalls[0] as { sessionID: string }).sessionID,
"ses_persisted",
);
NodeAssert.deepEqual(result.resumeCursor, {
schemaVersion: 1,
sessionId: "ses_persisted",
});
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("falls back to a fresh session when the persisted session is gone", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-opencode-stale");
runtimeMock.state.missingSessionIds.add("ses_stale");
const session = yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
resumeCursor: { schemaVersion: 1, sessionId: "ses_stale" },
});
// get probed the stale id, found nothing, then created a new session and
// emitted a fresh cursor rather than wedging the thread.
NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_stale"]);
NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
NodeAssert.deepEqual(session.resumeCursor, {
schemaVersion: 1,
sessionId: "http://127.0.0.1:9999/session",
});
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("ignores a malformed or wrong-version resume cursor", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-opencode-badcursor");
const session = yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
resumeCursor: { schemaVersion: 99, sessionId: "ses_persisted" },
});
// A foreign/stale-shaped cursor is treated as "no resume": never probed,
// a fresh session is created.
NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, []);
NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
NodeAssert.deepEqual(session.resumeCursor, {
schemaVersion: 1,
sessionId: "http://127.0.0.1:9999/session",
});
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("reuses the resumed session when the stored directory differs only lexically", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-opencode-samedir");
// Same working tree, different spelling (trailing slash) — must reuse,
// not fork.
runtimeMock.state.sessionDirectoryById.set("ses_samedir", `${process.cwd()}/`);
const session = yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
resumeCursor: { schemaVersion: 1, sessionId: "ses_samedir" },
});
NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_samedir"]);
NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
NodeAssert.deepEqual(runtimeMock.state.forkCalls, []);
NodeAssert.deepEqual(session.resumeCursor, {
schemaVersion: 1,
sessionId: "ses_samedir",
});
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("rolls back session state when sendTurn fails before OpenCode accepts the prompt", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId: asThreadId("thread-send-turn-failure"),
runtimeMode: "full-access",
});
runtimeMock.state.promptAsyncError = new Error("prompt failed");
const error = yield* adapter
.sendTurn({
threadId: asThreadId("thread-send-turn-failure"),
input: "Fix it",
modelSelection: {
instanceId: ProviderInstanceId.make("opencode"),
model: "openai/gpt-5",
},
})
.pipe(Effect.flip);
const sessions = yield* adapter.listSessions();
NodeAssert.equal(error._tag, "ProviderAdapterRequestError");
if (!Predicate.isTagged(error, "ProviderAdapterRequestError")) {
throw new Error("Unexpected error type");
}
NodeAssert.equal(error.detail, "prompt failed");
NodeAssert.equal(
error.message,
"Provider adapter request failed (opencode) for session.promptAsync: prompt failed",
);
NodeAssert.equal(sessions.length, 1);
NodeAssert.equal(sessions[0]?.status, "ready");
NodeAssert.equal(sessions[0]?.activeTurnId, undefined);
NodeAssert.equal(sessions[0]?.lastError, "prompt failed");
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("steers a running turn instead of opening a new one on mid-turn sendTurn", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-steer");
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
});
const turn = yield* adapter.sendTurn({
threadId,
input: "run 5 commands",
modelSelection: {
instanceId: ProviderInstanceId.make("opencode"),
model: "openai/gpt-5",
},
});
// Steer: OpenCode queues the prompt into the busy session, so the
// active turn id is reused instead of opening a new turn.
const steeredTurn = yield* adapter.sendTurn({
threadId,
input: "actually run 15",
modelSelection: {
instanceId: ProviderInstanceId.make("opencode"),
model: "openai/gpt-5",
},
});
NodeAssert.equal(String(steeredTurn.turnId), String(turn.turnId));
const sessions = yield* adapter.listSessions();
const session = sessions.find((entry) => entry.threadId === threadId);
NodeAssert.equal(session?.status, "running");
NodeAssert.equal(String(session?.activeTurnId), String(turn.turnId));
NodeAssert.equal(runtimeMock.state.promptCalls.length, 2);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("keeps the running turn when a steer prompt fails", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-steer-failure");
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
});
const turn = yield* adapter.sendTurn({
threadId,
input: "run 5 commands",
modelSelection: {
instanceId: ProviderInstanceId.make("opencode"),
model: "openai/gpt-5",
},
});
runtimeMock.state.promptAsyncError = new Error("steer failed");
const error = yield* adapter
.sendTurn({
threadId,
input: "actually run 15",
modelSelection: {
instanceId: ProviderInstanceId.make("opencode"),
model: "openai/gpt-5",
},
})
.pipe(Effect.flip);
// The original turn keeps running — only the steer prompt failed.
NodeAssert.equal(error._tag, "ProviderAdapterRequestError");
const sessions = yield* adapter.listSessions();
const session = sessions.find((entry) => entry.threadId === threadId);
NodeAssert.equal(session?.status, "running");
NodeAssert.equal(String(session?.activeTurnId), String(turn.turnId));
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("passes agent and variant options for the adapter's bound custom instance id", () => {
const instanceId = ProviderInstanceId.make("opencode_zen");
const adapterLayer = Layer.effect(
OpenCodeAdapter,
makeOpenCodeAdapter(openCodeAdapterTestSettings, { instanceId }),
).pipe(
Layer.provideMerge(Layer.succeed(OpenCodeRuntime, OpenCodeRuntimeTestDouble)),
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
Layer.provideMerge(ServerSettingsService.layerTest()),
Layer.provideMerge(providerSessionDirectoryTestLayer),
Layer.provideMerge(NodeServices.layer),
);
return Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId: asThreadId("thread-custom-instance"),
runtimeMode: "full-access",
});
yield* adapter.sendTurn({
threadId: asThreadId("thread-custom-instance"),
input: "Fix it",
modelSelection: createModelSelection(
ProviderInstanceId.make("opencode_zen"),
"anthropic/claude-sonnet-4-5",
[
{ id: "agent", value: "github-copilot" },
{ id: "variant", value: "high" },
],
),
});
NodeAssert.deepEqual(runtimeMock.state.promptCalls.at(-1), {
sessionID: "http://127.0.0.1:9999/session",
model: {
providerID: "anthropic",
modelID: "claude-sonnet-4-5",
},
agent: "github-copilot",
variant: "high",
parts: [{ type: "text", text: "Fix it" }],
});
yield* adapter.sendTurn({
threadId: asThreadId("thread-custom-instance"),
input: "Again",
modelSelection: createModelSelection(
ProviderInstanceId.make("opencode_zen"),
"anthropic/claude-sonnet-4-5",
[{ id: "variant", value: OPENCODE_PROVIDER_DEFAULT_VARIANT }],
),
});
NodeAssert.deepEqual(runtimeMock.state.promptCalls.at(-1), {
sessionID: "http://127.0.0.1:9999/session",
model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
parts: [{ type: "text", text: "Again" }],
});
yield* adapter.sendTurn({
threadId: asThreadId("thread-custom-instance"),
input: "Once more",
modelSelection: createModelSelection(
ProviderInstanceId.make("opencode_zen"),
"anthropic/claude-sonnet-4-5",
[{ id: "variant", value: "default" }],
),
});
NodeAssert.deepEqual(runtimeMock.state.promptCalls.at(-1), {
sessionID: "http://127.0.0.1:9999/session",
model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
variant: "default",
parts: [{ type: "text", text: "Once more" }],
});
}).pipe(Effect.provide(adapterLayer));
});
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("uses the bound custom instance id for fallback sendTurn model selection", () => {
const instanceId = ProviderInstanceId.make("opencode_zen");
const adapterLayer = Layer.effect(
OpenCodeAdapter,
makeOpenCodeAdapter(openCodeAdapterTestSettings, { instanceId }),
).pipe(
Layer.provideMerge(Layer.succeed(OpenCodeRuntime, OpenCodeRuntimeTestDouble)),
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
Layer.provideMerge(ServerSettingsService.layerTest()),
Layer.provideMerge(providerSessionDirectoryTestLayer),
Layer.provideMerge(NodeServices.layer),
);
return Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-custom-instance-fallback-model");
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
modelSelection: createModelSelection(
ProviderInstanceId.make("opencode_zen"),
"anthropic/claude-sonnet-4-5",
),
});
yield* adapter.sendTurn({
threadId,
input: "Fix it",
});
NodeAssert.deepEqual(runtimeMock.state.promptCalls.at(-1), {
sessionID: "http://127.0.0.1:9999/session",
model: {
providerID: "anthropic",
modelID: "claude-sonnet-4-5",
},
parts: [{ type: "text", text: "Fix it" }],
});
}).pipe(Effect.provide(adapterLayer));
});
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("rejects sendTurn model selections for another instance id", () => {
const instanceId = ProviderInstanceId.make("opencode_zen");
const adapterLayer = Layer.effect(
OpenCodeAdapter,
makeOpenCodeAdapter(openCodeAdapterTestSettings, { instanceId }),
).pipe(
Layer.provideMerge(Layer.succeed(OpenCodeRuntime, OpenCodeRuntimeTestDouble)),
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
Layer.provideMerge(ServerSettingsService.layerTest()),
Layer.provideMerge(providerSessionDirectoryTestLayer),
Layer.provideMerge(NodeServices.layer),
);
return Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-custom-instance-wrong-selection");
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
});
const error = yield* adapter
.sendTurn({
threadId,
input: "Fix it",
modelSelection: createModelSelection(
ProviderInstanceId.make("opencode"),
"anthropic/claude-sonnet-4-5",
),
})
.pipe(Effect.flip);
NodeAssert.equal(error._tag, "ProviderAdapterValidationError");
if (!Predicate.isTagged(error, "ProviderAdapterValidationError")) {
throw new Error("Unexpected error type");
}
NodeAssert.equal(
error.issue,
"OpenCode model selection is bound to instance 'opencode', expected 'opencode_zen'.",
);
NodeAssert.deepEqual(runtimeMock.state.promptCalls, []);
}).pipe(Effect.provide(adapterLayer));
});
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("classifies a confirmed not-found across the shapes the SDK/runtime can produce", () =>
Effect.sync(() => {
// The real production shape: runOpenCodeSdk wraps the thrown Error
// (cause = { body, status }) under OpenCodeRuntimeError.
const wrappedError = new Error("Session not found: ses_x", {
cause: { body: { name: "NotFoundError" }, status: 404 },
});
NodeAssert.equal(
isOpenCodeNotFound({
_tag: "OpenCodeRuntimeError",
operation: "session.get",
detail: "Session not found: ses_x",
cause: wrappedError,
}),
true,
);
// 404 expressed only via response.status (the bot's flagged shape).
NodeAssert.equal(isOpenCodeNotFound({ cause: { response: { status: 404 } } }), true);
// 404 via a bare numeric status / statusCode.
NodeAssert.equal(isOpenCodeNotFound(new Error("x", { cause: { status: 404 } })), true);
NodeAssert.equal(isOpenCodeNotFound({ statusCode: 404 }), true);
// OpenCode NotFoundError body name with no status.
NodeAssert.equal(isOpenCodeNotFound({ body: { name: "NotFoundError" } }), true);
for (const tag of ["QuestionNotFoundError", "PermissionNotFoundError"]) {
const body = { _tag: tag, requestID: "req_missing", message: "Request not found" };
NodeAssert.equal(isOpenCodeNotFound(body), true);
NodeAssert.equal(isOpenCodeNotFound({ cause: body }), true);
NodeAssert.equal(isOpenCodeNotFound({ error: { data: body } }), true);
NodeAssert.equal(isOpenCodeNotFound({ status: 503, body }), false);
NodeAssert.equal(isOpenCodeNotFound({ ...body, statusCode: 500 }), false);
NodeAssert.equal(isOpenCodeNotFound({ response: { status: 401 }, cause: body }), false);
}
NodeAssert.equal(isOpenCodeNotFound({ _tag: "ProviderNotFoundError" }), false);
NodeAssert.equal(isOpenCodeNotFound({ _tag: "questionnotfounderror" }), false);
// NOT a miss: only structured signals count, never free text. A non-404
// error whose message/detail merely contains "not found" must propagate,
// not be misread as a missing session and silently start fresh.
NodeAssert.equal(
isOpenCodeNotFound(new Error("upstream provider not found", { cause: { status: 500 } })),
false,
);
NodeAssert.equal(isOpenCodeNotFound({ detail: "status=500 body={...not found...}" }), false);
// An explicit non-404 status seals its subtree: a 500 whose serialized
// body echoes a NotFoundError name — or that is itself named
// *NotFound* — is a real failure, never a miss.
NodeAssert.equal(isOpenCodeNotFound({ status: 500, body: { name: "NotFoundError" } }), false);
NodeAssert.equal(isOpenCodeNotFound({ name: "UpstreamNotFoundError", status: 500 }), false);
// A "NotFound"-flavored name that isn't OpenCode's exact `NotFoundError`
// is not a confirmed miss even without a sealing status.
NodeAssert.equal(isOpenCodeNotFound({ name: "UpstreamNotFoundError" }), false);
NodeAssert.equal(isOpenCodeNotFound({ cause: { name: "ProviderNotFoundError" } }), false);
NodeAssert.equal(
isOpenCodeNotFound(
new Error("x", { cause: { status: 502, body: { name: "NotFoundError" } } }),
),
false,
);
// Other transient/auth/network failures must propagate too.
NodeAssert.equal(isOpenCodeNotFound(new Error("boom", { cause: { status: 500 } })), false);
NodeAssert.equal(isOpenCodeNotFound({ cause: { response: { status: 401 } } }), false);
NodeAssert.equal(isOpenCodeNotFound(new Error("network error (no response)")), false);
NodeAssert.equal(isOpenCodeNotFound(undefined), false);
}),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("treats lexically or physically identical directories as the same", () =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const sameDirectory = (left: string, right: string) =>
isSameOpenCodeDirectory(fileSystem, path, left, right);
// Lexical-only differences (trailing slash, dot segments) short-circuit
// without touching the filesystem — the paths need not exist.
NodeAssert.equal(yield* sameDirectory("/repo/project/", "/repo/project"), true);
NodeAssert.equal(yield* sameDirectory("/repo/nested/../project", "/repo/project"), true);
// Nonexistent paths degrade to the lexical comparison instead of failing.
NodeAssert.equal(yield* sameDirectory("/repo/project", "/repo/other"), false);
// A symlinked cwd (the macOS `/tmp` → `/private/tmp` shape) resolves to
// the directory it points at, so the two spellings compare equal.
const base = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-opencode-dir-" });
const real = path.join(base, "real");
const link = path.join(base, "link");
yield* fileSystem.makeDirectory(real);
yield* fileSystem.symlink(real, link);
NodeAssert.equal(yield* sameDirectory(link, real), true);
NodeAssert.equal(yield* sameDirectory(link, path.join(base, "other")), false);
}).pipe(Effect.scoped),
);
});
it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
it.effect("lets OpenCode own session title generation and emits title metadata updates", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
const threadId = asThreadId("thread-opencode-title-sync");
runtimeMock.state.subscribedEvents = [
{
type: "session.updated",
properties: {
info: {
id: "http://127.0.0.1:9999/session",
title: "Investigate OpenCode title sync",
},
},
},
];
const eventsFiber = yield* adapter.streamEvents.pipe(
Stream.filter((event) => event.threadId === threadId),
Stream.take(3),
Stream.runCollect,
Effect.forkChild,
);
yield* adapter.startSession({
provider: ProviderDriverKind.make("opencode"),
threadId,
runtimeMode: "full-access",
});
const events = Array.from(yield* Fiber.join(eventsFiber).pipe(Effect.timeout("1 second")));
NodeAssert.equal(runtimeMock.state.sessionCreateInputs.length, 1);
NodeAssert.equal("title" in (runtimeMock.state.sessionCreateInputs[0] ?? {}), false);
const metadataUpdated = events.find((event) => event.type === "thread.metadata.updated");
NodeAssert.ok(metadataUpdated);
if (metadataUpdated.type === "thread.metadata.updated") {
NodeAssert.equal(metadataUpdated.payload.name, "Investigate OpenCode title sync");
}
}),
);
});