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 { ProviderInstanceRegistryMutator } from "./provider/Services/ProviderInstanceRegistryMutator.ts";
import { HostProcessEnvironment } from "@akeru/shared/hostProcess";
import { DEFAULT_SERVER_SETTINGS, type PreviewEvent } from "@akeru/contracts";
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 PubSub from "effect/PubSub";
import * as Stream from "effect/Stream";
import { ChildProcessSpawner } from "effect/unstable/process";
import { FetchHttpClient, HttpRouter } from "effect/unstable/http";
import * as BackgroundPolicy from "./background/BackgroundPolicy.ts";
import * as ServerConfig from "./config.ts";
import { routesLayer } from "./server.ts";
import * as CheckpointDiffQuery from "./checkpointing/CheckpointDiffQuery.ts";
import * as Keybindings from "./keybindings.ts";
import * as ExternalLauncher from "./process/externalLauncher.ts";
import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts";
import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";
import { ThreadDeletionReactor } from "./orchestration/Services/ThreadDeletionReactor.ts";
import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";
import { SqlitePersistenceMemory } from "./persistence/Layers/Sqlite.ts";
import { OrchestrationCommandReceiptRepository } from "./persistence/Services/OrchestrationCommandReceipts.ts";
import * as ProjectionBots from "./persistence/Services/ProjectionBots.ts";
import * as ProjectionGroups from "./persistence/Services/ProjectionGroups.ts";
import { EntityMemoryRepositoryLive } from "./memory/Layers/EntityMemoryRepository.ts";
import { MemoryRevisionWriteLockLive } from "./memory/Services/MemoryRevisionWriteLock.ts";
import {
EntityMemoryRepository,
type EntityMemoryRepositoryShape,
type EntityMemoryRepositoryError,
} from "./memory/Services/EntityMemoryRepository.ts";
import * as AgentController from "./provider/Services/AgentController.ts";
import * as ProviderRegistry from "./provider/Services/ProviderRegistry.ts";
import { manualOnlyProviderMaintenanceCapabilities } from "./provider/providerMaintenance.ts";
import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";
import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts";
import * as ServerSettings from "./serverSettings.ts";
import * as PreviewManager from "./preview/Manager.ts";
import * as PortScanner from "./preview/PortScanner.ts";
import * as BrowserTraceCollector from "./observability/BrowserTraceCollector.ts";
import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts";
import * as ServerEnvironment from "./environment/ServerEnvironment.ts";
import * as WorkspaceEntries from "./workspace/WorkspaceEntries.ts";
import * as WorkspaceFileSystem from "./workspace/WorkspaceFileSystem.ts";
import * as WorkspacePaths from "./workspace/WorkspacePaths.ts";
import * as GitVcsDriver from "./vcs/GitVcsDriver.ts";
import * as VcsDriver from "./vcs/VcsDriver.ts";
import * as VcsDriverRegistry from "./vcs/VcsDriverRegistry.ts";
import * as GitWorkflowService from "./git/GitWorkflowService.ts";
import * as ServerSecretStore from "./auth/ServerSecretStore.ts";
import * as ChannelDeliveryStore from "./channels/ChannelDeliveryStore.ts";
import * as ChannelRuntime from "./channels/ChannelRuntime.ts";
import * as ProcessDiagnostics from "./diagnostics/ProcessDiagnostics.ts";
import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts";
import * as TraceDiagnostics from "./diagnostics/TraceDiagnostics.ts";
import * as DesktopTelemetryReceiver from "./resourceTelemetry/DesktopTelemetryReceiver.ts";
import * as NativeTelemetryClient from "./resourceTelemetry/NativeTelemetryClient.ts";
import * as ResourceAttribution from "./resourceTelemetry/ResourceAttribution.ts";
import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts";
import * as UsageService from "./usage/UsageService.ts";
import { BotUsageLedger, type BotUsageLedgerShape } from "./usage/BotUsageLedger.ts";
import * as AnalyticsService from "./telemetry/AnalyticsService.ts";
import { RoutineRepository, type RoutineRepositoryShape } from "./routines/Repository.ts";
import { RoutineRuntime, type RoutineRuntimeShape } from "./routines/Runtime.ts";
import {
defaultDesktopBootstrapToken,
TEST_EPOCH,
defaultOrchestrationReadModel,
defaultThreadId,
testEnvironmentDescriptor,
} from "./serverTestFixtures.ts";
import { authTestLayer } from "./serverTestClients.ts";
export const buildAppUnderTest = (options?: {
durableMemory?: {
readonly seed?: (
repository: EntityMemoryRepositoryShape,
) => Effect.Effect<void, EntityMemoryRepositoryError, never>;
};
config?: Partial<ServerConfig.ServerConfig["Service"]>;
layers?: {
keybindings?: Partial<Keybindings.Keybindings["Service"]>;
providerRegistry?: Partial<ProviderRegistry.ProviderRegistry["Service"]>;
agentController?: Partial<AgentController.AgentController["Service"]>;
serverSettings?: Partial<ServerSettings.ServerSettingsService["Service"]>;
externalLauncher?: Partial<ExternalLauncher.ExternalLauncher["Service"]>;
vcsDriver?: Partial<VcsDriver.VcsDriver["Service"]>;
vcsDriverRegistry?: Partial<VcsDriverRegistry.VcsDriverRegistry["Service"]>;
gitVcsDriver?: Partial<GitVcsDriver.GitVcsDriver["Service"]>;
previewManager?: Partial<PreviewManager.PreviewManager["Service"]>;
orchestrationEngine?: Partial<OrchestrationEngine.OrchestrationEngineService["Service"]>;
commandReceipts?: Partial<OrchestrationCommandReceiptRepository["Service"]>;
threadDeletionReactor?: Partial<ThreadDeletionReactor["Service"]>;
routineRepository?: Partial<RoutineRepositoryShape>;
routineRuntime?: Partial<RoutineRuntimeShape>;
projectionSnapshotQuery?: Partial<ProjectionSnapshotQuery.ProjectionSnapshotQuery["Service"]>;
projectionBots?: Partial<ProjectionBots.ProjectionBotRepositoryShape>;
projectionGroups?: Partial<ProjectionGroups.ProjectionGroupRepositoryShape>;
botUsageLedger?: Partial<BotUsageLedgerShape>;
checkpointDiffQuery?: Partial<CheckpointDiffQuery.CheckpointDiffQuery["Service"]>;
browserTraceCollector?: Partial<BrowserTraceCollector.BrowserTraceCollector["Service"]>;
serverLifecycleEvents?: Partial<ServerLifecycleEvents.ServerLifecycleEvents["Service"]>;
serverRuntimeStartup?: Partial<ServerRuntimeStartup.ServerRuntimeStartup["Service"]>;
channelDeliveryStore?: ChannelDeliveryStore.ChannelDeliveryStoreShape | null;
channelRuntime?: Partial<ChannelRuntime.ChannelRuntimeShape> &
Pick<ChannelRuntime.ChannelRuntimeShape, "channelBindingsForRuntime">;
serverEnvironment?: Partial<ServerEnvironment.ServerEnvironment["Service"]>;
repositoryIdentityResolver?: Partial<
RepositoryIdentityResolver.RepositoryIdentityResolver["Service"]
>;
nativeTelemetryClient?: Partial<NativeTelemetryClient.NativeTelemetryClient["Service"]>;
desktopTelemetryReceiver?: Partial<
DesktopTelemetryReceiver.DesktopTelemetryReceiver["Service"]
>;
};
}) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const tempBaseDir = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-router-test-" });
const baseDir = options?.config?.baseDir ?? tempBaseDir;
const devUrl = options?.config?.devUrl;
const derivedPaths = yield* ServerConfig.deriveServerPaths(baseDir, devUrl);
const config: ServerConfig.ServerConfig["Service"] = {
logLevel: "Info",
traceMinLevel: "Info",
traceTimingEnabled: true,
traceBatchWindowMs: 200,
traceMaxBytes: 10 * 1024 * 1024,
traceMaxFiles: 10,
otlpTracesUrl: undefined,
otlpMetricsUrl: undefined,
otlpExportIntervalMs: 10_000,
otlpServiceName: "akeru-server",
mode: "desktop",
port: 0,
host: "127.0.0.1",
cwd: process.cwd(),
baseDir,
...derivedPaths,
staticDir: undefined,
devUrl,
devAllowedOrigins: [],
noBrowser: true,
startupPresentation: "browser",
desktopBootstrapToken: defaultDesktopBootstrapToken,
autoBootstrapProjectFromCwd: false,
logWebSocketEvents: false,
tailscaleServeEnabled: false,
tailscaleServePort: 443,
publicOrigin: undefined,
...options?.config,
};
const layerConfig = ServerConfig.layer(config);
const defaultVcsDriver: VcsDriver.VcsDriver["Service"] = {
capabilities: {
kind: "git",
supportsWorktrees: true,
supportsBookmarks: false,
supportsAtomicSnapshot: false,
supportsPushDefaultRemote: true,
ignoreClassifier: "native",
},
execute: () =>
Effect.succeed({
exitCode: ChildProcessSpawner.ExitCode(0),
stdout: "",
stderr: "",
stdoutTruncated: false,
stderrTruncated: false,
}),
detectRepository: () => Effect.succeed(null),
isInsideWorkTree: () => Effect.succeed(false),
listWorkspaceFiles: () =>
Effect.succeed({
paths: [],
truncated: false,
freshness: {
source: "live-local",
observedAt: TEST_EPOCH,
expiresAt: Option.none(),
},
}),
listRemotes: () =>
Effect.succeed({
remotes: [],
freshness: {
source: "live-local",
observedAt: TEST_EPOCH,
expiresAt: Option.none(),
},
}),
filterIgnoredPaths: (_cwd, relativePaths) => Effect.succeed(relativePaths),
initRepository: () => Effect.void,
...options?.layers?.vcsDriver,
};
const vcsDriverRegistryLayer = Layer.mock(VcsDriverRegistry.VcsDriverRegistry)({
get: () => Effect.succeed(defaultVcsDriver),
detect: (input) =>
defaultVcsDriver.detectRepository(input.cwd).pipe(
Effect.flatMap((repository) =>
repository
? Effect.succeed(repository)
: defaultVcsDriver.isInsideWorkTree(input.cwd).pipe(
Effect.map((isInsideWorkTree) =>
isInsideWorkTree
? {
kind: "git" as const,
rootPath: input.cwd,
metadataPath: null,
freshness: {
source: "live-local" as const,
observedAt: TEST_EPOCH,
expiresAt: Option.none(),
},
}
: null,
),
),
),
Effect.map((repository) =>
repository
? ({
kind: repository.kind,
repository,
driver: defaultVcsDriver,
} satisfies VcsDriverRegistry.VcsDriverHandle)
: null,
),
),
resolve: (input) =>
Effect.succeed({
kind:
input.requestedKind === "auto" || !input.requestedKind ? "git" : input.requestedKind,
repository: {
kind:
input.requestedKind === "auto" || !input.requestedKind ? "git" : input.requestedKind,
rootPath: input.cwd,
metadataPath: null,
freshness: {
source: "live-local",
observedAt: TEST_EPOCH,
expiresAt: Option.none(),
},
},
driver: defaultVcsDriver,
}),
...options?.layers?.vcsDriverRegistry,
});
const gitVcsDriverLayer = Layer.mock(GitVcsDriver.GitVcsDriver)({
...options?.layers?.gitVcsDriver,
});
const workspaceEntriesLayer = WorkspaceEntries.layer.pipe(
Layer.provide(WorkspacePaths.layer),
Layer.provideMerge(vcsDriverRegistryLayer),
);
const workspaceAndProjectServicesLayer = Layer.mergeAll(
WorkspacePaths.layer,
workspaceEntriesLayer,
WorkspaceFileSystem.layer.pipe(
Layer.provide(WorkspacePaths.layer),
Layer.provide(workspaceEntriesLayer),
),
);
const gitWorkflowLayer = GitWorkflowService.layer.pipe(
Layer.provideMerge(vcsDriverRegistryLayer),
Layer.provideMerge(gitVcsDriverLayer),
);
const resourceTelemetryLayer = ResourceTelemetry.layer.pipe(
Layer.provide(
Layer.mergeAll(
NativeTelemetryClient.layerTest(options?.layers?.nativeTelemetryClient),
DesktopTelemetryReceiver.layerTest(options?.layers?.desktopTelemetryReceiver),
ResourceAttribution.layer,
),
),
);
const serviceLauncherClientLayer = ServiceLauncherClient.layer.pipe(
Layer.provide(Layer.succeed(HostProcessEnvironment, {})),
);
const servedRoutesLayer = HttpRouter.serve(
routesLayer.pipe(Layer.provide(serviceLauncherClientLayer)),
{
disableListenLog: true,
disableLogger: true,
},
).pipe(
Layer.provide(
Layer.mock(Keybindings.Keybindings)({
loadConfigState: Effect.succeed({
keybindings: [],
issues: [],
}),
streamChanges: Stream.empty,
...options?.layers?.keybindings,
}),
),
Layer.provide(
Layer.mergeAll(
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
refresh: () => Effect.succeed([]),
refreshInstance: () => Effect.succeed([]),
getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider) =>
Effect.succeed(
manualOnlyProviderMaintenanceCapabilities({ provider, packageName: null }),
),
setProviderMaintenanceActionState: () => Effect.succeed([]),
streamChanges: Stream.empty,
...options?.layers?.providerRegistry,
}),
Layer.succeed(ProviderInstanceRegistryMutator, { reconcile: () => Effect.void }),
Layer.mock(AgentController.AgentController)({
uploadFeedback: () => Effect.die("Provider feedback is not stubbed in this test"),
...options?.layers?.agentController,
}),
),
),
Layer.provide(
Layer.mock(ServerSettings.ServerSettingsService)({
start: Effect.void,
ready: Effect.void,
getSettings: Effect.succeed(DEFAULT_SERVER_SETTINGS),
updateSettings: () => Effect.succeed(DEFAULT_SERVER_SETTINGS),
streamChanges: Stream.empty,
...options?.layers?.serverSettings,
}),
),
Layer.provide(
Layer.mergeAll(
Layer.mock(ExternalLauncher.ExternalLauncher)({
resolveAvailableEditors: () => Effect.succeed([]),
resolveFileManagerRevealKind: () => Effect.sync((): undefined => undefined),
...options?.layers?.externalLauncher,
}),
Layer.mock(RemoteOpenTargets.RemoteOpenTargets)({
resolveTargets: () => Effect.succeed([]),
}),
),
),
Layer.provide(
Layer.mock(ProcessDiagnostics.ProcessDiagnostics)({
read: Effect.succeed({
serverPid: process.pid,
readAt: TEST_EPOCH,
processCount: 0,
totalRssBytes: 0,
totalCpuPercent: 0,
processes: [],
error: Option.none(),
}),
signal: (input) =>
Effect.succeed({
pid: input.pid,
signal: input.signal,
signaled: true,
message: Option.none(),
}),
}),
),
Layer.provide(
Layer.mock(ProcessResourceMonitor.ProcessResourceMonitor)({
readHistory: (input) =>
Effect.succeed({
readAt: TEST_EPOCH,
windowMs: input.windowMs,
bucketMs: input.bucketMs,
sampleIntervalMs: 5_000,
retainedSampleCount: 0,
totalCpuSecondsApprox: 0,
buckets: [],
topProcesses: [],
error: Option.none(),
}),
}),
),
Layer.provide(
Layer.mock(TraceDiagnostics.TraceDiagnostics)({
read: () =>
Effect.succeed({
traceFilePath: "",
scannedFilePaths: [],
readAt: TEST_EPOCH,
recordCount: 0,
parseErrorCount: 0,
firstSpanAt: Option.none(),
lastSpanAt: Option.none(),
failureCount: 0,
interruptionCount: 0,
slowSpanThresholdMs: 1_000,
slowSpanCount: 0,
logLevelCounts: {},
topSpansByCount: [],
slowestSpans: [],
commonFailures: [],
latestFailures: [],
latestWarningAndErrorLogs: [],
partialFailure: Option.none(),
error: Option.none(),
}),
}),
),
Layer.provide(gitVcsDriverLayer),
Layer.provide(gitWorkflowLayer),
Layer.provide(
Layer.mergeAll(
Layer.mock(PreviewManager.PreviewManager)({
open: () => Effect.die("PreviewManager not stubbed in this test"),
navigate: () => Effect.die("PreviewManager not stubbed in this test"),
resize: () => Effect.die("PreviewManager not stubbed in this test"),
reportStatus: () => Effect.void,
refresh: () => Effect.void,
close: () => Effect.void,
list: () => Effect.succeed({ sessions: [], serverEpoch: "test-server", revision: 0 }),
streamEvents: () => Stream.empty,
subscribeEvents: Effect.flatMap(PubSub.unbounded<PreviewEvent>(), (pubsub) =>
PubSub.subscribe(pubsub),
),
...options?.layers?.previewManager,
}),
Layer.mock(PortScanner.PortDiscovery)({
scan: () => Effect.succeed([]),
subscribe: () => Effect.void,
retain: Effect.void,
}),
),
),
Layer.provide(
Layer.mergeAll(
Layer.mock(OrchestrationEngine.OrchestrationEngineService)({
readEvents: () => Stream.empty,
readThreadEvents: () => Stream.empty,
getThreadReplayStats: () =>
Effect.succeed({
eventCount: 0,
payloadBytes: 0,
hasCreateEvent: false,
}),
dispatch: () => Effect.succeed({ sequence: 0 }),
streamDomainEvents: Stream.empty,
subscribeDomainEvents: Effect.succeed(Stream.empty),
latestSequence: Effect.succeed(0),
...options?.layers?.orchestrationEngine,
}),
Layer.succeed(
OrchestrationCommandReceiptRepository,
OrchestrationCommandReceiptRepository.of({
getByCommandId: () => Effect.succeed(Option.none()),
upsert: () => Effect.void,
...options?.layers?.commandReceipts,
}),
),
Layer.mock(ThreadDeletionReactor)({
start: () => Effect.void,
drain: Effect.void,
drainThrough: () => Effect.void,
...options?.layers?.threadDeletionReactor,
}),
Layer.succeed(
RoutineRepository,
RoutineRepository.of({
listAll: Effect.succeed([]),
listEnabled: Effect.succeed([]),
getById: () => Effect.succeed(null),
listRuns: () => Effect.succeed([]),
listThreadRuns: () => Effect.succeed({ runs: [], nextCursor: null }),
listAllRuns: Effect.succeed([]),
getActiveRunByThreadRef: () => Effect.succeed(null),
listSkillAssignments: Effect.succeed([]),
claim: () => Effect.succeed(false),
markDispatched: () => Effect.void,
markBlocked: () => Effect.void,
listRecoverable: Effect.succeed([]),
...options?.layers?.routineRepository,
markSettled: options?.layers?.routineRepository?.markSettled ?? (() => Effect.void),
} satisfies RoutineRepositoryShape),
),
Layer.succeed(
RoutineRuntime,
RoutineRuntime.of({
runDue: Effect.void,
canRunNow: () => Effect.succeed(true),
runNow: () => Effect.succeed(null),
recover: Effect.void,
start: Effect.void,
...options?.layers?.routineRuntime,
} satisfies RoutineRuntimeShape),
),
),
),
Layer.provide(
Layer.mergeAll(
Layer.succeed(ProjectionBots.ProjectionBotRepository, {
upsert: () => Effect.void,
getById: () => Effect.succeed(Option.none()),
listAll: () => Effect.succeed([]),
deleteById: () => Effect.void,
...options?.layers?.projectionBots,
} satisfies ProjectionBots.ProjectionBotRepositoryShape),
Layer.mock(BotUsageLedger)({
pricingTotals: () => Effect.succeed({ complete: true, models: [] }),
summarize: (botId) =>
Effect.succeed({
botId,
consumedTokens: 0,
reservedTokens: 0,
measurements: {
input: { tokens: 0, unavailableEntries: 0 },
output: { tokens: 0, unavailableEntries: 0 },
observer: { tokens: 0, unavailableEntries: 0 },
reflector: { tokens: 0, unavailableEntries: 0 },
},
entries: [],
}),
...options?.layers?.botUsageLedger,
}),
Layer.succeed(ProjectionGroups.ProjectionGroupRepository, {
upsert: () => Effect.void,
getById: () => Effect.succeed(Option.none()),
listAll: () => Effect.succeed([]),
deleteById: () => Effect.void,
...options?.layers?.projectionGroups,
} satisfies ProjectionGroups.ProjectionGroupRepositoryShape),
Layer.mock(ProjectionSnapshotQuery.ProjectionSnapshotQuery)({
getCommandReadModel: () => Effect.succeed(defaultOrchestrationReadModel()),
getSnapshot: () => Effect.succeed(defaultOrchestrationReadModel()),
getShellSnapshot: () =>
Effect.succeed({
snapshotSequence: 0,
bots: [],
groups: [],
delegations: [],
projects: [],
threads: [],
updatedAt: "1970-01-01T00:00:00.000Z",
}),
getArchivedShellSnapshot: () =>
Effect.succeed({
snapshotSequence: 0,
bots: [],
groups: [],
delegations: [],
projects: [],
threads: [],
updatedAt: "1970-01-01T00:00:00.000Z",
}),
searchThreads: () => Effect.succeed({ matches: [] }),
getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }),
getProjectShellById: () => Effect.succeed(Option.none()),
getThreadShellById: () => Effect.succeed(Option.none()),
getThreadRuntimeContext: () => Effect.die("unused"),
getTurnStartMessage: () => Effect.die("unused"),
getThreadDetailById: () => Effect.succeed(Option.none()),
getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),
getEventReplayStats: ({ fromSequenceExclusive, toSequenceInclusive }) =>
Effect.succeed({
eventCount: Math.max(0, toSequenceInclusive - fromSequenceExclusive),
payloadBytes: 0,
}),
getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),
getThreadCheckpointContext: () => Effect.succeed(Option.none()),
...options?.layers?.projectionSnapshotQuery,
}),
),
),
Layer.provide(
Layer.mock(CheckpointDiffQuery.CheckpointDiffQuery)({
getTurnDiff: () =>
Effect.succeed({
threadId: defaultThreadId,
fromTurnCount: 0,
toTurnCount: 0,
diff: "",
}),
getFullThreadDiff: () =>
Effect.succeed({
threadId: defaultThreadId,
fromTurnCount: 0,
toTurnCount: 0,
diff: "",
}),
...options?.layers?.checkpointDiffQuery,
}),
),
);
const appLayer = servedRoutesLayer.pipe(
Layer.provide(resourceTelemetryLayer),
Layer.provide(UsageService.layerTest),
Layer.provide(
Layer.mock(AnalyticsService.AnalyticsService)({
flush: Effect.void,
}),
),
Layer.provide(
Layer.mock(BrowserTraceCollector.BrowserTraceCollector)({
record: () => Effect.void,
...options?.layers?.browserTraceCollector,
}),
),
Layer.provide(
Layer.mock(ServerLifecycleEvents.ServerLifecycleEvents)({
publish: (event) => Effect.succeed({ ...event, sequence: 1 }),
snapshot: Effect.succeed({ sequence: 0, events: [] }),
stream: Stream.empty,
...options?.layers?.serverLifecycleEvents,
}),
),
Layer.provide(
Layer.mock(ServerRuntimeStartup.ServerRuntimeStartup)({
awaitCommandReady: Effect.void,
markHttpListening: Effect.void,
enqueueCommand: (effect) => effect,
...options?.layers?.serverRuntimeStartup,
}),
),
Layer.provide(
Layer.mock(BackgroundPolicy.BackgroundPolicy)({
reportClientActivity: () => Effect.void,
removeRpcClient: () => Effect.void,
reportHostPowerState: () => Effect.void,
snapshot: Effect.succeed({
hostPower: {
source: "unknown",
idle: "unknown",
idleSeconds: null,
locked: "unknown",
suspended: false,
onBattery: "unknown",
lowPowerMode: "unknown",
thermalState: "unknown",
stale: true,
updatedAt: TEST_EPOCH,
},
leases: [],
activeForegroundLeaseCount: 0,
activeScopeKeys: [],
shouldRunOpportunisticWork: false,
updatedAt: TEST_EPOCH,
}),
streamChanges: Stream.empty,
subscribe: Effect.succeed({
latest: {
hostPower: {
source: "unknown",
idle: "unknown",
idleSeconds: null,
locked: "unknown",
suspended: false,
onBattery: "unknown",
lowPowerMode: "unknown",
thermalState: "unknown",
stale: true,
updatedAt: TEST_EPOCH,
},
leases: [],
activeForegroundLeaseCount: 0,
activeScopeKeys: [],
shouldRunOpportunisticWork: false,
updatedAt: TEST_EPOCH,
},
changes: Stream.empty,
}),
hasDemand: () => Effect.succeed(false),
shouldRunScopeWork: () => Effect.succeed(false),
shouldRunOpportunisticWork: Effect.succeed(false),
}),
),
Layer.provide(
Layer.mock(ServerEnvironment.ServerEnvironment)({
getEnvironmentId: Effect.succeed(testEnvironmentDescriptor.environmentId),
getDescriptor: Effect.succeed(testEnvironmentDescriptor),
...options?.layers?.serverEnvironment,
}),
),
Layer.provide(
Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({
resolve: () => Effect.succeed(null),
...options?.layers?.repositoryIdentityResolver,
}),
),
Layer.provideMerge(authTestLayer()),
Layer.provideMerge(
options?.durableMemory
? EntityMemoryRepositoryLive.pipe(
Layer.provide(MemoryRevisionWriteLockLive),
Layer.provide(SqlitePersistenceMemory),
Layer.tap((context) =>
options.durableMemory?.seed
? options.durableMemory.seed(Context.get(context, EntityMemoryRepository))
: Effect.void,
),
)
: Layer.empty,
),
Layer.provideMerge(ServerSecretStore.layer),
Layer.provideMerge(
options?.layers?.channelRuntime
? Layer.mock(ChannelRuntime.ChannelRuntime)(options.layers.channelRuntime)
: Layer.empty,
),
Layer.provideMerge(
options?.layers?.channelDeliveryStore === null
? Layer.empty
: Layer.succeed(
ChannelDeliveryStore.ChannelDeliveryStore,
options?.layers?.channelDeliveryStore ??
ChannelDeliveryStore.memoryChannelDeliveryStore(),
),
),
Layer.provide(workspaceAndProjectServicesLayer),
Layer.provideMerge(FetchHttpClient.layer),
Layer.provide(layerConfig),
);
yield* Layer.build(Layer.fresh(appLayer));
return config;
});