@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

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

@@ -1,9 +1,98 @@
 import { app } from 'electron';
 import path from 'path';
 import fs from 'fs';
-import { DEFAULT_SCENE } from '../../../shared/constants.js';
+import { NORMAL_COMPILE_INDEX, compileConfigToMode, compileConfigToModes, emptyCompileModes, isNormalCompile, normalizeCompileModes, resolveCompileConfig, } from '../../../shared/compile-modes.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('projects');
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Merge project.config.json + project.private.config.json (private wins),
+ * mirroring `dimina/fe/packages/compiler/src/env.js`'s `storeInfo`.
+ */
+function readProjectConfig(dirPath) {
+    let merged = {};
+    for (const fileName of ['project.config.json', 'project.private.config.json']) {
+        const configPath = path.join(dirPath, fileName);
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            merged = { ...merged, ...JSON.parse(fs.readFileSync(configPath, 'utf-8')) };
+        }
+        catch (err) {
+            log.warn(`Failed to parse ${configPath}`, err);
+        }
+    }
+    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
+ * game.json + game.js/.ts with no app.json present.
+ */
+function detectRuntimeType(dirPath) {
+    const compileType = readProjectConfig(dirPath).compileType;
+    if (compileType === 'game')
+        return 'minigame';
+    if (compileType === 'miniprogram')
+        return 'miniprogram';
+    const hasMiniProgramConfig = fs.existsSync(path.join(dirPath, 'app.json'));
+    const hasMiniGameConfig = fs.existsSync(path.join(dirPath, 'game.json'));
+    const hasMiniGameEntry = ['game.js', 'game.ts']
+        .some((fileName) => fs.existsSync(path.join(dirPath, fileName)));
+    if (!hasMiniProgramConfig && hasMiniGameConfig && hasMiniGameEntry)
+        return 'minigame';
+    return 'miniprogram';
+}
 function getProjectsFile() {
     return path.join(app.getPath('userData'), 'dimina-projects.json');
 }
@@ -28,6 +117,12 @@ export function validateProjectDir(dirPath) {
     if (!fs.existsSync(dirPath)) {
         return `小程序目录不存在：${dirPath}`;
     }
+    if (detectRuntimeType(dirPath) === 'minigame') {
+        if (!fs.existsSync(path.join(dirPath, 'game.json'))) {
+            return '该目录缺少 game.json，请选择包含小游戏源码的目录';
+        }
+        return null;
+    }
     if (!fs.existsSync(path.join(dirPath, 'app.json'))) {
         const configPath = path.join(dirPath, 'project.config.json');
         if (fs.existsSync(configPath)) {
@@ -51,22 +146,14 @@ 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);
-    }
-    const project = { name, path: dirPath, lastOpened: null };
+    // 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);
     if (idx >= 0) {
-        projects[idx] = { ...projects[idx], name };
+        projects[idx] = { ...projects[idx], name, type };
     }
     else {
         projects.unshift(project);
@@ -77,6 +164,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);
@@ -85,16 +209,138 @@ export function updateLastOpened(dirPath) {
         save(projects);
     }
 }
-export function getCompileConfig(dirPath) {
+/**
+ * Read a project's compile modes from `project.config.json`'s
+ * `condition.miniprogram` — WeChat DevTools' own location and shape, so a
+ * project checked into git carries its modes to every machine, and the same
+ * directory opened in that tool shows the same list.
+ *
+ * Projects imported before compile modes existed fall back to migrating the
+ * legacy single config out of the project list file.
+ */
+export function getCompileModes(dirPath) {
+    if (!dirPath)
+        return emptyCompileModes();
+    const condition = readProjectConfig(dirPath).condition;
+    const stored = isRecord(condition) && condition.miniprogram !== undefined
+        ? normalizeCompileModes(condition.miniprogram)
+        : null;
+    // A stored list with entries is the answer — it is the user's own edit. An
+    // EMPTY block is not evidence that the project has no modes: WeChat DevTools
+    // writes `"miniprogram": {"list": []}` into any project it opens, and taking
+    // that as "no modes" would drop the start page a user configured before
+    // compile modes existed.
+    if (stored && stored.list.length > 0)
+        return stored;
+    return migrateLegacyCompileConfig(dirPath) ?? stored ?? emptyCompileModes();
+}
+/**
+ * Which config file owns `condition` for this project — the one a save has to
+ * land in to be read back.
+ *
+ * `readProjectConfig` merges the private file over the public one key by key,
+ * so a private file carrying any `condition` at all (even one that only holds
+ * a mini-game block, with no `miniprogram` in it) replaces the whole merged
+ * `condition`. Writing modes to the public file in that case reports success
+ * and then reads back as if nothing had been saved.
+ *
+ * With no private `condition`, modes stay in the shared public file, where the
+ * team gets them from git.
+ */
+function compileModesConfigPath(dirPath) {
+    const privatePath = path.join(dirPath, 'project.private.config.json');
+    if (fs.existsSync(privatePath)) {
+        try {
+            const privateConfig = JSON.parse(fs.readFileSync(privatePath, 'utf-8'));
+            if (isRecord(privateConfig) && privateConfig.condition !== undefined)
+                return privatePath;
+        }
+        catch {
+            // Unparseable — readProjectConfig skips this file too, so the public one
+            // is what a read actually sees.
+        }
+    }
+    return path.join(dirPath, 'project.config.json');
+}
+/**
+ * Persist compile modes, merged so the rest of the target file survives —
+ * including the rest of `condition`, which for a mini-game project holds its
+ * own `condition.game` block.
+ */
+export function saveCompileModes(dirPath, modes) {
+    if (!dirPath)
+        return;
+    const configPath = compileModesConfigPath(dirPath);
+    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 project's
+            // build settings, which a blind rewrite would drop.
+            throw new Error(`无法保存编译模式：${configPath} 不是合法 JSON`);
+        }
+    }
+    const condition = isRecord(config.condition) ? config.condition : {};
+    fs.writeFileSync(configPath, JSON.stringify({ ...config, condition: { ...condition, miniprogram: modes } }, null, 2));
+    // The user has now said what this project's modes are, so the pre-compile-
+    // modes single config is spent. Retiring it here is what makes deleting a
+    // migrated mode stick: an empty stored list would otherwise be read as
+    // "nothing stored yet" and migrate the old config back.
+    clearLegacyCompileConfig(dirPath);
+}
+/**
+ * Projects imported before compile modes existed stored one unnamed compile
+ * config in the project list file. Surface it as a selected mode rather than
+ * silently dropping the user's start page — but only when it asks for
+ * something 普通编译 can't already do, so the common case stays an empty list.
+ * Returns null when there is nothing to migrate.
+ *
+ * Read-only: opening a project must not rewrite the user's git-tracked
+ * project.config.json. The legacy record is retired instead by the first
+ * explicit save (see `saveCompileModes`), which is also what keeps a deleted
+ * mode deleted — without that, an empty stored list would migrate again and
+ * put the mode back.
+ */
+function migrateLegacyCompileConfig(dirPath) {
+    const legacy = load().find((p) => p.path === dirPath)?.compileConfig;
+    if (!legacy)
+        return null;
+    const modes = compileConfigToModes(legacy, getProjectPages(dirPath).entryPagePath);
+    return modes.list.length > 0 ? modes : null;
+}
+/** Remove the pre-compile-modes single config from a project record. */
+function clearLegacyCompileConfig(dirPath) {
     const projects = load();
-    const project = projects.find((p) => p.path === dirPath);
-    return (project?.compileConfig ?? {
-        startPage: '',
-        scene: DEFAULT_SCENE,
-        queryParams: [],
-    });
+    const idx = projects.findIndex((p) => p.path === dirPath);
+    if (idx < 0 || projects[idx].compileConfig === undefined)
+        return;
+    const { compileConfig: _legacy, ...rest } = projects[idx];
+    projects[idx] = rest;
+    save(projects);
+}
+/**
+ * The launch parameters the selected mode resolves to. 普通编译 resolves to
+ * an empty start page; it is filled in here with the project's real entry
+ * page (mirrors getProjectPages: 'game' for mini-games, app.json's
+ * entryPagePath for mini-programs) rather than a mini-program-only literal —
+ * the simulator URL builders' own 'pages/index/index' fallback only fires
+ * when this is still empty (unreadable/malformed manifest).
+ */
+export function getCompileConfig(dirPath) {
+    const config = resolveCompileConfig(getCompileModes(dirPath));
+    if (config.startPage)
+        return config;
+    return { ...config, startPage: getProjectPages(dirPath).entryPagePath };
 }
 export function getProjectPages(dirPath) {
+    if (detectRuntimeType(dirPath) === 'minigame') {
+        // Mini-games have no page router — the compiler always emits a single
+        // synthetic 'game' entry (dimina/fe/packages/compiler/src/env.js
+        // storeAppConfig), mirrored here rather than reading a nonexistent app.json.
+        return { pages: ['game'], entryPagePath: 'game' };
+    }
     const appJsonPath = path.join(dirPath, 'app.json');
     try {
         const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));
@@ -108,13 +354,25 @@ export function getProjectPages(dirPath) {
         return { pages: [], entryPagePath: '' };
     }
 }
+/**
+ * @deprecated Compile modes are the stored form — call `saveCompileModes`.
+ * Kept working for embedding hosts still on the single-config setter: the
+ * config lands on the selected mode, or becomes a new selected mode when
+ * 普通编译 is selected and the config asks for more than it can express.
+ */
 export function saveCompileConfig(dirPath, config) {
-    const projects = load();
-    const idx = projects.findIndex((p) => p.path === dirPath);
-    if (idx >= 0) {
-        projects[idx] = { ...projects[idx], compileConfig: config };
-        save(projects);
+    const modes = getCompileModes(dirPath);
+    if (modes.current === NORMAL_COMPILE_INDEX) {
+        if (isNormalCompile(config, getProjectPages(dirPath).entryPagePath))
+            return;
+        saveCompileModes(dirPath, {
+            current: modes.list.length,
+            list: [...modes.list, compileConfigToMode(config, '')],
+        });
+        return;
     }
+    const list = modes.list.map((mode, i) => (i === modes.current ? { ...mode, ...compileConfigToMode(config, mode.name) } : mode));
+    saveCompileModes(dirPath, { ...modes, list });
 }
 /** Read a subset of `project.config.json` exposed to the settings panel. */
 export function getProjectSettings(projectPath) {
@@ -132,30 +390,6 @@ export function getProjectSettings(projectPath) {
         return { uploadWithSourceMap: false };
     }
 }
-export function getLaunchConfigs(dirPath) {
-    const project = load().find((p) => p.path === dirPath);
-    return project?.launchConfigs ?? [];
-}
-export function saveLaunchConfigs(dirPath, configs) {
-    const projects = load();
-    const idx = projects.findIndex((p) => p.path === dirPath);
-    if (idx >= 0) {
-        projects[idx] = { ...projects[idx], launchConfigs: configs };
-        save(projects);
-    }
-}
-export function getActiveLaunchConfigId(dirPath) {
-    const project = load().find((p) => p.path === dirPath);
-    return project?.activeLaunchConfigId ?? null;
-}
-export function saveActiveLaunchConfigId(dirPath, id) {
-    const projects = load();
-    const idx = projects.findIndex((p) => p.path === dirPath);
-    if (idx >= 0) {
-        projects[idx] = { ...projects[idx], activeLaunchConfigId: id };
-        save(projects);
-    }
-}
 /** Persist a partial patch into the `setting` block of `project.config.json`. */
 export function updateProjectSettings(projectPath, patch) {
     if (!projectPath)

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

@@ -4,9 +4,9 @@
  * `WorkbenchAppConfig` to fully take over the project source-of-truth, the
  * template catalog, and the "新建项目" dialog.
  */
-import type { CompileConfig, LaunchConfig } from '../../../shared/types.js';
-import type { Project } from './project-repository.js';
-export type { Project };
+import type { CompileConfig, CompileModes } from '../../../shared/types.js';
+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).
      *
@@ -48,20 +59,43 @@ export interface ProjectsProvider {
      */
     updateLastOpened?(dirPath: string): void | Promise<void>;
     /**
-     * Read the per-project compile config.
+     * Read the per-project compile config — the launch parameters the
+     * SELECTED compile mode resolves to.
      *
-     * Default when omitted: returns `DEFAULT_COMPILE_CONFIG`
-     * (`{ startPage: '', scene: 1001, queryParams: [] }`).
+     * Default when omitted: derived from `getCompileModes`, or
+     * `DEFAULT_COMPILE_CONFIG` (`{ startPage: '', scene: 1001, queryParams: [] }`)
+     * when that is absent too. Implement this only if you can resolve the
+     * project's own entry page for 普通编译 — the derived default leaves
+     * `startPage` empty and lets the renderer substitute it.
      */
     getCompileConfig?(dirPath: string): CompileConfig | Promise<CompileConfig>;
     /**
-     * Persist the per-project compile config.
+     * @deprecated Implement `saveCompileModes` instead — the named mode list
+     * is the stored form, and this setter can only express the selected
+     * mode's parameters.
      *
-     * 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.
+     * Default when omitted: silently no-ops.
      */
     saveCompileConfig?(dirPath: string, cfg: CompileConfig): void | Promise<void>;
+    /**
+     * Read the project's compile modes and which one is selected. The stored
+     * form behind the toolbar's compile-mode dropdown; `LocalProjectsProvider`
+     * keeps it in the project's own `project.config.json` under
+     * `condition.miniprogram` (WeChat DevTools' location and shape).
+     *
+     * Default when omitted: `{ current: -1, list: [] }` — the dropdown then
+     * offers 普通编译 only.
+     */
+    getCompileModes?(dirPath: string): CompileModes | Promise<CompileModes>;
+    /**
+     * Persist the project's compile modes and selection.
+     *
+     * Default when omitted: falls back to `saveCompileConfig` with the
+     * resolved launch parameters, so a host on the older setter keeps the
+     * selection's effect but not the named list. With neither, edits do not
+     * survive a reload.
+     */
+    saveCompileModes?(dirPath: string, modes: CompileModes): 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
@@ -81,30 +115,6 @@ export interface ProjectsProvider {
      * Default when omitted: returns `null`.
      */
     getThumbnail?(dirPath: string): string | null | Promise<string | null>;
-    /**
-     * Read saved launch configs for a project.
-     *
-     * Default when omitted: returns `[]`.
-     */
-    getLaunchConfigs?(dirPath: string): LaunchConfig[] | Promise<LaunchConfig[]>;
-    /**
-     * Persist the full list of launch configs for a project.
-     *
-     * Default when omitted: silently no-ops.
-     */
-    saveLaunchConfigs?(dirPath: string, configs: LaunchConfig[]): void | Promise<void>;
-    /**
-     * Read the active launch config id for a project.
-     *
-     * Default when omitted: returns `null` (normal mode).
-     */
-    getActiveLaunchConfigId?(dirPath: string): string | null | Promise<string | null>;
-    /**
-     * Persist the active launch config id for a project.
-     *
-     * Default when omitted: silently no-ops.
-     */
-    saveActiveLaunchConfigId?(dirPath: string, id: string | null): void | Promise<void>;
 }
 /** Built-in template policy. */
 export type BuiltinTemplatesMode = 'all' | 'none' | readonly string[];

package/dist/main/services/render-inspect/index.d.ts

@@ -16,7 +16,8 @@
 import type { WebContents } from 'electron';
 import type { ConnectionRegistry } from '@dimina-kit/electron-deck/main';
 import type { ElementInspection } from '../../../shared/ipc-channels.js';
-import type { WxmlNode } from '../../../preload/shared/sid-registry.js';
+import type { WxmlNode } from '@dimina-kit/inspect';
+import { type CdpSessionBroker } from '../cdp-session/index.js';
 export interface RenderInspector {
     /** Inject (once per wc) the inspector IIFE, then read the WXML tree. */
     getWxml(wc: WebContents): Promise<WxmlNode | null>;
@@ -38,13 +39,22 @@ export interface RenderInspectorOptions {
     /** Override the injected IIFE source (default: read the built bundle). Test seam. */
     loadSource?: () => string;
     /**
-     * Connection registry (foundation.md §4 / P2). When provided, the per-wc
+     * Connection registry (see foundation.md's teardown-paths section). When provided, the per-wc
      * `injected` bookkeeping is torn down via the wc's connection (deterministic
      * with the rest of that webContents's resources) instead of a bespoke
      * `once('destroyed')`. Optional so focused unit tests can omit it (they fall
      * back to the direct `once('destroyed')`).
      */
     connections?: ConnectionRegistry;
+    /**
+     * Shared CDP session broker (see cdp-session/index.ts) that owns every
+     * render-guest debugger session's attach/detach lifecycle — safe-area,
+     * elements-forward and network-forward acquire leases from the same
+     * instance. Absent → a private broker is created (never explicitly torn
+     * down here, matching this module's existing lack of a `dispose()`; the
+     * shared instance IS disposed at the app-context level).
+     */
+    broker?: CdpSessionBroker;
 }
 export declare function createRenderInspector(options?: RenderInspectorOptions): RenderInspector;
 //# sourceMappingURL=index.d.ts.map