@miaws/miaw 1.18.5 → 1.18.7

package/test/agent/plan-mode-subagent-bypass.test.ts

@@ -1,159 +0,0 @@
-import { PermissionV1 } from "@miaw/core/v1/permission"
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { Agent } from "../../src/agent/agent"
-import { deriveSubagentSessionPermission } from "../../src/agent/subagent-permissions"
-import { Permission } from "../../src/permission"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Agent.defaultLayer)
-
-function testAgent(input: {
-  name: string
-  mode: Agent.Info["mode"]
-  permission: Parameters<typeof Permission.fromConfig>[0]
-}) {
-  return {
-    name: input.name,
-    mode: input.mode,
-    permission: Permission.fromConfig(input.permission),
-    options: {},
-  } satisfies Agent.Info
-}
-
-// `deriveSubagentSessionPermission` is imported from production. The test
-// exercises the actual helper that task.ts uses to build the subagent's
-// session permission, so any regression in that helper trips this test.
-
-it.instance("subagent permissions take precedence over parent agent restrictions", () =>
-  Effect.gen(function* () {
-    const planAgent = yield* Agent.use.get("plan")
-    const generalAgent = yield* Agent.use.get("general")
-
-    expect(planAgent).toBeDefined()
-    expect(generalAgent).toBeDefined()
-    // Sanity: the plan agent itself blocks edit. (Note: `write` and
-    // `apply_patch` route through the `edit` permission at the runtime
-    // tool layer — see Permission.disabled / EDIT_TOOLS.)
-    expect(Permission.evaluate("edit", "/some/file.ts", planAgent!.permission).action).toBe("deny")
-
-    const parentSessionPermission: PermissionV1.Ruleset = []
-
-    const subagentSessionPermission = deriveSubagentSessionPermission({
-      parentSessionPermission,
-      subagent: generalAgent!,
-    })
-
-    // Mirror the runtime evaluation in session/prompt.ts (~line 410, 639):
-    //   ruleset: Permission.merge(agent.permission, session.permission ?? [])
-    const effective = Permission.merge(generalAgent!.permission, subagentSessionPermission)
-
-    expect(Permission.evaluate("edit", "/some/file.ts", effective).action).not.toBe("deny")
-    expect(Permission.disabled(["edit", "write", "apply_patch"], effective)).toEqual(new Set())
-  }),
-)
-
-it.instance("subagent's own read-only restriction remains effective", () =>
-  Effect.gen(function* () {
-    const explore = yield* Agent.use.get("explore")
-    expect(explore).toBeDefined()
-
-    const parentSessionPermission: PermissionV1.Ruleset = []
-    const subagentSessionPermission = deriveSubagentSessionPermission({
-      parentSessionPermission,
-      subagent: explore!,
-    })
-    const effective = Permission.merge(explore!.permission, subagentSessionPermission)
-
-    expect(Permission.evaluate("edit", "/x.ts", effective).action).toBe("deny")
-  }),
-)
-
-it.instance(
-  "custom subagent can explicitly enable edits denied to its parent agent",
-  () =>
-    Effect.gen(function* () {
-      const planAgent = yield* Agent.use.get("plan")
-      const my = yield* Agent.use.get("my_subagent")
-      expect(planAgent).toBeDefined()
-      expect(my).toBeDefined()
-
-      const parentSessionPermission: PermissionV1.Ruleset = []
-      const subagentSessionPermission = deriveSubagentSessionPermission({
-        parentSessionPermission,
-        subagent: my!,
-      })
-      const effective = Permission.merge(my!.permission, subagentSessionPermission)
-
-      expect(Permission.evaluate("edit", "/some/file.ts", planAgent!.permission).action).toBe("deny")
-      expect(Permission.evaluate("edit", "/some/file.ts", effective).action).toBe("allow")
-      expect(Permission.disabled(["edit", "write", "apply_patch"], effective)).toEqual(new Set())
-    }),
-  {
-    config: {
-      agent: {
-        my_subagent: {
-          description: "A user-defined subagent",
-          mode: "subagent",
-          permission: {
-            edit: "allow",
-          },
-        },
-      },
-    },
-  },
-)
-
-it.effect("subagent self permissions are preserved", () =>
-  Effect.sync(() => {
-    const executor = testAgent({
-      name: "executor",
-      mode: "subagent",
-      permission: {
-        "*": "deny",
-        read: "allow",
-        bash: "allow",
-        task: {
-          "*": "deny",
-          worker: "allow",
-        },
-        edit: "allow",
-      },
-    })
-
-    const effective = Permission.merge(
-      executor.permission,
-      deriveSubagentSessionPermission({
-        parentSessionPermission: [],
-        subagent: executor,
-      }),
-    )
-
-    expect(Permission.evaluate("read", "README.md", effective).action).toBe("allow")
-    expect(Permission.evaluate("bash", "git status", effective).action).toBe("allow")
-    expect(Permission.evaluate("task", "worker", effective).action).toBe("allow")
-    expect(Permission.evaluate("task", "other", effective).action).toBe("deny")
-    expect(Permission.disabled(["edit", "write", "apply_patch"], effective)).toEqual(new Set())
-  }),
-)
-
-it.effect("subagent inherits parent session deny rules as hard runtime ceilings", () =>
-  Effect.sync(() => {
-    const executor = testAgent({
-      name: "executor",
-      mode: "subagent",
-      permission: {
-        bash: "allow",
-      },
-    })
-    const effective = Permission.merge(
-      executor.permission,
-      deriveSubagentSessionPermission({
-        parentSessionPermission: Permission.fromConfig({ bash: "deny" }),
-        subagent: executor,
-      }),
-    )
-
-    expect(Permission.evaluate("bash", "git status", effective).action).toBe("deny")
-  }),
-)

package/test/agent/plugin-agent-regression.test.ts

@@ -1,64 +0,0 @@
-import { expect } from "bun:test"
-import { FSUtil } from "@miaw/core/fs-util"
-import { LocationServiceMap } from "@miaw/core/location-layer"
-import { Effect, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import path from "path"
-import { pathToFileURL } from "url"
-import { Agent } from "../../src/agent/agent"
-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"
-import { AccountTest } from "../fake/account"
-import { AuthTest } from "../fake/auth"
-import { NpmTest } from "../fake/npm"
-import { ProviderTest } from "../fake/provider"
-import { SkillTest } from "../fake/skill"
-import { testEffect } from "../lib/effect"
-import { PLUGIN_AGENT } from "../fixture/agent-plugin.constants"
-
-// `it.instance` skips InstanceBootstrap so LSP / MCP don't spin up — those
-// services hang during scope teardown on Windows and aren't needed
-// to verify plugin → config hook → Agent.list.
-const pluginUrl = pathToFileURL(path.join(import.meta.dir, "..", "fixture", "agent-plugin.ts")).href
-
-const provider = ProviderTest.fake()
-const configLayer = Config.layer.pipe(
-  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 agentLayer = Agent.layer.pipe(
-  Layer.provide(configLayer),
-  Layer.provide(AuthTest.empty),
-  Layer.provide(SkillTest.empty),
-  Layer.provide(provider.layer),
-  Layer.provide(pluginLayer),
-  Layer.provide(LocationServiceMap.layer),
-  Layer.provide(RuntimeFlags.layer({ disableDefaultPlugins: true })),
-)
-
-const it = testEffect(Layer.mergeAll(agentLayer, pluginLayer))
-
-it.instance(
-  "plugin-registered agents appear in Agent.list",
-  () =>
-    Effect.gen(function* () {
-      yield* Plugin.Service.use((p) => p.init())
-      const agents = yield* Agent.use.list()
-      const added = agents.find((agent) => agent.name === PLUGIN_AGENT.name)
-      expect(added?.description).toBe(PLUGIN_AGENT.description)
-      expect(added?.mode).toBe(PLUGIN_AGENT.mode)
-    }),
-  { config: { plugin: [pluginUrl] } },
-)

package/test/auth/auth.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Auth } from "../../src/auth"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { testEffect } from "../lib/effect"
-
-const node = CrossSpawnSpawner.defaultLayer
-
-const it = testEffect(Layer.mergeAll(Auth.defaultLayer, node))
-
-describe("Auth", () => {
-  it.instance("set normalizes trailing slashes in keys", () =>
-    Effect.gen(function* () {
-      const auth = yield* Auth.Service
-      yield* auth.set("https://example.com/", {
-        type: "wellknown",
-        key: "TOKEN",
-        token: "abc",
-      })
-      const data = yield* auth.all()
-      expect(data["https://example.com"]).toBeDefined()
-      expect(data["https://example.com/"]).toBeUndefined()
-    }),
-  )
-
-  it.instance("set cleans up pre-existing trailing-slash entry", () =>
-    Effect.gen(function* () {
-      const auth = yield* Auth.Service
-      yield* auth.set("https://example.com/", {
-        type: "wellknown",
-        key: "TOKEN",
-        token: "old",
-      })
-      yield* auth.set("https://example.com", {
-        type: "wellknown",
-        key: "TOKEN",
-        token: "new",
-      })
-      const data = yield* auth.all()
-      const keys = Object.keys(data).filter((key) => key.includes("example.com"))
-      expect(keys).toEqual(["https://example.com"])
-      const entry = data["https://example.com"]!
-      expect(entry.type).toBe("wellknown")
-      if (entry.type === "wellknown") expect(entry.token).toBe("new")
-    }),
-  )
-
-  it.instance("remove deletes both trailing-slash and normalized keys", () =>
-    Effect.gen(function* () {
-      const auth = yield* Auth.Service
-      yield* auth.set("https://example.com", {
-        type: "wellknown",
-        key: "TOKEN",
-        token: "abc",
-      })
-      yield* auth.remove("https://example.com/")
-      const data = yield* auth.all()
-      expect(data["https://example.com"]).toBeUndefined()
-      expect(data["https://example.com/"]).toBeUndefined()
-    }),
-  )
-
-  it.instance("set and remove are no-ops on keys without trailing slashes", () =>
-    Effect.gen(function* () {
-      const auth = yield* Auth.Service
-      yield* auth.set("anthropic", {
-        type: "api",
-        key: "sk-test",
-      })
-      const data = yield* auth.all()
-      expect(data["anthropic"]).toBeDefined()
-      yield* auth.remove("anthropic")
-      const after = yield* auth.all()
-      expect(after["anthropic"]).toBeUndefined()
-    }),
-  )
-})

package/test/background/job.test.ts

@@ -1,243 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Deferred, Effect } from "effect"
-import { BackgroundJob } from "@/background/job"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(BackgroundJob.defaultLayer)
-
-describe("background.job", () => {
-  it.instance("tracks started jobs through completion", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const latch = yield* Deferred.make<void>()
-      const job = yield* jobs.start({
-        type: "test",
-        title: "test job",
-        run: Deferred.await(latch).pipe(Effect.as("done")),
-      })
-
-      expect(job.id.startsWith("job_")).toBe(true)
-      expect(job.status).toBe("running")
-      expect(job.title).toBe("test job")
-
-      yield* Deferred.succeed(latch, undefined)
-      const done = yield* jobs.wait({ id: job.id })
-
-      expect(done.timedOut).toBe(false)
-      expect(done.info?.status).toBe("completed")
-      expect(done.info?.output).toBe("done")
-      expect((yield* jobs.list()).map((item) => item.id)).toEqual([job.id])
-    }),
-  )
-
-  it.instance("returns a running snapshot when wait times out", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const job = yield* jobs.start({
-        type: "test",
-        run: Effect.never,
-      })
-
-      const result = yield* jobs.wait({ id: job.id, timeout: 1 })
-
-      expect(result.timedOut).toBe(true)
-      expect(result.info?.status).toBe("running")
-    }),
-  )
-
-  it.instance("deduplicates concurrent starts for a running id", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const started = yield* Deferred.make<void>()
-      const id = "job_test"
-      const [first, second] = yield* Effect.all(
-        [
-          jobs.start({
-            id,
-            type: "test",
-            run: Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)),
-          }),
-          jobs.start({
-            id,
-            type: "test",
-            run: Effect.fail(new Error("duplicate started")),
-          }),
-        ],
-        { concurrency: "unbounded" },
-      )
-
-      yield* Deferred.await(started)
-
-      expect(first.id).toBe(id)
-      expect(second.id).toBe(id)
-      expect(first.status).toBe("running")
-      expect(second.status).toBe("running")
-      expect((yield* jobs.list()).map((item) => item.id)).toEqual([id])
-
-      yield* jobs.cancel(id)
-    }),
-  )
-
-  it.instance("waits for extensions before completing a running job", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const first = yield* Deferred.make<void>()
-      const second = yield* Deferred.make<void>()
-      const job = yield* jobs.start({
-        type: "test",
-        run: Deferred.await(first).pipe(Effect.as("first")),
-      })
-
-      expect(yield* jobs.extend({ id: job.id, run: Deferred.await(second).pipe(Effect.as("second")) })).toBe(true)
-      yield* Deferred.succeed(first, undefined)
-      expect((yield* jobs.get(job.id))?.status).toBe("running")
-
-      yield* Deferred.succeed(second, undefined)
-      const done = yield* jobs.wait({ id: job.id })
-      expect(done.info?.status).toBe("completed")
-      expect(done.info?.output).toBe("second")
-    }),
-  )
-
-  it.instance("runs extensions after earlier work completes", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const first = yield* Deferred.make<void>()
-      const order: string[] = []
-      const job = yield* jobs.start({
-        type: "test",
-        run: Effect.sync(() => order.push("start")).pipe(Effect.andThen(Deferred.await(first)), Effect.as("first")),
-      })
-
-      expect(
-        yield* jobs.extend({
-          id: job.id,
-          run: Effect.sync(() => order.push("extend")).pipe(Effect.as("second")),
-        }),
-      ).toBe(true)
-      yield* Effect.yieldNow
-      expect(order).toEqual(["start"])
-
-      yield* Deferred.succeed(first, undefined)
-      expect((yield* jobs.wait({ id: job.id })).info?.output).toBe("second")
-      expect(order).toEqual(["start", "extend"])
-    }),
-  )
-
-  it.instance("rejects extensions after a job completes", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const job = yield* jobs.start({ type: "test", run: Effect.succeed("done") })
-      yield* jobs.wait({ id: job.id })
-
-      expect(yield* jobs.extend({ id: job.id, run: Effect.succeed("late") })).toBe(false)
-      expect((yield* jobs.get(job.id))?.output).toBe("done")
-    }),
-  )
-
-  it.instance("records failed jobs", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const job = yield* jobs.start({
-        type: "test",
-        run: Effect.fail(new Error("boom")),
-      })
-
-      const result = yield* jobs.wait({ id: job.id })
-
-      expect(result.info?.status).toBe("error")
-      expect(result.info?.error).toBe("boom")
-    }),
-  )
-
-  it.instance("ignores stale settlements after restarting a failed job", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const fail = yield* Deferred.make<void>()
-      const interrupted = yield* Deferred.make<void>()
-      const release = yield* Deferred.make<void>()
-      const id = "job_test"
-      yield* jobs.start({
-        id,
-        type: "test",
-        run: Deferred.await(fail).pipe(Effect.andThen(Effect.fail(new Error("boom")))),
-      })
-      yield* jobs.extend({
-        id,
-        run: Effect.never.pipe(
-          Effect.ensuring(Deferred.succeed(interrupted, undefined).pipe(Effect.andThen(Deferred.await(release)))),
-        ),
-      })
-
-      yield* Deferred.succeed(fail, undefined)
-      expect((yield* jobs.wait({ id })).info?.status).toBe("error")
-      yield* Deferred.await(interrupted)
-      yield* jobs.start({ id, type: "test", run: Effect.never })
-
-      yield* Deferred.succeed(release, undefined)
-      yield* Effect.yieldNow
-      expect((yield* jobs.get(id))?.status).toBe("running")
-      yield* jobs.cancel(id)
-    }),
-  )
-
-  it.instance("can cancel running jobs", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const interrupted = yield* Deferred.make<void>()
-      const job = yield* jobs.start({
-        type: "test",
-        run: Effect.never.pipe(Effect.ensuring(Deferred.succeed(interrupted, undefined))),
-      })
-      yield* jobs.extend({
-        id: job.id,
-        run: Effect.never,
-      })
-
-      const cancelled = yield* jobs.cancel(job.id)
-
-      expect(cancelled?.status).toBe("cancelled")
-      yield* Deferred.await(interrupted).pipe(Effect.timeout("1 second"))
-      expect((yield* jobs.get(job.id))?.status).toBe("cancelled")
-    }),
-  )
-
-  it.instance("promotes running jobs without interrupting them", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const latch = yield* Deferred.make<void>()
-      const promoted = yield* Deferred.make<void>()
-      const job = yield* jobs.start({
-        type: "test",
-        metadata: { parentSessionId: "parent" },
-        onPromote: Deferred.succeed(promoted, undefined).pipe(Effect.asVoid),
-        run: Deferred.await(latch).pipe(Effect.as("done")),
-      })
-
-      const info = yield* jobs.promote(job.id)
-
-      expect(info?.status).toBe("running")
-      expect(info?.metadata?.background).toBe(true)
-      yield* Deferred.await(promoted)
-      expect((yield* jobs.get(job.id))?.status).toBe("running")
-
-      yield* Deferred.succeed(latch, undefined)
-      expect((yield* jobs.wait({ id: job.id })).info?.output).toBe("done")
-    }),
-  )
-
-  it.instance("returns immutable snapshots", () =>
-    Effect.gen(function* () {
-      const jobs = yield* BackgroundJob.Service
-      const job = yield* jobs.start({
-        type: "test",
-        metadata: { value: "initial" },
-        run: Effect.succeed("done"),
-      })
-
-      if (job.metadata) job.metadata.value = "changed"
-
-      expect((yield* jobs.get(job.id))?.metadata?.value).toBe("initial")
-    }),
-  )
-})

package/test/cli/account.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import stripAnsi from "strip-ansi"
-
-import { defaultConsoleUrl, formatAccountLabel, formatOrgLine } from "../../src/cli/cmd/account"
-
-describe("console account display", () => {
-  test("uses console.miaw as the default login URL", () => {
-    expect(defaultConsoleUrl).toBe("https://console.miaw")
-  })
-
-  test("includes the account url in account labels", () => {
-    expect(stripAnsi(formatAccountLabel({ email: "one@example.com", url: "https://one.example.com" }, false))).toBe(
-      "one@example.com https://one.example.com",
-    )
-  })
-
-  test("includes the active marker in account labels", () => {
-    expect(stripAnsi(formatAccountLabel({ email: "one@example.com", url: "https://one.example.com" }, true))).toBe(
-      "one@example.com https://one.example.com (active)",
-    )
-  })
-
-  test("includes the account url in org rows", () => {
-    expect(
-      stripAnsi(
-        formatOrgLine({ email: "one@example.com", url: "https://one.example.com" }, { id: "org-1", name: "One" }, true),
-      ),
-    ).toBe("  ● One  one@example.com  https://one.example.com  org-1")
-  })
-})

package/test/cli/acp/acp-test-client.ts

@@ -1,97 +0,0 @@
-import { expect } from "bun:test"
-import type { SessionConfigOption, SessionConfigSelectOption } from "@agentclientprotocol/sdk"
-import { Duration, Effect } from "effect"
-import type { AcpHandle } from "../../lib/cli-process"
-
-type JsonRpcRequest = {
-  readonly jsonrpc: "2.0"
-  readonly id: number
-  readonly method: string
-  readonly params?: unknown
-}
-
-type JsonRpcResponse<T = unknown> = {
-  readonly jsonrpc: "2.0"
-  readonly id: number
-  readonly result?: T
-  readonly error?: unknown
-}
-
-type JsonRpcNotification<T = unknown> = {
-  readonly jsonrpc: "2.0"
-  readonly method: string
-  readonly params?: T
-}
-
-export type AcpClient = {
-  readonly request: <T>(method: string, params?: unknown) => Effect.Effect<JsonRpcResponse<T>, unknown>
-  readonly receive: Effect.Effect<unknown>
-  readonly waitForNotification: <T>(
-    method: string,
-    predicate: (params: T) => boolean,
-    timeoutMs?: number,
-  ) => Effect.Effect<JsonRpcNotification<T>, unknown>
-}
-
-export function createAcpClient(acp: AcpHandle): AcpClient {
-  const state = { nextId: 1 }
-
-  const request = <T>(method: string, params?: unknown) =>
-    Effect.gen(function* () {
-      const id = state.nextId++
-      const message: JsonRpcRequest =
-        params === undefined ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params }
-      yield* acp.send(message)
-
-      while (true) {
-        const received = yield* acp.receive.pipe(Effect.timeout(Duration.seconds(15)))
-        if (isJsonRpcResponse<T>(received) && received.id === id) return received
-      }
-    })
-
-  const waitForNotification = <T>(method: string, predicate: (params: T) => boolean, timeoutMs = 15_000) =>
-    Effect.gen(function* () {
-      while (true) {
-        const received = yield* acp.receive.pipe(Effect.timeout(Duration.millis(timeoutMs)))
-        if (!isJsonRpcNotification<T>(received)) continue
-        if (received.method === method && predicate(received.params as T)) return received
-      }
-    })
-
-  return {
-    request,
-    receive: acp.receive,
-    waitForNotification,
-  }
-}
-
-export function expectOk<T>(response: JsonRpcResponse<T>) {
-  expect(response.error).toBeUndefined()
-  expect(response.result).toBeDefined()
-  return response.result as T
-}
-
-export function selectConfigOption(options: SessionConfigOption[] | null | undefined, id: string) {
-  return options?.find(
-    (option): option is Extract<SessionConfigOption, { type: "select" }> =>
-      option.id === id && option.type === "select",
-  )
-}
-
-export function firstAlternateValue(option: Extract<SessionConfigOption, { type: "select" }>) {
-  return flattenSelectOptions(option).find((item) => item.value !== option.currentValue)?.value
-}
-
-export function flattenSelectOptions(option: Extract<SessionConfigOption, { type: "select" }>) {
-  return option.options.flatMap((item): SessionConfigSelectOption[] => ("value" in item ? [item] : item.options))
-}
-
-function isJsonRpcResponse<T>(input: unknown): input is JsonRpcResponse<T> {
-  if (!input || typeof input !== "object") return false
-  return "id" in input && "jsonrpc" in input
-}
-
-function isJsonRpcNotification<T>(input: unknown): input is JsonRpcNotification<T> {
-  if (!input || typeof input !== "object") return false
-  return "method" in input && !("id" in input) && "jsonrpc" in input
-}