fix(gui-extensions): avoid startup round trip and keep renamed enable state (#53077)

This commit is contained in:
Luke Parker
2026-10-04 17:40:36 +10:00
committed by GitHub
Unverified
parent 715de7af15
commit 0d536d2d7d
29 changed files with 596 additions and 121 deletions
@@ -34,6 +34,8 @@ import { Persist, persisted } from "@/runtime/persistence/storage"
import { ServerScope } from "@/runtime/server/scope"
import { ExtensionHostProvider, useExtensionHost, type HostApiFactories } from "../src/runtime/extension/host"
import { createHostApis } from "../src/runtime/extension/host-apis"
import { createInstalled } from "../src/runtime/extension/installed"
import { extensionEnabled } from "@opencode/gui-extensions/sdk/bridge"
import { createRegion, RegionContent } from "../src/runtime/extension/panels"
import { ExtensionSlot } from "../src/runtime/extension/render"
import { persistedHandle } from "../src/runtime/extension/stores"
@@ -199,6 +201,7 @@ export function mountExtensionHost() {
export function mountExtensions(input: {
definitions: readonly Definition[]
disabled?: readonly string[]
bridge?: Parameters<typeof createInstalled>[0]
stored?: Readonly<Record<string, Json>>
/** Shows the production developer settings page for status-label contracts. */
settings?: boolean
@@ -242,10 +245,24 @@ export function mountExtensions(input: {
})
function MountedHost() {
const installed = input.bridge ? createInstalled(input.bridge) : undefined
const disabledState = createMemo(() => {
if (!installed) return disabled()
const state = installed.enableState()
if (!state) return undefined
return new Set(
input.definitions.flatMap((definition) => (extensionEnabled(definition, state) ? [] : [definition.id])),
)
})
return (
<ExtensionHostProvider
definitions={input.definitions}
disabled={disabled}
disabled={disabledState}
apis={fakeApis(storage)}
whenMounted={mounted}
>
@@ -9,6 +9,7 @@ import type {
SessionRef,
SessionScreen,
} from "@opencode/gui-extensions/sdk"
import type { Bridge, BridgeMessage, EnableState, Installed } from "@opencode/gui-extensions/sdk/bridge"
import { expect, sourceURL, story } from "../../storybook/playwright/story"
const fixture = sourceURL(new URL("./extension-host.fixture.tsx", import.meta.url))
@@ -895,3 +896,158 @@ story("declared global stores load before setup, so setup reads the stored value
expect(result).toEqual({ held: { status: "loading", seen: [] }, seen: [true] })
})
story("startup enable state does not wait for the manager, and live updates beat older replies", async ({ page }) => {
const result = await page.evaluate(async (fixture) => {
const { Contract, mountExtensions, until } = await import(fixture)
const Provider: Contract<number, "disabled.value"> = Contract.define("disabled.value")
const Dependent: Contract<number, "dependent.value"> = Contract.define("dependent.value")
const observed = { read: (): Live<number> => ({ status: "pending" }) }
const initial = Promise.withResolvers<readonly EnableState[]>()
const reply = Promise.withResolvers<readonly Installed[]>()
const listeners = new Set<(message: BridgeMessage) => void>()
const setups: string[] = []
const list = (disabled: readonly string[]): Installed[] =>
["dependent", "enabled", "disabled"].map((id) => ({
id,
name: id,
version: "1",
builtin: true,
enabled: !disabled.includes(id),
}))
const bridge: Bridge = {
packaged: false,
call: async () => undefined,
subscribe: async () => ({ available: false }),
on: (listener) => {
listeners.add(listener)
return () => void listeners.delete(listener)
},
embed() {},
capture: async () => undefined,
runMenubarItem() {},
configure() {},
manager: {
initial: initial.promise,
list: () => reply.promise,
enable: async () => {},
disable: async () => {},
reload: async () => {},
install: async () => {},
remove: async () => {},
source: async () => "",
asset: () => "",
},
}
const host = mountExtensions({
bridge,
// The consumer comes first; the provider's old-id setting arrives asynchronously from the preload.
definitions: [
{
id: "dependent",
requires: { provider: Provider },
provides: { value: Dependent },
renderer: async () => ({
default: (ctx: Context) => {
setups.push("dependent")
ctx.provide(Dependent, 2)
},
}),
},
{
id: "enabled",
uses: { value: Dependent },
renderer: async () => ({
default: (ctx: Context & { uses: { value: () => Live<number> } }) => {
setups.push("enabled")
observed.read = ctx.uses.value
},
}),
},
{
id: "disabled",
legacy: ["previous"],
provides: { value: Provider },
renderer: async () => ({
default: (ctx: Context) => {
setups.push("disabled")
ctx.provide(Provider, 1)
},
}),
},
],
})
await new Promise((resolve) => setTimeout(resolve, 50))
const before = [...setups]
initial.resolve([{ id: "previous", enabled: false }])
await until(() => host.ready())
const started = {
setups: [...setups],
status: host.status("disabled"),
dependent: host.status("dependent"),
live: observed.read(),
}
const unknown: { ready: boolean; setups: string[]; status?: string }[] = []
// A failed startup reply must not temporarily activate the disabled extension while list() waits.
for (const failure of ["unknown", "rejected"]) {
const initial = failure === "unknown" ? Promise.resolve(undefined) : Promise.reject(new Error("snapshot failed"))
const reply = Promise.withResolvers<readonly Installed[]>()
const failed = mountExtensions({
bridge: { ...bridge, manager: { ...bridge.manager, initial, list: () => reply.promise } },
definitions: [{ id: "disabled", renderer: async () => ({ default: () => void setups.push("wrongly enabled") }) }],
})
await new Promise((resolve) => setTimeout(resolve, 50))
const blocked = { ready: failed.ready(), setups: [...setups] }
reply.resolve(list(["disabled"]))
await until(() => failed.ready())
unknown.push({ ...blocked, status: failed.status("disabled") })
failed.unmount()
}
listeners.forEach((listener) => listener({ type: "extensions", list: list(["enabled"]) }))
await until(
() =>
host.status("disabled") === "active" &&
host.status("enabled") === "disabled" &&
host.status("dependent") === "active",
)
reply.resolve(list(["disabled"]))
await new Promise((resolve) => setTimeout(resolve, 50))
const updated = {
setups: [...setups],
status: [host.status("enabled"), host.status("disabled"), host.status("dependent")],
}
host.unmount()
return { before, started, unknown, updated, listeners: listeners.size }
}, fixture)
expect(result).toEqual({
before: [],
started: {
setups: ["enabled"],
status: "disabled",
dependent: "blocked",
live: { status: "inactive", reason: "blocked" },
},
unknown: [
{ ready: false, setups: ["enabled"], status: "disabled" },
{ ready: false, setups: ["enabled"], status: "disabled" },
],
updated: { setups: ["enabled", "disabled", "dependent"], status: ["disabled", "active", "active"] },
listeners: 0,
})
})
@@ -1,19 +1,24 @@
import { createResource, onCleanup } from "solid-js"
import { createMemo, createResource, onCleanup } from "solid-js"
import { createStore, reconcile } from "solid-js/store"
import type { Bridge, Installed } from "@opencode/gui-extensions/sdk/bridge"
/** The extensions main reports to this window: the initial list, then every list it pushes. */
/** Saved enable preferences and manager metadata; activation and blocked-dependency status belong to the host. */
export function createInstalled(bridge: Bridge | undefined) {
const [state, setState] = createStore({ list: [] as Installed[] })
const [state, setState] = createStore<{ list?: readonly Installed[] }>({})
// A pushed list is newer than the initial reply, so a reply that arrives after one is dropped.
const pushed = { count: 0 }
const [loaded] = createResource(async () => {
if (!bridge) return true
const [initial] = createResource(async () => (bridge ? bridge.manager.initial?.catch(() => undefined) : []))
// Metadata still loads for settings and failure reporting. Activation can use known preload rows before it arrives.
createResource(async () => {
if (!bridge) return
const seen = pushed.count
const list = await bridge.manager.list()
if (pushed.count === seen) setState("list", reconcile([...list]))
return true
})
if (bridge)
onCleanup(
bridge.on((message) => {
@@ -22,5 +27,9 @@ export function createInstalled(bridge: Bridge | undefined) {
setState("list", reconcile([...message.list]))
}),
)
return { loaded, list: () => state.list }
return {
enableState: createMemo(() => state.list ?? initial.latest),
list: () => state.list ?? [],
}
}
+10 -6
View File
@@ -1,4 +1,5 @@
import { createMemo, lazy, onCleanup, Show, Suspense, type ParentProps } from "solid-js"
import { extensionEnabled } from "@opencode/gui-extensions/sdk/bridge"
import type { Definition } from "@opencode/gui-extensions/sdk"
import { builtins } from "./builtins"
import { createInstalled } from "./installed"
@@ -35,12 +36,6 @@ export function ExtensionRoot(props: ParentProps) {
onCleanup(ipcs.dispose)
const installed = createInstalled(bridge)
const disabled = createMemo(() => {
if (!installed.loaded()) return undefined
return new Set(installed.list().flatMap((item) => (item.enabled ? [] : [item.id])))
})
const os = platform.platform === "desktop" ? platform.os : undefined
// Built-ins only: installed `.ocdx` archives run their main entry until that format ships renderer bundles.
@@ -48,6 +43,15 @@ export function ExtensionRoot(props: ParentProps) {
(definition: Definition) => !definition.os || (!!os && definition.os.includes(os)),
)
// Only enable preferences cross this boundary; the host derives blocked status from live hard dependencies.
const disabled = createMemo(() => {
const state = installed.enableState()
if (!state) return undefined
return new Set(definitions.flatMap((definition) => (extensionEnabled(definition, state) ? [] : [definition.id])))
})
const failed = (id: string) => installed.list().some((item) => item.id === id && item.error !== undefined)
return (
@@ -7,7 +7,9 @@ import type { DraftStore } from "@/runtime/persistence/drafts"
import type { Bridge } from "@opencode/gui-extensions/sdk/bridge"
type PickerPaths = string | string[] | null
type OpenDirectoryPickerOptions = { title?: string; multiple?: boolean }
type OpenAttachmentPickerOptions = {
title?: string
multiple?: boolean
@@ -15,8 +17,11 @@ type OpenAttachmentPickerOptions = {
extensions?: string[]
defaultPath?: string
}
type SaveFilePickerOptions = { title?: string; defaultPath?: string }
type PlatformName = "web" | "desktop"
type DesktopOS = "macos" | "windows" | "linux"
export type FatalRendererErrorLog = {
@@ -53,9 +58,9 @@ type PlatformBase = {
notify(title: string, description?: string, onClick?: () => void): Promise<void>
/** Open a native attachment picker and read selected files sequentially (desktop only) */
openAttachmentPickerDialog?(
openAttachmentPickerDialog?<Value>(
opts: OpenAttachmentPickerOptions,
onFile: (file: File) => Promise<unknown>,
onFile: (file: File) => Promise<Value>,
): Promise<void>
/** Resolve the native source path for a desktop File. */
@@ -40,8 +40,8 @@ test("a list main pushes while the initial list is pending wins over the older r
listeners.forEach((listener) => listener({ type: "extensions", list: [{ ...extension, enabled: false }] }))
reply.resolve([{ ...extension, enabled: true }])
await Bun.sleep(0)
expect({ loaded: root.installed.loaded(), enabled: root.installed.list().map((item) => item.enabled) }).toEqual({
loaded: true,
expect({ known: root.installed.enableState() !== undefined, enabled: root.installed.list().map((item) => item.enabled) }).toEqual({
known: true,
enabled: [false],
})
root.dispose()
@@ -0,0 +1,12 @@
import type { DatabaseSync } from "node:sqlite"
import type { EnableState } from "@opencode/gui-extensions/sdk/bridge"
/** Explicit settings only: both startup readers and the manager resolve absent rows through the same SDK rule. */
export function readEnableState(db: DatabaseSync): readonly EnableState[] {
return db.prepare("SELECT id, enabled FROM extension").all().map((row) => {
// SAFETY: extension.id is TEXT PRIMARY KEY; extension.enabled is INTEGER NOT NULL in every journaled schema.
const id = row.id as string
return { id, enabled: row.enabled === 1 }
})
}
@@ -128,6 +128,7 @@ export function createHost(input: {
const manager = createManager(
input.db,
(id) => id.startsWith("opencode") || definitions.some((definition) => definition.id === id),
definitions,
)
const embeds = createEmbeds()
@@ -0,0 +1,57 @@
import { expect, test } from "bun:test"
import { extensionEnabled } from "@opencode/gui-extensions/sdk/bridge"
import details from "../../../../gui-extensions/src/details/index"
import context from "../../../../gui-extensions/src/context/index"
import { openDatabase } from "../storage/database"
import { extension } from "../storage/schema"
import { readEnableState } from "./enable-state"
import { createManager } from "./manager"
test.each([
{ name: "no setting", rows: [], expected: true },
{ name: "an old disabled setting", rows: [{ id: "older", enabled: false }], expected: false },
{ name: "an old enabled setting", rows: [{ id: "older", enabled: true }], expected: true },
{
name: "the newest old setting",
rows: [{ id: "older", enabled: false }, { id: "previous", enabled: true }],
expected: true,
},
{
name: "the current enabled setting",
rows: [{ id: "previous", enabled: false }, { id: "current", enabled: true }],
expected: true,
},
{
name: "the current disabled setting",
rows: [{ id: "previous", enabled: true }, { id: "current", enabled: false }],
expected: false,
},
])("both hosts resolve $name from real database rows, and a new setting wins", (input) => {
const database = openDatabase(":memory:")
const definition = { id: "current", legacy: ["previous", "older"] }
const manager = createManager(database.db, () => false, [definition])
input.rows.forEach((row) => database.db.insert(extension).values(row).run())
expect(manager.enabled(definition.id)).toBe(input.expected)
expect(extensionEnabled(definition, readEnableState(database.db.$client))).toBe(input.expected)
const before = database.db.select().from(extension).all()
manager.setEnabled(definition.id, !input.expected)
expect(manager.enabled(definition.id)).toBe(!input.expected)
expect(extensionEnabled(definition, readEnableState(database.db.$client))).toBe(!input.expected)
expect(database.db.select().from(extension).all().filter((row) => row.id !== definition.id)).toEqual(
before.filter((row) => row.id !== definition.id),
)
database.close()
})
test.each([details, context])("$id preserves disabled state from its shipping legacy declaration", (definition) => {
const database = openDatabase(":memory:")
const manager = createManager(database.db, () => false, [definition])
database.db.insert(extension).values({ id: definition.legacy[0], enabled: false }).run()
expect(manager.enabled(definition.id)).toBe(false)
expect(extensionEnabled(definition, readEnableState(database.db.$client))).toBe(false)
database.close()
})
+31 -8
View File
@@ -1,19 +1,20 @@
import { randomUUID } from "node:crypto"
import { and, eq, isNotNull } from "drizzle-orm"
import { net } from "electron"
import { Option } from "effect"
import { Option, Predicate } from "effect"
import type { Definition } from "@opencode/gui-extensions/sdk/main"
import { extensionEnabled } from "@opencode/gui-extensions/sdk/bridge"
import type { Database } from "../storage/database"
import { extension, extensionFile } from "../storage/schema"
import { ExtensionError } from "./error"
import { decodeManifest } from "./manifest"
import { readEnableState } from "./enable-state"
/**
* Enable state and installed archives, committed together in the desktop database. Archive installs are groundwork for
* `.ocdx` extensions: an installed archive runs its main entry only, the renderer loads built-ins until that format
* ships renderer bundles, and packaged builds refuse the manager until installs have a trust model.
*/
export function createManager(db: Database, reserved: (id: string) => boolean) {
const row = (id: string) => db.select().from(extension).where(eq(extension.id, id)).get()
export function createManager(db: Database, reserved: (id: string) => boolean, definitions: readonly Definition[]) {
return {
/** Every installed archive. A manifest that no longer decodes is reported, not dropped. */
installed() {
@@ -29,9 +30,12 @@ export function createManager(db: Database, reserved: (id: string) => boolean) {
manifest: Option.getOrUndefined(decodeManifest(item.manifest)),
}))
},
/** Extensions without a row keep the default: enabled. */
/** The current id wins, then declared legacy ids newest first; no setting means enabled. */
enabled(id: string) {
return row(id)?.enabled ?? true
return extensionEnabled(
definitions.find((definition) => definition.id === id) ?? { id },
readEnableState(db.$client),
)
},
setEnabled(id: string, enabled: boolean) {
db.insert(extension).values({ id, enabled }).onConflictDoUpdate({ target: extension.id, set: { enabled } }).run()
@@ -49,9 +53,11 @@ export function createManager(db: Database, reserved: (id: string) => boolean) {
},
async install(source: Uint8Array | string) {
const { readArchive } = await import("./archive")
const archive = await readArchive(typeof source === "string" ? await download(source) : source)
const archive = await readArchive(Predicate.isString(source) ? await download(source) : source)
const id = archive.manifest.id
if (reserved(id)) throw new ExtensionError("reserved")
const values = { enabled: true, manifest: JSON.stringify(archive.manifest), revision: randomUUID() }
db.transaction((tx) => {
tx.delete(extensionFile).where(eq(extensionFile.extension_id, id)).run()
@@ -63,6 +69,7 @@ export function createManager(db: Database, reserved: (id: string) => boolean) {
tx.insert(extensionFile).values({ extension_id: id, path: file.path, data: file.data }).run(),
)
})
return archive.manifest
},
remove(id: string) {
@@ -76,27 +83,43 @@ export function createManager(db: Database, reserved: (id: string) => boolean) {
async function download(url: string) {
const { archiveLimit } = await import("./archive")
if (!URL.canParse(url) || !["http:", "https:"].includes(new URL(url).protocol)) throw new ExtensionError("url")
const response = await net.fetch(url).catch((error: unknown) => {
const { net } = await import("electron")
const response = await net.fetch(url).catch((error) => {
throw new ExtensionError("download", { cause: error })
})
if (!response.ok || !response.body) throw new ExtensionError("download", { message: String(response.status) })
if (Number(response.headers.get("content-length")) > archiveLimit) {
await response.body.cancel()
throw new ExtensionError("tooLarge")
}
const reader = response.body.getReader()
const chunks: Uint8Array[] = []
const pump = async (size: number): Promise<number> => {
const next = await reader.read()
if (next.done) return size
if (size + next.value.byteLength > archiveLimit) {
await reader.cancel()
throw new ExtensionError("tooLarge")
}
chunks.push(next.value)
return pump(size + next.value.byteLength)
}
await pump(0)
return Buffer.concat(chunks)
}
@@ -10,6 +10,7 @@ const tables = (db: ReturnType<typeof drizzle>) =>
db
.all<{ name: string }>(sql`SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name`)
.map((row) => row.name)
const expected = ["blob", "document", "extension", "extension_file", "migration", "state"]
describe("database", () => {
@@ -32,17 +33,32 @@ describe("database", () => {
expect(migrate(db)).toEqual([])
})
test("a failed migration rolls back the journal without losing existing data", () => {
const native = new DatabaseSync(":memory:")
native.exec("CREATE TABLE state (value TEXT); INSERT INTO state VALUES ('kept')")
const db = drizzle({ client: native })
expect(() => migrate(db)).toThrow()
expect(db.all(sql`SELECT id FROM migration`)).toEqual([])
expect(db.all(sql`SELECT value FROM state`)).toEqual([{ value: "kept" }])
native.close()
})
test("rendered registry matches the drizzle-kit output on disk", async () => {
const directory = path.join(import.meta.dirname, "migration")
const ids = (await Array.fromAsync(new Bun.Glob("*/migration.sql").scan({ cwd: directory })))
.map((file) => path.dirname(file))
.sort()
expect(migrations.map((migration) => migration.id)).toEqual(ids)
for (const migration of migrations) {
const source = (await Bun.file(path.join(directory, migration.id, "migration.sql")).text()).replaceAll(
"\r\n",
"\n",
)
for (const statement of migration.statements) expect(source).toContain(statement)
}
})
+3 -31
View File
@@ -1,17 +1,9 @@
import { DatabaseSync } from "node:sqlite"
import { sql } from "drizzle-orm"
import { drizzle } from "drizzle-orm/node-sqlite"
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core"
import { migrations } from "./migration.gen"
import { migrateDatabase } from "./migration"
export type Database = ReturnType<typeof drizzle>
// Owned by the runner rather than schema.ts so drizzle-kit never tries to migrate the journal itself.
const journal = sqliteTable("migration", {
id: text().primaryKey(),
time_completed: integer().notNull(),
})
export function openDatabase(filename: string) {
const native = new DatabaseSync(filename)
// WAL keeps readers off the writer. NORMAL fsyncs at checkpoints only, which survives an app
@@ -19,30 +11,10 @@ export function openDatabase(filename: string) {
native.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA temp_store=MEMORY")
const db = drizzle({ client: native })
migrate(db)
return { db, close: () => native.close() }
}
export function migrate(db: Database) {
db.run(sql`CREATE TABLE IF NOT EXISTS ${journal} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`)
const applied = new Set(
db
.select({ id: journal.id })
.from(journal)
.all()
.map((row) => row.id),
)
// drafts.sqlite predates the journal: its tables were created by hand, so the migration that
// would create them is recorded as applied instead of run.
const legacy =
applied.size === 0 &&
db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'document'`) !== undefined
const pending = migrations.filter((migration) => !applied.has(migration.id))
if (pending.length === 0) return []
db.transaction((tx) => {
pending.forEach((migration, index) => {
if (!(legacy && index === 0)) migration.statements.forEach((statement) => tx.run(sql.raw(statement)))
tx.insert(journal).values({ id: migration.id, time_completed: Date.now() }).run()
})
})
return pending.map((migration) => migration.id)
return migrateDatabase(db.$client)
}
+13 -3
View File
@@ -8,6 +8,7 @@ import { setStorageSnapshotProvider } from "./snapshot"
import { createDraftStore } from "./drafts"
import { importLegacyStores } from "./legacy"
import { createStateStore } from "./state"
import { readEnableState } from "../extension/enable-state"
export type Interface = ReturnType<typeof make>
@@ -19,9 +20,11 @@ export const layer = Layer.effect(
const path = yield* Path.Path
const runFork = Effect.runForkWith(yield* Effect.context())
const userData = app.getPath("userData")
const storage = make(path.join(userData, "drafts.sqlite"), (error) =>
runFork(Effect.logError("storage flush failed", { error })),
)
yield* importLegacyStores(storage.db, userData).pipe(
Effect.tap((result) =>
result.removed.length === 0
@@ -30,10 +33,10 @@ export const layer = Layer.effect(
),
Effect.catch((error) => Effect.logWarning("failed to import legacy store files", { error })),
)
const wire = (_event: Electron.Event, win: BrowserWindow) => win.on("session-end", storage.flush)
const wire = (_event: Electron.Event | undefined, win: BrowserWindow) => win.on("session-end", storage.flush)
app.on("before-quit", storage.flush)
app.on("browser-window-created", wire)
BrowserWindow.getAllWindows().forEach((win) => wire({} as Electron.Event, win))
BrowserWindow.getAllWindows().forEach((win) => wire(undefined, win))
yield* Effect.addFinalizer(() =>
Effect.sync(() => {
app.off("before-quit", storage.flush)
@@ -42,17 +45,24 @@ export const layer = Layer.effect(
storage.close()
}),
)
setStorageSnapshotProvider((names) => Object.fromEntries(names.map((name) => [name, storage.state.items(name)])))
setStorageSnapshotProvider((names) => ({
storage: Object.fromEntries(names.map((name) => [name, storage.state.items(name)])),
extensions: readEnableState(storage.db.$client),
}))
marks.storage = Date.now()
return Service.of(storage)
}),
)
// The file keeps its historical name; renaming it would mean moving the drafts it already holds.
// SAFETY: this observer only reports caught write failures; it never interprets them as stored values.
// oxlint-disable-next-line anti-slop/no-unknown-parameters -- see SAFETY above
export function make(filename: string, onError?: (error: unknown) => void) {
const database = openDatabase(filename)
const state = createStateStore(database.db, { onError })
const drafts = createDraftStore(database.db, { onError })
return {
db: database.db,
state,
@@ -0,0 +1,33 @@
import type { DatabaseSync } from "node:sqlite"
import { migrations } from "./migration.gen"
/** The desktop journal, usable by the early preload read without loading Drizzle or Effect. */
export function migrateDatabase(db: DatabaseSync) {
db.exec("CREATE TABLE IF NOT EXISTS migration (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)")
const applied = new Set(db.prepare("SELECT id FROM migration").all().map((row) => row.id))
// drafts.sqlite predates the journal: adopt its existing draft tables instead of creating them again.
const legacy =
applied.size === 0 &&
db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'document'").get() !== undefined
const pending = migrations.filter((migration) => !applied.has(migration.id))
if (pending.length === 0) return []
db.exec("BEGIN")
try {
const record = db.prepare("INSERT INTO migration (id, time_completed) VALUES (?, ?)")
pending.forEach((migration, index) => {
if (!(legacy && index === 0)) migration.statements.forEach((statement) => db.exec(statement))
record.run(migration.id, Date.now())
})
db.exec("COMMIT")
} catch (error) {
db.exec("ROLLBACK")
throw error
}
return pending.map((migration) => migration.id)
}
+14 -41
View File
@@ -1,56 +1,29 @@
import { existsSync, readdirSync } from "node:fs"
import path from "node:path"
import { DatabaseSync } from "node:sqlite"
import { app, ipcMain } from "electron"
import { StorageSnapshotChannel, type StorageSnapshot } from "../../shared/ipc-transport"
import { WindowSnapshotChannel, type WindowSnapshot } from "../../shared/ipc-transport"
import { isRendererUrl } from "../windows/scheme"
import { readWindowSnapshot } from "./window-snapshot"
// A window's preload asks for the namespaces its shell reads before the page runs, so the first
// render is the hydrated one. Until the storage layer is up (the first window asks before it exists)
// the answer comes from the database file; the layer takes over so later windows see queued writes.
type Provider = (names: ReadonlyArray<string>) => StorageSnapshot
type Provider = (names: ReadonlyArray<string>) => WindowSnapshot
let provider: Provider = readFromDisk
let provider: Provider = (names) => readWindowSnapshot(app.getPath("userData"), names)
export function setStorageSnapshotProvider(next: Provider) {
provider = next
}
export function registerStorageSnapshotHandler() {
ipcMain.handle(StorageSnapshotChannel, (event, names: unknown): StorageSnapshot => {
if (!isRendererUrl(event.senderFrame?.url)) return {}
if (!Array.isArray(names)) return {}
return provider(names.filter((name): name is string => typeof name === "string"))
// SAFETY: Electron delivers untrusted IPC arguments; accept only an array whose every element is a string here.
// oxlint-disable-next-line anti-slop/no-unknown-parameters -- see SAFETY above
ipcMain.handle(WindowSnapshotChannel, (event, names: unknown): WindowSnapshot => {
if (!isRendererUrl(event.senderFrame?.url)) return { storage: {} }
// SAFETY: this dependency-free boundary check establishes the complete array-of-strings contract.
// oxlint-disable-next-line anti-slop/no-runtime-typeof -- see SAFETY above
if (!Array.isArray(names) || !names.every((name) => typeof name === "string")) return { storage: {} }
return provider(names)
})
}
// Nothing has been written in this process yet, so every namespace is at revision 0, as the
// storage layer would report before its first update. Legacy electron-store files still waiting
// to be imported would make the database stale for this launch, so the renderer asks the layer then.
function readFromDisk(names: ReadonlyArray<string>): StorageSnapshot {
const userData = app.getPath("userData")
const file = path.join(userData, "drafts.sqlite")
if (!existsSync(file)) return {}
if (readdirSync(userData).some((name) => name === "default.dat" || /^opencode\..+\.dat$/.test(name))) return {}
try {
const db = new DatabaseSync(file)
try {
const rows = db.prepare("SELECT key, value FROM state WHERE name = ?")
return Object.fromEntries(
names.map((name) => [
name,
{
items: Object.fromEntries(
(rows.all(name) as { key: string; value: string }[]).map((row) => [row.key, row.value]),
),
revision: 0,
},
]),
)
} finally {
db.close()
}
} catch {
return {}
}
}
@@ -0,0 +1,41 @@
import { afterEach, expect, test } from "bun:test"
import { mkdtemp, rm } from "node:fs/promises"
import { tmpdir } from "node:os"
import path from "node:path"
import { DatabaseSync } from "node:sqlite"
import { readWindowSnapshot } from "./window-snapshot"
import { migrateDatabase } from "./migration"
const roots: string[] = []
// Bun's node:sqlite shim can retain file handles on Windows after close; only these owned test directories are removed.
afterEach(() => Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true }).catch(() => undefined))))
test.each(["missing", "unreadable"])("a $s database distinguishes default enable state from unknown", async (input) => {
const root = await mkdtemp(path.join(tmpdir(), "opencode-window-snapshot-"))
roots.push(root)
if (input === "unreadable") await Bun.write(path.join(root, "drafts.sqlite"), "not a SQLite database")
expect(readWindowSnapshot(root, ["shell"])).toEqual(
input === "missing" ? { storage: {}, extensions: [] } : { storage: {} },
)
})
test.each([false, true])("the early snapshot keeps explicit rows even with legacy files: %s", async (legacy) => {
const root = await mkdtemp(path.join(tmpdir(), "opencode-window-snapshot-"))
roots.push(root)
const db = new DatabaseSync(path.join(root, "drafts.sqlite"))
migrateDatabase(db)
db.prepare("INSERT INTO state (name, key, value, updated_at) VALUES (?, ?, ?, 0)").run("shell", "theme", "dark")
db.prepare("INSERT INTO extension (id, enabled) VALUES (?, ?)").run("previous", 0)
db.prepare("INSERT INTO extension (id, enabled) VALUES (?, ?)").run("current", 1)
db.close()
if (legacy) await Bun.write(path.join(root, "default.dat"), "{}")
expect(readWindowSnapshot(root, ["shell"])).toEqual({
storage: legacy ? {} : { shell: { items: { theme: "dark" }, revision: 0 } },
extensions: [{ id: "previous", enabled: false }, { id: "current", enabled: true }],
})
})
@@ -0,0 +1,47 @@
import { existsSync, readdirSync } from "node:fs"
import path from "node:path"
import { DatabaseSync } from "node:sqlite"
import type { WindowSnapshot } from "../../shared/ipc-transport"
import { migrateDatabase } from "./migration"
import { readEnableState } from "../extension/enable-state"
// Before the storage layer exists, nothing has been written in this process and every namespace is at revision 0.
// Legacy electron-store files can make storage stale, but explicit extension settings still come from SQLite.
export function readWindowSnapshot(userData: string, names: readonly string[]): WindowSnapshot {
const file = path.join(userData, "drafts.sqlite")
if (!existsSync(file)) return { storage: {}, extensions: [] }
try {
const legacy = readdirSync(userData).some((name) => name === "default.dat" || /^opencode\..+\.dat$/.test(name))
const db = new DatabaseSync(file)
try {
migrateDatabase(db)
const rows = db.prepare("SELECT key, value FROM state WHERE name = ?")
return {
storage: legacy
? {}
: Object.fromEntries(
names.map((name) => [
name,
{
// SAFETY: the journaled state table declares both selected columns TEXT NOT NULL.
items: Object.fromEntries(
(rows.all(name) as { key: string; value: string }[]).map((row) => [row.key, row.value]),
),
revision: 0,
},
]),
),
extensions: readEnableState(db),
}
} finally {
db.close()
}
} catch {
return { storage: {} }
}
}
+9 -6
View File
@@ -2,28 +2,31 @@ import { contextBridge, ipcRenderer, webUtils } from "electron"
import {
DragCancelEvent,
IpcTransportPort,
StorageSnapshotChannel,
WindowSnapshotChannel,
storageSnapshotNames,
type StorageSnapshot,
type WindowSnapshot,
} from "../shared/ipc-transport"
import { windowBootstrapFromArguments } from "../shared/window-bootstrap"
ipcRenderer.on(IpcTransportPort, (event) => {
const port = event.ports[0]
if (port) window.postMessage(IpcTransportPort, "*", [port])
})
ipcRenderer.on(DragCancelEvent, () => window.dispatchEvent(new Event(DragCancelEvent)))
const bootstrap = windowBootstrapFromArguments(process.argv)
// Asked before the page runs, so the stores the shell reads are hydrated on the first render.
const storageSnapshot: Promise<StorageSnapshot> = ipcRenderer
.invoke(StorageSnapshotChannel, storageSnapshotNames(bootstrap.id))
.catch(() => ({}))
const snapshot: Promise<WindowSnapshot> = ipcRenderer
.invoke(WindowSnapshotChannel, storageSnapshotNames(bootstrap.id))
.catch(() => ({ storage: {} }))
contextBridge.exposeInMainWorld("electron", {
windowID: bootstrap.id,
bootstrap,
storageSnapshot,
storageSnapshot: snapshot.then((snapshot) => snapshot.storage),
extensions: snapshot.then((snapshot) => snapshot.extensions),
getPathForFile: (file: File) => webUtils.getPathForFile(file),
})
+2 -1
View File
@@ -1,9 +1,10 @@
import type { StorageSnapshot } from "../shared/ipc-transport"
import type { StorageSnapshot, WindowSnapshot } from "../shared/ipc-transport"
import type { WindowBootstrap } from "../shared/window-bootstrap"
export type ElectronNative = {
windowID: string
bootstrap: WindowBootstrap
storageSnapshot: Promise<StorageSnapshot>
extensions: Promise<WindowSnapshot["extensions"]>
getPathForFile(file: File): string
}
@@ -63,6 +63,7 @@ export function createExtensionBridge(): Bridge {
runMenubarItem: (id) => send("ExtensionMenubarItem", { id }),
configure: (servers) => send("ExtensionConfigure", { servers }),
manager: {
initial: window.electron.extensions,
list: () => invoke("ExtensionList"),
enable: (id) => manage(invoke("ExtensionEnable", { id })),
disable: (id) => manage(invoke("ExtensionDisable", { id })),
@@ -16,6 +16,7 @@ export type DesktopWindowState = {
export function createDesktopPlatform(api: ElectronAPI, windowState: DesktopWindowState): Platform {
const os = desktopOS()
return {
platform: "desktop",
os,
@@ -30,11 +31,14 @@ export function createDesktopPlatform(api: ElectronAPI, windowState: DesktopWind
notify: createDesktopNotify(api),
fetch: (input, init) => {
if (input instanceof Request) return fetch(input)
return fetch(input, init)
},
getDefaultServer: async () => {
const url = await api.getDefaultServerUrl().catch(() => null)
if (!url) return null
return ServerConnection.Key.make(url)
},
setDefaultServer: async (url) => {
@@ -46,6 +50,7 @@ export function createDesktopPlatform(api: ElectronAPI, windowState: DesktopWind
setPinchZoomEnabled,
onDragCancel: (callback) => {
window.addEventListener(DragCancelEvent, callback)
return () => window.removeEventListener(DragCancelEvent, callback)
},
runDesktopMenuAction: createDesktopMenuAction(api),
@@ -58,7 +63,10 @@ export function createDesktopPlatform(api: ElectronAPI, windowState: DesktopWind
function desktopOS() {
if (navigator.userAgent.includes("Mac")) return "macos"
if (navigator.userAgent.includes("Windows")) return "windows"
if (navigator.userAgent.includes("Linux")) return "linux"
return undefined
}
+16 -1
View File
@@ -1,20 +1,35 @@
import type { EnableState } from "@opencode/gui-extensions/sdk/bridge"
export const IpcTransportPort = "desktop-rpc-port"
export const DragCancelEvent = "opencode:drag-cancel"
export const StorageSnapshotChannel = "desktop-storage-snapshot"
export const WindowSnapshotChannel = "desktop-window-snapshot"
// The main process decodes RPC payloads with the JSON codec, and JSON has no undefined: an
// optional field the caller left as `undefined` decodes only when its key is absent. Structured
// clone keeps the key, so drop such fields the way JSON.stringify would, leaving bytes untouched.
// SAFETY: transport normalization preserves encoded payloads except undefined keys; the RPC codec validates the result.
/* oxlint-disable anti-slop/no-unknown-parameters, anti-slop/no-unknown-returns, anti-slop/no-runtime-typeof -- see SAFETY above */
export function omitUndefined(value: unknown): unknown {
if (Array.isArray(value)) return value.map(omitUndefined)
if (typeof value !== "object" || value === null || value instanceof Uint8Array) return value
return Object.fromEntries(
Object.entries(value).flatMap(([key, item]) => (item === undefined ? [] : [[key, omitUndefined(item)]])),
)
}
/* oxlint-enable anti-slop/no-unknown-parameters, anti-slop/no-unknown-returns, anti-slop/no-runtime-typeof */
export type StorageSnapshot = Record<string, { items: Record<string, string>; revision: number }>
/** The preload's existing startup reply; missing enable state is unknown, not an all-enabled setting. */
export type WindowSnapshot = {
storage: StorageSnapshot
extensions?: readonly EnableState[]
}
// The namespaces a window reads while its shell mounts. The preload asks for them before the page
// runs so the first render already has them; mirrors windowStorage() in
// packages/app/src/runtime/persistence/storage.ts.
+3 -2
View File
@@ -4,7 +4,7 @@ Built-in features of the desktop and web app, each behind the SDK in `src/sdk/`.
## Structure
- One folder per extension: `index.ts` (`Extension.define({ id, os?, provides?, uses?, requires?, stores?, i18n })`), `contract.ts`, `renderer.tsx`, an optional `main.ts`, and `i18n/<locale>.ts`.
- One folder per extension: `index.ts` (`Extension.define({ id, legacy?, os?, provides?, uses?, requires?, stores?, i18n })`), `contract.ts`, `renderer.tsx`, an optional `main.ts`, and `i18n/<locale>.ts`.
- `src/renderer.ts` and `src/main.ts` are the only files that list the built-ins, each through `Extension.compose`. Main never imports window code. `src/builtins.typecheck.ts` fails the typecheck when a window `uses` or `requires` an Ipc that no main entry provides.
- Every extension here ships. Do not add an extension, fixture or wrapper only to document or demonstrate the SDK; the guide shows shipping code.
- Another extension may import only your `contract.ts` (tokens and schemas, no runtime code). Declare what other extensions provide in `uses` (or `requires`). Your own tokens, your Ipc included, go in `provides` only: the window reads each as `ctx.uses.<key>` too, and a key that names one token in `provides` and another in `uses` fails to compile. To declare an Ipc without loading its schemas at startup, use `Ipc.ref<typeof Token>("id")` and `ctx.uses.name.load(Token)` from the chunk that loads them; never put a reference in `requires`.
@@ -48,7 +48,8 @@ An instance lives from `setup` until it is disabled, reloaded, removed, or its w
- Desktop storage loads over IPC; web storage is synchronous, so a read before load passes every web e2e test and still breaks desktop. Declare stores (`Store.global`, `Store.session`): a global store is loaded before setup, a session store's `value` is undefined until it loads, and `update` waits for the load. `Storage.store`, for keys only known at runtime, returns the same `Persisted`; derive nothing from it, such as a request, before `value` is defined.
- Declare main-process state known up front with `Store.main`; the main entry reads it as `ctx.stores.name` (`MainSetup<typeof definition>`), always loaded. Each process's `ctx.stores` holds only its own stores. Main's `ctx.storage.store` is for keys only known at runtime.
- Stored keys live in your extension id's namespace (`extension.<id>.<key>`). Moving a stored value goes through `from` (and `from.sessions` for one session's slice of an app key); a list names older homes newest first, for example your earlier id's namespace, then the app key before it. A `pick` returns undefined when the older key holds none of its fields, never an object of undefined fields, or the next home is never read. In main, an older home is `{ settings: key, file? }` or `{ state: [namespace, key] }`. Keep the old field readable until every user has migrated; never drop user data. When you rename an extension, map its command ids in the keybind rename map and its panel keys in `Panel.legacy` too.
- Stored keys live in your extension id's namespace (`extension.<id>.<key>`). Move values through `from` (and `from.sessions` for one session's slice of an app key), with older homes newest first. A `pick` returns undefined when the old key holds none of its fields, never an object of undefined fields. Main's older homes are `{ settings: key, file? }` or `{ state: [namespace, key] }`. Keep old fields readable until every user has migrated; never drop user data.
- When you rename an extension, list earlier ids newest first in `Definition.legacy` for enable state, migrate command ids in the keybind rename map, and map panel keys in `Panel.legacy`.
- `update` mutates a deep-mutable draft and returns nothing or `undefined`; a returned replacement fails to compile and throws at runtime in both processes. `set` replaces the value. Plain readonly `Schema.Struct` fields work without `mutableKey`. Window `update` and `set` wait for load and apply in call order with each other, including runtime-key stores; main writes reach disk at once. Do not batch main writes yourself.
- `Storage.remove(key, { from })` takes the store's `from`, so the older key is never imported again and the key reads as `initial`.
+12 -1
View File
@@ -38,6 +38,7 @@ Unit tests of logic that carries a contract sit beside the code as `*.test.ts`,
| Field | What it declares | In the context |
| ---------- | ----------------------------------------------------------------------------- | ------------------------------------------------- |
| `id` | Prefix of every id: commands, panel keys, stored keys, contract and Ipc ids | `ctx.id` |
| `legacy` | Earlier extension ids, newest first; preserves desktop enable state after a rename | |
| `os` | The operating systems it runs on; omit it to run everywhere, the web included | |
| `provides` | Contracts from the window entry, Ipcs from the main entry | `ctx.provide(token, impl)`, and `ctx.uses.name()` |
| `uses` | Optional dependencies other extensions provide; it works while one is missing | `ctx.uses.name()` is `Live<T>` |
@@ -396,7 +397,17 @@ servers: Store.main(Schema.Array(SshConfig), [], { settings: "ssh.servers" }),
- `from` imports an older value once, while the store holds none. A list names older homes, newest first. With `pick`, the older key stays for its other owners; a pick returns undefined when that key holds none of its fields, never an object of undefined fields, so the next home is read.
- `update(mutate)` edits a deep-mutable draft and must return nothing or `undefined`. Returning the next value is a compile error and throws at runtime in both processes; use `set(next)` to replace the complete value, including main primitives and lists. Plain `Schema.Struct` fields work without `mutableKey`. Window calls wait for load and apply in call order with each other; main writes reach disk immediately. Runtime-key stores have the same contract.
- `Storage.remove(key, { from })` reads as `initial` again and never imports `from` again.
- Renaming an extension moves three things: stored keys (`from`), command ids (the keybind rename map in `packages/app/src/settings/keybinds/migration.ts`), and panel keys (`Panel.legacy`). Never drop user data.
- Renaming an extension moves four things: enable state (`Definition.legacy`), stored keys (`from`), command ids (the keybind rename map in `packages/app/src/settings/keybinds/migration.ts`), and panel keys (`Panel.legacy`). Never drop user data.
Declare earlier ids newest first, for example `Extension.define({ id: "details", legacy: ["summary"] })`. The current id's explicit enable setting always wins. Without one, the first earlier id with a setting wins; with no setting at all, the extension is enabled. Both desktop hosts use this rule. Old rows stay intact, and enable/disable changes write only under the current id. A failed startup snapshot is unknown, so the window waits for the manager list rather than running disabled extensions.
The enable preference is separate from activation: an enabled extension with an unavailable hard dependency is `blocked`. The window publishes disabled providers before starting enabled entries, so consumers settle as blocked regardless of declaration order.
<!-- source: src/details/index.ts#legacy -->
```ts
legacy: ["summary"],
```
## Runtime rules
@@ -3,6 +3,7 @@ import en from "./i18n/en"
export default Extension.define({
id: "context",
legacy: ["usage"],
i18n: {
en,
am: () => import("./i18n/am"),
@@ -7,6 +7,7 @@ const Prefs = Schema.Struct({ projectExpanded: Schema.Boolean, serverExpanded: S
export default Extension.define({
id: "details",
legacy: ["summary"],
uses: { changes: Changes },
stores: {
// Stored under the extension's earlier id `summary`, and before extensions in the app settings.
+32
View File
@@ -4,6 +4,32 @@
* Payloads are structured-clone values already encoded with the Ipc's schemas. The `ipc` fields name an Ipc by id.
*/
import type { Definition } from "./core"
/** One explicit desktop enable-state row. An absent row means there is no setting under that id. */
export interface EnableState {
/** The extension id the user saved a setting under, including ids from before a rename. */
readonly id: string
/** The saved setting: true enables the extension; false disables it. */
readonly enabled: boolean
}
/**
* Resolves desktop enable state without changing stored rows. The current id wins, then legacy ids newest first;
* no matching row means enabled. Both hosts use this rule, including a window's preload snapshot.
*
* @param definition - The current id and its optional earlier ids.
* @param state - Explicit saved rows, or the manager's resolved list.
* @returns Whether the extension is enabled.
*/
export function extensionEnabled(definition: Pick<Definition, "id" | "legacy">, state: readonly EnableState[]) {
const row = [definition.id, ...(definition.legacy ?? [])]
.map((id) => state.find((item) => item.id === id))
.find((item) => item !== undefined)
return row?.enabled ?? true
}
/** Where an embed sits in its window, as the renderer measured it. */
export interface BridgeLayout {
/** The embed should be on screen. */
@@ -186,6 +212,12 @@ export interface Bridge {
): void
/** The extension manager. */
readonly manager: {
/**
* Explicit enable-state rows from the existing preload startup reply, including earlier ids. Undefined (or an
* omitted promise) means unknown: activation waits for `list()` or a live list, never assumes all are enabled.
* An empty list is authoritative: no saved settings. A rejected promise also falls back to the manager list.
*/
readonly initial?: Promise<readonly EnableState[] | undefined>
/** The installed extensions, built-ins included. */
list(): Promise<readonly Installed[]>
/**
+13
View File
@@ -85,6 +85,19 @@ export interface Definition {
* all of those; migrate them as the guide describes.
*/
readonly id: string
/**
* Earlier extension ids, newest first, used to preserve desktop enable state after a rename. The current id's
* explicit setting wins; otherwise the first earlier id with a setting wins. Omit this for a new extension.
* With no setting under any id, the extension is enabled. Old rows stay intact; changes write under the current id.
* Stored keys, commands and panels still need their own migrations (`from`, the keybind map and `Panel.legacy`).
* This restores the enable preference only; hard dependencies still gate activation and can leave it blocked.
*
* @example
* ```ts
* Extension.define({ id: "details", legacy: ["summary"] })
* ```
*/
readonly legacy?: readonly string[]
/**
* The operating systems the extension runs on. Omit it to run everywhere, the web included. An extension that lists
* any OS does not run on the web, where no OS is known.
+21 -9
View File
@@ -5,8 +5,8 @@
// a member of an exported object such as `Store.global` has no doc comment;
// - a documented function or method leaves a parameter without `@param`, or names one it does not have.
// It also fails when a code block of the guide (`packages/gui-extensions/README.md`) marked `<!-- source: path -->` (a
// whole file of a shipping extension) or `<!-- source: path#name -->` (the first declaration, object property or call
// statement named `name` in that file, with the comments directly above it) differs from that source, or when the
// whole file of a shipping extension) or `<!-- source: path#name -->` (a top-level declaration or call named `name`,
// else the first nested match, with the comments directly above it) differs from that source, or when the
// guide or the package's AGENTS.md names a `ctx.<member>` no context declares.
// Usage: bun script/sdk-docs.ts
import path from "node:path"
@@ -256,8 +256,8 @@ async function read(file: string) {
}
/**
* The file's lines, or, for a name, the lines of the first declaration, object property or call statement it names,
* with the comment lines directly above it, dedented.
* The file's lines, or, for a name, the lines of its top-level match (else the first nested match), with the comment
* lines directly above it, dedented.
*/
function excerpt(file: string, text: string, name: string | undefined) {
const lines = text.replace(/\n$/, "").split("\n")
@@ -278,10 +278,22 @@ function excerpt(file: string, text: string, name: string | undefined) {
return picked.map((line) => line.slice(indent))
}
/** The first node, in source order, that declares `name`, is an object property named `name`, or calls `name`. */
/** Top-level matches win; otherwise find the first nested declaration, property or call in source order. */
function named(node: ts.Node, name: string): ts.Node | undefined {
if (ts.isSourceFile(node)) {
const top = node.statements.find((statement) => matches(statement, name))
if (top) return top
}
if (matches(node, name)) return node
return ts.forEachChild(node, (child) => named(child, name))
}
function matches(node: ts.Node, name: string) {
if (ts.isVariableStatement(node)) {
if (node.declarationList.declarations.some((declaration) => declaration.name.getText() === name)) return node
return node.declarationList.declarations.some((declaration) => declaration.name.getText() === name)
}
if (
@@ -293,16 +305,16 @@ function named(node: ts.Node, name: string): ts.Node | undefined {
ts.isMethodDeclaration(node)) &&
node.name?.getText() === name
)
return node
return true
if (
ts.isExpressionStatement(node) &&
ts.isCallExpression(node.expression) &&
node.expression.expression.getText() === name
)
return node
return true
return ts.forEachChild(node, (child) => named(child, name))
return false
}
function parse(file: string, text: string) {