fix: keep opened project metadata single-sourced

Author: wangzexi

packages/app/src/context/opened-projects.tsx

@@ -15,7 +15,6 @@ export type ConfigProjectEntry = {
   icon?: {
     color?: string
     override?: string
-    emoji?: string
   }
   commands?: {
     start?: string

packages/opencode/src/config/projects.ts

@@ -5,7 +5,6 @@ import { withStatics } from "@/util/schema"
 export const ProjectIcon = Schema.Struct({
   override: Schema.optional(Schema.String),
   color: Schema.optional(Schema.String),
-  emoji: Schema.optional(Schema.String),
 })
 
 export const ProjectCommands = Schema.Struct({

packages/opencode/src/server/routes/global.ts

@@ -15,9 +15,11 @@ import * as Log from "@opencode-ai/core/util/log"
 import { lazy } from "../../util/lazy"
 import { Config } from "@/config/config"
 import { ConfigProjects } from "@/config/projects"
+import { Project } from "@/project/project"
 import { errors } from "../error"
 import { Event as ServerEvent } from "../event"
 import { disposeAllInstancesAndEmitGlobalDisposed } from "../global-lifecycle"
+import { OpenedProjects } from "../shared/opened-projects"
 
 const log = Log.create({ service: "server" })
 
@@ -219,8 +221,14 @@ export const GlobalRoutes = lazy(() =>
         },
       }),
       async (c) => {
-        const cfg = await AppRuntime.runPromise(Config.Service.use((svc) => svc.getGlobal()))
-        return c.json(cfg.projects ?? [])
+        const projects = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const config = yield* Config.Service
+            const project = yield* Project.Service
+            return yield* OpenedProjects.list(config, project)
+          }),
+        )
+        return c.json(projects)
       },
     )
     .post(
@@ -244,17 +252,13 @@ export const GlobalRoutes = lazy(() =>
       async (c) => {
         const input = c.req.valid("json")
         const next = await AppRuntime.runPromise(
-          Config.Service.use((svc) =>
-            Effect.gen(function* () {
-              const cfg = yield* svc.getGlobal()
-              const projects = cfg.projects ?? []
-              if (projects.some((project) => project.worktree === input.worktree)) return projects
-              const next = [{ worktree: input.worktree }, ...projects]
-              yield* svc.updateGlobal({ ...cfg, projects: next })
-              yield* Effect.sync(emitOpenedProjectsUpdated)
-              return next
-            }),
-          ),
+          Effect.gen(function* () {
+            const config = yield* Config.Service
+            const project = yield* Project.Service
+            const next = yield* OpenedProjects.open(config, project, input.worktree)
+            yield* Effect.sync(emitOpenedProjectsUpdated)
+            return next
+          }),
         )
         return c.json(next)
       },
@@ -280,15 +284,13 @@ export const GlobalRoutes = lazy(() =>
       async (c) => {
         const input = c.req.valid("json")
         const next = await AppRuntime.runPromise(
-          Config.Service.use((svc) =>
-            Effect.gen(function* () {
-              const cfg = yield* svc.getGlobal()
-              const next = (cfg.projects ?? []).filter((project) => project.worktree !== input.worktree)
-              yield* svc.updateGlobal({ ...cfg, projects: next })
-              yield* Effect.sync(emitOpenedProjectsUpdated)
-              return next
-            }),
-          ),
+          Effect.gen(function* () {
+            const config = yield* Config.Service
+            const project = yield* Project.Service
+            const next = yield* OpenedProjects.close(config, project, input.worktree)
+            yield* Effect.sync(emitOpenedProjectsUpdated)
+            return next
+          }),
         )
         return c.json(next)
       },
@@ -319,7 +321,6 @@ export const GlobalRoutes = lazy(() =>
             .object({
               color: z.string().optional(),
               override: z.string().optional(),
-              emoji: z.string().optional(),
             })
             .optional(),
           commands: z
@@ -332,24 +333,13 @@ export const GlobalRoutes = lazy(() =>
       async (c) => {
         const input = c.req.valid("json")
         const next = await AppRuntime.runPromise(
-          Config.Service.use((svc) =>
-            Effect.gen(function* () {
-              const cfg = yield* svc.getGlobal()
-              const projects = cfg.projects ?? []
-              const next = projects.map((project) => {
-                if (project.worktree !== input.worktree) return project
-                return {
-                  ...project,
-                  ...(input.name !== undefined ? { name: input.name } : {}),
-                  ...(input.icon !== undefined ? { icon: { ...project.icon, ...input.icon } } : {}),
-                  ...(input.commands !== undefined ? { commands: { ...project.commands, ...input.commands } } : {}),
-                }
-              })
-              yield* svc.updateGlobal({ ...cfg, projects: next })
-              yield* Effect.sync(emitOpenedProjectsUpdated)
-              return next
-            }),
-          ),
+          Effect.gen(function* () {
+            const config = yield* Config.Service
+            const project = yield* Project.Service
+            const next = yield* OpenedProjects.meta(config, project, input)
+            yield* Effect.sync(emitOpenedProjectsUpdated)
+            return next
+          }),
         )
         return c.json(next)
       },
@@ -375,14 +365,13 @@ export const GlobalRoutes = lazy(() =>
       async (c) => {
         const input = c.req.valid("json")
         const next = await AppRuntime.runPromise(
-          Config.Service.use((svc) =>
-            Effect.gen(function* () {
-              const cfg = yield* svc.getGlobal()
-              yield* svc.updateGlobal({ ...cfg, projects: input.projects })
-              yield* Effect.sync(emitOpenedProjectsUpdated)
-              return input.projects
-            }),
-          ),
+          Effect.gen(function* () {
+            const config = yield* Config.Service
+            const project = yield* Project.Service
+            const next = yield* OpenedProjects.reorder(config, project, input.projects)
+            yield* Effect.sync(emitOpenedProjectsUpdated)
+            return next
+          }),
         )
         return c.json(next)
       },

packages/opencode/src/server/routes/instance/httpapi/groups/global.ts

@@ -16,7 +16,6 @@ const OpenedMetaPayload = Schema.Struct({
     Schema.Struct({
       color: Schema.optional(Schema.String),
       override: Schema.optional(Schema.String),
-      emoji: Schema.optional(Schema.String),
     }),
   ),
   commands: Schema.optional(

packages/opencode/src/server/routes/instance/httpapi/handlers/global.ts

@@ -1,11 +1,13 @@
 import { Config } from "@/config/config"
 import type { Project as ConfigProject } from "@/config/projects"
+import { Project } from "@/project/project"
 import { GlobalBus, type GlobalEvent as GlobalBusEvent } from "@/bus/global"
 import { EffectBridge } from "@/effect/bridge"
 import { Bus } from "@/bus"
 import { Installation } from "@/installation"
 import { disposeAllInstancesAndEmitGlobalDisposed } from "@/server/global-lifecycle"
 import { Event as ServerEvent } from "@/server/event"
+import { OpenedProjects } from "@/server/shared/opened-projects"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import * as Log from "@opencode-ai/core/util/log"
 import { Effect, Queue, Schema } from "effect"
@@ -82,6 +84,7 @@ function eventResponse() {
 export const globalHandlers = HttpApiBuilder.group(RootHttpApi, "global", (handlers) =>
   Effect.gen(function* () {
     const config = yield* Config.Service
+    const projects = yield* Project.Service
     const installation = yield* Installation.Service
     const bridge = yield* EffectBridge.make()
 
@@ -169,26 +172,17 @@ export const globalHandlers = HttpApiBuilder.group(RootHttpApi, "global", (handl
     })
 
     const openedList = Effect.fn("GlobalHttpApi.openedList")(function* () {
-      const cfg = yield* config.getGlobal()
-      return cfg.projects ?? []
+      return yield* OpenedProjects.list(config, projects)
     })
 
     const openedOpen = Effect.fn("GlobalHttpApi.openedOpen")(function* (ctx: { payload: { worktree: string } }) {
-      const { worktree } = ctx.payload
-      const cfg = yield* config.getGlobal()
-      const projects = cfg.projects ?? []
-      if (projects.some((p) => p.worktree === worktree)) return projects
-      const next = [{ worktree }, ...projects]
-      yield* config.updateGlobal({ ...cfg, projects: next })
+      const next = yield* OpenedProjects.open(config, projects, ctx.payload.worktree)
       yield* Effect.sync(emitOpenedProjectsUpdated)
       return next
     })
 
     const openedClose = Effect.fn("GlobalHttpApi.openedClose")(function* (ctx: { payload: { worktree: string } }) {
-      const { worktree } = ctx.payload
-      const cfg = yield* config.getGlobal()
-      const next = (cfg.projects ?? []).filter((p) => p.worktree !== worktree)
-      yield* config.updateGlobal({ ...cfg, projects: next })
+      const next = yield* OpenedProjects.close(config, projects, ctx.payload.worktree)
       yield* Effect.sync(emitOpenedProjectsUpdated)
       return next
     })
@@ -197,32 +191,21 @@ export const globalHandlers = HttpApiBuilder.group(RootHttpApi, "global", (handl
       payload: {
         worktree: string
         name?: string
-        icon?: { color?: string; override?: string; emoji?: string }
+        icon?: { color?: string; override?: string }
         commands?: { start?: string }
       }
     }) {
-      const { worktree, ...patch } = ctx.payload
-      const cfg = yield* config.getGlobal()
-      const projects = cfg.projects ?? []
-      const idx = projects.findIndex((p) => p.worktree === worktree)
-      if (idx === -1) return projects
-      const existing = projects[idx]
-      const updated = {
-        ...existing,
-        ...(patch.name !== undefined ? { name: patch.name } : {}),
-        ...(patch.commands !== undefined ? { commands: { ...existing.commands, ...patch.commands } } : {}),
-        ...(patch.icon !== undefined ? { icon: { ...existing.icon, ...patch.icon } } : {}),
-      }
-      const next = projects.map((p, i) => (i === idx ? updated : p))
-      yield* config.updateGlobal({ ...cfg, projects: next })
+      const next = yield* OpenedProjects.meta(config, projects, ctx.payload)
       yield* Effect.sync(emitOpenedProjectsUpdated)
       return next
     })
 
     const openedReorder = Effect.fn("GlobalHttpApi.openedReorder")(function* (ctx) {
-      const cfg = yield* config.getGlobal()
-      const next = (ctx as { payload: { projects: ConfigProject[] } }).payload.projects
-      yield* config.updateGlobal({ ...cfg, projects: next })
+      const next = yield* OpenedProjects.reorder(
+        config,
+        projects,
+        (ctx as { payload: { projects: ConfigProject[] } }).payload.projects,
+      )
       yield* Effect.sync(emitOpenedProjectsUpdated)
       return next
     })

packages/opencode/src/server/shared/opened-projects.ts

@@ -0,0 +1,137 @@
+import type { Config } from "@/config/config"
+import type { Project as ConfigProject } from "@/config/projects"
+import { Project } from "@/project/project"
+import { ProjectID } from "@/project/schema"
+import { ProjectTable } from "@/project/project.sql"
+import { Database } from "@/storage/db"
+import { Effect } from "effect"
+
+const db = <T>(fn: Parameters<typeof Database.use<T>>[0]) => Effect.sync(() => Database.use(fn))
+
+function openedOnly(projects: ConfigProject[]) {
+  return projects.map((project) => ({ worktree: project.worktree }))
+}
+
+function findProject(projects: Project.Info[], worktree: string) {
+  return projects.find((project) => project.worktree === worktree || project.sandboxes.includes(worktree))
+}
+
+function fromProject(worktree: string, project?: Project.Info): ConfigProject {
+  return {
+    worktree,
+    ...(project?.name !== undefined ? { name: project.name } : {}),
+    ...(project?.icon ? { icon: { color: project.icon.color, override: project.icon.override } } : {}),
+    ...(project?.commands ? { commands: project.commands } : {}),
+  }
+}
+
+function projectID(worktree: string) {
+  return ProjectID.make(`worktree:${worktree}`)
+}
+
+const ensureProject = Effect.fn("OpenedProjects.ensureProject")(function* (
+  project: Project.Interface,
+  worktree: string,
+) {
+  const existing = findProject(yield* project.list(), worktree)
+  if (existing) return existing
+
+  const now = Date.now()
+  const result = yield* db((tx) =>
+    tx
+      .insert(ProjectTable)
+      .values({
+        id: projectID(worktree),
+        worktree,
+        vcs: null,
+        time_created: now,
+        time_updated: now,
+        time_initialized: null,
+        sandboxes: [],
+      })
+      .onConflictDoUpdate({
+        target: ProjectTable.id,
+        set: {
+          worktree,
+          time_updated: now,
+        },
+      })
+      .returning()
+      .get(),
+  )
+  return Project.fromRow(result)
+})
+
+const list = Effect.fn("OpenedProjects.list")(function* (config: Config.Interface, project: Project.Interface) {
+  const cfg = yield* config.getGlobal()
+  const opened = openedOnly(cfg.projects ?? [])
+  const dbProjects = yield* project.list()
+  return opened.map((entry) => fromProject(entry.worktree, findProject(dbProjects, entry.worktree)))
+})
+
+const open = Effect.fn("OpenedProjects.open")(function* (
+  config: Config.Interface,
+  project: Project.Interface,
+  worktree: string,
+) {
+  const cfg = yield* config.getGlobal()
+  const opened = openedOnly(cfg.projects ?? [])
+  if (opened.some((entry) => entry.worktree === worktree)) return yield* list(config, project)
+  yield* config.updateGlobal({ ...cfg, projects: [{ worktree }, ...opened] })
+  return yield* list(config, project)
+})
+
+const close = Effect.fn("OpenedProjects.close")(function* (
+  config: Config.Interface,
+  project: Project.Interface,
+  worktree: string,
+) {
+  const cfg = yield* config.getGlobal()
+  yield* config.updateGlobal({
+    ...cfg,
+    projects: openedOnly(cfg.projects ?? []).filter((entry) => entry.worktree !== worktree),
+  })
+  return yield* list(config, project)
+})
+
+const meta = Effect.fn("OpenedProjects.meta")(function* (
+  config: Config.Interface,
+  project: Project.Interface,
+  input: {
+    worktree: string
+    name?: string
+    icon?: { color?: string; override?: string }
+    commands?: { start?: string }
+  },
+) {
+  const cfg = yield* config.getGlobal()
+  if (!(cfg.projects ?? []).some((entry) => entry.worktree === input.worktree)) return yield* list(config, project)
+
+  const existing = yield* ensureProject(project, input.worktree)
+
+  yield* project.update({
+    projectID: existing.id,
+    name: input.name ?? existing.name,
+    icon: input.icon ? { ...existing.icon, ...input.icon } : existing.icon,
+    commands: input.commands ? { ...existing.commands, ...input.commands } : existing.commands,
+  })
+  return yield* list(config, project)
+})
+
+const reorder = Effect.fn("OpenedProjects.reorder")(function* (
+  config: Config.Interface,
+  project: Project.Interface,
+  projects: ConfigProject[],
+) {
+  const cfg = yield* config.getGlobal()
+  yield* config.updateGlobal({ ...cfg, projects: openedOnly(projects) })
+  return yield* list(config, project)
+})
+
+export const OpenedProjects = {
+  list,
+  open,
+  close,
+  meta,
+  reorder,
+}