@neurocode-ai/core 1.18.8

package/test/integration.test.ts

@@ -0,0 +1,349 @@
+import { describe, expect } from "bun:test"
+import { Duration, Effect, Exit, Fiber, Scope, Stream } from "effect"
+import * as TestClock from "effect/testing/TestClock"
+import { Credential } from "@neurocode-ai/core/credential"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { EventV2 } from "@neurocode-ai/core/event"
+import { Integration } from "@neurocode-ai/core/integration"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([Integration.node, Credential.node, EventV2.node])))
+
+describe("Integration", () => {
+  it.effect("registers integrations through the editor", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const scope = yield* Scope.fork(yield* Scope.Scope)
+      const openai = Integration.ID.make("openai")
+
+      yield* integrations
+        .transform((editor) => editor.update(openai, (integration) => (integration.name = "OpenAI")))
+        .pipe(Scope.provide(scope))
+      expect(yield* integrations.get(openai)).toEqual(
+        new Integration.Info({ id: openai, name: "OpenAI", methods: [], connections: [] }),
+      )
+
+      yield* Scope.close(scope, Exit.void)
+      expect(yield* integrations.get(openai)).toBeUndefined()
+    }),
+  )
+
+  it.effect("reveals the previous registration when an override closes", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const id = Integration.ID.make("openai")
+      const first = yield* Scope.fork(yield* Scope.Scope)
+      const second = yield* Scope.fork(yield* Scope.Scope)
+
+      yield* integrations
+        .transform((editor) => editor.update(id, (integration) => (integration.name = "OpenAI")))
+        .pipe(Scope.provide(first))
+      yield* integrations
+        .transform((editor) => editor.update(id, (integration) => (integration.name = "OpenAI Override")))
+        .pipe(Scope.provide(second))
+      expect((yield* integrations.get(id))?.name).toBe("OpenAI Override")
+
+      yield* Scope.close(second, Exit.void)
+      expect((yield* integrations.get(id))?.name).toBe("OpenAI")
+      expect((yield* integrations.list()).map((integration) => integration.id)).toEqual([id])
+    }),
+  )
+
+  it.effect("registers and overrides methods independently", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const integrationID = Integration.ID.make("openai")
+      const methodID = Integration.MethodID.make("chatgpt")
+      const first = yield* Scope.fork(yield* Scope.Scope)
+      const second = yield* Scope.fork(yield* Scope.Scope)
+      const authorize = () =>
+        Effect.succeed({
+          mode: "auto" as const,
+          url: "https://example.com/authorize",
+          instructions: "Sign in",
+          callback: Effect.never,
+        })
+
+      yield* integrations
+        .transform((editor) =>
+          editor.method.update({
+            integrationID,
+            method: { id: methodID, type: "oauth", label: "ChatGPT" },
+            authorize,
+          }),
+        )
+        .pipe(Scope.provide(first))
+      yield* integrations
+        .transform((editor) => {
+          expect(editor.get(integrationID)).toEqual({ id: integrationID, name: "openai" })
+          expect(editor.list()).toEqual([{ id: integrationID, name: "openai" }])
+          expect(editor.method.list(integrationID)).toEqual([
+            expect.objectContaining({ id: methodID, label: "ChatGPT" }),
+          ])
+          editor.method.update({
+            integrationID,
+            method: { id: methodID, type: "oauth", label: "ChatGPT Override" },
+            authorize,
+          })
+        })
+        .pipe(Scope.provide(second))
+
+      expect((yield* integrations.get(integrationID))?.name).toBe("openai")
+      expect((yield* integrations.get(integrationID))?.methods[0]).toMatchObject({ label: "ChatGPT Override" })
+
+      yield* Scope.close(second, Exit.void)
+      expect((yield* integrations.get(integrationID))?.methods[0]).toMatchObject({ label: "ChatGPT" })
+      expect((yield* integrations.get(integrationID))?.methods).toEqual([expect.objectContaining({ id: methodID })])
+    }),
+  )
+
+  it.effect("connects with a key and stores the credential", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const credentials = yield* Credential.Service
+      const events = yield* EventV2.Service
+      const integrationID = Integration.ID.make("openai")
+      yield* integrations.transform((editor) =>
+        editor.method.update({
+          integrationID,
+          method: { type: "key", label: "API key" },
+        }),
+      )
+      const updated = yield* events
+        .subscribe(Integration.Event.Updated)
+        .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+      yield* Effect.yieldNow
+
+      yield* integrations.connection.key({
+        integrationID,
+        key: "secret",
+        label: "Work",
+      })
+
+      expect(yield* credentials.list(integrationID)).toEqual([
+        expect.objectContaining({
+          integrationID,
+          label: "Work",
+          value: Credential.Key.make({ type: "key", key: "secret" }),
+        }),
+      ])
+      expect((yield* Fiber.join(updated)).length).toBe(1)
+    }),
+  )
+
+  it.effect("completes code OAuth once and stores the credential", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const credentials = yield* Credential.Service
+      const integrationID = Integration.ID.make("openai")
+      const methodID = Integration.MethodID.make("chatgpt")
+      yield* integrations.transform((editor) =>
+        editor.method.update({
+          integrationID,
+          method: { id: methodID, type: "oauth", label: "ChatGPT" },
+          authorize: () =>
+            Effect.succeed({
+              mode: "code" as const,
+              url: "https://example.com/authorize",
+              instructions: "Paste the code",
+              callback: (code: string) =>
+                Effect.succeed(
+                  Credential.OAuth.make({
+                    type: "oauth",
+                    methodID,
+                    access: "access",
+                    refresh: "refresh",
+                    expires: 1,
+                    metadata: { code },
+                  }),
+                ),
+            }),
+        }),
+      )
+
+      const attempt = yield* integrations.connection.oauth({
+        integrationID,
+        methodID,
+        inputs: {},
+        label: "Personal",
+      })
+      expect(attempt.mode).toBe("code")
+      yield* integrations.attempt.complete({ attemptID: attempt.attemptID, code: "1234" })
+
+      expect((yield* credentials.list(integrationID))[0]).toEqual(
+        expect.objectContaining({
+          integrationID,
+          label: "Personal",
+          value: Credential.OAuth.make({
+            type: "oauth",
+            methodID,
+            access: "access",
+            refresh: "refresh",
+            expires: 1,
+            metadata: { code: "1234" },
+          }),
+        }),
+      )
+    }),
+  )
+
+  it.effect("keeps code attempts open when the code is missing and closes them on cancel", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const credentials = yield* Credential.Service
+      const integrationID = Integration.ID.make("openai")
+      const methodID = Integration.MethodID.make("chatgpt")
+      let closed = false
+      yield* integrations.transform((editor) =>
+        editor.method.update({
+          integrationID,
+          method: { id: methodID, type: "oauth", label: "ChatGPT" },
+          authorize: () =>
+            Effect.addFinalizer(() => Effect.sync(() => (closed = true))).pipe(
+              Effect.as({
+                mode: "code" as const,
+                url: "https://example.com/authorize",
+                instructions: "Paste the code",
+                callback: () => Effect.die("unexpected callback"),
+              }),
+            ),
+        }),
+      )
+
+      const attempt = yield* integrations.connection.oauth({ integrationID, methodID, inputs: {} })
+      expect(yield* integrations.attempt.complete({ attemptID: attempt.attemptID }).pipe(Effect.flip)).toBeInstanceOf(
+        Integration.CodeRequiredError,
+      )
+      expect(closed).toBe(false)
+      yield* integrations.attempt.cancel(attempt.attemptID)
+      expect(closed).toBe(true)
+      expect(yield* credentials.list(integrationID)).toEqual([])
+    }),
+  )
+
+  it.effect("completes auto OAuth in the background", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const credentials = yield* Credential.Service
+      const integrationID = Integration.ID.make("openai")
+      const methodID = Integration.MethodID.make("browser")
+      yield* integrations.transform((editor) =>
+        editor.method.update({
+          integrationID,
+          method: { id: methodID, type: "oauth", label: "Browser" },
+          authorize: () =>
+            Effect.succeed({
+              mode: "auto" as const,
+              url: "https://example.com/authorize",
+              instructions: "Sign in",
+              callback: Effect.succeed(
+                Credential.OAuth.make({ type: "oauth", methodID, access: "access", refresh: "refresh", expires: 1 }),
+              ),
+            }),
+        }),
+      )
+
+      const attempt = yield* integrations.connection.oauth({ integrationID, methodID, inputs: {} })
+      yield* Effect.yieldNow
+      expect(yield* integrations.attempt.status(attempt.attemptID)).toEqual({
+        status: "complete",
+        time: attempt.time,
+      })
+      expect(yield* credentials.list(integrationID)).toHaveLength(1)
+    }),
+  )
+
+  it.effect("expires abandoned OAuth attempts", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const credentials = yield* Credential.Service
+      const integrationID = Integration.ID.make("openai")
+      const methodID = Integration.MethodID.make("browser")
+      let closed = false
+      yield* integrations.transform((editor) =>
+        editor.method.update({
+          integrationID,
+          method: { id: methodID, type: "oauth", label: "Browser" },
+          authorize: () =>
+            Effect.addFinalizer(() => Effect.sync(() => (closed = true))).pipe(
+              Effect.as({
+                mode: "auto" as const,
+                url: "https://example.com/authorize",
+                instructions: "Sign in",
+                callback: Effect.never,
+              }),
+            ),
+        }),
+      )
+
+      const attempt = yield* integrations.connection.oauth({ integrationID, methodID, inputs: {} })
+      expect(attempt.time.expires - attempt.time.created).toBe(Duration.toMillis(Duration.minutes(10)))
+      yield* TestClock.adjust(Duration.minutes(10))
+      yield* Effect.yieldNow
+      expect(yield* integrations.attempt.status(attempt.attemptID)).toEqual({
+        status: "expired",
+        time: attempt.time,
+      })
+      expect(closed).toBe(true)
+      expect(yield* credentials.list(integrationID)).toEqual([])
+    }),
+  )
+
+  it.effect("projects credential and env connections", () => {
+    const integrationID = Integration.ID.make("acme")
+    return Effect.acquireUseRelease(
+      Effect.sync(() => {
+        const previous = process.env.INTEGRATION_TEST_ACME_KEY
+        process.env.INTEGRATION_TEST_ACME_KEY = "secret"
+        delete process.env.INTEGRATION_TEST_ACME_MISSING
+        return previous
+      }),
+      () =>
+        Effect.gen(function* () {
+          const integrations = yield* Integration.Service
+          const credentials = yield* Credential.Service
+          yield* integrations.transform((editor) =>
+            editor.method.update({
+              integrationID,
+              method: {
+                type: "env",
+                names: ["INTEGRATION_TEST_ACME_KEY", "INTEGRATION_TEST_ACME_MISSING"],
+              },
+            }),
+          )
+          const work = yield* credentials.create({
+            integrationID,
+            label: "Work",
+            value: Credential.Key.make({ type: "key", key: "a" }),
+          })
+          const personal = yield* credentials.create({
+            integrationID,
+            label: "Personal",
+            value: Credential.Key.make({ type: "key", key: "b" }),
+          })
+
+          // Stored credentials and detected env vars appear as connections.
+          expect((yield* integrations.get(integrationID))?.connections).toEqual([
+            {
+              type: "credential",
+              id: personal.id,
+              label: "Personal",
+            },
+            { type: "env", name: "INTEGRATION_TEST_ACME_KEY" },
+          ])
+          expect(yield* integrations.connection.active(integrationID)).toEqual({
+            type: "credential",
+            id: personal.id,
+            label: "Personal",
+          })
+          expect(work.id).not.toBe(personal.id)
+        }),
+      (previous) =>
+        Effect.sync(() => {
+          if (previous === undefined) delete process.env.INTEGRATION_TEST_ACME_KEY
+          else process.env.INTEGRATION_TEST_ACME_KEY = previous
+        }),
+    )
+  })
+})

package/test/legacy-event-schema.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test"
+import { SessionV1 as Wire } from "@neurocode-ai/schema/session-v1"
+import { SessionV1 } from "../src/v1/session"
+
+describe("legacy event schema compatibility", () => {
+  test("Core references canonical SessionV1 definitions", () => {
+    expect(SessionV1.Event.Created).toBe(Wire.Event.Created)
+    expect(SessionV1.Event.PartUpdated).toBe(Wire.Event.PartUpdated)
+  })
+
+  test("Core retains NamedError constructor identity", () => {
+    const error = new SessionV1.APIError({ message: "failed", isRetryable: false })
+    expect(error).toBeInstanceOf(SessionV1.APIError)
+    expect(error.toObject()).toEqual({ name: "APIError", data: { message: "failed", isRetryable: false } })
+  })
+})

package/test/lib/effect.ts

@@ -0,0 +1,53 @@
+import { test, type TestOptions } from "bun:test"
+import { Cause, Effect, Exit, Layer } from "effect"
+import type * as Scope from "effect/Scope"
+import * as TestClock from "effect/testing/TestClock"
+import * as TestConsole from "effect/testing/TestConsole"
+
+type Body<A, E, R> = Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>)
+
+const body = <A, E, R>(value: Body<A, E, R>) => Effect.suspend(() => (typeof value === "function" ? value() : value))
+
+const run = <A, E, R, E2>(value: Body<A, E, R | Scope.Scope>, layer: Layer.Layer<R, E2>) =>
+  Effect.gen(function* () {
+    const exit = yield* body(value).pipe(Effect.scoped, Effect.provide(layer), Effect.exit)
+    if (Exit.isFailure(exit)) {
+      for (const err of Cause.prettyErrors(exit.cause)) {
+        yield* Effect.logError(err)
+      }
+    }
+    return yield* exit
+  }).pipe(Effect.runPromise)
+
+const make = <R, E>(testLayer: Layer.Layer<R, E>, liveLayer: Layer.Layer<R, E>) => {
+  const effect = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test(name, () => run(value, testLayer), opts)
+
+  effect.only = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test.only(name, () => run(value, testLayer), opts)
+
+  effect.skip = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test.skip(name, () => run(value, testLayer), opts)
+
+  const live = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test(name, () => run(value, liveLayer), opts)
+
+  live.only = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test.only(name, () => run(value, liveLayer), opts)
+
+  live.skip = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test.skip(name, () => run(value, liveLayer), opts)
+
+  return { effect, live }
+}
+
+// Test environment with TestClock and TestConsole
+const testEnv = Layer.mergeAll(TestConsole.layer, TestClock.layer())
+
+// Live environment - uses real clock, but keeps TestConsole for output capture
+const liveEnv = TestConsole.layer
+
+export const it = make(testEnv, liveEnv)
+
+export const testEffect = <R, E>(layer: Layer.Layer<R, E>) =>
+  make(Layer.provideMerge(layer, testEnv), Layer.provideMerge(layer, liveEnv))

package/test/lib/tool.ts

@@ -0,0 +1,20 @@
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { SessionMessage } from "@neurocode-ai/core/session/message"
+import { ToolRegistry } from "@neurocode-ai/core/tool/registry"
+import { Effect } from "effect"
+
+export const toolIdentity = {
+  agent: AgentV2.ID.make("build"),
+  assistantMessageID: SessionMessage.ID.make("msg_tool_test"),
+}
+
+export const toolDefinitions = (
+  registry: ToolRegistry.Interface,
+  permissions?: Parameters<typeof registry.materialize>[0],
+) => registry.materialize(permissions).pipe(Effect.map((materialized) => materialized.definitions))
+
+export const settleTool = (registry: ToolRegistry.Interface, input: ToolRegistry.ExecuteInput) =>
+  registry.materialize().pipe(Effect.flatMap((materialized) => materialized.settle(input)))
+
+export const executeTool = (registry: ToolRegistry.Interface, input: ToolRegistry.ExecuteInput) =>
+  settleTool(registry, input).pipe(Effect.map((settlement) => settlement.result))

package/test/location-filesystem.test.ts

@@ -0,0 +1,69 @@
+import fs from "fs/promises"
+import path from "path"
+import { describe, expect } from "bun:test"
+import { Effect, Exit, Layer } from "effect"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { FileSystem } from "@neurocode-ai/core/filesystem"
+import { Location } from "@neurocode-ai/core/location"
+import { AbsolutePath, RelativePath } from "@neurocode-ai/core/schema"
+import { location } from "./fixture/location"
+import { tmpdir } from "./fixture/tmpdir"
+import { it } from "./lib/effect"
+
+const provide = (directory: string) =>
+  Effect.provide(
+    LayerNode.compile(FileSystem.node, [
+      [
+        Location.node,
+        Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
+      ],
+    ]),
+  )
+
+const withTmp = <A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) =>
+  Effect.acquireRelease(
+    Effect.promise(() => tmpdir()),
+    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+  ).pipe(Effect.flatMap((tmp) => f(tmp.path)))
+
+describe("FileSystem", () => {
+  it.live("reads text and binary files", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => fs.writeFile(path.join(directory, "text.txt"), "hello"))
+        yield* Effect.promise(() => fs.writeFile(path.join(directory, "data.bin"), Buffer.from([0, 1, 2])))
+        const service = yield* FileSystem.Service
+        const text = yield* service.read({ path: RelativePath.make("text.txt") })
+        const binary = yield* service.read({ path: RelativePath.make("data.bin") })
+        expect(new TextDecoder().decode(text.content)).toBe("hello")
+        expect(text.mime).toBe("text/plain")
+        expect(binary.content).toEqual(new Uint8Array([0, 1, 2]))
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("lists direct children", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => fs.mkdir(path.join(directory, "src")))
+        yield* Effect.promise(() => fs.writeFile(path.join(directory, "README.md"), "# Test"))
+        const entries = yield* (yield* FileSystem.Service).list()
+        expect(entries.map((entry) => ({ path: entry.path, type: entry.type }))).toEqual([
+          { path: RelativePath.make("src" + path.sep), type: "directory" },
+          { path: RelativePath.make("README.md"), type: "file" },
+        ])
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("rejects lexical escapes", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const result = yield* (yield* FileSystem.Service)
+          .read({ path: RelativePath.make("../outside.txt") })
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(result)).toBe(true)
+      }).pipe(provide(directory)),
+    ),
+  )
+})