@dimina-kit/devtools 0.4.0-dev.20260828092243 → 0.4.0-dev.20260831134112

package/dist/main/app/app.js

@@ -169,6 +169,10 @@ function createContext(config, mainWindow, rendererDir) {
         projectTemplates: config.projectTemplates,
         builtinTemplates: config.builtinTemplates,
         customCreateProjectDialog: config.customCreateProjectDialog,
+        // No cast needed here: the hook receives the project record, so the
+        // main-process `Project` the context hands it satisfies the structural
+        // `EditableProject` the config declares.
+        customEditProjectDialog: config.customEditProjectDialog,
         onBeforeOpenProject: config.onBeforeOpenProject,
     });
 }

package/dist/main/index.bundle.js

@@ -485,10 +485,14 @@ var ProjectsChannel = {
   List: "projects:list",
   Add: "projects:add",
   Remove: "projects:remove",
+  /** Edit an existing record's name / icon; its path stays the identity. */
+  Update: "projects:update",
   /** Merged + sanitized template catalog for the create-project dialog. */
   ListTemplates: "projects:listTemplates",
   /** Host-supplied create-project dialog hook (returns input or null). */
   OpenCreateDialog: "projects:openCreateDialog",
+  /** Host-supplied edit-project dialog hook; `null` means no hook is configured. */
+  OpenEditDialog: "projects:openEditDialog",
   /** Server-side scaffold + register (delegates to create-project-service). */
   Create: "projects:create",
   /** Default values used to pre-fill the create-project dialog (baseDir). */
@@ -6391,6 +6395,7 @@ __export(project_repository_exports, {
   removeProject: () => removeProject,
   saveCompileConfig: () => saveCompileConfig,
   updateLastOpened: () => updateLastOpened,
+  updateProject: () => updateProject,
   updateProjectSettings: () => updateProjectSettings,
   validateProjectDir: () => validateProjectDir
 });
@@ -6411,6 +6416,30 @@ function readProjectConfig(dirPath) {
   }
   return merged;
 }
+function readProjectName(dirPath) {
+  const raw = readProjectConfig(dirPath).projectname;
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return raw;
+  }
+}
+function writeProjectName(dirPath, name) {
+  const configPath = path9.join(dirPath, "project.private.config.json");
+  let config = {};
+  if (fs5.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+    } catch {
+      throw new Error(`\u65E0\u6CD5\u91CD\u547D\u540D\uFF1A${configPath} \u4E0D\u662F\u5408\u6CD5 JSON`);
+    }
+  }
+  fs5.writeFileSync(
+    configPath,
+    JSON.stringify({ ...config, projectname: encodeURIComponent(name) }, null, 2)
+  );
+}
 function detectRuntimeType(dirPath) {
   const compileType = readProjectConfig(dirPath).compileType;
   if (compileType === "game") return "minigame";
@@ -6472,16 +6501,7 @@ function hasProject(dirPath) {
 }
 function addProject(dirPath) {
   const projects = load();
-  let name = path9.basename(dirPath);
-  try {
-    const configPath = path9.join(dirPath, "project.config.json");
-    if (fs5.existsSync(configPath)) {
-      const cfg = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
-      if (cfg.projectname) name = cfg.projectname;
-    }
-  } catch (err2) {
-    log2.warn("Failed to read project name from config", err2);
-  }
+  const name = readProjectName(dirPath) ?? path9.basename(dirPath);
   const type = detectRuntimeType(dirPath);
   const project = { name, path: dirPath, lastOpened: null, type };
   const idx = projects.findIndex((p) => p.path === dirPath);
@@ -6496,6 +6516,26 @@ function addProject(dirPath) {
 function removeProject(dirPath) {
   save(load().filter((p) => p.path !== dirPath));
 }
+function updateProject(dirPath, patch) {
+  const projects = load();
+  const idx = projects.findIndex((p) => p.path === dirPath);
+  if (idx < 0) return null;
+  const next = { ...projects[idx] };
+  if (patch.name !== void 0) {
+    const name = patch.name.trim();
+    if (!name) throw new Error("Project name cannot be empty");
+    next.name = name;
+  }
+  if (patch.iconUrl !== void 0) {
+    const iconUrl = patch.iconUrl.trim();
+    if (iconUrl) next.iconUrl = iconUrl;
+    else delete next.iconUrl;
+  }
+  if (next.name !== projects[idx].name) writeProjectName(dirPath, next.name);
+  projects[idx] = next;
+  save(projects);
+  return next;
+}
 function updateLastOpened(dirPath) {
   const projects = load();
   const idx = projects.findIndex((p) => p.path === dirPath);
@@ -6725,6 +6765,15 @@ function createWorkspaceService(ctx) {
     removeProject: async (dirPath) => {
       await provider.removeProject(dirPath);
     },
+    updateProject: async (dirPath, patch) => {
+      const projects = await provider.listProjects();
+      const existing = projects.find((p) => p.path === dirPath);
+      if (!existing) throw new Error(`No such project: ${dirPath}`);
+      if (!provider.updateProject) {
+        throw new Error("\u5F53\u524D\u5BBF\u4E3B\u4E0D\u652F\u6301\u7F16\u8F91\u9879\u76EE");
+      }
+      return provider.updateProject(dirPath, patch);
+    },
     hasProject: async (dirPath) => {
       const projects = await provider.listProjects();
       return projects.some((p) => p.path === dirPath);
@@ -6895,6 +6944,11 @@ function createLocalProjectsProvider() {
     listProjects: () => listProjects(),
     addProject: (dirPath) => addProject(dirPath),
     removeProject: (dirPath) => removeProject(dirPath),
+    updateProject: (dirPath, patch) => {
+      const updated = updateProject(dirPath, patch);
+      if (!updated) throw new Error(`No such project: ${dirPath}`);
+      return updated;
+    },
     validateProjectDir: (dirPath) => validateProjectDir(dirPath),
     updateLastOpened: (dirPath) => updateLastOpened(dirPath),
     getCompileConfig: (dirPath) => getCompileConfig(dirPath),
@@ -7167,6 +7221,7 @@ function createWorkbenchContext(opts) {
     opts.builtinTemplates ?? "all"
   );
   ctx.customCreateProjectDialog = opts.customCreateProjectDialog;
+  ctx.customEditProjectDialog = opts.customEditProjectDialog;
   ctx.onBeforeOpenProject = opts.onBeforeOpenProject;
   ctx.workspace = createWorkspaceService(ctx);
   ctx.senderPolicy = createWorkbenchSenderPolicy(ctx);
@@ -7443,7 +7498,15 @@ var SimulatorCustomApiInvokeSchema = z3.tuple([
 ]);
 var ProjectGetPagesSchema = z3.tuple([AbsolutePath]);
 var ProjectGetCompileConfigSchema = z3.tuple([AbsolutePath]);
+var ProjectsUpdateSchema = z3.tuple([
+  AbsolutePath,
+  z3.object({
+    name: z3.string().min(1).max(200).optional(),
+    iconUrl: z3.string().max(2048).optional()
+  })
+]);
 var ProjectsRemoveSchema = z3.tuple([AbsolutePath]);
+var ProjectsOpenEditDialogSchema = z3.tuple([AbsolutePath]);
 var WorkbenchSettingsSaveSchema = z3.tuple([
   z3.looseObject({
     cdp: z3.looseObject({
@@ -7625,7 +7688,7 @@ function writeProjectConfig(target, name) {
       cfg = {};
     }
   }
-  cfg.projectname = name;
+  cfg.projectname = encodeURIComponent(name);
   fs7.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
 }
 async function createProject(input, ctx) {
@@ -7680,6 +7743,13 @@ function registerProjectsIpc(ctx) {
   }).handle(ProjectsChannel.Remove, (_event, ...args) => {
     const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
     return ctx.workspace.removeProject(dirPath);
+  }).handle(ProjectsChannel.Update, (_event, ...args) => {
+    const [dirPath, patch] = validate(
+      ProjectsChannel.Update,
+      ProjectsUpdateSchema,
+      args
+    );
+    return ctx.workspace.updateProject(dirPath, patch);
   }).handle(ProjectsChannel.ListTemplates, () => {
     return sanitizeTemplates(ctx.projectTemplates ?? []);
   }).handle(ProjectsChannel.OpenCreateDialog, async () => {
@@ -7689,6 +7759,20 @@ function registerProjectsIpc(ctx) {
       parentWindow: ctx.windows.mainWindow,
       templates: sanitized
     });
+  }).handle(ProjectsChannel.OpenEditDialog, async (_event, ...args) => {
+    if (!ctx.customEditProjectDialog) return null;
+    const [dirPath] = validate(
+      ProjectsChannel.OpenEditDialog,
+      ProjectsOpenEditDialogSchema,
+      args
+    );
+    const project = (await ctx.workspace.listProjects()).find((p) => p.path === dirPath);
+    if (!project) throw new Error(`No such project: ${dirPath}`);
+    const result = await ctx.customEditProjectDialog({
+      parentWindow: ctx.windows.mainWindow,
+      project
+    });
+    return { result };
   }).handle(ProjectsChannel.Create, async (_event, ...args) => {
     const [raw] = args;
     if (!raw || typeof raw !== "object") {
@@ -11108,6 +11192,10 @@ function createContext(config, mainWindow, rendererDir2) {
     projectTemplates: config.projectTemplates,
     builtinTemplates: config.builtinTemplates,
     customCreateProjectDialog: config.customCreateProjectDialog,
+    // No cast needed here: the hook receives the project record, so the
+    // main-process `Project` the context hands it satisfies the structural
+    // `EditableProject` the config declares.
+    customEditProjectDialog: config.customEditProjectDialog,
     onBeforeOpenProject: config.onBeforeOpenProject
   });
 }

package/dist/main/ipc/projects.d.ts

@@ -1,7 +1,7 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { WorkbenchModule } from '../services/module.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-type ProjectsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'windows' | 'senderPolicy' | 'projectsProvider' | 'projectTemplates' | 'customCreateProjectDialog' | 'notify' | 'views'>;
+type ProjectsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'windows' | 'senderPolicy' | 'projectsProvider' | 'projectTemplates' | 'customCreateProjectDialog' | 'customEditProjectDialog' | 'notify' | 'views'>;
 export declare function registerProjectsIpc(ctx: ProjectsIpcCtx): Disposable;
 export declare const projectsModule: WorkbenchModule;
 export {};

package/dist/main/ipc/projects.js

@@ -1,7 +1,7 @@
 import { app, dialog } from 'electron';
 import path from 'path';
 import { ProjectsChannel, DialogChannel } from '../../shared/ipc-channels.js';
-import { ProjectsAddSchema, ProjectsRemoveSchema, } from '../../shared/ipc-schemas.js';
+import { ProjectsAddSchema, ProjectsOpenEditDialogSchema, ProjectsRemoveSchema, ProjectsUpdateSchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
 import { sanitizeTemplates } from '../services/projects/templates.js';
@@ -59,6 +59,10 @@ export function registerProjectsIpc(ctx) {
         .handle(ProjectsChannel.Remove, (_event, ...args) => {
         const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
         return ctx.workspace.removeProject(dirPath);
+    })
+        .handle(ProjectsChannel.Update, (_event, ...args) => {
+        const [dirPath, patch] = validate(ProjectsChannel.Update, ProjectsUpdateSchema, args);
+        return ctx.workspace.updateProject(dirPath, patch);
     })
         // ── template catalog + create flow ──
         .handle(ProjectsChannel.ListTemplates, () => {
@@ -75,6 +79,26 @@ export function registerProjectsIpc(ctx) {
             parentWindow: ctx.windows.mainWindow,
             templates: sanitized,
         });
+    })
+        .handle(ProjectsChannel.OpenEditDialog, async (_event, ...args) => {
+        if (!ctx.customEditProjectDialog)
+            return null;
+        const [dirPath] = validate(ProjectsChannel.OpenEditDialog, ProjectsOpenEditDialogSchema, args);
+        // Read from the workspace, not the renderer's args — the host sees
+        // devtools' own authoritative record, never a client-supplied one.
+        const project = (await ctx.workspace.listProjects()).find((p) => p.path === dirPath);
+        if (!project)
+            throw new Error(`No such project: ${dirPath}`);
+        const result = await ctx.customEditProjectDialog({
+            parentWindow: ctx.windows.mainWindow,
+            project,
+        });
+        // Wrapped in `{ result }` so `null` on the wire means ONLY "no hook
+        // configured" (renderer falls back to the built-in dialog). A hook that
+        // ran and was cancelled resolves `result: null`, which the renderer
+        // must treat as "do nothing" — otherwise a cancelled host dialog would
+        // fall through into the built-in one right behind it.
+        return { result };
     })
         .handle(ProjectsChannel.Create, async (_event, ...args) => {
         // We deliberately don't run this through zod yet — the input shape is

package/dist/main/services/projects/create-project-service.js

@@ -8,7 +8,8 @@
  *  3. copies the template `source` directory into `input.path`, or invokes
  *     `template.generate(input.path, { name })` for programmatic templates.
  *  4. rewrites `<input.path>/project.config.json`'s `projectname` to
- *     `input.name`.
+ *     `encodeURIComponent(input.name)` — same encoding project-repository's
+ *     `readProjectName`/`writeProjectName` use for the edit path.
  *  5. registers the project with `ctx.projectsProvider.addProject(input.path)`
  *     and returns the resulting Project.
  */
@@ -81,6 +82,12 @@ async function materializeTemplate(target, template, name) {
  * Rewrite `<target>/project.config.json`'s `projectname` (best-effort: create
  * the file if the template didn't ship one — gives the user a working
  * starting point even for tiny generators).
+ *
+ * Encodes with `encodeURIComponent`, the same convention project-repository's
+ * `readProjectName`/`writeProjectName` use (aligned with WeChat DevTools:
+ * non-ASCII names go through URL encoding). Writing the raw name here would
+ * make this the one path that disagrees with the rename path, so a name with
+ * `%` or non-ASCII characters would come back different after an edit.
  */
 function writeProjectConfig(target, name) {
     const cfgPath = path.join(target, 'project.config.json');
@@ -93,7 +100,7 @@ function writeProjectConfig(target, name) {
             cfg = {};
         }
     }
-    cfg.projectname = name;
+    cfg.projectname = encodeURIComponent(name);
     fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
 }
 export async function createProject(input, ctx) {

package/dist/main/services/projects/local-provider.js

@@ -14,6 +14,12 @@ export function createLocalProjectsProvider() {
         listProjects: () => repo.listProjects(),
         addProject: (dirPath) => repo.addProject(dirPath),
         removeProject: (dirPath) => repo.removeProject(dirPath),
+        updateProject: (dirPath, patch) => {
+            const updated = repo.updateProject(dirPath, patch);
+            if (!updated)
+                throw new Error(`No such project: ${dirPath}`);
+            return updated;
+        },
         validateProjectDir: (dirPath) => repo.validateProjectDir(dirPath),
         updateLastOpened: (dirPath) => repo.updateLastOpened(dirPath),
         getCompileConfig: (dirPath) => repo.getCompileConfig(dirPath),

package/dist/main/services/projects/project-repository.d.ts

@@ -7,6 +7,22 @@ export interface Project {
     compileConfig?: CompileConfig;
     /** Absent on projects added before mini-game support — treat as 'miniprogram'. */
     type?: ProjectType;
+    /**
+     * User-supplied icon for the project card. Absent means the card falls back
+     * to the first character of `name`.
+     */
+    iconUrl?: string;
+}
+/**
+ * The subset of a project record the user may edit after import. `path` is the
+ * record's identity (it keys every other per-project store — compile config,
+ * thumbnail, watcher) and is deliberately not patchable: pointing an existing
+ * record at another directory is an import, not an edit.
+ */
+export interface ProjectPatch {
+    name?: string;
+    /** Empty string clears the icon and restores the name-initial fallback. */
+    iconUrl?: string;
 }
 export interface ProjectPages {
     pages: string[];
@@ -20,6 +36,15 @@ export declare function validateProjectDir(dirPath: string): string | null;
 export declare function hasProject(dirPath: string): boolean;
 export declare function addProject(dirPath: string): Project;
 export declare function removeProject(dirPath: string): void;
+/**
+ * Apply a user edit to the record at `dirPath`. Returns the updated record, or
+ * `null` when no record matches — callers decide whether a missing project is
+ * an error (the IPC path) or a no-op.
+ *
+ * A name change is written through to the project's own config (see
+ * `writeProjectName`); the icon lives only in our list.
+ */
+export declare function updateProject(dirPath: string, patch: ProjectPatch): Project | null;
 export declare function updateLastOpened(dirPath: string): void;
 export declare function getCompileConfig(dirPath: string): CompileConfig;
 export declare function getProjectPages(dirPath: string): ProjectPages;

package/dist/main/services/projects/project-repository.js

@@ -23,6 +23,54 @@ function readProjectConfig(dirPath) {
     }
     return merged;
 }
+/**
+ * The project's display name as the project itself carries it.
+ *
+ * `projectname` lives in the merged config with the private file winning, and
+ * is URL-encoded when it leaves ASCII — WeChat DevTools 36.6.0 writes
+ * `"projectname": "%E6%BD%AE%E7%8E%A9%E6%97%8F"` and its own project list only
+ * mirrors that value. ASCII names encode to themselves, so plain values that
+ * were written by hand round-trip unchanged.
+ *
+ * Returns null when the config carries no usable name, leaving the caller to
+ * fall back to the directory name.
+ */
+function readProjectName(dirPath) {
+    const raw = readProjectConfig(dirPath).projectname;
+    if (typeof raw !== 'string' || !raw.trim())
+        return null;
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        // A literal '%' that isn't a valid escape — keep the author's text.
+        return raw;
+    }
+}
+/**
+ * Persist the display name into `project.private.config.json`, the per-
+ * developer half of the project config (WeChat DevTools writes the name there
+ * too, leaving the shared `project.config.json` alone).
+ *
+ * This is what makes the config — not our list file — the single owner of the
+ * name: `addProject` re-reads it, so re-importing a directory restores the
+ * user's rename instead of resetting it.
+ */
+function writeProjectName(dirPath, name) {
+    const configPath = path.join(dirPath, 'project.private.config.json');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            // Refuse rather than overwrite: this file also holds the user's IDE
+            // settings and compile conditions, which a blind rewrite would drop.
+            throw new Error(`无法重命名：${configPath} 不是合法 JSON`);
+        }
+    }
+    fs.writeFileSync(configPath, JSON.stringify({ ...config, projectname: encodeURIComponent(name) }, null, 2));
+}
 /**
  * Mirrors `dimina/fe/packages/compiler/src/env.js`'s `detectRuntimeType` —
  * an explicit `compileType` wins, else a mini-game is inferred from
@@ -95,18 +143,9 @@ export function hasProject(dirPath) {
 }
 export function addProject(dirPath) {
     const projects = load();
-    let name = path.basename(dirPath);
-    try {
-        const configPath = path.join(dirPath, 'project.config.json');
-        if (fs.existsSync(configPath)) {
-            const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-            if (cfg.projectname)
-                name = cfg.projectname;
-        }
-    }
-    catch (err) {
-        log.warn('Failed to read project name from config', err);
-    }
+    // The config is the name's owner, so re-adding a directory picks up a rename
+    // the user made here rather than reverting it.
+    const name = readProjectName(dirPath) ?? path.basename(dirPath);
     const type = detectRuntimeType(dirPath);
     const project = { name, path: dirPath, lastOpened: null, type };
     const idx = projects.findIndex((p) => p.path === dirPath);
@@ -122,6 +161,43 @@ export function addProject(dirPath) {
 export function removeProject(dirPath) {
     save(load().filter((p) => p.path !== dirPath));
 }
+/**
+ * Apply a user edit to the record at `dirPath`. Returns the updated record, or
+ * `null` when no record matches — callers decide whether a missing project is
+ * an error (the IPC path) or a no-op.
+ *
+ * A name change is written through to the project's own config (see
+ * `writeProjectName`); the icon lives only in our list.
+ */
+export function updateProject(dirPath, patch) {
+    const projects = load();
+    const idx = projects.findIndex((p) => p.path === dirPath);
+    if (idx < 0)
+        return null;
+    const next = { ...projects[idx] };
+    if (patch.name !== undefined) {
+        const name = patch.name.trim();
+        if (!name)
+            throw new Error('Project name cannot be empty');
+        next.name = name;
+    }
+    if (patch.iconUrl !== undefined) {
+        const iconUrl = patch.iconUrl.trim();
+        if (iconUrl)
+            next.iconUrl = iconUrl;
+        else
+            delete next.iconUrl;
+    }
+    // The config write comes first and is allowed to throw: a rename that only
+    // reached our list would look applied until the next re-import silently
+    // reverted it. The icon has no counterpart in the project config — it is
+    // ours alone — so it never touches the project directory.
+    if (next.name !== projects[idx].name)
+        writeProjectName(dirPath, next.name);
+    projects[idx] = next;
+    save(projects);
+    return next;
+}
 export function updateLastOpened(dirPath) {
     const projects = load();
     const idx = projects.findIndex((p) => p.path === dirPath);

package/dist/main/services/projects/types.d.ts

@@ -5,8 +5,8 @@
  * template catalog, and the "新建项目" dialog.
  */
 import type { CompileConfig } from '../../../shared/types.js';
-import type { Project } from './project-repository.js';
-export type { Project };
+import type { Project, ProjectPatch } from './project-repository.js';
+export type { Project, ProjectPatch };
 export type { ProjectTemplate, CreateProjectInput } from '../../../shared/types.js';
 /**
  * Default compile config returned by WorkspaceService when the injected
@@ -40,6 +40,17 @@ export interface ProjectsProvider {
     validateProjectDir?(dirPath: string): string | null | Promise<string | null>;
     addProject(dirPath: string): Project | Promise<Project>;
     removeProject(dirPath: string): void | Promise<void>;
+    /**
+     * Apply a user edit (name / icon) to an existing record. `dirPath` is the
+     * record's identity, so it is never part of the patch — see `ProjectPatch`.
+     *
+     * Default when omitted: throws, and the renderer shows that error in the
+     * edit dialog. A silent no-op would report success (dialog closes, list
+     * reloads) while discarding the user's input, since the caller has no way
+     * to tell "saved" apart from "provider doesn't support this". Implement
+     * this if your UI exposes the project-edit dialog.
+     */
+    updateProject?(dirPath: string, patch: ProjectPatch): Project | Promise<Project>;
     /**
      * Record that the user just opened a project (drives "recent" ordering).
      *

package/dist/main/services/workbench-context.d.ts

@@ -21,8 +21,8 @@ import { type WorkspaceService } from './workspace/workspace-service.js';
 import { type SimulatorApiRegistry } from './simulator/custom-apis.js';
 import { type SimulatorUiExtensionRegistry } from './simulator/ui-extensions.js';
 import { sanitizeTemplates } from './projects/templates.js';
-import type { ProjectsProvider, ProjectTemplate } from './projects/types.js';
-import type { CustomCreateProjectDialogResult } from '../../shared/types.js';
+import type { Project, ProjectsProvider, ProjectTemplate } from './projects/types.js';
+import type { CustomCreateProjectDialogResult, CustomEditProjectDialogResult } from '../../shared/types.js';
 /**
  * Shared mutable state for the workbench application.
  * Passed to each IPC module so they can read/write shared state without closures.
@@ -96,6 +96,17 @@ export interface WorkbenchContext extends RuntimeContext {
         parentWindow: BrowserWindow;
         templates: ProjectTemplate[];
     }) => Promise<CustomCreateProjectDialogResult>;
+    /**
+     * Optional host hook for the "编辑项目" dialog. When present, the
+     * `projects:openEditDialog` IPC runs it and wraps whatever it resolves to
+     * as `{ result }`; when absent, the IPC returns `null` and the renderer
+     * shows the built-in dialog. `project` comes from `workspace.listProjects`,
+     * not the renderer's IPC args.
+     */
+    customEditProjectDialog?: (ctx: {
+        parentWindow: BrowserWindow;
+        project: Project;
+    }) => Promise<CustomEditProjectDialogResult>;
     /**
      * Host permission gate consulted by `workspace.openProject` BEFORE any side
      * effect. Throwing vetoes the open (see `WorkbenchAppConfig.onBeforeOpenProject`).
@@ -239,8 +250,9 @@ export interface WorkbenchContext extends RuntimeContext {
  * because their shapes intentionally differ from the config:
  *  - `preloadPath` / `rendererDir` are REQUIRED here (the caller resolves the
  *    defaults before constructing the context) but optional in the config;
- *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` use
- *    the main-process types, not the structural mirrors in `shared/types`.
+ *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` /
+ *    `customEditProjectDialog` use the main-process types, not the structural
+ *    mirrors in `shared/types`.
  */
 export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' | 'apiNamespaces' | 'appName' | 'fileTypes'> {
     mainWindow: BrowserWindow;
@@ -255,6 +267,8 @@ export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' |
     builtinTemplates?: 'all' | 'none' | readonly string[];
     /** Host-supplied "新建项目" dialog hook. */
     customCreateProjectDialog?: WorkbenchContext['customCreateProjectDialog'];
+    /** Host-supplied "编辑项目" dialog hook. */
+    customEditProjectDialog?: WorkbenchContext['customEditProjectDialog'];
     /** Host permission gate run before a project opens (throw to veto). */
     onBeforeOpenProject?: WorkbenchContext['onBeforeOpenProject'];
 }

package/dist/main/services/workbench-context.js

@@ -74,6 +74,7 @@ export function createWorkbenchContext(opts) {
     ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();
     ctx.projectTemplates = resolveTemplates(BUILTIN_TEMPLATES, opts.projectTemplates ?? [], opts.builtinTemplates ?? 'all');
     ctx.customCreateProjectDialog = opts.customCreateProjectDialog;
+    ctx.customEditProjectDialog = opts.customEditProjectDialog;
     ctx.onBeforeOpenProject = opts.onBeforeOpenProject;
     ctx.workspace = createWorkspaceService(ctx);
     ctx.senderPolicy = createWorkbenchSenderPolicy(ctx);

package/dist/main/services/workspace/workspace-service.d.ts

@@ -1,6 +1,7 @@
 import type { AppInfo, CompileConfig, ProjectSession } from '../../../shared/types.js';
 import type { WorkbenchContext } from '../workbench-context.js';
 import type { Project, ProjectPages, ProjectSettings } from '../projects/project-repository.js';
+import type { ProjectPatch } from '../projects/types.js';
 /**
  * Result returned to the renderer after `project:open` finishes.
  * Mirrors the previous inline shape in ipc/session.ts so no
@@ -28,6 +29,7 @@ export interface WorkspaceService {
     listProjects(): Promise<Project[]>;
     addProject(dirPath: string): Promise<Project>;
     removeProject(dirPath: string): Promise<void>;
+    updateProject(dirPath: string, patch: ProjectPatch): Promise<Project>;
     hasProject(dirPath: string): Promise<boolean>;
     validateProjectDir(dirPath: string): Promise<string | null>;
     openProject(projectPath: string): Promise<OpenProjectResult>;

package/dist/main/services/workspace/workspace-service.js

@@ -158,6 +158,20 @@ export function createWorkspaceService(ctx) {
         removeProject: async (dirPath) => {
             await provider.removeProject(dirPath);
         },
+        updateProject: async (dirPath, patch) => {
+            const projects = await provider.listProjects();
+            const existing = projects.find((p) => p.path === dirPath);
+            if (!existing)
+                throw new Error(`No such project: ${dirPath}`);
+            // A provider without `updateProject` cannot persist the edit. Returning
+            // the record unchanged would look like a successful save to the
+            // renderer (dialog closes, list reloads) while silently discarding the
+            // user's input, so this must fail loudly instead.
+            if (!provider.updateProject) {
+                throw new Error('当前宿主不支持编辑项目');
+            }
+            return provider.updateProject(dirPath, patch);
+        },
         hasProject: async (dirPath) => {
             const projects = await provider.listProjects();
             return projects.some((p) => p.path === dirPath);