@dimina-kit/devtools 0.4.0-dev.20260702182435 → 0.4.0-dev.20260703101348

package/dist/main/services/mcp/tools/simulator-tools.js

@@ -11,6 +11,111 @@
  */
 import { z } from 'zod';
 import { getClient } from '../target-manager.js';
+function ok(text) {
+    return { content: [{ type: 'text', text }] };
+}
+function err(msg) {
+    return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+}
+async function clickAt(c, x, y) {
+    await c.Input.dispatchMouseEvent({ type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+    await c.Input.dispatchMouseEvent({ type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+}
+async function tapCoord(c, x, y) {
+    if (typeof x !== 'number' || typeof y !== 'number')
+        return err('tap_coord requires x and y');
+    await clickAt(c, x, y);
+    return ok(`Tapped at (${x}, ${y})`);
+}
+/**
+ * In-page expression evaluated by `tap_selector`: locates the nth match,
+ * scrolls it into view, and reports its center point (or a reason it can't be
+ * tapped) so the caller can dispatch a real mouse click at that point.
+ */
+function buildTapSelectorExpression(selector, index) {
+    return `(() => {
+    const payload = ${JSON.stringify({ selector, index })}
+    try {
+      const matches = Array.from(document.querySelectorAll(payload.selector))
+      if (matches.length === 0) {
+        return { ok: false, reason: 'no_match', message: \`selector matched no elements: \${payload.selector}\` }
+      }
+      if (payload.index < 0 || payload.index >= matches.length) {
+        return { ok: false, reason: 'out_of_range', message: \`nth \${payload.index} out of range (matches: \${matches.length})\` }
+      }
+      const element = matches[payload.index]
+      element.scrollIntoView({ block: 'center', inline: 'center' })
+      const rect = element.getBoundingClientRect()
+      if (rect.width === 0 || rect.height === 0) {
+        return { ok: false, reason: 'not_visible', message: \`selector matched an element, but it is not visible or rendered (zero rect): \${payload.selector}[\${payload.index}]\` }
+      }
+      return {
+        ok: true,
+        selector: payload.selector,
+        index: payload.index,
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2,
+        rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height },
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return { ok: false, reason: 'selector_error', message: \`invalid selector: \${payload.selector} (\${message})\` }
+    }
+  })()`;
+}
+async function tapSelector(c, selector, nth) {
+    if (!selector)
+        return err('tap_selector requires selector');
+    const index = nth ?? 0;
+    const expression = buildTapSelectorExpression(selector, index);
+    const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
+    const value = result.result?.value;
+    if (!value)
+        return err(`selector evaluation returned no result: ${selector}[${index}]`);
+    if (!value.ok)
+        return err(value.message);
+    await clickAt(c, value.x, value.y);
+    return ok(`Tapped selector ${value.selector}[${value.index}] at (${value.x}, ${value.y}) within rect (${value.rect.left}, ${value.rect.top}, ${value.rect.width} x ${value.rect.height})`);
+}
+async function typeText(c, selector, nth, text) {
+    if (!selector || typeof text !== 'string')
+        return err('type requires selector and text');
+    const { root } = await c.DOM.getDocument({ depth: 0 });
+    const { nodeIds } = await c.DOM.querySelectorAll({ nodeId: root.nodeId, selector });
+    if (!nodeIds || nodeIds.length === 0)
+        return err(`selector matched no elements: ${selector}`);
+    const index = nth ?? 0;
+    if (index < 0 || index >= nodeIds.length)
+        return err(`nth ${index} out of range (matches: ${nodeIds.length})`);
+    await c.DOM.focus({ nodeId: nodeIds[index] });
+    try {
+        await c.Input.insertText({ text });
+    }
+    catch {
+        for (const ch of text) {
+            await c.Input.dispatchKeyEvent({ type: 'char', text: ch });
+        }
+    }
+    return ok(`Typed ${text.length} char(s) into ${selector}[${index}]`);
+}
+async function scrollAt(c, x, y, deltaX, deltaY) {
+    if (typeof x !== 'number' || typeof y !== 'number' || typeof deltaX !== 'number' || typeof deltaY !== 'number') {
+        return err('scroll requires x, y, deltaX, deltaY');
+    }
+    await c.Input.dispatchMouseEvent({ type: 'mouseWheel', x, y, deltaX, deltaY });
+    return ok(`Scrolled at (${x}, ${y}) by (${deltaX}, ${deltaY})`);
+}
+async function dispatchKey(c, key) {
+    if (!key)
+        return err('key requires key');
+    const isSingleChar = key.length === 1;
+    const down = { type: 'keyDown', key, code: key };
+    if (isSingleChar)
+        down.text = key;
+    await c.Input.dispatchKeyEvent(down);
+    await c.Input.dispatchKeyEvent({ type: 'keyUp', key, code: key });
+    return ok(`Dispatched key ${key}`);
+}
 export function registerSimulatorTools(server) {
     server.tool('simulator_navigate', 'Navigate the simulator to a URL, or reload the current page', {
         url: z.string().optional().describe('URL to navigate to'),
@@ -40,104 +145,20 @@ export function registerSimulatorTools(server) {
         deltaY: z.number().optional().describe('Vertical wheel delta for `scroll`'),
     }, async ({ action, x, y, selector, nth, text, key, deltaX, deltaY }) => {
         const c = getClient('simulator');
-        const err = (msg) => ({ content: [{ type: 'text', text: `Error: ${msg}` }], isError: true });
-        const clickAt = async (cx, cy) => {
-            await c.Input.dispatchMouseEvent({ type: 'mousePressed', x: cx, y: cy, button: 'left', clickCount: 1 });
-            await c.Input.dispatchMouseEvent({ type: 'mouseReleased', x: cx, y: cy, button: 'left', clickCount: 1 });
-        };
-        if (action === 'tap_coord') {
-            if (typeof x !== 'number' || typeof y !== 'number')
-                return err('tap_coord requires x and y');
-            await clickAt(x, y);
-            return { content: [{ type: 'text', text: `Tapped at (${x}, ${y})` }] };
-        }
-        if (action === 'tap_selector') {
-            if (!selector)
-                return err('tap_selector requires selector');
-            const index = nth ?? 0;
-            const expression = `(() => {
-        const payload = ${JSON.stringify({ selector, index })}
-        try {
-          const matches = Array.from(document.querySelectorAll(payload.selector))
-          if (matches.length === 0) {
-            return { ok: false, reason: 'no_match', message: \`selector matched no elements: \${payload.selector}\` }
-          }
-          if (payload.index < 0 || payload.index >= matches.length) {
-            return { ok: false, reason: 'out_of_range', message: \`nth \${payload.index} out of range (matches: \${matches.length})\` }
-          }
-          const element = matches[payload.index]
-          element.scrollIntoView({ block: 'center', inline: 'center' })
-          const rect = element.getBoundingClientRect()
-          if (rect.width === 0 || rect.height === 0) {
-            return { ok: false, reason: 'not_visible', message: \`selector matched an element, but it is not visible or rendered (zero rect): \${payload.selector}[\${payload.index}]\` }
-          }
-          return {
-            ok: true,
-            selector: payload.selector,
-            index: payload.index,
-            x: rect.left + rect.width / 2,
-            y: rect.top + rect.height / 2,
-            rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height },
-          }
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error)
-          return { ok: false, reason: 'selector_error', message: \`invalid selector: \${payload.selector} (\${message})\` }
-        }
-      })()`;
-            const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
-            const value = result.result?.value;
-            if (!value)
-                return err(`selector evaluation returned no result: ${selector}[${index}]`);
-            if (!value.ok)
-                return err(value.message);
-            await clickAt(value.x, value.y);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Tapped selector ${value.selector}[${value.index}] at (${value.x}, ${value.y}) within rect (${value.rect.left}, ${value.rect.top}, ${value.rect.width} x ${value.rect.height})`,
-                    }],
-            };
-        }
-        if (action === 'type') {
-            if (!selector || typeof text !== 'string')
-                return err('type requires selector and text');
-            const { root } = await c.DOM.getDocument({ depth: 0 });
-            const { nodeIds } = await c.DOM.querySelectorAll({ nodeId: root.nodeId, selector });
-            if (!nodeIds || nodeIds.length === 0)
-                return err(`selector matched no elements: ${selector}`);
-            const index = nth ?? 0;
-            if (index < 0 || index >= nodeIds.length)
-                return err(`nth ${index} out of range (matches: ${nodeIds.length})`);
-            await c.DOM.focus({ nodeId: nodeIds[index] });
-            try {
-                await c.Input.insertText({ text });
-            }
-            catch {
-                for (const ch of text) {
-                    await c.Input.dispatchKeyEvent({ type: 'char', text: ch });
-                }
-            }
-            return { content: [{ type: 'text', text: `Typed ${text.length} char(s) into ${selector}[${index}]` }] };
-        }
-        if (action === 'scroll') {
-            if (typeof x !== 'number' || typeof y !== 'number' || typeof deltaX !== 'number' || typeof deltaY !== 'number') {
-                return err('scroll requires x, y, deltaX, deltaY');
-            }
-            await c.Input.dispatchMouseEvent({ type: 'mouseWheel', x, y, deltaX, deltaY });
-            return { content: [{ type: 'text', text: `Scrolled at (${x}, ${y}) by (${deltaX}, ${deltaY})` }] };
-        }
-        if (action === 'key') {
-            if (!key)
-                return err('key requires key');
-            const isSingleChar = key.length === 1;
-            const down = { type: 'keyDown', key, code: key };
-            if (isSingleChar)
-                down.text = key;
-            await c.Input.dispatchKeyEvent(down);
-            await c.Input.dispatchKeyEvent({ type: 'keyUp', key, code: key });
-            return { content: [{ type: 'text', text: `Dispatched key ${key}` }] };
+        switch (action) {
+            case 'tap_coord':
+                return tapCoord(c, x, y);
+            case 'tap_selector':
+                return tapSelector(c, selector, nth);
+            case 'type':
+                return typeText(c, selector, nth, text);
+            case 'scroll':
+                return scrollAt(c, x, y, deltaX, deltaY);
+            case 'key':
+                return dispatchKey(c, key);
+            default:
+                return err(`unknown action: ${String(action)}`);
         }
-        return err(`unknown action: ${action}`);
     });
 }
 //# sourceMappingURL=simulator-tools.js.map

package/dist/main/services/network-forward/dispatch-batch.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure batch-packing for the native dispatch queue: greedily pack queued CDP
+ * messages up to `maxBatchChars` so one `executeJavaScript` call stays sized,
+ * pulling any oversized message (over `maxSingleChars`) into `chunked` for the
+ * separate chunked transport instead.
+ *
+ * An oversized message reached while `batch` is still empty is queued into
+ * `chunked` immediately and packing continues past it, so several oversized
+ * messages in a row are all pulled out in one pass. One reached once `batch`
+ * already has items stops packing there, leaving it (and everything after) in
+ * `remaining` for the next flush — this preserves delivery order across passes.
+ */
+export interface PackedDispatchBatch {
+    /** Messages to send in one `executeJavaScript` batch dispatch. */
+    batch: string[];
+    /** Oversized messages to dispatch individually via the chunked transport. */
+    chunked: string[];
+    /** Whatever the queue had left after this pass. */
+    remaining: string[];
+}
+export declare function packDispatchBatch(queue: readonly string[], maxSingleChars: number, maxBatchChars: number): PackedDispatchBatch;
+//# sourceMappingURL=dispatch-batch.d.ts.map

package/dist/main/services/network-forward/dispatch-batch.js

@@ -0,0 +1,21 @@
+export function packDispatchBatch(queue, maxSingleChars, maxBatchChars) {
+    const batch = [];
+    const chunked = [];
+    let batchChars = 0;
+    let i = 0;
+    for (; i < queue.length; i++) {
+        const msg = queue[i];
+        if (msg.length > maxSingleChars) {
+            if (batch.length > 0)
+                break;
+            chunked.push(msg);
+            continue;
+        }
+        if (batch.length > 0 && batchChars + msg.length > maxBatchChars)
+            break;
+        batch.push(msg);
+        batchChars += msg.length;
+    }
+    return { batch, chunked, remaining: queue.slice(i) };
+}
+//# sourceMappingURL=dispatch-batch.js.map

package/dist/main/services/network-forward/index.js

@@ -1,5 +1,6 @@
 import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
 import { isFrontendSettled } from '../views/inject-when-ready.js';
+import { packDispatchBatch } from './dispatch-batch.js';
 // ── requestId namespacing (pure, testable) ──────────────────────────────────
 /**
  * CDP events whose `params.requestId` we rewrite into the virtual namespace.
@@ -252,6 +253,16 @@ export function createNetworkForwarder(bridge) {
     // degrade, dropped if we go ready (so a request shows in exactly one sink).
     let probeConsoleBuffer = [];
     let readyTimeoutTimer = null;
+    // Wall-clock deadline for the CURRENT probe, set once when 'probing' begins.
+    // scheduleReadyRetry() re-checks this on every retry so the retry chain is
+    // itself authoritative on giving up — it does not depend on winning a race
+    // against readyTimeoutTimer firing first (two timers due at the same virtual
+    // instant have no guaranteed firing order under fake timers, which let a
+    // never-ready host's retry chain outlive the nominal timeout in CI: an
+    // "Aborting after running 10000 timers" abort in `network-forward`'s
+    // ready-timeout test). readyTimeoutTimer stays as a backstop for hosts that
+    // never retry at all (e.g. the queue drains before the deadline).
+    let probeDeadline = null;
     // ── Batched native dispatch into the DevTools front-end ───────────────────
     // Queued raw CDP messages (already namespaced + JSON-stringified) awaiting a
     // microtask flush — coalescing many events into one executeJavaScript avoids
@@ -268,6 +279,7 @@ export function createNetworkForwarder(bridge) {
         if (sink === 'probing')
             return;
         sink = 'probing';
+        probeDeadline = Date.now() + DEVTOOLS_READY_TIMEOUT_MS;
         if (readyTimeoutTimer)
             clearTimeout(readyTimeoutTimer);
         readyTimeoutTimer = setTimeout(() => {
@@ -280,6 +292,7 @@ export function createNetworkForwarder(bridge) {
     /** Native path confirmed live: console buffer is moot, drop it. */
     function markReady() {
         sink = 'ready';
+        probeDeadline = null;
         if (readyTimeoutTimer) {
             clearTimeout(readyTimeoutTimer);
             readyTimeoutTimer = null;
@@ -298,6 +311,7 @@ export function createNetworkForwarder(bridge) {
      */
     function degradeToConsole() {
         sink = 'degraded';
+        probeDeadline = null;
         dispatchQueue = [];
         if (readyTimeoutTimer) {
             clearTimeout(readyTimeoutTimer);
@@ -375,26 +389,10 @@ export function createNetworkForwarder(bridge) {
         if (sink === 'idle')
             beginProbing();
         // Pack greedily up to MAX_BATCH_CHARS so one executeJavaScript stays sized;
-        // oversized single messages go via the chunked transport.
-        const batch = [];
-        let batchChars = 0;
-        let i = 0;
-        for (; i < dispatchQueue.length; i++) {
-            const msg = dispatchQueue[i];
-            if (msg.length > MAX_SINGLE_DISPATCH_CHARS) {
-                // Flush whatever's accumulated first to preserve ordering, then chunk.
-                if (batch.length > 0)
-                    break;
-                dispatchChunked(wc, msg);
-                continue;
-            }
-            if (batch.length > 0 && batchChars + msg.length > MAX_BATCH_CHARS)
-                break;
-            batch.push(msg);
-            batchChars += msg.length;
-        }
-        // Everything up to i was either batched or chunk-dispatched; keep the rest.
-        const remaining = dispatchQueue.slice(i);
+        // oversized single messages go via the chunked transport (see packDispatchBatch).
+        const { batch, chunked, remaining } = packDispatchBatch(dispatchQueue, MAX_SINGLE_DISPATCH_CHARS, MAX_BATCH_CHARS);
+        for (const msg of chunked)
+            dispatchChunked(wc, msg);
         if (batch.length === 0) {
             // Only chunked messages were processed this turn; continue with the rest.
             dispatchQueue = remaining;
@@ -459,10 +457,21 @@ export function createNetworkForwarder(bridge) {
     function scheduleReadyRetry() {
         if (readyRetryTimer || sink === 'ready' || sink === 'degraded')
             return;
+        // Self-terminate on the same deadline readyTimeoutTimer enforces, instead of
+        // trusting that timer to win a same-instant race against this one (see the
+        // comment on `probeDeadline`'s declaration).
+        if (probeDeadline !== null && Date.now() >= probeDeadline) {
+            degradeToConsole();
+            return;
+        }
         readyRetryTimer = setTimeout(() => {
             readyRetryTimer = null;
             if (sink === 'degraded')
                 return;
+            if (probeDeadline !== null && Date.now() >= probeDeadline) {
+                degradeToConsole();
+                return;
+            }
             if (dispatchQueue.length > 0)
                 scheduleFlush();
         }, READY_RETRY_MS);
@@ -519,6 +528,7 @@ export function createNetworkForwarder(bridge) {
         // A new simulator attach restarts the native sink: 'idle' until the next
         // event re-probes the (possibly already-set) host.
         sink = 'idle';
+        probeDeadline = null;
         if (readyRetryTimer) {
             clearTimeout(readyRetryTimer);
             readyRetryTimer = null;
@@ -707,6 +717,7 @@ export function createNetworkForwarder(bridge) {
             clearTimeout(readyRetryTimer);
             readyRetryTimer = null;
         }
+        probeDeadline = null;
         // Records buffered while probing the OLD host are stale — drop, don't flush
         // (their native copies were already queued; on a host swap we restart clean).
         probeConsoleBuffer = [];
@@ -747,6 +758,12 @@ export function createNetworkForwarder(bridge) {
                 catch { /* gone */ }
             });
         }
+        // A host swap while still 'probing' the OLD host must not inherit its
+        // window: beginProbing()'s `sink === 'probing'` guard would otherwise skip
+        // (re-)arming readyTimeoutTimer/probeDeadline for the NEW host, leaving it
+        // probing forever with no timeout. Force through 'idle' so beginProbing()
+        // always arms a fresh window for whichever host is now current.
+        sink = 'idle';
         beginProbing();
         if (dispatchQueue.length > 0)
             scheduleFlush();

package/dist/main/services/notifications/renderer-notifier.d.ts

@@ -11,6 +11,43 @@ export interface ProjectStatusPayload {
     message: string;
     /** True when the status update is emitted by the file-watcher rebuild loop. */
     hotReload?: boolean;
+    /** Freshly-read page list, carried on a hot-reload status so the launch dropdown stays current. Absent when the read failed or wasn't attempted. */
+    pages?: string[];
+    /** Present (`'dead'`) once the project's file watcher has stopped — saves no longer trigger an automatic rebuild. */
+    watcher?: 'dead';
+}
+/**
+ * Payload for the `session:runtimeStatus` push — the post-compile SESSION
+ * lifecycle main tracks per `appSessionId` in bridge-router (`AppSession`
+ * itself is main-private; this is the public projection). A successful
+ * compile only means the resource tree exists; it says nothing about whether
+ * the simulator actually booted — this closes that gap.
+ */
+export interface SessionRuntimeStatusPayload {
+    appId: string;
+    phase: 'launching' | 'running' | 'launch-failed' | 'crashed';
+    /**
+     * Machine-readable cause, present on `'launch-failed'` and `'crashed'`:
+     * `'timeout'` — the launch watchdog (`LAUNCH_TIMEOUT_MS`) expired before the
+     * root page reported `domReady`; `'logic-bundle-unreachable'` — the
+     * compiled `logic.js` could not be fetched/executed;
+     * `'service-host-navigation-failed'` — the service-host window failed to
+     * navigate to its spawn URL; `'service-host-crashed'` — the service host's
+     * renderer process was gone. Plain `string` (not a literal union) so an
+     * unrecognized future code degrades gracefully instead of a type error.
+     */
+    code?: string;
+    /** Human-readable detail, mirroring the short form of the matching `ctx.diagnostics` report. */
+    reason?: string;
+    /**
+     * Present on `'launching'` when `handleSpawn`'s page-mount gate
+     * (`resolveRootPagePath`) substituted the resolved page for the request —
+     * i.e. `SpawnResult.pageFallbackApplied` was true for this spawn.
+     */
+    pageFallback?: {
+        requested: string;
+        resolved: string;
+    };
 }
 /**
  * Payload for the `project:compileLog` push — one filtered dmcc log line.
@@ -51,6 +88,8 @@ export interface WorkbenchSettingsInitPayload {
 export interface RendererNotifier {
     /** Broadcast project compile status transitions to the main renderer. */
     projectStatus(payload: ProjectStatusPayload): void;
+    /** Broadcast a session's post-compile runtime lifecycle to the main renderer. */
+    sessionRuntimeStatus(payload: SessionRuntimeStatusPayload): void;
     /** Push one per-line dmcc compile-log entry to the main renderer. */
     compileLog(payload: CompileLogPayload): void;
     /** Ask the main renderer to navigate back to its landing screen. */

package/dist/main/services/notifications/renderer-notifier.js

@@ -1,4 +1,4 @@
-import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, SessionChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -24,6 +24,9 @@ export function createRendererNotifier(ctx) {
         projectStatus(payload) {
             sendToMain(ProjectChannel.Status, payload);
         },
+        sessionRuntimeStatus(payload) {
+            sendToMain(SessionChannel.RuntimeStatus, payload);
+        },
         compileLog(payload) {
             sendToMain(ProjectChannel.CompileLog, payload);
         },

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

@@ -15,55 +15,67 @@
 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();
+/** Non-empty-after-trim `input.name`, or throws. */
+function resolveName(rawName) {
+    const name = (rawName ?? '').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;
+    return name;
+}
+/** `input.path` does-not-exist OR exists+empty, or throws. */
+function validateTargetPath(target) {
     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}`);
-        }
+    if (!fs.existsSync(target))
+        return;
+    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);
+}
+/** Look up `templateId` (default 'blank') and confirm it can materialise a project. */
+function resolveTemplate(templates, templateId) {
+    const id = templateId ?? DEFAULT_TEMPLATE_ID;
+    const template = templates.find((t) => t.id === id);
     if (!template) {
-        throw new Error(`Template not found: ${templateId}`);
+        throw new Error(`Template not found: ${id}`);
     }
     if (!template.source && !template.generate) {
-        throw new Error(`Template '${templateId}' has neither a source directory nor a generate function`);
+        throw new Error(`Template '${id}' has neither a source directory nor a generate function`);
     }
-    // 4. materialise: ensure target exists, then copy or generate.
+    return template;
+}
+/** Ensure `target` exists, then copy the template's `source` tree or run its `generate`. */
+async function materializeTemplate(target, template, name) {
     fs.mkdirSync(target, { recursive: true });
     if (template.generate) {
         await template.generate(target, { name });
+        return;
     }
-    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,
-        });
+    if (!template.source)
+        return;
+    if (!fs.existsSync(template.source.path)) {
+        throw new Error(`Template source missing on disk: ${template.source.path}`);
     }
-    // 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).
+    // `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,
+    });
+}
+/**
+ * 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).
+ */
+function writeProjectConfig(target, name) {
     const cfgPath = path.join(target, 'project.config.json');
     let cfg = {};
     if (fs.existsSync(cfgPath)) {
@@ -76,7 +88,15 @@ export async function createProject(input, ctx) {
     }
     cfg.projectname = name;
     fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
-    // 6. register with provider — this is what makes the new project appear
+}
+export async function createProject(input, ctx) {
+    const name = resolveName(input.name);
+    const target = input.path;
+    validateTargetPath(target);
+    const template = resolveTemplate(ctx.templates, input.templateId);
+    await materializeTemplate(target, template, name);
+    writeProjectConfig(target, name);
+    // 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;

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

@@ -103,7 +103,8 @@ export function getProjectPages(dirPath) {
             entryPagePath: appJson.entryPagePath || appJson.pages?.[0] || '',
         };
     }
-    catch {
+    catch (err) {
+        log.warn(`Failed to read project pages from ${appJsonPath}`, err);
         return { pages: [], entryPagePath: '' };
     }
 }

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

@@ -7,6 +7,7 @@
 import type { CompileConfig } from '../../../shared/types.js';
 import type { Project } from './project-repository.js';
 export type { Project };
+export type { ProjectTemplate, CreateProjectInput } from '../../../shared/types.js';
 /**
  * Default compile config returned by WorkspaceService when the injected
  * provider omits `getCompileConfig`, or when no record exists for a path.
@@ -81,38 +82,6 @@ export interface ProjectsProvider {
      */
     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