@miaws/miaw 1.18.4 → 1.18.5

package/test/plugin/shared.test.ts

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,278 @@
+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

@@ -0,0 +1,120 @@
+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

@@ -0,0 +1,140 @@
+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" },
+      })
+    }),
+  )
+})