fix(core): discover local plugin packages

packages/core/src/config/plugin/source.ts

@@ -4,7 +4,7 @@ import { Directory, Document, type Entry } from "@opencode-ai/schema/config"
 import { ConfigPlugin } from "@opencode-ai/schema/config/plugin"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer, Option, PubSub, Scope, Stream } from "effect"
+import { Context, Effect, Layer, Option, PubSub, Schema, Scope, Stream } from "effect"
 import path from "path"
 import { fileURLToPath } from "url"
 import { Config } from "../../config"
@@ -154,6 +154,12 @@ const scan = Effect.fn("ConfigPluginSource.scan")(function* (
 })
 
 const sourceDirectories = ["plugin", "plugins"] as const
+const Package = Schema.Struct({
+  exports: Schema.optional(Schema.Unknown),
+  module: Schema.optional(Schema.Unknown),
+  main: Schema.optional(Schema.Unknown),
+})
+const decodePackage = Schema.decodeUnknownOption(Package)
 
 function discoverDirectory(fs: FSUtil.Interface, directory: string) {
   return Effect.gen(function* () {
@@ -166,7 +172,38 @@ function discoverDirectory(fs: FSUtil.Interface, directory: string) {
         symlink: true,
       })
       .pipe(Effect.orElseSucceed(() => []))
-    return files.sort().map((target): Operation => ({ type: "add", target, options: {} }))
+    const children = yield* fs
+      .scan(`{${sourceDirectories.join(",")}}/*`, {
+        cwd: directory,
+        absolute: true,
+        include: "all",
+        dot: true,
+        symlink: true,
+      })
+      .pipe(Effect.orElseSucceed(() => []))
+    const directories = yield* Effect.filter(children.sort(), fs.isDir)
+    const packages = yield* Effect.forEach(directories, (child) => discoverPackage(fs, child))
+    return [...files.sort(), ...packages.filter((target): target is string => typeof target === "string")].map(
+      (target): Operation => ({ type: "add", target, options: {} }),
+    )
+  })
+}
+
+function discoverPackage(fs: FSUtil.Interface, directory: string) {
+  return Effect.gen(function* () {
+    const manifest = yield* fs
+      .readJson(path.join(directory, "package.json"))
+      .pipe(Effect.map(decodePackage), Effect.orElseSucceed(Option.none))
+    const configured = Option.isSome(manifest)
+      ? [manifest.value.exports, manifest.value.module, manifest.value.main].filter(
+          (entry): entry is string => typeof entry === "string",
+        )
+      : []
+    const target = yield* Effect.findFirst(
+      [...configured, "index.ts", "index.js"].map((entry) => path.resolve(directory, entry)),
+      fs.isFile,
+    )
+    return Option.getOrUndefined(target)
   })
 }
 

packages/core/src/database/v1-migration.ts

@@ -440,7 +440,7 @@ export function status(): Effect.Effect<Status, never, Database.Service> {
 
 export const layer = Layer.effectDiscard(
   Effect.gen(function* () {
-    runtimeState = { status: "running", progress: { label: "Migrating sessions" } }
+    runtimeState = { status: "running", progress: { label: "Clearing old events" } }
     yield* run().pipe(
       Effect.matchCauseEffect({
         onFailure: (cause) =>
@@ -485,6 +485,7 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
           yield* db
             .transaction((tx) =>
               Effect.gen(function* () {
+                yield* tx.delete(EventTable).run()
                 yield* tx
                   .insert(KVTable)
                   .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } })
@@ -566,7 +567,6 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
                 yield* Effect.forEach(transformed.warnings, (warning) =>
                   Effect.logWarning("Skipped V1 migration row", warning),
                 )
-                yield* tx.delete(EventTable).where(eq(EventTable.aggregate_id, next.id)).run()
                 yield* tx.delete(SessionMessageTable).where(eq(SessionMessageTable.session_id, next.id)).run()
                 yield* Effect.forEach(transformed.messages, (message) =>
                   tx.run(sql`

packages/core/test/config/plugin.test.ts

@@ -168,6 +168,69 @@ describe("PluginSupervisor config", () => {
     ),
   )
 
+  it.live("loads auto-discovered plugin packages from package metadata", () =>
+    withLocation(
+      undefined,
+      Effect.gen(function* () {
+        yield* ready()
+        const plugins = yield* Plugin.Service
+        expect((yield* plugins.list()).map((plugin) => String(plugin.id))).toContain("package-metadata")
+      }),
+      false,
+      async (directory) => {
+        const plugin = path.join(directory, ".opencode", "plugins", "package-metadata")
+        await fs.mkdir(plugin, { recursive: true })
+        await fs.writeFile(path.join(plugin, "package.json"), JSON.stringify({ exports: "./entry.ts" }))
+        await fs.writeFile(path.join(plugin, "entry.ts"), discoveredPlugin("package-metadata"))
+      },
+    ),
+  )
+
+  it.live("loads auto-discovered plugin packages from index fallback", () =>
+    withLocation(
+      undefined,
+      Effect.gen(function* () {
+        yield* ready()
+        const plugins = yield* Plugin.Service
+        expect((yield* plugins.list()).map((plugin) => String(plugin.id))).toContain("index-fallback")
+      }),
+      false,
+      async (directory) => {
+        const plugin = path.join(directory, ".opencode", "plugins", "index-fallback")
+        await fs.mkdir(plugin, { recursive: true })
+        await fs.writeFile(path.join(plugin, "index.js"), discoveredPlugin("index-fallback"))
+      },
+    ),
+  )
+
+  it.live("prefers package metadata over index fallback", () =>
+    withLocation(
+      undefined,
+      Effect.gen(function* () {
+        yield* ready()
+        const plugins = yield* Plugin.Service
+        const ids = (yield* plugins.list()).map((plugin) => String(plugin.id))
+        expect(ids).toContain("metadata-precedence")
+        expect(ids).not.toContain("module-collision")
+        expect(ids).not.toContain("main-collision")
+        expect(ids).not.toContain("index-collision")
+      }),
+      false,
+      async (directory) => {
+        const plugin = path.join(directory, ".opencode", "plugins", "collision")
+        await fs.mkdir(plugin, { recursive: true })
+        await fs.writeFile(
+          path.join(plugin, "package.json"),
+          JSON.stringify({ exports: "./entry.js", module: "./module.js", main: "./main.js" }),
+        )
+        await fs.writeFile(path.join(plugin, "entry.js"), discoveredPlugin("metadata-precedence"))
+        await fs.writeFile(path.join(plugin, "module.js"), discoveredPlugin("module-collision"))
+        await fs.writeFile(path.join(plugin, "main.js"), discoveredPlugin("main-collision"))
+        await fs.writeFile(path.join(plugin, "index.js"), discoveredPlugin("index-collision"))
+      },
+    ),
+  )
+
   staticIt.live("uses only internal and SDK plugins when the static source is wired", () =>
     Effect.gen(function* () {
       const sdk = yield* SdkPlugins.Service
@@ -389,3 +452,7 @@ export default Plugin.define({
 })
 `
 }
+
+function discoveredPlugin(id: string) {
+  return `export default { id: ${JSON.stringify(id)}, setup() {} }`
+}

packages/core/test/v1-migration.test.ts

@@ -1039,7 +1039,7 @@ describe("V1Migration database workflow", () => {
     )
   })
 
-  test("deletes events only in each successfully checkpointed session transaction", async () => {
+  test("rolls back one session atomically and resumes from the committed cursor", async () => {
     await database(
       Effect.gen(function* () {
         const { db } = yield* Database.Service
@@ -1057,19 +1057,9 @@ describe("V1Migration database workflow", () => {
         yield* db.run(
           sql`INSERT INTO session_message (id, session_id, type, seq, time_created, time_updated, data) VALUES ('msg_stale_b', 'ses_b', 'user', 0, 7, 8, '{"text":"stale","time":{"created":7}}')`,
         )
-        yield* db.run(sql`
-          INSERT INTO event_sequence (aggregate_id, seq, owner_id) VALUES
-            ('ses_a', 7, 'owner'),
-            ('ses_b', 7, 'owner'),
-            ('ses_c', 7, 'owner'),
-            ('ses_unrelated', 7, 'owner')
-        `)
+        yield* db.run(sql`INSERT INTO event_sequence (aggregate_id, seq, owner_id) VALUES ('ses_b', 7, 'owner')`)
         yield* db.run(
-          sql`INSERT INTO event (id, aggregate_id, seq, created, type, data) VALUES
-            ('event_stale_a', 'ses_a', 7, 1, 'session.renamed.1', '{}'),
-            ('event_stale_b', 'ses_b', 7, 1, 'session.renamed.1', '{}'),
-            ('event_stale_c', 'ses_c', 7, 1, 'session.renamed.1', '{}'),
-            ('event_unrelated', 'ses_unrelated', 7, 1, 'session.renamed.1', '{}')`,
+          sql`INSERT INTO event (id, aggregate_id, seq, created, type, data) VALUES ('event_stale_b', 'ses_b', 7, 1, 'session.renamed.1', '{}')`,
         )
         yield* Layer.launch(V1Migration.layer).pipe(Effect.forkScoped)
         const failed = yield* V1Migration.status().pipe(
@@ -1101,14 +1091,13 @@ describe("V1Migration database workflow", () => {
           seq: 7,
           owner_id: "owner",
         })
-        expect(yield* db.all(sql`SELECT id FROM event ORDER BY id`)).toEqual([
-          { id: "event_stale_a" },
-          { id: "event_stale_b" },
-          { id: "event_unrelated" },
-        ])
+        expect(yield* db.all(sql`SELECT id FROM event WHERE aggregate_id = 'ses_b'`)).toEqual([])
         expect(yield* db.get(sql`SELECT value FROM kv WHERE key = 'migration.v1-v2'`)).toEqual({
           value: '{"phase":"sessions","cursor":"ses_c"}',
         })
+        yield* db.run(
+          sql`INSERT INTO event (id, aggregate_id, seq, created, type, data) VALUES ('event_after_clear', 'ses_c', 0, 2, 'session.renamed.1', '{}')`,
+        )
         yield* db.run(sql`DROP TRIGGER fail_b`)
         yield* Layer.launch(V1Migration.layer).pipe(Effect.forkScoped)
         yield* V1Migration.status().pipe(
@@ -1121,7 +1110,7 @@ describe("V1Migration database workflow", () => {
           seq: -1,
           owner_id: null,
         })
-        expect(yield* db.all(sql`SELECT id FROM event`)).toEqual([{ id: "event_unrelated" }])
+        expect(yield* db.all(sql`SELECT id FROM event`)).toEqual([{ id: "event_after_clear" }])
       }),
     )
   })