@dimina-kit/devtools 0.3.1 → 0.3.2-dev.20260522110734

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; 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/project-repository.d.ts

@@ -12,9 +12,9 @@ export interface ProjectPages {
 export interface ProjectSettings {
     uploadWithSourceMap: boolean;
 }
-export type { CompileConfig } from '../../../shared/types.js';
 export declare function listProjects(): Project[];
 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;
 export declare function updateLastOpened(dirPath: string): void;

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

@@ -46,6 +46,9 @@ export function validateProjectDir(dirPath) {
     }
     return null;
 }
+export function hasProject(dirPath) {
+    return load().some((p) => p.path === dirPath);
+}
 export function addProject(dirPath) {
     const projects = load();
     let name = path.basename(dirPath);

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

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,37 @@
+import { createHash } from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { app } from 'electron';
+function getThumbnailDir() {
+    return path.join(app.getPath('userData'), 'thumbnails');
+}
+function hashProjectPath(projectPath) {
+    return createHash('sha256').update(projectPath).digest('hex').slice(0, 16);
+}
+function getThumbnailPath(projectPath) {
+    return path.join(getThumbnailDir(), `${hashProjectPath(projectPath)}.png`);
+}
+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_URL_PNG_PREFIX}${buf.toString('base64')}`;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=thumbnail.js.map

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

@@ -8,7 +8,18 @@ export interface WorkbenchSettings {
         enabled: boolean;
         port: number;
     };
+    compile: {
+        /** Watch project files and auto-recompile on change. */
+        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

@@ -1,16 +1,21 @@
 import { app, nativeTheme } from 'electron';
 import fs from 'fs';
 import path from 'path';
+import { DEFAULT_CDP_PORT } from '../../../shared/constants.js';
 const DEFAULTS = {
     cdp: {
         enabled: false,
-        port: 9222,
+        port: DEFAULT_CDP_PORT,
     },
     mcp: {
         enabled: false,
         port: 7789,
     },
+    compile: {
+        watch: true,
+    },
     theme: 'system',
+    lastCreateBaseDir: null,
 };
 function getSettingsFile() {
     return path.join(app.getPath('userData'), 'dimina-workbench-settings.json');
@@ -30,11 +35,22 @@ export function loadWorkbenchSettings() {
                 enabled: data.mcp?.enabled ?? DEFAULTS.mcp.enabled,
                 port: data.mcp?.port ?? DEFAULTS.mcp.port,
             },
+            compile: {
+                watch: data.compile?.watch ?? DEFAULTS.compile.watch,
+            },
             theme,
+            lastCreateBaseDir: typeof data.lastCreateBaseDir === 'string'
+                ? data.lastCreateBaseDir
+                : DEFAULTS.lastCreateBaseDir,
         };
     }
     catch {
-        return { ...DEFAULTS, cdp: { ...DEFAULTS.cdp }, mcp: { ...DEFAULTS.mcp } };
+        return {
+            ...DEFAULTS,
+            cdp: { ...DEFAULTS.cdp },
+            mcp: { ...DEFAULTS.mcp },
+            compile: { ...DEFAULTS.compile },
+        };
     }
 }
 export function saveWorkbenchSettings(settings) {

package/dist/main/services/simulator/custom-apis.d.ts

@@ -0,0 +1,10 @@
+export type SimulatorApiHandler = (params: unknown) => unknown | Promise<unknown>;
+export interface SimulatorApiRegistry {
+    register(name: string, handler: SimulatorApiHandler): () => void;
+    list(): string[];
+    invoke(name: string, params: unknown): Promise<unknown>;
+    clear(): void;
+}
+export declare function createSimulatorApiRegistry(): SimulatorApiRegistry;
+export declare const simulatorApiRegistry: SimulatorApiRegistry;
+//# sourceMappingURL=custom-apis.d.ts.map

package/dist/main/services/simulator/custom-apis.js

@@ -0,0 +1,26 @@
+export function createSimulatorApiRegistry() {
+    const handlers = new Map();
+    return {
+        register(name, handler) {
+            handlers.set(name, handler);
+            return () => {
+                if (handlers.get(name) === handler)
+                    handlers.delete(name);
+            };
+        },
+        list() {
+            return Array.from(handlers.keys());
+        },
+        async invoke(name, params) {
+            const handler = handlers.get(name);
+            if (!handler)
+                throw new Error(`Simulator API "${name}" is not registered`);
+            return await handler(params);
+        },
+        clear() {
+            handlers.clear();
+        },
+    };
+}
+export const simulatorApiRegistry = createSimulatorApiRegistry();
+//# sourceMappingURL=custom-apis.js.map

package/dist/main/services/simulator-storage/index.d.ts

@@ -16,5 +16,26 @@
  *     events stop flowing until they close it.
  */
 import { type WebContents } from 'electron';
-export declare function setupSimulatorStorage(host: WebContents): void;
+import { type Disposable } from '../../utils/disposable.js';
+import { type SenderPolicy } from '../../utils/ipc-registry.js';
+export interface SimulatorStorageOptions {
+    /**
+     * Sender gate applied to `SimulatorStorageChannel.GetSnapshot`.
+     * When provided, the IpcRegistry rejects invocations whose `event.sender`
+     * is not whitelisted (typically the workbench-wide policy that allows
+     * the main window renderer and overlay views only).
+     * Omitted in unit tests that mock the electron module.
+     */
+    senderPolicy?: SenderPolicy;
+    /**
+     * Returns the appId of the currently-active project session, or null when
+     * no session is active. The simulator uses a fixed `persist:simulator`
+     * partition + simulator.html origin, so localStorage is shared across
+     * every project that has ever opened. The dimina runtime isolates writes
+     * with `${appId}_` prefixes; this callback lets the panel filter the
+     * CDP snapshot/event stream to the active appId.
+     */
+    getActiveAppId: () => string | null;
+}
+export declare function setupSimulatorStorage(host: WebContents, options: SimulatorStorageOptions): Disposable;
 //# sourceMappingURL=index.d.ts.map