@dimina-kit/devtools 0.3.1-dev.20260518054451 → 0.3.1-dev.20260518114324

package/dist/main/ipc/projects.js

@@ -1,8 +1,12 @@
-import { dialog } from 'electron';
+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 { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
+import { sanitizeTemplates } from '../services/projects/templates.js';
+import { createProject } from '../services/projects/create-project-service.js';
+import { loadWorkbenchSettings, saveWorkbenchSettings, } from '../services/settings/index.js';
 export function registerProjectsIpc(ctx) {
     return new IpcRegistry(ctx.senderPolicy)
         .handle(ProjectsChannel.List, () => {
@@ -17,7 +21,7 @@ export function registerProjectsIpc(ctx) {
     })
         .handle(ProjectsChannel.Add, async (_event, ...args) => {
         const [dirPath] = validate(ProjectsChannel.Add, ProjectsAddSchema, args);
-        const dirError = ctx.workspace.validateProjectDir(dirPath);
+        const dirError = await ctx.workspace.validateProjectDir(dirPath);
         if (dirError) {
             await dialog.showMessageBox(ctx.mainWindow, {
                 type: 'error',
@@ -28,8 +32,8 @@ export function registerProjectsIpc(ctx) {
             });
             throw new Error(dirError);
         }
-        const duplicate = ctx.workspace.hasProject(dirPath);
-        const project = ctx.workspace.addProject(dirPath);
+        const duplicate = await ctx.workspace.hasProject(dirPath);
+        const project = await ctx.workspace.addProject(dirPath);
         if (duplicate) {
             await dialog.showMessageBox(ctx.mainWindow, {
                 type: 'info',
@@ -44,8 +48,88 @@ export function registerProjectsIpc(ctx) {
         .handle(ProjectsChannel.Remove, (_event, ...args) => {
         const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
         return ctx.workspace.removeProject(dirPath);
+    })
+        // ── Phase 3: template catalog + create flow ──
+        .handle(ProjectsChannel.ListTemplates, () => {
+        // Sanitize at the IPC boundary: `generate` is a function and the
+        // structured-clone algorithm Electron uses for invoke would otherwise
+        // throw "could not be cloned" before the renderer ever sees it.
+        return sanitizeTemplates(ctx.projectTemplates ?? []);
+    })
+        .handle(ProjectsChannel.OpenCreateDialog, async () => {
+        if (!ctx.customCreateProjectDialog)
+            return null;
+        const sanitized = sanitizeTemplates(ctx.projectTemplates ?? []);
+        return await ctx.customCreateProjectDialog({
+            parentWindow: ctx.mainWindow,
+            templates: sanitized,
+        });
+    })
+        .handle(ProjectsChannel.Create, async (_event, ...args) => {
+        // We deliberately don't run this through zod yet — the input shape is
+        // wide (any template can stash arbitrary `extra` fields) and the
+        // service does its own per-field validation. Bound size to keep this
+        // a cheap DoS guard.
+        const [raw] = args;
+        if (!raw || typeof raw !== 'object') {
+            throw new Error('projects:create expects a CreateProjectInput object');
+        }
+        const input = raw;
+        let project;
+        try {
+            project = await createProject(input, {
+                templates: ctx.projectTemplates ?? [],
+                projectsProvider: ctx.projectsProvider,
+            });
+        }
+        catch (err) {
+            // Mirror the Add flow: surface scaffold failures (invalid name,
+            // non-empty target dir, missing template, remote backend reject,
+            // …) as a native dialog so users see *why* the create silently
+            // fizzled. The renderer's catch then just bails out.
+            await dialog.showMessageBox(ctx.mainWindow, {
+                type: 'error',
+                title: '创建项目失败',
+                message: '无法创建项目',
+                detail: err instanceof Error ? err.message : String(err),
+                buttons: ['确定'],
+            });
+            throw err;
+        }
+        // Remember the parent of the just-created project so the next open of
+        // the create dialog pre-fills its directory under the same workspace.
+        try {
+            const settings = loadWorkbenchSettings();
+            const newBase = path.dirname(input.path);
+            if (newBase && settings.lastCreateBaseDir !== newBase) {
+                saveWorkbenchSettings({ ...settings, lastCreateBaseDir: newBase });
+            }
+        }
+        catch (err) {
+            console.warn('[projects:create] failed to persist lastCreateBaseDir', err);
+        }
+        return project;
+    })
+        .handle(ProjectsChannel.GetCreateDefaults, () => {
+        // Fallback chain: persisted last parent → user's Documents → home.
+        // Documents covers the common "我把项目都放在 Documents/ 下" case for
+        // first-time users on macOS; home is just a safe final fallback.
+        const settings = loadWorkbenchSettings();
+        const baseDir = settings.lastCreateBaseDir ??
+            safeAppPath('documents') ??
+            safeAppPath('home') ??
+            '';
+        return { baseDir };
     });
 }
+function safeAppPath(name) {
+    try {
+        return app.getPath(name);
+    }
+    catch {
+        return null;
+    }
+}
 export const projectsModule = {
     setup: (ctx) => registerProjectsIpc(ctx),
 };

package/dist/main/ipc/settings.js

@@ -45,10 +45,11 @@ export function registerSettingsIpc(ctx) {
         const [visible] = validate(SettingsChannel.SetVisible, SettingsSetVisibleSchema, args);
         if (visible) {
             await ctx.views.showSettings();
+            const projectPath = ctx.workspace.getProjectPath();
             ctx.notify.settingsInit({
-                projectPath: ctx.workspace.getProjectPath(),
-                config: ctx.workspace.getCompileConfig(ctx.workspace.getProjectPath()),
-                projectSettings: ctx.workspace.getProjectSettings(ctx.workspace.getProjectPath()),
+                projectPath,
+                config: await ctx.workspace.getCompileConfig(projectPath),
+                projectSettings: ctx.workspace.getProjectSettings(projectPath),
             });
         }
         else {
@@ -56,10 +57,11 @@ export function registerSettingsIpc(ctx) {
             ctx.notify.settingsClosed();
         }
     })
-        .on(SettingsChannel.ConfigChanged, (_, ...args) => {
+        .on(SettingsChannel.ConfigChanged, async (_, ...args) => {
         const [config] = validate(SettingsChannel.ConfigChanged, SettingsConfigChangedSchema, args);
-        if (ctx.workspace.getProjectPath()) {
-            ctx.workspace.saveCompileConfig(ctx.workspace.getProjectPath(), config);
+        const projectPath = ctx.workspace.getProjectPath();
+        if (projectPath) {
+            await ctx.workspace.saveCompileConfig(projectPath, config);
         }
         ctx.notify.settingsChanged(config);
     })

package/dist/main/services/projects/builtin-templates.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectTemplate } from './types.js';
+export declare const BUILTIN_TEMPLATES: ProjectTemplate[];
+//# sourceMappingURL=builtin-templates.d.ts.map

package/dist/main/services/projects/builtin-templates.js

@@ -0,0 +1,24 @@
+/**
+ * Built-in template catalog. Each entry's `source.path` points at a
+ * directory inside `<devtools-package-root>/templates/`, which is
+ * committed to the repo and (via the `files` field of package.json's
+ * publish manifest) included in the published tarball.
+ */
+import path from 'node:path';
+import { devtoolsPackageRoot } from '../../utils/paths.js';
+const TEMPLATES_DIR = path.join(devtoolsPackageRoot, 'templates');
+export const BUILTIN_TEMPLATES = [
+    {
+        id: 'blank',
+        name: 'Blank',
+        description: '最小骨架：app.* + 一个 index 页面',
+        source: { type: 'directory', path: path.join(TEMPLATES_DIR, 'blank') },
+    },
+    {
+        id: 'taro-todo',
+        name: 'Taro Todo',
+        description: 'Taro 编译产物的 Todo 示例',
+        source: { type: 'directory', path: path.join(TEMPLATES_DIR, 'taro-todo') },
+    },
+];
+//# sourceMappingURL=builtin-templates.js.map

package/dist/main/services/projects/create-project-service.d.ts

@@ -0,0 +1,7 @@
+import type { CreateProjectInput, Project, ProjectTemplate, ProjectsProvider } from './types.js';
+export interface CreateProjectCtx {
+    templates: ProjectTemplate[];
+    projectsProvider: ProjectsProvider;
+}
+export declare function createProject(input: CreateProjectInput, ctx: CreateProjectCtx): Promise<Project>;
+//# sourceMappingURL=create-project-service.d.ts.map

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

@@ -0,0 +1,84 @@
+/**
+ * Canonical server-side path for the "新建项目" flow.
+ *
+ * `createProject(input, ctx)`:
+ *  1. validates `input.name` (non-empty after trim) and `input.path` (does
+ *     not exist OR exists but is an empty directory).
+ *  2. resolves `input.templateId` (default 'blank') against `ctx.templates`.
+ *  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`.
+ *  5. registers the project with `ctx.projectsProvider.addProject(input.path)`
+ *     and returns the resulting Project.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+const DEFAULT_TEMPLATE_ID = 'blank';
+export async function createProject(input, ctx) {
+    // 1. name validation
+    const name = (input.name ?? '').trim();
+    if (name.length === 0) {
+        throw new Error('Project name cannot be empty');
+    }
+    // 2. path validation: does-not-exist OR exists+empty.
+    const target = input.path;
+    if (!target || typeof target !== 'string') {
+        throw new Error('Project path is required');
+    }
+    if (fs.existsSync(target)) {
+        const stat = fs.statSync(target);
+        if (!stat.isDirectory()) {
+            throw new Error(`Project path exists and is not a directory: ${target}`);
+        }
+        const entries = fs.readdirSync(target);
+        if (entries.length > 0) {
+            throw new Error(`Project path is not empty (refusing to overwrite): ${target}`);
+        }
+    }
+    // 3. template lookup (default 'blank')
+    const templateId = input.templateId ?? DEFAULT_TEMPLATE_ID;
+    const template = ctx.templates.find((t) => t.id === templateId);
+    if (!template) {
+        throw new Error(`Template not found: ${templateId}`);
+    }
+    if (!template.source && !template.generate) {
+        throw new Error(`Template '${templateId}' has neither a source directory nor a generate function`);
+    }
+    // 4. materialise: ensure target exists, then copy or generate.
+    fs.mkdirSync(target, { recursive: true });
+    if (template.generate) {
+        await template.generate(target, { name });
+    }
+    else if (template.source) {
+        if (!fs.existsSync(template.source.path)) {
+            throw new Error(`Template source missing on disk: ${template.source.path}`);
+        }
+        // `recursive: true` makes cpSync mirror the entire tree (files,
+        // subdirs, symlinks). `force: true` mirrors over an empty target.
+        fs.cpSync(template.source.path, target, {
+            recursive: true,
+            force: true,
+        });
+    }
+    // 5. rewrite project.config.json projectname (best-effort: create the file
+    // if the template didn't ship one — gives the user a working starting
+    // point even for tiny generators).
+    const cfgPath = path.join(target, 'project.config.json');
+    let cfg = {};
+    if (fs.existsSync(cfgPath)) {
+        try {
+            cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+        }
+        catch {
+            cfg = {};
+        }
+    }
+    cfg.projectname = name;
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+    // 6. register with provider — this is what makes the new project appear
+    // in the list immediately after the dialog closes.
+    const created = await ctx.projectsProvider.addProject(target);
+    return created;
+}
+//# sourceMappingURL=create-project-service.js.map

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

@@ -1,2 +1,9 @@
 export * from './project-repository.js';
+export { createLocalProjectsProvider } from './local-provider.js';
+export type { ProjectsProvider, ProjectTemplate, CreateProjectInput, BuiltinTemplatesMode, } from './types.js';
+export { DEFAULT_COMPILE_CONFIG } from './types.js';
+export { resolveTemplates, sanitizeTemplates } from './templates.js';
+export { BUILTIN_TEMPLATES } from './builtin-templates.js';
+export { createProject } from './create-project-service.js';
+export type { CreateProjectCtx } from './create-project-service.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/services/projects/index.js

@@ -2,5 +2,14 @@
 // keeps working. The filesystem-level helpers live in project-repository.ts;
 // higher-level coordination (session + renderer notifications) lives in
 // ../workspace/workspace-service.ts.
+//
+// Phase 1 adds the extensibility surface: `types.ts` (ProjectsProvider,
+// ProjectTemplate, CreateProjectInput) and `local-provider.ts` (the default
+// implementation injected when the host omits `projectsProvider`).
 export * from './project-repository.js';
+export { createLocalProjectsProvider } from './local-provider.js';
+export { DEFAULT_COMPILE_CONFIG } from './types.js';
+export { resolveTemplates, sanitizeTemplates } from './templates.js';
+export { BUILTIN_TEMPLATES } from './builtin-templates.js';
+export { createProject } from './create-project-service.js';
 //# sourceMappingURL=index.js.map

package/dist/main/services/projects/local-provider.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectsProvider } from './types.js';
+export declare function createLocalProjectsProvider(): ProjectsProvider;
+//# sourceMappingURL=local-provider.d.ts.map

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

@@ -0,0 +1,25 @@
+/**
+ * Default ProjectsProvider — persists the project list to
+ * `<userData>/dimina-projects.json` and exposes the validation / compile-
+ * config helpers historically provided by `project-repository.ts`.
+ *
+ * The repository module is kept for thumbnail/paths/page helpers and for
+ * back-compat re-exports; the canonical list & validation surface for the
+ * workspace service is this provider.
+ */
+import * as repo from './project-repository.js';
+import { loadThumbnail, saveThumbnailFromDataUrl } from './thumbnail.js';
+export function createLocalProjectsProvider() {
+    return {
+        listProjects: () => repo.listProjects(),
+        addProject: (dirPath) => repo.addProject(dirPath),
+        removeProject: (dirPath) => repo.removeProject(dirPath),
+        validateProjectDir: (dirPath) => repo.validateProjectDir(dirPath),
+        updateLastOpened: (dirPath) => repo.updateLastOpened(dirPath),
+        getCompileConfig: (dirPath) => repo.getCompileConfig(dirPath),
+        saveCompileConfig: (dirPath, cfg) => repo.saveCompileConfig(dirPath, cfg),
+        saveThumbnail: (dirPath, dataUrl) => saveThumbnailFromDataUrl(dirPath, dataUrl),
+        getThumbnail: (dirPath) => loadThumbnail(dirPath),
+    };
+}
+//# sourceMappingURL=local-provider.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * Built-in template policy merge logic.
+ *
+ * `resolveTemplates(builtin, injected, mode)`:
+ *  - mode='all'     → keep every built-in
+ *  - mode='none'    → drop every built-in
+ *  - mode=string[]  → keep only built-ins whose id is in the whitelist
+ *
+ * Injected templates always win over a same-id built-in. Order is:
+ * injected (input order) ++ remaining built-ins (in their input order
+ * for 'all'; in the whitelist's order for an array mode).
+ */
+import type { BuiltinTemplatesMode, ProjectTemplate } from './types.js';
+export declare function resolveTemplates(builtin: ProjectTemplate[], injected: ProjectTemplate[], mode: BuiltinTemplatesMode): ProjectTemplate[];
+/**
+ * Strip non-serialisable fields (e.g. `generate` functions) so the merged
+ * catalog can be sent across the renderer IPC boundary. Anything left is
+ * structured-clonable.
+ */
+export declare function sanitizeTemplates(templates: ProjectTemplate[]): ProjectTemplate[];
+//# sourceMappingURL=templates.d.ts.map

package/dist/main/services/projects/templates.js

@@ -0,0 +1,39 @@
+export function resolveTemplates(builtin, injected, mode) {
+    let kept;
+    if (mode === 'none') {
+        kept = [];
+    }
+    else if (mode === 'all') {
+        kept = [...builtin];
+    }
+    else {
+        // Whitelist: keep only listed ids, in the whitelist's order. Unknown
+        // ids are dropped silently — the user opted in to a curated subset and
+        // we don't want a typo to crash the new-project dialog.
+        const byId = new Map(builtin.map((t) => [t.id, t]));
+        kept = [];
+        for (const id of mode) {
+            const t = byId.get(id);
+            if (t)
+                kept.push(t);
+        }
+    }
+    // Strip any built-ins whose id is overridden by an injected template, then
+    // prepend the injected list so host-supplied versions win on rendering.
+    const injectedIds = new Set(injected.map((t) => t.id));
+    const remaining = kept.filter((t) => !injectedIds.has(t.id));
+    return [...injected, ...remaining];
+}
+/**
+ * Strip non-serialisable fields (e.g. `generate` functions) so the merged
+ * catalog can be sent across the renderer IPC boundary. Anything left is
+ * structured-clonable.
+ */
+export function sanitizeTemplates(templates) {
+    return templates.map((t) => {
+        // `generate` is a function and would throw on structuredClone / IPC.
+        const { generate: _generate, ...rest } = t;
+        return rest;
+    });
+}
+//# sourceMappingURL=templates.js.map

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

@@ -1,4 +1,8 @@
-import { type NativeImage } from 'electron';
-export declare function saveThumbnail(projectPath: string, image: NativeImage): string | null;
+/**
+ * Persist a data-URL screenshot for the local default provider. Silently
+ * drops the call when the URL isn't the expected PNG base64 form — the
+ * provider contract documents this as best-effort.
+ */
+export declare function saveThumbnailFromDataUrl(projectPath: string, imageDataUrl: string): void;
 export declare function loadThumbnail(projectPath: string): string | null;
 //# sourceMappingURL=thumbnail.d.ts.map

package/dist/main/services/projects/thumbnail.js

@@ -11,19 +11,24 @@ function hashProjectPath(projectPath) {
 function getThumbnailPath(projectPath) {
     return path.join(getThumbnailDir(), `${hashProjectPath(projectPath)}.png`);
 }
-export function saveThumbnail(projectPath, image) {
-    const png = image.toPNG();
-    const dir = getThumbnailDir();
-    fs.mkdirSync(dir, { recursive: true });
-    const filePath = getThumbnailPath(projectPath);
-    fs.writeFileSync(filePath, png);
-    return `data:image/png;base64,${png.toString('base64')}`;
+const DATA_URL_PNG_PREFIX = 'data:image/png;base64,';
+/**
+ * Persist a data-URL screenshot for the local default provider. Silently
+ * drops the call when the URL isn't the expected PNG base64 form — the
+ * provider contract documents this as best-effort.
+ */
+export function saveThumbnailFromDataUrl(projectPath, imageDataUrl) {
+    if (!imageDataUrl.startsWith(DATA_URL_PNG_PREFIX))
+        return;
+    const png = Buffer.from(imageDataUrl.slice(DATA_URL_PNG_PREFIX.length), 'base64');
+    fs.mkdirSync(getThumbnailDir(), { recursive: true });
+    fs.writeFileSync(getThumbnailPath(projectPath), png);
 }
 export function loadThumbnail(projectPath) {
     const filePath = getThumbnailPath(projectPath);
     try {
         const buf = fs.readFileSync(filePath);
-        return `data:image/png;base64,${buf.toString('base64')}`;
+        return `${DATA_URL_PNG_PREFIX}${buf.toString('base64')}`;
     }
     catch {
         return null;

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

@@ -0,0 +1,118 @@
+/**
+ * Public extensibility surface for the project list panel. Hosts that embed
+ * dimina-devtools (e.g. qdmp) can inject implementations of these types via
+ * `WorkbenchAppConfig` to fully take over the project source-of-truth, the
+ * template catalog, and the "新建项目" dialog.
+ */
+import type { CompileConfig } from '../../../shared/types.js';
+import type { Project } from './project-repository.js';
+export type { Project };
+/**
+ * Default compile config returned by WorkspaceService when the injected
+ * provider omits `getCompileConfig`, or when no record exists for a path.
+ * Exported so host providers can mirror the canonical shape instead of
+ * re-deriving the magic values.
+ */
+export declare const DEFAULT_COMPILE_CONFIG: CompileConfig;
+/**
+ * Pluggable project-list backend. The default implementation
+ * (LocalProjectsProvider) persists to `<userData>/dimina-projects.json`.
+ *
+ * All methods may return synchronously OR as a Promise.
+ *
+ * Optional methods documented per field below; when the host omits an
+ * optional method, WorkspaceService applies a documented default
+ * (typically a safe no-op) — it does NOT silently fall back to the local
+ * file-system helpers, since for a remote provider the project path may
+ * not exist on this machine at all.
+ */
+export interface ProjectsProvider {
+    listProjects(): Project[] | Promise<Project[]>;
+    /**
+     * Validate that `dirPath` points at a mini-app source tree.
+     * Return `null` if valid, or a user-facing error message string.
+     *
+     * Default when omitted: returns `null` (no validation). Remote
+     * providers SHOULD implement this if the host UI exposes "import an
+     * existing directory"; otherwise the user can add unreachable paths.
+     */
+    validateProjectDir?(dirPath: string): string | null | Promise<string | null>;
+    addProject(dirPath: string): Project | Promise<Project>;
+    removeProject(dirPath: string): void | Promise<void>;
+    /**
+     * Record that the user just opened a project (drives "recent" ordering).
+     *
+     * Default when omitted: silently no-ops. The renderer's "recent" sort
+     * order will then reflect whatever the provider's `listProjects` returns.
+     */
+    updateLastOpened?(dirPath: string): void | Promise<void>;
+    /**
+     * Read the per-project compile config.
+     *
+     * Default when omitted: returns `DEFAULT_COMPILE_CONFIG`
+     * (`{ startPage: '', scene: 1001, queryParams: [] }`).
+     */
+    getCompileConfig?(dirPath: string): CompileConfig | Promise<CompileConfig>;
+    /**
+     * Persist the per-project compile config.
+     *
+     * Default when omitted: silently no-ops — the renderer's edits will
+     * not survive a reload. Implement this if your UI exposes the compile
+     * config panel.
+     */
+    saveCompileConfig?(dirPath: string, cfg: CompileConfig): void | Promise<void>;
+    /**
+     * Persist a captured screenshot for the given project. `imageDataUrl`
+     * is a `data:image/png;base64,...` string so a remote provider can ship
+     * it straight to its backend without re-encoding.
+     *
+     * Default when omitted: silently no-ops (the screenshot is dropped).
+     * Implement this for hosts whose projects don't live on the local
+     * filesystem and that want thumbnails to round-trip through their own
+     * storage.
+     */
+    saveThumbnail?(dirPath: string, imageDataUrl: string): void | Promise<void>;
+    /**
+     * Load the most recently saved thumbnail for the given project.
+     * Returns a `data:image/png;base64,...` string or `null` when there
+     * is none.
+     *
+     * Default when omitted: returns `null`.
+     */
+    getThumbnail?(dirPath: string): string | null | Promise<string | null>;
+}
+/**
+ * A template the user can pick from in the "新建项目" dialog. Exactly one of
+ * `source` or `generate` should be supplied; if both are omitted, the
+ * service refuses to materialise the template.
+ */
+export interface ProjectTemplate {
+    /** Stable identifier. Used by host whitelists and the `templateId` field of CreateProjectInput. */
+    id: string;
+    /** Human-readable label shown in the dialog. */
+    name: string;
+    description?: string;
+    icon?: string;
+    /** Copy-tree source. `path` must be absolute. */
+    source?: {
+        type: 'directory';
+        path: string;
+    };
+    /** Programmatic generator. `target` is the absolute destination directory. */
+    generate?: (target: string, opts: {
+        name: string;
+    }) => Promise<void>;
+}
+/**
+ * Payload returned from the create-project dialog. The service uses this to
+ * scaffold disk content and to register the project with the provider.
+ */
+export interface CreateProjectInput {
+    name: string;
+    path: string;
+    templateId?: string;
+    extra?: Record<string, unknown>;
+}
+/** Built-in template policy. */
+export type BuiltinTemplatesMode = 'all' | 'none' | readonly string[];
+//# sourceMappingURL=types.d.ts.map

package/dist/main/services/projects/types.js

@@ -0,0 +1,19 @@
+/**
+ * Public extensibility surface for the project list panel. Hosts that embed
+ * dimina-devtools (e.g. qdmp) can inject implementations of these types via
+ * `WorkbenchAppConfig` to fully take over the project source-of-truth, the
+ * template catalog, and the "新建项目" dialog.
+ */
+import { DEFAULT_SCENE } from '../../../shared/constants.js';
+/**
+ * Default compile config returned by WorkspaceService when the injected
+ * provider omits `getCompileConfig`, or when no record exists for a path.
+ * Exported so host providers can mirror the canonical shape instead of
+ * re-deriving the magic values.
+ */
+export const DEFAULT_COMPILE_CONFIG = {
+    startPage: '',
+    scene: DEFAULT_SCENE,
+    queryParams: [],
+};
+//# sourceMappingURL=types.js.map

package/dist/main/services/settings/index.d.ts

@@ -13,6 +13,13 @@ export interface WorkbenchSettings {
         watch: boolean;
     };
     theme: ThemeSource;
+    /**
+     * Parent directory used to pre-fill the "新建项目" dialog's target path.
+     * Updated whenever a project is successfully created. `null` until the
+     * first create; the dialog then falls back to a platform default
+     * (Documents).
+     */
+    lastCreateBaseDir: string | null;
 }
 export declare function loadWorkbenchSettings(): WorkbenchSettings;
 export declare function saveWorkbenchSettings(settings: WorkbenchSettings): void;

package/dist/main/services/settings/index.js

@@ -14,6 +14,7 @@ const DEFAULTS = {
         watch: true,
     },
     theme: 'system',
+    lastCreateBaseDir: null,
 };
 function getSettingsFile() {
     return path.join(app.getPath('userData'), 'dimina-workbench-settings.json');
@@ -37,6 +38,9 @@ export function loadWorkbenchSettings() {
                 watch: data.compile?.watch ?? DEFAULTS.compile.watch,
             },
             theme,
+            lastCreateBaseDir: typeof data.lastCreateBaseDir === 'string'
+                ? data.lastCreateBaseDir
+                : DEFAULTS.lastCreateBaseDir,
         };
     }
     catch {