@miaws/miaw 1.18.5 → 1.18.6

package/test/plugin/shared.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { parsePluginSpecifier } from "../../src/plugin/shared"
-
-describe("parsePluginSpecifier", () => {
-  test("parses standard npm package without version", () => {
-    expect(parsePluginSpecifier("acme")).toEqual({
-      pkg: "acme",
-      version: "latest",
-    })
-  })
-
-  test("parses standard npm package with version", () => {
-    expect(parsePluginSpecifier("acme@1.0.0")).toEqual({
-      pkg: "acme",
-      version: "1.0.0",
-    })
-  })
-
-  test("parses scoped npm package without version", () => {
-    expect(parsePluginSpecifier("@miaw/acme")).toEqual({
-      pkg: "@miaw/acme",
-      version: "latest",
-    })
-  })
-
-  test("parses scoped npm package with version", () => {
-    expect(parsePluginSpecifier("@miaw/acme@1.0.0")).toEqual({
-      pkg: "@miaw/acme",
-      version: "1.0.0",
-    })
-  })
-
-  test("parses package with git+https url", () => {
-    expect(parsePluginSpecifier("acme@git+https://github.com/miaw/acme.git")).toEqual({
-      pkg: "acme",
-      version: "git+https://github.com/miaw/acme.git",
-    })
-  })
-
-  test("parses scoped package with git+https url", () => {
-    expect(parsePluginSpecifier("@miaw/acme@git+https://github.com/miaw/acme.git")).toEqual({
-      pkg: "@miaw/acme",
-      version: "git+https://github.com/miaw/acme.git",
-    })
-  })
-
-  test("parses package with git+ssh url containing another @", () => {
-    expect(parsePluginSpecifier("acme@git+ssh://git@github.com/miaw/acme.git")).toEqual({
-      pkg: "acme",
-      version: "git+ssh://git@github.com/miaw/acme.git",
-    })
-  })
-
-  test("parses scoped package with git+ssh url containing another @", () => {
-    expect(parsePluginSpecifier("@miaw/acme@git+ssh://git@github.com/miaw/acme.git")).toEqual({
-      pkg: "@miaw/acme",
-      version: "git+ssh://git@github.com/miaw/acme.git",
-    })
-  })
-
-  test("parses unaliased git+ssh url", () => {
-    expect(parsePluginSpecifier("git+ssh://git@github.com/miaw/acme.git")).toEqual({
-      pkg: "git+ssh://git@github.com/miaw/acme.git",
-      version: "",
-    })
-  })
-
-  test("parses npm alias using the alias name", () => {
-    expect(parsePluginSpecifier("acme@npm:@miaw/acme@1.0.0")).toEqual({
-      pkg: "acme",
-      version: "npm:@miaw/acme@1.0.0",
-    })
-  })
-
-  test("parses bare npm protocol specifier using the target package", () => {
-    expect(parsePluginSpecifier("npm:@miaw/acme@1.0.0")).toEqual({
-      pkg: "@miaw/acme",
-      version: "1.0.0",
-    })
-  })
-
-  test("parses unversioned npm protocol specifier", () => {
-    expect(parsePluginSpecifier("npm:@miaw/acme")).toEqual({
-      pkg: "@miaw/acme",
-      version: "latest",
-    })
-  })
-})

package/test/plugin/snowflake-cortex.test.ts

@@ -1,278 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { OAUTH_DUMMY_KEY } from "../../src/auth"
-import { oauthScope, SnowflakeCortexAuthPlugin } from "../../src/plugin/snowflake-cortex"
-
-function makeInput() {
-  let auth: any = {
-    type: "oauth",
-    access: "access-old",
-    refresh: "refresh-old",
-    expires: Date.now() + 3600_000,
-    accountId: "myorg-myaccount",
-  }
-  const setCalls: Array<Record<string, unknown>> = []
-
-  return {
-    getAuth: async () => auth,
-    setAuth: (next: any) => {
-      auth = next
-    },
-    input: {
-      client: {
-        auth: {
-          set: async (request: any) => {
-            setCalls.push(request)
-            auth = request.body
-          },
-        },
-      },
-    } as any,
-    setCalls,
-  }
-}
-
-describe("plugin.snowflake-cortex", () => {
-  test("oauthScope uses Snowflake-compatible scope values", () => {
-    expect(oauthScope(undefined)).toBe("refresh_token")
-    expect(oauthScope("PUBLIC")).toBe("refresh_token session:role:PUBLIC")
-    expect(oauthScope("AUTH SNOWFLAKE")).toBe("refresh_token session:role-encoded:AUTH%20SNOWFLAKE")
-  })
-
-  test("loader returns empty options when auth is not oauth", async () => {
-    const hooks = await SnowflakeCortexAuthPlugin({} as any)
-    const options = await hooks.auth!.loader!(async () => ({ type: "api", key: "token" }) as any, {} as any)
-    expect(options).toEqual({})
-  })
-
-  test("loader injects bearer header and preserves custom headers", async () => {
-    const { input, getAuth, setAuth } = makeInput()
-    setAuth({
-      type: "oauth",
-      access: "access-live",
-      refresh: "refresh-live",
-      expires: Date.now() + 60 * 60 * 1000,
-      accountId: "myorg-myaccount",
-    })
-    const hooks = await SnowflakeCortexAuthPlugin(input)
-    const options = await hooks.auth!.loader!(getAuth as any, {} as any)
-    expect(options.apiKey).toBe(OAUTH_DUMMY_KEY)
-
-    const originalFetch = globalThis.fetch
-    const captured: Headers[] = []
-    globalThis.fetch = (async (_request, init) => {
-      captured.push(new Headers(init?.headers))
-      return new Response("{}", { status: 200, headers: { "content-type": "application/json" } })
-    }) as typeof fetch
-
-    try {
-      await options.fetch("https://example.test/v1/chat", {
-        headers: { Authorization: `Bearer ${OAUTH_DUMMY_KEY}`, "x-keep": "yes" },
-      })
-    } finally {
-      globalThis.fetch = originalFetch
-    }
-
-    expect(captured).toHaveLength(1)
-    expect(captured[0].get("authorization")).toBe("Bearer access-live")
-    expect(captured[0].get("x-keep")).toBe("yes")
-    expect(captured[0].get("user-agent")).toMatch(/^miaw\//)
-  })
-
-  test("loader refreshes expired token with single-flight and persists refreshed oauth", async () => {
-    const { input, getAuth, setCalls } = makeInput()
-    let refreshCalls = 0
-    const apiAuthHeaders: string[] = []
-
-    // Must mock fetch before calling loader because startup refresh triggers for expires: 0
-    const originalFetch = globalThis.fetch
-    globalThis.fetch = (async (request, init) => {
-      const url =
-        typeof request === "string" ? request : request instanceof URL ? request.toString() : String(request.url)
-
-      if (url.includes("/oauth/token-request")) {
-        refreshCalls += 1
-        const body = new URLSearchParams(String(init?.body ?? ""))
-        expect(body.get("grant_type")).toBe("refresh_token")
-        expect(body.get("refresh_token")).toBe("refresh-old")
-        expect(new Headers(init?.headers).get("authorization")).toMatch(/^Basic /)
-        await new Promise((resolve) => setTimeout(resolve, 20))
-        return Response.json({ access_token: "access-new", refresh_token: "refresh-new", expires_in: 3600 })
-      }
-
-      apiAuthHeaders.push(new Headers(init?.headers).get("authorization") || "")
-      return new Response("{}", { status: 200, headers: { "content-type": "application/json" } })
-    }) as typeof fetch
-
-    try {
-      const hooks = await SnowflakeCortexAuthPlugin(input)
-      const options = await hooks.auth!.loader!(
-        async () =>
-          ({
-            type: "oauth",
-            access: "access-expired",
-            refresh: "refresh-old",
-            expires: 0,
-            accountId: "myorg-myaccount",
-          }) as any,
-        {} as any,
-      )
-
-      await Promise.all([
-        options.fetch("https://example.test/v1/chat", { headers: {} }),
-        options.fetch("https://example.test/v1/chat", { headers: {} }),
-      ])
-    } finally {
-      globalThis.fetch = originalFetch
-    }
-
-    expect(refreshCalls).toBe(1)
-    expect(apiAuthHeaders).toEqual(["Bearer access-new", "Bearer access-new"])
-    expect(setCalls).toHaveLength(1)
-    expect((setCalls[0] as any).body).toMatchObject({
-      type: "oauth",
-      access: "access-new",
-      refresh: "refresh-new",
-      accountId: "myorg-myaccount",
-    })
-  })
-
-  test("loader retries once after 401 by refreshing token", async () => {
-    const { input, getAuth, setCalls } = makeInput()
-    const hooks = await SnowflakeCortexAuthPlugin(input)
-    const options = await hooks.auth!.loader!(
-      async () =>
-        ({
-          type: "oauth",
-          access: "access-stale",
-          refresh: "refresh-old",
-          expires: Date.now() + 60 * 60 * 1000,
-          accountId: "myorg-myaccount",
-        }) as any,
-      {} as any,
-    )
-
-    let apiCalls = 0
-    const seenAuth: string[] = []
-    const originalFetch = globalThis.fetch
-    globalThis.fetch = (async (request, init) => {
-      const url =
-        typeof request === "string" ? request : request instanceof URL ? request.toString() : String(request.url)
-
-      if (url.includes("/oauth/token-request")) {
-        return Response.json({ access_token: "access-fresh", refresh_token: "refresh-fresh", expires_in: 3600 })
-      }
-
-      apiCalls += 1
-      seenAuth.push(new Headers(init?.headers).get("authorization") || "")
-      if (apiCalls === 1) return new Response("unauthorized", { status: 401 })
-      return new Response("{}", { status: 200, headers: { "content-type": "application/json" } })
-    }) as typeof fetch
-
-    try {
-      const response = await options.fetch("https://example.test/v1/chat", { headers: {} })
-      expect(response.status).toBe(200)
-    } finally {
-      globalThis.fetch = originalFetch
-    }
-
-    expect(apiCalls).toBe(2)
-    expect(seenAuth).toEqual(["Bearer access-stale", "Bearer access-fresh"])
-    expect(setCalls).toHaveLength(1)
-    expect((setCalls[0] as any).body).toMatchObject({
-      type: "oauth",
-      access: "access-fresh",
-      refresh: "refresh-fresh",
-      accountId: "myorg-myaccount",
-    })
-  })
-
-  test("loader converts max_tokens to max_completion_tokens in request body", async () => {
-    const { input, getAuth } = makeInput()
-    const hooks = await SnowflakeCortexAuthPlugin(input)
-    const options = await hooks.auth!.loader!(getAuth as any, {} as any)
-
-    let sentBody: string | undefined
-    const originalFetch = globalThis.fetch
-    globalThis.fetch = (async (request, init) => {
-      sentBody = typeof init?.body === "string" ? init.body : undefined
-      return new Response("{}", { status: 200, headers: { "content-type": "application/json" } })
-    }) as typeof fetch
-
-    try {
-      await options.fetch("https://example.test/v1/chat", {
-        method: "POST",
-        body: JSON.stringify({ model: "claude-sonnet-4-5", max_tokens: 4096, messages: [] }),
-      })
-    } finally {
-      globalThis.fetch = originalFetch
-    }
-
-    expect(sentBody).toBeDefined()
-    const parsed = JSON.parse(sentBody!)
-    expect(parsed.max_completion_tokens).toBe(4096)
-    expect(parsed.max_tokens).toBeUndefined()
-    expect(parsed.model).toBe("claude-sonnet-4-5")
-  })
-
-  test("loader maps 400 'conversation complete' to 200 stop", async () => {
-    const { input, getAuth } = makeInput()
-    const hooks = await SnowflakeCortexAuthPlugin(input)
-    const options = await hooks.auth!.loader!(getAuth as any, {} as any)
-
-    const originalFetch = globalThis.fetch
-    globalThis.fetch = (async () => {
-      return new Response(JSON.stringify({ message: "Conversation complete" }), {
-        status: 400,
-        headers: { "content-type": "application/json" },
-      })
-    }) as unknown as typeof fetch
-
-    try {
-      const response = await options.fetch("https://example.test/v1/chat", {
-        method: "POST",
-        body: JSON.stringify({ model: "test", messages: [] }),
-      })
-      expect(response.status).toBe(200)
-      const body = await response.json()
-      expect(body.choices[0].finish_reason).toBe("stop")
-    } finally {
-      globalThis.fetch = originalFetch
-    }
-  })
-
-  test("loader fixes empty role in SSE stream", async () => {
-    const { input, getAuth } = makeInput()
-    const hooks = await SnowflakeCortexAuthPlugin(input)
-    const options = await hooks.auth!.loader!(getAuth as any, {} as any)
-
-    const originalFetch = globalThis.fetch
-    const sseChunk = `data: {"choices":[{"delta":{"role":"","content":"hello"}}]}\n\n`
-    globalThis.fetch = (async () => {
-      const stream = new ReadableStream({
-        start(ctrl) {
-          ctrl.enqueue(new TextEncoder().encode(sseChunk))
-          ctrl.close()
-        },
-      })
-      return new Response(stream, {
-        status: 200,
-        headers: { "content-type": "text/event-stream" },
-      })
-    }) as unknown as typeof fetch
-
-    try {
-      const response = await options.fetch("https://example.test/v1/chat", {
-        method: "POST",
-        body: JSON.stringify({ model: "test", messages: [], stream: true }),
-      })
-      expect(response.status).toBe(200)
-      const reader = response.body!.getReader()
-      const { value } = await reader.read()
-      const text = new TextDecoder().decode(value)
-      expect(text).not.toContain('"role":""')
-      expect(text).toContain('"role":"assistant"')
-    } finally {
-      globalThis.fetch = originalFetch
-    }
-  })
-})

package/test/plugin/trigger.test.ts

@@ -1,120 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { FSUtil } from "@miaw/core/fs-util"
-import { EffectFlock } from "@miaw/core/util/effect-flock"
-import path from "path"
-import { pathToFileURL } from "url"
-import { EventV2Bridge } from "../../src/event-v2-bridge"
-import { Config } from "../../src/config/config"
-import { Env } from "../../src/env"
-import { RuntimeFlags } from "../../src/effect/runtime-flags"
-import { Plugin } from "../../src/plugin/index"
-
-import { TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { AccountTest } from "../fake/account"
-import { AuthTest } from "../fake/auth"
-import { NpmTest } from "../fake/npm"
-import { ProviderV2 } from "@miaw/core/provider"
-import { ModelV2 } from "@miaw/core/model"
-
-const configLayer = Config.layer.pipe(
-  Layer.provide(EffectFlock.defaultLayer),
-  Layer.provide(FSUtil.defaultLayer),
-  Layer.provide(Env.defaultLayer),
-  Layer.provide(AuthTest.empty),
-  Layer.provide(AccountTest.empty),
-  Layer.provide(NpmTest.noop),
-  Layer.provide(FetchHttpClient.layer),
-)
-const it = testEffect(
-  Layer.mergeAll(
-    Plugin.layer.pipe(
-      Layer.provide(EventV2Bridge.defaultLayer),
-      Layer.provide(configLayer),
-      Layer.provide(RuntimeFlags.layer({ disableDefaultPlugins: true })),
-    ),
-    CrossSpawnSpawner.defaultLayer,
-  ),
-)
-const systemHook = "experimental.chat.system.transform"
-
-function withProject<A, E, R>(source: string, self: Effect.Effect<A, E, R>) {
-  return Effect.gen(function* () {
-    const test = yield* TestInstance
-    const file = path.join(test.directory, "plugin.ts")
-    yield* Effect.all(
-      [
-        Effect.promise(() => Bun.write(file, source)),
-        Effect.promise(() =>
-          Bun.write(
-            path.join(test.directory, "miaw.json"),
-            JSON.stringify(
-              {
-                $schema: "https://miaw/config.json",
-                plugin: [pathToFileURL(file).href],
-              },
-              null,
-              2,
-            ),
-          ),
-        ),
-      ],
-      { discard: true, concurrency: 2 },
-    )
-    return yield* self
-  })
-}
-
-const triggerSystemTransform = Effect.fn("PluginTriggerTest.triggerSystemTransform")(function* () {
-  const plugin = yield* Plugin.Service
-  const out = { system: [] as string[] }
-  yield* plugin.trigger(
-    systemHook,
-    {
-      model: {
-        providerID: ProviderV2.ID.anthropic,
-        modelID: ModelV2.ID.make("claude-sonnet-4-6"),
-      },
-    },
-    out,
-  )
-  return out.system
-})
-
-describe("plugin.trigger", () => {
-  it.instance("runs synchronous hooks without crashing", () =>
-    withProject(
-      [
-        "export default async () => ({",
-        `  ${JSON.stringify(systemHook)}: (_input, output) => {`,
-        '    output.system.unshift("sync")',
-        "  },",
-        "})",
-        "",
-      ].join("\n"),
-      Effect.gen(function* () {
-        expect(yield* triggerSystemTransform()).toEqual(["sync"])
-      }),
-    ),
-  )
-
-  it.instance("awaits asynchronous hooks", () =>
-    withProject(
-      [
-        "export default async () => ({",
-        `  ${JSON.stringify(systemHook)}: async (_input, output) => {`,
-        "    await Bun.sleep(1)",
-        '    output.system.unshift("async")',
-        "  },",
-        "})",
-        "",
-      ].join("\n"),
-      Effect.gen(function* () {
-        expect(yield* triggerSystemTransform()).toEqual(["async"])
-      }),
-    ),
-  )
-})

package/test/plugin/workspace-adapter.test.ts

@@ -1,140 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { Database } from "@miaw/core/database/database"
-import { FSUtil } from "@miaw/core/fs-util"
-import { Ripgrep } from "@miaw/core/ripgrep"
-import { EffectFlock } from "@miaw/core/util/effect-flock"
-import path from "path"
-import { pathToFileURL } from "url"
-import { Auth } from "../../src/auth"
-import { EventV2Bridge } from "../../src/event-v2-bridge"
-import { Config } from "../../src/config/config"
-import { Env } from "../../src/env"
-import { RuntimeFlags } from "../../src/effect/runtime-flags"
-import { Workspace } from "../../src/control-plane/workspace"
-import { Plugin } from "../../src/plugin/index"
-import { InstanceBootstrap } from "../../src/project/bootstrap-service"
-import { InstanceStore } from "../../src/project/instance-store"
-import { Project } from "../../src/project/project"
-import { Vcs } from "../../src/project/vcs"
-import { InstanceState } from "../../src/effect/instance-state"
-import { Session } from "../../src/session/session"
-import { SessionPrompt } from "../../src/session/prompt"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { AccountTest } from "../fake/account"
-import { AuthTest } from "../fake/auth"
-import { NpmTest } from "../fake/npm"
-
-const configLayer = Config.layer.pipe(
-  Layer.provide(EffectFlock.defaultLayer),
-  Layer.provide(FSUtil.defaultLayer),
-  Layer.provide(Env.defaultLayer),
-  Layer.provide(AuthTest.empty),
-  Layer.provide(AccountTest.empty),
-  Layer.provide(NpmTest.noop),
-  Layer.provide(FetchHttpClient.layer),
-)
-const pluginLayer = Plugin.layer.pipe(
-  Layer.provide(EventV2Bridge.defaultLayer),
-  Layer.provide(configLayer),
-  Layer.provide(RuntimeFlags.layer({ disableDefaultPlugins: true })),
-)
-const noopBootstrapLayer = Layer.succeed(InstanceBootstrap.Service, InstanceBootstrap.Service.of({ run: Effect.void }))
-const workspaceLayer = Workspace.layer.pipe(
-  Layer.provide(Auth.defaultLayer),
-  Layer.provide(Session.defaultLayer),
-  Layer.provide(SessionPrompt.defaultLayer),
-  Layer.provide(Project.defaultLayer),
-  Layer.provide(Vcs.defaultLayer),
-  Layer.provide(FetchHttpClient.layer),
-  Layer.provide(Database.defaultLayer),
-  Layer.provide(EventV2Bridge.defaultLayer),
-  Layer.provide(FSUtil.defaultLayer),
-  Layer.provide(InstanceStore.defaultLayer.pipe(Layer.provide(noopBootstrapLayer))),
-  Layer.provide(RuntimeFlags.layer({ experimentalWorkspaces: true })),
-)
-const it = testEffect(
-  Layer.mergeAll(pluginLayer, workspaceLayer, CrossSpawnSpawner.defaultLayer).pipe(Layer.provide(Ripgrep.defaultLayer)),
-)
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-describe("plugin.workspace", () => {
-  it.instance("plugin can install a workspace adapter", () =>
-    Effect.gen(function* () {
-      const dir = (yield* TestInstance).directory
-      const type = `plug-${Math.random().toString(36).slice(2)}`
-      const file = path.join(dir, "plugin.ts")
-      const mark = path.join(dir, "created.json")
-      const space = path.join(dir, "space")
-      yield* Effect.promise(() =>
-        Bun.write(
-          file,
-          [
-            "export default async ({ experimental_workspace }) => {",
-            `  experimental_workspace.register(${JSON.stringify(type)}, {`,
-            '    name: "plug",',
-            '    description: "plugin workspace adapter",',
-            "    configure(input) {",
-            `      return { ...input, name: "plug", branch: "plug/main", directory: ${JSON.stringify(space)} }`,
-            "    },",
-            "    async create(input) {",
-            `      await Bun.write(${JSON.stringify(mark)}, JSON.stringify(input))`,
-            "    },",
-            "    async remove() {},",
-            "    target(input) {",
-            '      return { type: "local", directory: input.directory }',
-            "    },",
-            "  })",
-            "  return {}",
-            "}",
-            "",
-          ].join("\n"),
-        ),
-      )
-
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(dir, "miaw.json"),
-          JSON.stringify(
-            {
-              $schema: "https://miaw/config.json",
-              plugin: [pathToFileURL(file).href],
-            },
-            null,
-            2,
-          ),
-        ),
-      )
-
-      const plugin = yield* Plugin.Service
-      yield* plugin.init()
-      const workspace = yield* Workspace.Service
-      const ctx = yield* InstanceState.context
-      const info = yield* workspace.create({
-        type,
-        branch: null,
-        extra: { key: "value" },
-        projectID: ctx.project.id,
-      })
-
-      expect(info.type).toBe(type)
-      expect(info.name).toBe("plug")
-      expect(info.branch).toBe("plug/main")
-      expect(info.directory).toBe(space)
-      expect(info.extra).toEqual({ key: "value" })
-      expect(JSON.parse(yield* Effect.promise(() => Bun.file(mark).text()))).toMatchObject({
-        type,
-        name: "plug",
-        branch: "plug/main",
-        directory: space,
-        extra: { key: "value" },
-      })
-    }),
-  )
-})